immunio 1.2.1 → 2.0.2

data/lua-hooks/ext/lua-cmsgpack/.gitignore

@@ -1,13 +0,0 @@
-*~
-.*~
-\#*\#
-.\#*\#
-
-.DS_Store
-.project
-.settings
-
-*.o
-*.so
-
-build/

data/lua-hooks/ext/lua-cmsgpack/CMakeLists.txt

@@ -1,45 +0,0 @@
-# If Lua is installed in a non-standard location, please set the LUA_DIR
-# environment variable to point to prefix for the install. Eg:
-#       Unix: export LUA_DIR=/home/user/pkg
-#       Windows: set LUA_DIR=c:\lua51
-
-project(lua-cmsgpack C)
-cmake_minimum_required(VERSION 2.6)
-
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release CACHE STRING
-        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
-        FORCE)
-endif()
-
-find_package(Lua51 REQUIRED)
-include_directories(${LUA_INCLUDE_DIR})
-
-if(APPLE)
-    set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS
-        "${CMAKE_SHARED_MODULE_CREATE_C_FLAGS} -undefined dynamic_lookup")
-endif()
-
-if(WIN32)
-    # Win32 modules need to be linked to the Lua library.
-    set(_MODULE_LINK ${LUA_LIBRARY} ${_MODULE_LINK})
-    set(_lua_module_dir "${_lua_lib_dir}")
-else()
-    set(_lua_module_dir "${_lua_lib_dir}/lua/5.1")
-endif()
-
-option(Build32Bit "Build 32-bit Library" OFF)
-
-set(CMAKE_C_FLAGS "-O2 -g -ggdb -Wall -pedantic -std=c99")
-add_library(cmsgpack MODULE lua_cmsgpack.c)
-set_target_properties(cmsgpack PROPERTIES PREFIX "")
-
-if(Build32Bit)
-    set_target_properties(cmsgpack
-                          PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32")
-endif()
-
-target_link_libraries(cmsgpack ${_MODULE_LINK})
-install(TARGETS cmsgpack DESTINATION "${_lua_module_dir}")
-
-# vi:ai et sw=4 ts=4:

data/lua-hooks/ext/lua-cmsgpack/README.md

@@ -1,115 +0,0 @@
-README for lua-cmsgpack.c
-===
-
-Lua-cmsgpack is a [MessagePack](http://msgpack.org) implementation and bindings for
-Lua 5.1/5.2/5.3 in a self contained C file without external dependencies.
-
-This library is open source software licensed under the BSD two-clause license.
-
-INSTALLATION
----
-
-Using LuaRocks (http://luarocks.org):
-
-* Install current stable release:
-
-    sudo luarocks install lua-cmsgpack
-
-* Install current Git master head from GitHub:
-
-    sudo luarocks install lua-cmsgpack --from=rocks-cvs
-
-* Install from current working copy
-
-    cd lua-cmsgpack/
-    sudo luarocks make rockspec/lua-cmsgpack-scm-1.rockspec
-
-If you embed Lua and all modules into your C project, just add the
-`lua_cmsgpack.c` file and call the following function after creating the Lua
-interpreter:
-
-    luaopen_cmsgpack(L);
-
-USAGE
----
-
-The exported API is very simple, consisting of four functions:
-
-Basic API:
-
-    msgpack = cmsgpack.pack(lua_object1, lua_object2, ..., lua_objectN)
-    lua_object1, lua_object2, ..., lua_objectN = cmsgpack.unpack(msgpack)
-
-Detailed API giving you more control over unpacking multiple values:
-
-    resume_offset, lua_object1 = cmsgpack.unpack_one(msgpack)
-    resume_offset1, lua_object2 = cmsgpack.unpack_one(msgpack, resume_offset)
-    ...
-    -1, lua_objectN = cmsgpack.unpack_one(msgpack, resume_offset_previous)
-
-    resume_offset, lua_object1, lua_object2 = cmsgpack.unpack_limit(msgpack, 2)
-    resume_offset2, lua_object3 = cmsgpack.unpack_limit(msgpack, 1, resume_offset1)
-
-Functions:
-
-  - `pack(arg1, arg2, ..., argn)` - pack any number of lua objects into one msgpack stream.  returns: msgpack
-  - `unpack(msgpack)` - unpack all objects in msgpack to individual return values. returns: object1, object2, ..., objectN
-  - `unpack_one(msgpack); unpack_one(msgpack, offset)` - unpacks the first object after offset. returns: offset, object
-  - `unpack_limit(msgpack, limit); unpack_limit(msgpack, limit, offset)` - unpacks the first `limit` objects and returns: offset, object1, objet2, ..., objectN (up to limit, but may return fewer than limit if not that many objects remain to be unpacked)
-
-When you reach the end of your input stream with `unpack_one` or `unpack_limit`, an offset of `-1` is returned.
-
-You may `require "msgpack"` or you may `require "msgpack.safe"`.  The safe version returns errors as (nil, errstring).
-
-However because of the nature of Lua numerical and table type a few behavior
-of the library must be well understood to avoid problems:
-
-* A table is converted into a MessagePack array type only if *all* the keys are
-composed of incrementing integers starting at 1 end ending at N, without holes,
-without additional non numerical keys. All the other tables are converted into
-maps.
-* An empty table is always converted into a MessagePack array, the rationale is that empty lists are much more common than empty maps (usually used to represent objects with fields).
-* A Lua number is converted into an integer type if floor(number) == number, otherwise it is converted into the MessagePack float or double value.
-* When a Lua number is converted to float or double, the former is preferred if there is no loss of precision compared to the double representation.
-* When a MessagePack big integer (64 bit) is converted to a Lua number it is possible that the resulting number will not represent the original number but just an approximation. This is unavoidable because the Lua numerical type is usually a double precision floating point type.
-
-TESTING
----
-
-Build and test:
-
-    mkdir build; cd build
-    cmake ..
-    make
-    lua ../test.lua
-
-You can build a 32-bit module on a 64-bit platform with:
-
-    mkdir build; cd build
-    cmake -DBuild32Bit=ON ..
-    make
-    lua ../test.lua
-
-NESTED TABLES
----
-Nested tables are handled correctly up to `LUACMSGPACK_MAX_NESTING` levels of
-nesting (that is set to 16 by default).
-Every table that is nested at a greater level than the maxium is encoded
-as MessagePack nil value.
-
-It is worth to note that in Lua it is possible to create tables that mutually
-refer to each other, creating a cycle. For example:
-
-    a = {x=nil,y=5}
-    b = {x=a}
-    a['x'] = b
-
-This condition will simply make the encoder reach the max level of nesting,
-thus avoiding an infinite loop.
-
-CREDITS
----
-
-This library was written by Salvatore Sanfilippo for Redis, but is maintained as a separated project by the author.
-
-Some of the test vectors in "test.lua" are obtained from the Javascript [MessagePack-JS library](https://github.com/cuzic/MessagePack-JS).

data/lua-hooks/ext/lua-cmsgpack/lua_cmsgpack.c

@@ -1,970 +0,0 @@
-#include <math.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <assert.h>
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#define LUACMSGPACK_NAME        "cmsgpack"
-#define LUACMSGPACK_SAFE_NAME   "cmsgpack_safe"
-#define LUACMSGPACK_VERSION     "lua-cmsgpack 0.4.0.1"
-#define LUACMSGPACK_COPYRIGHT   "Copyright (C) 2012, Salvatore Sanfilippo"
-#define LUACMSGPACK_DESCRIPTION "MessagePack C implementation for Lua"
-
-/* Allows a preprocessor directive to override MAX_NESTING */
-#ifndef LUACMSGPACK_MAX_NESTING
-    #define LUACMSGPACK_MAX_NESTING  16 /* Max tables nesting. */
-#endif
-
-/* Check if float or double can be an integer without loss of precision */
-#define IS_INT_TYPE_EQUIVALENT(x, T) (!isinf(x) && (T)(x) == (x))
-
-#define IS_INT64_EQUIVALENT(x) IS_INT_TYPE_EQUIVALENT(x, int64_t)
-#define IS_INT_EQUIVALENT(x) IS_INT_TYPE_EQUIVALENT(x, int)
-
-/* If size of pointer is equal to a 4 byte integer, we're on 32 bits. */
-#if UINTPTR_MAX == UINT_MAX
-    #define BITS_32 1
-#else
-    #define BITS_32 0
-#endif
-
-#if BITS_32
-    #define lua_pushunsigned(L, n) lua_pushnumber(L, n)
-#else
-    #define lua_pushunsigned(L, n) lua_pushinteger(L, n)
-#endif
-
-/* =============================================================================
- * MessagePack implementation and bindings for Lua 5.1/5.2.
- * Copyright(C) 2012 Salvatore Sanfilippo <antirez@gmail.com>
- *
- * http://github.com/antirez/lua-cmsgpack
- *
- * For MessagePack specification check the following web site:
- * http://wiki.msgpack.org/display/MSGPACK/Format+specification
- *
- * See Copyright Notice at the end of this file.
- *
- * CHANGELOG:
- * 19-Feb-2012 (ver 0.1.0): Initial release.
- * 20-Feb-2012 (ver 0.2.0): Tables encoding improved.
- * 20-Feb-2012 (ver 0.2.1): Minor bug fixing.
- * 20-Feb-2012 (ver 0.3.0): Module renamed lua-cmsgpack (was lua-msgpack).
- * 04-Apr-2014 (ver 0.3.1): Lua 5.2 support and minor bug fix.
- * 07-Apr-2014 (ver 0.4.0): Multiple pack/unpack, lua allocator, efficiency.
- *
- * Immunio Changes:
- * 09-2015  (ver 0.4.0.1): Add an metatable check for tables.
- * ========================================================================== */
-
-/* -------------------------- Endian conversion --------------------------------
- * We use it only for floats and doubles, all the other conversions performed
- * in an endian independent fashion. So the only thing we need is a function
- * that swaps a binary string if arch is little endian (and left it untouched
- * otherwise). */
-
-/* Reverse memory bytes if arch is little endian. Given the conceptual
- * simplicity of the Lua build system we prefer check for endianess at runtime.
- * The performance difference should be acceptable. */
-void memrevifle(void *ptr, size_t len) {
-    unsigned char   *p = (unsigned char *)ptr,
-                    *e = (unsigned char *)p+len-1,
-                    aux;
-    int test = 1;
-    unsigned char *testp = (unsigned char*) &test;
-
-    if (testp[0] == 0) return; /* Big endian, nothing to do. */
-    len /= 2;
-    while(len--) {
-        aux = *p;
-        *p = *e;
-        *e = aux;
-        p++;
-        e--;
-    }
-}
-
-/* ---------------------------- String buffer ----------------------------------
- * This is a simple implementation of string buffers. The only operation
- * supported is creating empty buffers and appending bytes to it.
- * The string buffer uses 2x preallocation on every realloc for O(N) append
- * behavior.  */
-
-typedef struct mp_buf {
-    lua_State *L;
-    unsigned char *b;
-    size_t len, free;
-} mp_buf;
-
-void *mp_realloc(lua_State *L, void *target, size_t osize,size_t nsize) {
-    void *(*local_realloc) (void *, void *, size_t osize, size_t nsize) = NULL;
-    void *ud;
-
-    local_realloc = lua_getallocf(L, &ud);
-
-    return local_realloc(ud, target, osize, nsize);
-}
-
-mp_buf *mp_buf_new(lua_State *L) {
-    mp_buf *buf = NULL;
-
-    /* Old size = 0; new size = sizeof(*buf) */
-    buf = (mp_buf*)mp_realloc(L, NULL, 0, sizeof(*buf));
-
-    buf->L = L;
-    buf->b = NULL;
-    buf->len = buf->free = 0;
-    return buf;
-}
-
-void mp_buf_append(mp_buf *buf, const unsigned char *s, size_t len) {
-    if (buf->free < len) {
-        size_t newlen = buf->len+len;
-
-        buf->b = (unsigned char*)mp_realloc(buf->L, buf->b, buf->len, newlen*2);
-        buf->free = newlen;
-    }
-    memcpy(buf->b+buf->len,s,len);
-    buf->len += len;
-    buf->free -= len;
-}
-
-void mp_buf_free(mp_buf *buf) {
-    mp_realloc(buf->L, buf->b, buf->len, 0); /* realloc to 0 = free */
-    mp_realloc(buf->L, buf, sizeof(*buf), 0);
-}
-
-/* ---------------------------- String cursor ----------------------------------
- * This simple data structure is used for parsing. Basically you create a cursor
- * using a string pointer and a length, then it is possible to access the
- * current string position with cursor->p, check the remaining length
- * in cursor->left, and finally consume more string using
- * mp_cur_consume(cursor,len), to advance 'p' and subtract 'left'.
- * An additional field cursor->error is set to zero on initialization and can
- * be used to report errors. */
-
-#define MP_CUR_ERROR_NONE   0
-#define MP_CUR_ERROR_EOF    1   /* Not enough data to complete operation. */
-#define MP_CUR_ERROR_BADFMT 2   /* Bad data format */
-
-typedef struct mp_cur {
-    const unsigned char *p;
-    size_t left;
-    int err;
-} mp_cur;
-
-void mp_cur_init(mp_cur *cursor, const unsigned char *s, size_t len) {
-    cursor->p = s;
-    cursor->left = len;
-    cursor->err = MP_CUR_ERROR_NONE;
-}
-
-#define mp_cur_consume(_c,_len) do { _c->p += _len; _c->left -= _len; } while(0)
-
-/* When there is not enough room we set an error in the cursor and return. This
- * is very common across the code so we have a macro to make the code look
- * a bit simpler. */
-#define mp_cur_need(_c,_len) do { \
-    if (_c->left < _len) { \
-        _c->err = MP_CUR_ERROR_EOF; \
-        return; \
-    } \
-} while(0)
-
-/* ------------------------- Low level MP encoding -------------------------- */
-
-void mp_encode_bytes(mp_buf *buf, const unsigned char *s, size_t len) {
-    unsigned char hdr[5];
-    int hdrlen;
-
-    if (len < 32) {
-        hdr[0] = 0xa0 | (len&0xff); /* fix raw */
-        hdrlen = 1;
-    } else if (len <= 0xffff) {
-        hdr[0] = 0xda;
-        hdr[1] = (len&0xff00)>>8;
-        hdr[2] = len&0xff;
-        hdrlen = 3;
-    } else {
-        hdr[0] = 0xdb;
-        hdr[1] = (len&0xff000000)>>24;
-        hdr[2] = (len&0xff0000)>>16;
-        hdr[3] = (len&0xff00)>>8;
-        hdr[4] = len&0xff;
-        hdrlen = 5;
-    }
-    mp_buf_append(buf,hdr,hdrlen);
-    mp_buf_append(buf,s,len);
-}
-
-/* we assume IEEE 754 internal format for single and double precision floats. */
-void mp_encode_double(mp_buf *buf, double d) {
-    unsigned char b[9];
-    float f = d;
-
-    assert(sizeof(f) == 4 && sizeof(d) == 8);
-    if (d == (double)f) {
-        b[0] = 0xca;    /* float IEEE 754 */
-        memcpy(b+1,&f,4);
-        memrevifle(b+1,4);
-        mp_buf_append(buf,b,5);
-    } else if (sizeof(d) == 8) {
-        b[0] = 0xcb;    /* double IEEE 754 */
-        memcpy(b+1,&d,8);
-        memrevifle(b+1,8);
-        mp_buf_append(buf,b,9);
-    }
-}
-
-void mp_encode_int(mp_buf *buf, int64_t n) {
-    unsigned char b[9];
-    int enclen;
-
-    if (n >= 0) {
-        if (n <= 127) {
-            b[0] = n & 0x7f;    /* positive fixnum */
-            enclen = 1;
-        } else if (n <= 0xff) {
-            b[0] = 0xcc;        /* uint 8 */
-            b[1] = n & 0xff;
-            enclen = 2;
-        } else if (n <= 0xffff) {
-            b[0] = 0xcd;        /* uint 16 */
-            b[1] = (n & 0xff00) >> 8;
-            b[2] = n & 0xff;
-            enclen = 3;
-        } else if (n <= 0xffffffffLL) {
-            b[0] = 0xce;        /* uint 32 */
-            b[1] = (n & 0xff000000) >> 24;
-            b[2] = (n & 0xff0000) >> 16;
-            b[3] = (n & 0xff00) >> 8;
-            b[4] = n & 0xff;
-            enclen = 5;
-        } else {
-            b[0] = 0xcf;        /* uint 64 */
-            b[1] = (n & 0xff00000000000000LL) >> 56;
-            b[2] = (n & 0xff000000000000LL) >> 48;
-            b[3] = (n & 0xff0000000000LL) >> 40;
-            b[4] = (n & 0xff00000000LL) >> 32;
-            b[5] = (n & 0xff000000) >> 24;
-            b[6] = (n & 0xff0000) >> 16;
-            b[7] = (n & 0xff00) >> 8;
-            b[8] = n & 0xff;
-            enclen = 9;
-        }
-    } else {
-        if (n >= -32) {
-            b[0] = ((signed char)n);   /* negative fixnum */
-            enclen = 1;
-        } else if (n >= -128) {
-            b[0] = 0xd0;        /* int 8 */
-            b[1] = n & 0xff;
-            enclen = 2;
-        } else if (n >= -32768) {
-            b[0] = 0xd1;        /* int 16 */
-            b[1] = (n & 0xff00) >> 8;
-            b[2] = n & 0xff;
-            enclen = 3;
-        } else if (n >= -2147483648LL) {
-            b[0] = 0xd2;        /* int 32 */
-            b[1] = (n & 0xff000000) >> 24;
-            b[2] = (n & 0xff0000) >> 16;
-            b[3] = (n & 0xff00) >> 8;
-            b[4] = n & 0xff;
-            enclen = 5;
-        } else {
-            b[0] = 0xd3;        /* int 64 */
-            b[1] = (n & 0xff00000000000000LL) >> 56;
-            b[2] = (n & 0xff000000000000LL) >> 48;
-            b[3] = (n & 0xff0000000000LL) >> 40;
-            b[4] = (n & 0xff00000000LL) >> 32;
-            b[5] = (n & 0xff000000) >> 24;
-            b[6] = (n & 0xff0000) >> 16;
-            b[7] = (n & 0xff00) >> 8;
-            b[8] = n & 0xff;
-            enclen = 9;
-        }
-    }
-    mp_buf_append(buf,b,enclen);
-}
-
-void mp_encode_array(mp_buf *buf, int64_t n) {
-    unsigned char b[5];
-    int enclen;
-
-    if (n <= 15) {
-        b[0] = 0x90 | (n & 0xf);    /* fix array */
-        enclen = 1;
-    } else if (n <= 65535) {
-        b[0] = 0xdc;                /* array 16 */
-        b[1] = (n & 0xff00) >> 8;
-        b[2] = n & 0xff;
-        enclen = 3;
-    } else {
-        b[0] = 0xdd;                /* array 32 */
-        b[1] = (n & 0xff000000) >> 24;
-        b[2] = (n & 0xff0000) >> 16;
-        b[3] = (n & 0xff00) >> 8;
-        b[4] = n & 0xff;
-        enclen = 5;
-    }
-    mp_buf_append(buf,b,enclen);
-}
-
-void mp_encode_map(mp_buf *buf, int64_t n) {
-    unsigned char b[5];
-    int enclen;
-
-    if (n <= 15) {
-        b[0] = 0x80 | (n & 0xf);    /* fix map */
-        enclen = 1;
-    } else if (n <= 65535) {
-        b[0] = 0xde;                /* map 16 */
-        b[1] = (n & 0xff00) >> 8;
-        b[2] = n & 0xff;
-        enclen = 3;
-    } else {
-        b[0] = 0xdf;                /* map 32 */
-        b[1] = (n & 0xff000000) >> 24;
-        b[2] = (n & 0xff0000) >> 16;
-        b[3] = (n & 0xff00) >> 8;
-        b[4] = n & 0xff;
-        enclen = 5;
-    }
-    mp_buf_append(buf,b,enclen);
-}
-
-/* --------------------------- Lua types encoding --------------------------- */
-
-void mp_encode_lua_string(lua_State *L, mp_buf *buf) {
-    size_t len;
-    const char *s;
-
-    s = lua_tolstring(L,-1,&len);
-    mp_encode_bytes(buf,(const unsigned char*)s,len);
-}
-
-void mp_encode_lua_bool(lua_State *L, mp_buf *buf) {
-    unsigned char b = lua_toboolean(L,-1) ? 0xc3 : 0xc2;
-    mp_buf_append(buf,&b,1);
-}
-
-/* Lua 5.3 has a built in 64-bit integer type */
-void mp_encode_lua_integer(lua_State *L, mp_buf *buf) {
-#if (LUA_VERSION_NUM < 503) && BITS_32
-    lua_Number i = lua_tonumber(L,-1);
-#else
-    lua_Integer i = lua_tointeger(L,-1);
-#endif
-    mp_encode_int(buf, (int64_t)i);
-}
-
-/* Lua 5.2 and lower only has 64-bit doubles, so we need to
- * detect if the double may be representable as an int
- * for Lua < 5.3 */
-void mp_encode_lua_number(lua_State *L, mp_buf *buf) {
-    lua_Number n = lua_tonumber(L,-1);
-
-    if (IS_INT64_EQUIVALENT(n)) {
-        mp_encode_lua_integer(L, buf);
-    } else {
-        mp_encode_double(buf,(double)n);
-    }
-}
-
-void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level);
-
-/* Convert a lua table into a message pack list. */
-void mp_encode_lua_table_as_array(lua_State *L, mp_buf *buf, int level) {
-#if LUA_VERSION_NUM < 502
-    size_t len = lua_objlen(L,-1), j;
-#else
-    size_t len = lua_rawlen(L,-1), j;
-#endif
-
-    mp_encode_array(buf,len);
-    for (j = 1; j <= len; j++) {
-        lua_pushnumber(L,j);
-        lua_gettable(L,-2);
-        mp_encode_lua_type(L,buf,level+1);
-    }
-}
-
-/* Convert a lua table into a message pack key-value map. */
-void mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {
-    size_t len = 0;
-
-    /* First step: count keys into table. No other way to do it with the
-     * Lua API, we need to iterate a first time. Note that an alternative
-     * would be to do a single run, and then hack the buffer to insert the
-     * map opcodes for message pack. Too hackish for this lib. */
-    lua_pushnil(L);
-    while(lua_next(L,-2)) {
-        lua_pop(L,1); /* remove value, keep key for next iteration. */
-        len++;
-    }
-
-    /* Step two: actually encoding of the map. */
-    mp_encode_map(buf,len);
-    lua_pushnil(L);
-    while(lua_next(L,-2)) {
-        /* Stack: ... key value */
-        lua_pushvalue(L,-2); /* Stack: ... key value key */
-        mp_encode_lua_type(L,buf,level+1); /* encode key */
-        mp_encode_lua_type(L,buf,level+1); /* encode val */
-    }
-}
-
-/* Returns true if the Lua table on top of the stack is exclusively composed
- * of keys from numerical keys from 1 up to N, with N being the total number
- * of elements, without any hole in the middle. */
-int table_is_an_array(lua_State *L) {
-    int count = 0, max = 0;
-#if LUA_VERSION_NUM < 503
-    lua_Number n;
-#else
-    lua_Integer n;
-#endif
-
-    /* Stack top on function entry */
-    int stacktop;
-
-    stacktop = lua_gettop(L);
-
-    if (lua_getmetatable(L, -1)) {
-        lua_pushliteral(L, "__is_dict");
-        lua_rawget(L, -2);
-        if (lua_isboolean(L, -1) && lua_toboolean(L, -1)) {
-            lua_settop(L, stacktop);
-            return 0;
-        }
-        lua_settop(L, stacktop);
-    }
-
-    lua_pushnil(L);
-    while(lua_next(L,-2)) {
-        /* Stack: ... key value */
-        lua_pop(L,1); /* Stack: ... key */
-        /* The <= 0 check is valid here because we're comparing indexes. */
-#if LUA_VERSION_NUM < 503
-        if ((LUA_TNUMBER != lua_type(L,-1)) || (n = lua_tonumber(L, -1)) <= 0 ||
-            !IS_INT_EQUIVALENT(n))
-#else
-        if (!lua_isinteger(L,-1) || (n = lua_tointeger(L, -1)) <= 0)
-#endif
-        {
-            lua_settop(L, stacktop);
-            return 0;
-        }
-        max = (n > max ? n : max);
-        count++;
-    }
-    /* We have the total number of elements in "count". Also we have
-     * the max index encountered in "max". We can't reach this code
-     * if there are indexes <= 0. If you also note that there can not be
-     * repeated keys into a table, you have that if max==count you are sure
-     * that there are all the keys form 1 to count (both included). */
-    lua_settop(L, stacktop);
-    return max == count;
-}
-
-/* If the length operator returns non-zero, that is, there is at least
- * an object at key '1', we serialize to message pack list. Otherwise
- * we use a map. */
-void mp_encode_lua_table(lua_State *L, mp_buf *buf, int level) {
-    if (table_is_an_array(L))
-        mp_encode_lua_table_as_array(L,buf,level);
-    else
-        mp_encode_lua_table_as_map(L,buf,level);
-}
-
-void mp_encode_lua_null(lua_State *L, mp_buf *buf) {
-    unsigned char b[1];
-    (void)L;
-
-    b[0] = 0xc0;
-    mp_buf_append(buf,b,1);
-}
-
-void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level) {
-    int t = lua_type(L,-1);
-
-    /* Limit the encoding of nested tables to a specified maximum depth, so that
-     * we survive when called against circular references in tables. */
-    if (t == LUA_TTABLE && level == LUACMSGPACK_MAX_NESTING) t = LUA_TNIL;
-    switch(t) {
-    case LUA_TSTRING: mp_encode_lua_string(L,buf); break;
-    case LUA_TBOOLEAN: mp_encode_lua_bool(L,buf); break;
-    case LUA_TNUMBER:
-    #if LUA_VERSION_NUM < 503
-        mp_encode_lua_number(L,buf); break;
-    #else
-        if (lua_isinteger(L, -1)) {
-            mp_encode_lua_integer(L, buf);
-        } else {
-            mp_encode_lua_number(L, buf);
-        }
-        break;
-    #endif
-    case LUA_TTABLE: mp_encode_lua_table(L,buf,level); break;
-    default: mp_encode_lua_null(L,buf); break;
-    }
-    lua_pop(L,1);
-}
-
-/*
- * Packs all arguments as a stream for multiple upacking later.
- * Returns error if no arguments provided.
- */
-int mp_pack(lua_State *L) {
-    int nargs = lua_gettop(L);
-    int i;
-    mp_buf *buf;
-
-    if (nargs == 0)
-        return luaL_argerror(L, 0, "MessagePack pack needs input.");
-
-    buf = mp_buf_new(L);
-    for(i = 1; i <= nargs; i++) {
-        /* Copy argument i to top of stack for _encode processing;
-         * the encode function pops it from the stack when complete. */
-        lua_pushvalue(L, i);
-
-        mp_encode_lua_type(L,buf,0);
-
-        lua_pushlstring(L,(char*)buf->b,buf->len);
-
-        /* Reuse the buffer for the next operation by
-         * setting its free count to the total buffer size
-         * and the current position to zero. */
-        buf->free += buf->len;
-        buf->len = 0;
-    }
-    mp_buf_free(buf);
-
-    /* Concatenate all nargs buffers together */
-    lua_concat(L, nargs);
-    return 1;
-}
-
-/* ------------------------------- Decoding --------------------------------- */
-
-void mp_decode_to_lua_type(lua_State *L, mp_cur *c);
-
-void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
-    assert(len <= UINT_MAX);
-    int index = 1;
-
-    lua_newtable(L);
-    while(len--) {
-        lua_pushnumber(L,index++);
-        mp_decode_to_lua_type(L,c);
-        if (c->err) return;
-        lua_settable(L,-3);
-    }
-}
-
-void mp_decode_to_lua_hash(lua_State *L, mp_cur *c, size_t len) {
-    assert(len <= UINT_MAX);
-    lua_newtable(L);
-    while(len--) {
-        mp_decode_to_lua_type(L,c); /* key */
-        if (c->err) return;
-        mp_decode_to_lua_type(L,c); /* value */
-        if (c->err) return;
-        lua_settable(L,-3);
-    }
-}
-
-/* Decode a Message Pack raw object pointed by the string cursor 'c' to
- * a Lua type, that is left as the only result on the stack. */
-void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
-    mp_cur_need(c,1);
-
-    /* If we return more than 18 elements, we must resize the stack to
-     * fit all our return values.  But, there is no way to
-     * determine how many objects a msgpack will unpack to up front, so
-     * we request a +1 larger stack on each iteration (noop if stack is
-     * big enough, and when stack does require resize it doubles in size) */
-    luaL_checkstack(L, 1,
-        "too many return values at once; "
-        "use unpack_one or unpack_limit instead.");
-
-    switch(c->p[0]) {
-    case 0xcc:  /* uint 8 */
-        mp_cur_need(c,2);
-        lua_pushunsigned(L,c->p[1]);
-        mp_cur_consume(c,2);
-        break;
-    case 0xd0:  /* int 8 */
-        mp_cur_need(c,2);
-        lua_pushinteger(L,(signed char)c->p[1]);
-        mp_cur_consume(c,2);
-        break;
-    case 0xcd:  /* uint 16 */
-        mp_cur_need(c,3);
-        lua_pushunsigned(L,
-            (c->p[1] << 8) |
-             c->p[2]);
-        mp_cur_consume(c,3);
-        break;
-    case 0xd1:  /* int 16 */
-        mp_cur_need(c,3);
-        lua_pushinteger(L,(int16_t)
-            (c->p[1] << 8) |
-             c->p[2]);
-        mp_cur_consume(c,3);
-        break;
-    case 0xce:  /* uint 32 */
-        mp_cur_need(c,5);
-        lua_pushunsigned(L,
-            ((uint32_t)c->p[1] << 24) |
-            ((uint32_t)c->p[2] << 16) |
-            ((uint32_t)c->p[3] << 8) |
-             (uint32_t)c->p[4]);
-        mp_cur_consume(c,5);
-        break;
-    case 0xd2:  /* int 32 */
-        mp_cur_need(c,5);
-        lua_pushinteger(L,
-            ((int32_t)c->p[1] << 24) |
-            ((int32_t)c->p[2] << 16) |
-            ((int32_t)c->p[3] << 8) |
-             (int32_t)c->p[4]);
-        mp_cur_consume(c,5);
-        break;
-    case 0xcf:  /* uint 64 */
-        mp_cur_need(c,9);
-        lua_pushunsigned(L,
-            ((uint64_t)c->p[1] << 56) |
-            ((uint64_t)c->p[2] << 48) |
-            ((uint64_t)c->p[3] << 40) |
-            ((uint64_t)c->p[4] << 32) |
-            ((uint64_t)c->p[5] << 24) |
-            ((uint64_t)c->p[6] << 16) |
-            ((uint64_t)c->p[7] << 8) |
-             (uint64_t)c->p[8]);
-        mp_cur_consume(c,9);
-        break;
-    case 0xd3:  /* int 64 */
-        mp_cur_need(c,9);
-#if LUA_VERSION_NUM < 503
-        lua_pushnumber(L,
-#else
-        lua_pushinteger(L,
-#endif
-            ((int64_t)c->p[1] << 56) |
-            ((int64_t)c->p[2] << 48) |
-            ((int64_t)c->p[3] << 40) |
-            ((int64_t)c->p[4] << 32) |
-            ((int64_t)c->p[5] << 24) |
-            ((int64_t)c->p[6] << 16) |
-            ((int64_t)c->p[7] << 8) |
-             (int64_t)c->p[8]);
-        mp_cur_consume(c,9);
-        break;
-    case 0xc0:  /* nil */
-        lua_pushnil(L);
-        mp_cur_consume(c,1);
-        break;
-    case 0xc3:  /* true */
-        lua_pushboolean(L,1);
-        mp_cur_consume(c,1);
-        break;
-    case 0xc2:  /* false */
-        lua_pushboolean(L,0);
-        mp_cur_consume(c,1);
-        break;
-    case 0xca:  /* float */
-        mp_cur_need(c,5);
-        assert(sizeof(float) == 4);
-        {
-            float f;
-            memcpy(&f,c->p+1,4);
-            memrevifle(&f,4);
-            lua_pushnumber(L,f);
-            mp_cur_consume(c,5);
-        }
-        break;
-    case 0xcb:  /* double */
-        mp_cur_need(c,9);
-        assert(sizeof(double) == 8);
-        {
-            double d;
-            memcpy(&d,c->p+1,8);
-            memrevifle(&d,8);
-            lua_pushnumber(L,d);
-            mp_cur_consume(c,9);
-        }
-        break;
-    case 0xda:  /* raw 16 */
-        mp_cur_need(c,3);
-        {
-            size_t l = (c->p[1] << 8) | c->p[2];
-            mp_cur_need(c,3+l);
-            lua_pushlstring(L,(char*)c->p+3,l);
-            mp_cur_consume(c,3+l);
-        }
-        break;
-    case 0xdb:  /* raw 32 */
-        mp_cur_need(c,5);
-        {
-            size_t l = ((size_t)c->p[1] << 24) |
-                       ((size_t)c->p[2] << 16) |
-                       ((size_t)c->p[3] << 8) |
-                       (size_t)c->p[4];
-            mp_cur_consume(c,5);
-            mp_cur_need(c,l);
-            lua_pushlstring(L,(char*)c->p,l);
-            mp_cur_consume(c,l);
-        }
-        break;
-    case 0xdc:  /* array 16 */
-        mp_cur_need(c,3);
-        {
-            size_t l = (c->p[1] << 8) | c->p[2];
-            mp_cur_consume(c,3);
-            mp_decode_to_lua_array(L,c,l);
-        }
-        break;
-    case 0xdd:  /* array 32 */
-        mp_cur_need(c,5);
-        {
-            size_t l = ((size_t)c->p[1] << 24) |
-                       ((size_t)c->p[2] << 16) |
-                       ((size_t)c->p[3] << 8) |
-                       (size_t)c->p[4];
-            mp_cur_consume(c,5);
-            mp_decode_to_lua_array(L,c,l);
-        }
-        break;
-    case 0xde:  /* map 16 */
-        mp_cur_need(c,3);
-        {
-            size_t l = (c->p[1] << 8) | c->p[2];
-            mp_cur_consume(c,3);
-            mp_decode_to_lua_hash(L,c,l);
-        }
-        break;
-    case 0xdf:  /* map 32 */
-        mp_cur_need(c,5);
-        {
-            size_t l = ((size_t)c->p[1] << 24) |
-                       ((size_t)c->p[2] << 16) |
-                       ((size_t)c->p[3] << 8) |
-                       (size_t)c->p[4];
-            mp_cur_consume(c,5);
-            mp_decode_to_lua_hash(L,c,l);
-        }
-        break;
-    default:    /* types that can't be idenitified by first byte value. */
-        if ((c->p[0] & 0x80) == 0) {   /* positive fixnum */
-            lua_pushunsigned(L,c->p[0]);
-            mp_cur_consume(c,1);
-        } else if ((c->p[0] & 0xe0) == 0xe0) {  /* negative fixnum */
-            lua_pushinteger(L,(signed char)c->p[0]);
-            mp_cur_consume(c,1);
-        } else if ((c->p[0] & 0xe0) == 0xa0) {  /* fix raw */
-            size_t l = c->p[0] & 0x1f;
-            mp_cur_need(c,1+l);
-            lua_pushlstring(L,(char*)c->p+1,l);
-            mp_cur_consume(c,1+l);
-        } else if ((c->p[0] & 0xf0) == 0x90) {  /* fix map */
-            size_t l = c->p[0] & 0xf;
-            mp_cur_consume(c,1);
-            mp_decode_to_lua_array(L,c,l);
-        } else if ((c->p[0] & 0xf0) == 0x80) {  /* fix map */
-            size_t l = c->p[0] & 0xf;
-            mp_cur_consume(c,1);
-            mp_decode_to_lua_hash(L,c,l);
-        } else {
-            c->err = MP_CUR_ERROR_BADFMT;
-        }
-    }
-}
-
-int mp_unpack_full(lua_State *L, int limit, int offset) {
-    size_t len;
-    const char *s;
-    mp_cur c;
-    int cnt; /* Number of objects unpacked */
-    int decode_all = (!limit && !offset);
-
-    s = luaL_checklstring(L,1,&len); /* if no match, exits */
-
-    if (offset < 0 || limit < 0) /* requesting negative off or lim is invalid */
-        return luaL_error(L,
-            "Invalid request to unpack with offset of %d and limit of %d.",
-            offset, len);
-    else if (offset > len)
-        return luaL_error(L,
-            "Start offset %d greater than input length %d.", offset, len);
-
-    if (decode_all) limit = INT_MAX;
-
-    mp_cur_init(&c,(const unsigned char *)s+offset,len-offset);
-
-    /* We loop over the decode because this could be a stream
-     * of multiple top-level values serialized together */
-    for(cnt = 0; c.left > 0 && cnt < limit; cnt++) {
-        mp_decode_to_lua_type(L,&c);
-
-        if (c.err == MP_CUR_ERROR_EOF) {
-            return luaL_error(L,"Missing bytes in input.");
-        } else if (c.err == MP_CUR_ERROR_BADFMT) {
-            return luaL_error(L,"Bad data format in input.");
-        }
-    }
-
-    if (!decode_all) {
-        /* c->left is the remaining size of the input buffer.
-         * subtract the entire buffer size from the unprocessed size
-         * to get our next start offset */
-        int offset = len - c.left;
-        /* Return offset -1 when we have have processed the entire buffer. */
-        lua_pushinteger(L, c.left == 0 ? -1 : offset);
-        /* Results are returned with the arg elements still
-         * in place. Lua takes care of only returning
-         * elements above the args for us.
-         * In this case, we have one arg on the stack
-         * for this function, so we insert our first return
-         * value at position 2. */
-        lua_insert(L, 2);
-        cnt += 1; /* increase return count by one to make room for offset */
-    }
-
-    return cnt;
-}
-
-int mp_unpack(lua_State *L) {
-    return mp_unpack_full(L, 0, 0);
-}
-
-int mp_unpack_one(lua_State *L) {
-    int offset = luaL_optinteger(L, 2, 0);
-    /* Variable pop because offset may not exist */
-    lua_pop(L, lua_gettop(L)-1);
-    return mp_unpack_full(L, 1, offset);
-}
-
-int mp_unpack_limit(lua_State *L) {
-    int limit = luaL_checkinteger(L, 2);
-    int offset = luaL_optinteger(L, 3, 0);
-    /* Variable pop because offset may not exist */
-    lua_pop(L, lua_gettop(L)-1);
-
-    return mp_unpack_full(L, limit, offset);
-}
-
-int mp_safe(lua_State *L) {
-    int argc, err, total_results;
-
-    argc = lua_gettop(L);
-
-    /* This adds our function to the bottom of the stack
-     * (the "call this function" position) */
-    lua_pushvalue(L, lua_upvalueindex(1));
-    lua_insert(L, 1);
-
-    err = lua_pcall(L, argc, LUA_MULTRET, 0);
-    total_results = lua_gettop(L);
-
-    if (!err) {
-        return total_results;
-    } else {
-        lua_pushnil(L);
-        lua_insert(L,-2);
-        return 2;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-const struct luaL_Reg cmds[] = {
-    {"pack", mp_pack},
-    {"unpack", mp_unpack},
-    {"unpack_one", mp_unpack_one},
-    {"unpack_limit", mp_unpack_limit},
-    {0}
-};
-
-int luaopen_create(lua_State *L) {
-    int i;
-    /* Manually construct our module table instead of
-     * relying on _register or _newlib */
-    lua_newtable(L);
-
-    for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {
-        lua_pushcfunction(L, cmds[i].func);
-        lua_setfield(L, -2, cmds[i].name);
-    }
-
-    /* Add metadata */
-    lua_pushliteral(L, LUACMSGPACK_NAME);
-    lua_setfield(L, -2, "_NAME");
-    lua_pushliteral(L, LUACMSGPACK_VERSION);
-    lua_setfield(L, -2, "_VERSION");
-    lua_pushliteral(L, LUACMSGPACK_COPYRIGHT);
-    lua_setfield(L, -2, "_COPYRIGHT");
-    lua_pushliteral(L, LUACMSGPACK_DESCRIPTION);
-    lua_setfield(L, -2, "_DESCRIPTION");
-    return 1;
-}
-
-LUALIB_API int luaopen_cmsgpack(lua_State *L) {
-    luaopen_create(L);
-
-#if LUA_VERSION_NUM < 502
-    /* Register name globally for 5.1 */
-    lua_pushvalue(L, -1);
-    lua_setglobal(L, LUACMSGPACK_NAME);
-#endif
-
-    return 1;
-}
-
-LUALIB_API int luaopen_cmsgpack_safe(lua_State *L) {
-    int i;
-
-    luaopen_cmsgpack(L);
-
-    /* Wrap all functions in the safe handler */
-    for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {
-        lua_getfield(L, -1, cmds[i].name);
-        lua_pushcclosure(L, mp_safe, 1);
-        lua_setfield(L, -2, cmds[i].name);
-    }
-
-#if LUA_VERSION_NUM < 502
-    /* Register name globally for 5.1 */
-    lua_pushvalue(L, -1);
-    lua_setglobal(L, LUACMSGPACK_SAFE_NAME);
-#endif
-
-    return 1;
-}
-
-/******************************************************************************
-* Copyright (C) 2012 Salvatore Sanfilippo.  All rights reserved.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/