hirlite 0.0.1

data/vendor/rlite/deps/utilfromredis.c

@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "utilfromredis.h"
+#include <ctype.h>
+#include <limits.h>
+#include <string.h>
+#include <stdint.h>
+
+// https://github.com/antirez/redis/blob/unstable/src/util.c#L45
+//
+/* Glob-style pattern matching. */
+int rl_stringmatchlen(const char *pattern, int patternLen,
+        const char *string, int stringLen, int nocase)
+{
+    while(patternLen) {
+        switch(pattern[0]) {
+        case '*':
+            while (pattern[1] == '*') {
+                pattern++;
+                patternLen--;
+            }
+            if (patternLen == 1)
+                return 1; /* match */
+            while(stringLen) {
+                if (rl_stringmatchlen(pattern+1, patternLen-1,
+                            string, stringLen, nocase))
+                    return 1; /* match */
+                string++;
+                stringLen--;
+            }
+            return 0; /* no match */
+            break;
+        case '?':
+            if (stringLen == 0)
+                return 0; /* no match */
+            string++;
+            stringLen--;
+            break;
+        case '[':
+        {
+            int not, match;
+
+            pattern++;
+            patternLen--;
+            not = pattern[0] == '^';
+            if (not) {
+                pattern++;
+                patternLen--;
+            }
+            match = 0;
+            while(1) {
+                if (pattern[0] == '\\') {
+                    pattern++;
+                    patternLen--;
+                    if (pattern[0] == string[0])
+                        match = 1;
+                } else if (pattern[0] == ']') {
+                    break;
+                } else if (patternLen == 0) {
+                    pattern--;
+                    patternLen++;
+                    break;
+                } else if (pattern[1] == '-' && patternLen >= 3) {
+                    int start = pattern[0];
+                    int end = pattern[2];
+                    int c = string[0];
+                    if (start > end) {
+                        int t = start;
+                        start = end;
+                        end = t;
+                    }
+                    if (nocase) {
+                        start = tolower(start);
+                        end = tolower(end);
+                        c = tolower(c);
+                    }
+                    pattern += 2;
+                    patternLen -= 2;
+                    if (c >= start && c <= end)
+                        match = 1;
+                } else {
+                    if (!nocase) {
+                        if (pattern[0] == string[0])
+                            match = 1;
+                    } else {
+                        if (tolower((int)pattern[0]) == tolower((int)string[0]))
+                            match = 1;
+                    }
+                }
+                pattern++;
+                patternLen--;
+            }
+            if (not)
+                match = !match;
+            if (!match)
+                return 0; /* no match */
+            string++;
+            stringLen--;
+            break;
+        }
+        case '\\':
+            if (patternLen >= 2) {
+                pattern++;
+                patternLen--;
+            }
+            /* fall through */
+        default:
+            if (!nocase) {
+                if (pattern[0] != string[0])
+                    return 0; /* no match */
+            } else {
+                if (tolower((int)pattern[0]) != tolower((int)string[0]))
+                    return 0; /* no match */
+            }
+            string++;
+            stringLen--;
+            break;
+        }
+        pattern++;
+        patternLen--;
+        if (stringLen == 0) {
+            while(*pattern == '*') {
+                pattern++;
+                patternLen--;
+            }
+            break;
+        }
+    }
+    if (patternLen == 0 && stringLen == 0)
+        return 1;
+    return 0;
+}
+
+// Adapted from https://github.com/antirez/redis/blob/unstable/src/bitops.c#L287
+/* BITOP op_name target_key src_key1 src_key2 src_key3 ... src_keyN */
+void rl_internal_bitop(int op, unsigned long numkeys, unsigned char **objects, unsigned long *objectslen, unsigned char **result, long *resultlen)
+{
+    unsigned long j;
+    unsigned long maxlen = 0; /* Array of length of src strings, and max len. */
+    unsigned long minlen = 0; /* Min len among the input keys. */
+    unsigned char *res = NULL; /* Resulting string. */
+
+
+    /* Lookup keys, and store pointers to the string objects into an array. */
+    for (j = 0; j < numkeys; j++) {
+        if (objectslen[j] > maxlen) maxlen = objectslen[j];
+        if (j == 0 || objectslen[j] < minlen) minlen = objectslen[j];
+    }
+
+    /* Compute the bit operation, if at least one string is not empty. */
+    if (maxlen) {
+        res = (unsigned char *)malloc(sizeof(unsigned char) * maxlen);
+        unsigned char output, byte;
+        unsigned long i;
+
+        /* Fast path: as far as we have data for all the input bitmaps we
+         * can take a fast path that performs much better than the
+         * vanilla algorithm. */
+        j = 0;
+        if (minlen && numkeys <= 16) {
+            unsigned long *lp[16];
+            unsigned long *lres = (unsigned long*) res;
+
+            memcpy(lp, objects, sizeof(unsigned long*) * numkeys);
+            memcpy(res, objects[0], minlen);
+
+            /* Different branches per different operations for speed (sorry). */
+            if (op == BITOP_AND) {
+                while(minlen >= sizeof(unsigned long)*4) {
+                    for (i = 1; i < numkeys; i++) {
+                        lres[0] &= lp[i][0];
+                        lres[1] &= lp[i][1];
+                        lres[2] &= lp[i][2];
+                        lres[3] &= lp[i][3];
+                        lp[i]+=4;
+                    }
+                    lres+=4;
+                    j += sizeof(unsigned long)*4;
+                    minlen -= sizeof(unsigned long)*4;
+                }
+            } else if (op == BITOP_OR) {
+                while(minlen >= sizeof(unsigned long)*4) {
+                    for (i = 1; i < numkeys; i++) {
+                        lres[0] |= lp[i][0];
+                        lres[1] |= lp[i][1];
+                        lres[2] |= lp[i][2];
+                        lres[3] |= lp[i][3];
+                        lp[i]+=4;
+                    }
+                    lres+=4;
+                    j += sizeof(unsigned long)*4;
+                    minlen -= sizeof(unsigned long)*4;
+                }
+            } else if (op == BITOP_XOR) {
+                while(minlen >= sizeof(unsigned long)*4) {
+                    for (i = 1; i < numkeys; i++) {
+                        lres[0] ^= lp[i][0];
+                        lres[1] ^= lp[i][1];
+                        lres[2] ^= lp[i][2];
+                        lres[3] ^= lp[i][3];
+                        lp[i]+=4;
+                    }
+                    lres+=4;
+                    j += sizeof(unsigned long)*4;
+                    minlen -= sizeof(unsigned long)*4;
+                }
+            } else if (op == BITOP_NOT) {
+                while(minlen >= sizeof(unsigned long)*4) {
+                    lres[0] = ~lres[0];
+                    lres[1] = ~lres[1];
+                    lres[2] = ~lres[2];
+                    lres[3] = ~lres[3];
+                    lres+=4;
+                    j += sizeof(unsigned long)*4;
+                    minlen -= sizeof(unsigned long)*4;
+                }
+            }
+        }
+
+        /* j is set to the next byte to process by the previous loop. */
+        for (; j < maxlen; j++) {
+            output = (objectslen[0] <= j) ? 0 : objects[0][j];
+            if (op == BITOP_NOT) output = ~output;
+            for (i = 1; i < numkeys; i++) {
+                byte = (objectslen[i] <= j) ? 0 : objects[i][j];
+                switch(op) {
+                case BITOP_AND: output &= byte; break;
+                case BITOP_OR:  output |= byte; break;
+                case BITOP_XOR: output ^= byte; break;
+                }
+            }
+            res[j] = output;
+        }
+    }
+
+    *result = res;
+    *resultlen = maxlen;
+}
+
+// https://github.com/antirez/redis/blob/unstable/src/bitops.c#L61
+/* Count number of bits set in the binary array pointed by 's' and long
+ * 'count' bytes. The implementation of this function is required to
+ * work with a input string length up to 512 MB. */
+size_t rl_redisPopcount(void *s, long count) {
+    size_t bits = 0;
+    unsigned char *p = s;
+    uint32_t *p4;
+    static const unsigned char bitsinbyte[256] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8};
+
+    /* Count initial bytes not aligned to 32 bit. */
+    while((unsigned long)p & 3 && count) {
+        bits += bitsinbyte[*p++];
+        count--;
+    }
+
+    /* Count bits 16 bytes at a time */
+    p4 = (uint32_t*)p;
+    while(count>=16) {
+        uint32_t aux1, aux2, aux3, aux4;
+
+        aux1 = *p4++;
+        aux2 = *p4++;
+        aux3 = *p4++;
+        aux4 = *p4++;
+        count -= 16;
+
+        aux1 = aux1 - ((aux1 >> 1) & 0x55555555);
+        aux1 = (aux1 & 0x33333333) + ((aux1 >> 2) & 0x33333333);
+        aux2 = aux2 - ((aux2 >> 1) & 0x55555555);
+        aux2 = (aux2 & 0x33333333) + ((aux2 >> 2) & 0x33333333);
+        aux3 = aux3 - ((aux3 >> 1) & 0x55555555);
+        aux3 = (aux3 & 0x33333333) + ((aux3 >> 2) & 0x33333333);
+        aux4 = aux4 - ((aux4 >> 1) & 0x55555555);
+        aux4 = (aux4 & 0x33333333) + ((aux4 >> 2) & 0x33333333);
+        bits += ((((aux1 + (aux1 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24) +
+                ((((aux2 + (aux2 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24) +
+                ((((aux3 + (aux3 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24) +
+                ((((aux4 + (aux4 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24);
+    }
+    /* Count the remaining bytes. */
+    p = (unsigned char*)p4;
+    while(count--) bits += bitsinbyte[*p++];
+    return bits;
+}
+
+// https://github.com/antirez/redis/blob/unstable/src/bitops.c#L110
+/* Return the position of the first bit set to one (if 'bit' is 1) or
+ * zero (if 'bit' is 0) in the bitmap starting at 's' and long 'count' bytes.
+ *
+ * The function is guaranteed to return a value >= 0 if 'bit' is 0 since if
+ * no zero bit is found, it returns count*8 assuming the string is zero
+ * padded on the right. However if 'bit' is 1 it is possible that there is
+ * not a single set bit in the bitmap. In this special case -1 is returned. */
+long rl_internal_bitpos(void *s, unsigned long count, int bit) {
+    unsigned long *l;
+    unsigned char *c;
+    unsigned long skipval, word = 0, one;
+    long pos = 0; /* Position of bit, to return to the caller. */
+    unsigned long j;
+
+    /* Process whole words first, seeking for first word that is not
+     * all ones or all zeros respectively if we are lookig for zeros
+     * or ones. This is much faster with large strings having contiguous
+     * blocks of 1 or 0 bits compared to the vanilla bit per bit processing.
+     *
+     * Note that if we start from an address that is not aligned
+     * to sizeof(unsigned long) we consume it byte by byte until it is
+     * aligned. */
+
+    /* Skip initial bits not aligned to sizeof(unsigned long) byte by byte. */
+    skipval = bit ? 0 : UCHAR_MAX;
+    c = (unsigned char*) s;
+    while((unsigned long)c & (sizeof(*l)-1) && count) {
+        if (*c != skipval) break;
+        c++;
+        count--;
+        pos += 8;
+    }
+
+    /* Skip bits with full word step. */
+    skipval = bit ? 0 : ULONG_MAX;
+    l = (unsigned long*) c;
+    while (count >= sizeof(*l)) {
+        if (*l != skipval) break;
+        l++;
+        count -= sizeof(*l);
+        pos += sizeof(*l)*8;
+    }
+
+    /* Load bytes into "word" considering the first byte as the most significant
+     * (we basically consider it as written in big endian, since we consider the
+     * string as a set of bits from left to right, with the first bit at position
+     * zero.
+     *
+     * Note that the loading is designed to work even when the bytes left
+     * (count) are less than a full word. We pad it with zero on the right. */
+    c = (unsigned char*)l;
+    for (j = 0; j < sizeof(*l); j++) {
+        word <<= 8;
+        if (count) {
+            word |= *c;
+            c++;
+            count--;
+        }
+    }
+
+    /* Special case:
+     * If bits in the string are all zero and we are looking for one,
+     * return -1 to signal that there is not a single "1" in the whole
+     * string. This can't happen when we are looking for "0" as we assume
+     * that the right of the string is zero padded. */
+    if (bit == 1 && word == 0) return -1;
+
+    /* Last word left, scan bit by bit. The first thing we need is to
+     * have a single "1" set in the most significant position in an
+     * unsigned long. We don't know the size of the long so we use a
+     * simple trick. */
+    one = ULONG_MAX; /* All bits set to 1.*/
+    one >>= 1;       /* All bits set to 1 but the MSB. */
+    one = ~one;      /* All bits set to 0 but the MSB. */
+
+    while(one) {
+        if (((one & word) != 0) == bit) return pos;
+        pos++;
+        one >>= 1;
+    }
+
+    /* If we reached this point, there is a bug in the algorithm, since
+     * the case of no match is handled as a special case before. */
+    return -2;
+}

data/vendor/rlite/deps/utilfromredis.h

@@ -0,0 +1,11 @@
+#include <stdlib.h>
+
+#define BITOP_AND 0
+#define BITOP_OR 1
+#define BITOP_XOR 2
+#define BITOP_NOT 3
+
+int rl_stringmatchlen(const char *pattern, int patternLen, const char *string, int stringLen, int nocase);
+void rl_internal_bitop(int op, unsigned long numkeys, unsigned char **objects, unsigned long *objectslen, unsigned char **result, long *resultlen);
+size_t rl_redisPopcount(void *s, long count);
+long rl_internal_bitpos(void *s, unsigned long count, int bit);

data/vendor/rlite/src/Makefile

@@ -0,0 +1,79 @@
+OPTIMIZATION?=-O2
+
+ifeq ($(uname_S),SunOS)
+  # make isinf() available
+  CFLAGS?= -pedantic $(OPTIMIZATION) -Wall -W -D__EXTENSIONS__ -D_XPG6
+  DEBUG?=-g -ggdb
+else
+  CFLAGS?= -pedantic $(OPTIMIZATION) -Wall -W $(ARCH) $(PROF)
+  DEBUG?=-g -ggdb
+endif
+
+DEBUG.gcc += -rdynamic
+CFLAGS.gcc += -std=c99 -I./
+
+ifeq ($(shell $(CC) -v 2>&1 | grep -c "clang version"), 1)
+DEBUG += ${DEBUG.clang}
+CFLAGS += ${CFLAGS.clang}
+else
+DEBUG += ${DEBUG.gcc}
+CFLAGS += ${CFLAGS.gcc}
+endif
+
+LIBS=-lm
+
+all: buildtest buildhirlitetest
+
+gcov: CFLAGS += -fprofile-arcs -ftest-coverage
+gcov: clean test
+
+builddebug: CFLAGS += -DDEBUG=1
+builddebug: clean buildtest
+
+debug: builddebug vtest
+
+lcov: gcov
+	mkdir -p lcov
+	lcov --directory . --capture --output-file lcov/app.info
+	genhtml  lcov/app.info -o lcov/html
+
+full-lcov: CFLAGS += -fprofile-arcs -ftest-coverage -DDEBUG=1
+full-lcov: clean buildtest buildhirlitetest
+
+clang-analyzer:
+	rm -rf analyzer
+	scan-build -o analyzer make
+
+.c.o:
+	$(CC) $(ARCH) $(DEBUG) $(CFLAGS) -c $<
+
+libhirlite.a: hirlite.o librlite.a
+	ar -cq libhirlite.a rlite.o page_skiplist.o page_string.o page_list.o page_btree.o page_key.o type_string.o type_list.o type_set.o type_zset.o type_hash.o page_long.o page_multi_string.o util.o utilfromredis.o hyperloglog.o sha1.o crc64.o restore.o dump.o lzf_c.o lzf_d.o sort.o pqsort.o hirlite.o
+
+librlite.a: rlite.o page_skiplist.o page_string.o page_list.o page_btree.o page_key.o page_multi_string.o page_long.o type_string.o type_list.o type_set.o type_zset.o type_hash.o util.o restore.o dump.o sort.o pqsort.o ../deps/utilfromredis.o ../deps/hyperloglog.o ../deps/sha1.o ../deps/crc64.o ../deps/lzf_c.o ../deps/lzf_d.o
+	ar -cq librlite.a rlite.o page_skiplist.o page_string.o page_list.o page_btree.o page_key.o type_string.o type_list.o type_set.o type_zset.o type_hash.o page_long.o page_multi_string.o util.o utilfromredis.o hyperloglog.o sha1.o crc64.o lzf_c.o lzf_d.o restore.o dump.o sort.o pqsort.o
+
+buildtest: librlite.a test/rlite-test.o test/btree-test.o test/list-test.o test/string-test.o test/multi_string-test.o test/multi-test.o test/key-test.o test/type_string-test.o test/type_list-test.o test/type_set-test.o test/type_zset-test.o test/type_hash-test.o test/skiplist-test.o test/long-test.o test/restore-test.o test/hyperloglog-test.o test/dump-test.o test/sort-test.o test/test_util.o test/test.o
+	$(CC) $(DEBUG) $(CFLAGS) -o rlite-test test.o rlite-test.o btree-test.o list-test.o string-test.o multi_string-test.o multi-test.o key-test.o type_string-test.o type_list-test.o type_set-test.o type_zset-test.o type_hash-test.o skiplist-test.o long-test.o restore-test.o hyperloglog-test.o dump-test.o sort-test.o test_util.o librlite.a $(LIBS)
+
+buildhirlitetest: libhirlite.a test/echo.o test/hash.o test/list.o test/parser.o test/set.o test/string.o test/test_hirlite.o test/zset.o test/db.o test/multi.o test/sort.o
+	$(CC) $(DEBUG) $(CFLAGS) -o hirlite-test echo.o hash.o list.o parser.o set.o string.o test_hirlite.o zset.o db.o multi.o sort.o libhirlite.a $(LIBS)
+
+rlitetest: buildtest
+	./rlite-test
+
+hirlitetest: buildhirlitetest
+	./hirlite-test
+
+test: rlitetest hirlitetest
+
+vrlitetest: buildtest
+	valgrind --track-origins=yes --leak-check=full --show-reachable=yes ./rlite-test
+
+vhirlitetest: buildhirlitetest
+	valgrind --track-origins=yes --leak-check=full --show-reachable=yes ./hirlite-test
+
+vtest: vrlitetest vhirlitetest
+
+clean:
+	rm -rf *-test *.o *.a *.dSYM *.gcda *.gcno lcov

data/vendor/rlite/src/constants.h

@@ -0,0 +1,15 @@
+#define _POSIX_C_SOURCE 199309L
+
+#define RLITE_CRLF "\r\n"
+#define RLITE_STR_OK "OK"
+#define RLITE_STR_ERR "ERR"
+#define RLITE_PONG "PONG"
+#define RLITE_QUEUED "QUEUED"
+#define RLITE_WRONGTYPEERR "WRONGTYPE Operation against a key holding the wrong kind of value"
+#define RLITE_WRONGNUMBEROFARGUMENTS "ERR wrong number of arguments for %s"
+#define RLITE_NOKEYERR "ERR No such key"
+#define RLITE_SYNTAXERR "ERR syntax error"
+#define RLITE_SAMEOBJECTERR "ERR source and destination objects are the same"
+#define RLITE_OUTOFRANGEERR "ERR index out of range"
+#define RLITE_INVALIDMINMAXERR "ERR min or max not valid string range item"
+#define RLITE_NOSCRIPTERR "NOSCRIPT No matching script. Please use EVAL."

data/vendor/rlite/src/dump.c

@@ -0,0 +1,191 @@
+#include <arpa/inet.h>
+#include "rlite.h"
+#include "util.h"
+#include "../deps/crc64.h"
+#include "../deps/endianconv.h"
+
+int rl_dump(struct rlite *db, const unsigned char *key, long keylen, unsigned char **data, long *datalen)
+{
+	int retval;
+	uint64_t crc;
+	unsigned char type;
+	unsigned char *value = NULL, *value2 = NULL;
+	unsigned char *buf = NULL;
+	long buflen;
+	long valuelen, value2len;
+	unsigned char **values = NULL;
+	long i = -1, *valueslen = NULL;
+	uint32_t length;
+	double score;
+	char f[40];
+
+	RL_CALL(rl_key_get, RL_FOUND, db, key, keylen, &type, NULL, NULL, NULL, NULL);
+	if (type == RL_TYPE_STRING) {
+		RL_CALL(rl_get, RL_OK, db, key, keylen, &value, &valuelen);
+		RL_MALLOC(buf, sizeof(unsigned char) * (16 + valuelen));
+		buf[0] = REDIS_RDB_TYPE_STRING;
+		buf[1] = (REDIS_RDB_32BITLEN << 6);
+		length = htonl(valuelen);
+		memcpy(&buf[2], &length, 4);
+		memcpy(&buf[6], value, valuelen);
+		buflen = valuelen + 6;
+	} else if (type == RL_TYPE_LIST) {
+		RL_CALL(rl_lrange, RL_OK, db, key, keylen, 0, -1, &valuelen, &values, &valueslen);
+		buflen = 16;
+		for (i = 0; i < valuelen; i++) {
+			buflen += 5 + valueslen[i];
+		}
+		RL_MALLOC(buf, sizeof(unsigned char) * buflen);
+		buf[0] = REDIS_RDB_TYPE_LIST;
+		buf[1] = (REDIS_RDB_32BITLEN << 6);
+		length = htonl(valuelen);
+		memcpy(&buf[2], &length, 4);
+		buflen = 6;
+		for (i = 0; i < valuelen; i++) {
+			buf[buflen++] = (REDIS_RDB_32BITLEN << 6);
+			length = htonl(valueslen[i]);
+			memcpy(&buf[buflen], &length, 4);
+			buflen += 4;
+			memcpy(&buf[buflen], values[i], valueslen[i]);
+			buflen += valueslen[i];
+		}
+	} else if (type == RL_TYPE_SET) {
+		rl_set_iterator *iterator;
+		RL_CALL(rl_smembers, RL_OK, db, &iterator, key, keylen);
+		buflen = 16;
+		length = 0;
+		while ((retval = rl_set_iterator_next(iterator, NULL, &valuelen)) == RL_OK) {
+			buflen += 5 + valuelen;
+			length++;
+		}
+		if (retval != RL_END) {
+			goto cleanup;
+		}
+
+		RL_MALLOC(buf, sizeof(unsigned char) * buflen);
+		buf[0] = REDIS_RDB_TYPE_SET;
+		buf[1] = (REDIS_RDB_32BITLEN << 6);
+		length = htonl(length);
+		memcpy(&buf[2], &length, 4);
+		buflen = 6;
+
+		RL_CALL(rl_smembers, RL_OK, db, &iterator, key, keylen);
+		while ((retval = rl_set_iterator_next(iterator, &value, &valuelen)) == RL_OK) {
+			buf[buflen++] = (REDIS_RDB_32BITLEN << 6);
+			length = htonl(valuelen);
+			memcpy(&buf[buflen], &length, 4);
+			buflen += 4;
+			memcpy(&buf[buflen], value, valuelen);
+			buflen += valuelen;
+			rl_free(value);
+			value = NULL;
+		}
+		if (retval != RL_END) {
+			goto cleanup;
+		}
+	} else if (type == RL_TYPE_ZSET) {
+		rl_zset_iterator *iterator;
+		RL_CALL(rl_zrange, RL_OK, db, key, keylen, 0, -1, &iterator);
+		buflen = 16;
+		length = 0;
+		while ((retval = rl_zset_iterator_next(iterator, &score, NULL, &valuelen)) == RL_OK) {
+			buflen += 6 + valuelen + snprintf(f, 40, "%lf", score);
+			length++;
+		}
+		if (retval != RL_END) {
+			goto cleanup;
+		}
+
+		RL_MALLOC(buf, sizeof(unsigned char) * buflen);
+		buf[0] = REDIS_RDB_TYPE_ZSET;
+		buf[1] = (REDIS_RDB_32BITLEN << 6);
+		length = htonl(length);
+		memcpy(&buf[2], &length, 4);
+		buflen = 6;
+
+		RL_CALL(rl_zrange, RL_OK, db, key, keylen, 0, -1, &iterator);
+		while ((retval = rl_zset_iterator_next(iterator, &score, &value, &valuelen)) == RL_OK) {
+			buf[buflen++] = (REDIS_RDB_32BITLEN << 6);
+			length = htonl(valuelen);
+			memcpy(&buf[buflen], &length, 4);
+			buflen += 4;
+			memcpy(&buf[buflen], value, valuelen);
+			buflen += valuelen;
+			rl_free(value);
+			value = NULL;
+
+			valuelen = snprintf(f, 40, "%lf", score);
+			buf[buflen++] = valuelen;
+			memcpy(&buf[buflen], f, valuelen);
+			buflen += valuelen;
+		}
+		if (retval != RL_END) {
+			goto cleanup;
+		}
+	} else if (type == RL_TYPE_HASH) {
+		rl_hash_iterator *iterator;
+		RL_CALL(rl_hgetall, RL_OK, db, &iterator, key, keylen);
+		buflen = 16;
+		length = 0;
+		while ((retval = rl_hash_iterator_next(iterator, NULL, &value2len, NULL, &valuelen)) == RL_OK) {
+			buflen += 10 + valuelen + value2len;
+			length++;
+		}
+		if (retval != RL_END) {
+			goto cleanup;
+		}
+
+		RL_MALLOC(buf, sizeof(unsigned char) * buflen);
+		buf[0] = REDIS_RDB_TYPE_HASH;
+		buf[1] = (REDIS_RDB_32BITLEN << 6);
+		length = htonl(length);
+		memcpy(&buf[2], &length, 4);
+		buflen = 6;
+
+		RL_CALL(rl_hgetall, RL_OK, db, &iterator, key, keylen);
+		while ((retval = rl_hash_iterator_next(iterator, &value, &valuelen, &value2, &value2len)) == RL_OK) {
+			buf[buflen++] = (REDIS_RDB_32BITLEN << 6);
+			length = htonl(valuelen);
+			memcpy(&buf[buflen], &length, 4);
+			buflen += 4;
+			memcpy(&buf[buflen], value, valuelen);
+			buflen += valuelen;
+			rl_free(value);
+			value = NULL;
+
+			buf[buflen++] = (REDIS_RDB_32BITLEN << 6);
+			length = htonl(value2len);
+			memcpy(&buf[buflen], &length, 4);
+			buflen += 4;
+			memcpy(&buf[buflen], value2, value2len);
+			buflen += value2len;
+			rl_free(value2);
+			value2 = NULL;
+		}
+	} else {
+		retval = RL_UNEXPECTED;
+		goto cleanup;
+	}
+	buf[buflen++] = REDIS_RDB_VERSION;
+	buf[buflen++] = REDIS_RDB_VERSION >> 8;
+
+	crc = rl_crc64(0, buf, buflen);
+	memrev64ifbe(&crc);
+	memcpy(&buf[buflen], &crc, 8);
+	buflen += 8;
+
+	*data = buf;
+	*datalen = buflen;
+	retval = RL_OK;
+cleanup:
+	if (values) {
+		for (i = 0; i < valuelen; i++) {
+			rl_free(values[i]);
+		}
+		rl_free(values);
+	}
+	rl_free(valueslen);
+	rl_free(value);
+	rl_free(value2);
+	return retval;
+}

data/vendor/rlite/src/dump.h

@@ -0,0 +1,3 @@
+#include "rlite.h"
+
+int rl_dump(struct rlite *db, const unsigned char *key, long keylen, unsigned char **data, long *datalen);