heroku-tokyotyrant 0.4

data/ext/tokyocabinet-1.4.41/md5.h

@@ -0,0 +1,101 @@
+/*
+  Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  ghost@aladdin.com
+
+ */
+/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+        http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.h is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Removed support for non-ANSI compilers; removed
+        references to Ghostscript; clarified derivation from RFC 1321;
+        now handles byte order either statically or dynamically.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+        added conditionalization for C++ compilation from Martin
+        Purschke <purschke@bnl.gov>.
+  1999-05-03 lpd Original version.
+ */
+
+#ifndef md5_INCLUDED
+#  define md5_INCLUDED
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+
+/*
+ * hack to avoid conflict of application symbol names
+ */
+#define md5_init      _tc_md5_init
+#define md5_append    _tc_md5_append
+#define md5_finish    _tc_md5_finish
+
+
+
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+    md5_word_t count[2];        /* message length in bits, lsw first */
+    md5_word_t abcd[4];         /* digest buffer */
+    md5_byte_t buf[64];         /* accumulate block */
+} md5_state_t;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* Initialize the algorithm. */
+void md5_init(md5_state_t *pms);
+
+/* Append a string to the message. */
+void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+
+/* Finish the message and return the digest. */
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+
+#ifdef __cplusplus
+}  /* end extern "C" */
+#endif
+
+#endif /* md5_INCLUDED */

data/ext/tokyocabinet-1.4.41/myconf.c

@@ -0,0 +1,493 @@
+/*************************************************************************************************
+ * System-dependent configurations of Tokyo Cabinet
+ *                                                      Copyright (C) 2006-2009 Mikio Hirabayashi
+ * This file is part of Tokyo Cabinet.
+ * Tokyo Cabinet is free software; you can redistribute it and/or modify it under the terms of
+ * the GNU Lesser General Public License as published by the Free Software Foundation; either
+ * version 2.1 of the License or any later version.  Tokyo Cabinet is distributed in the hope
+ * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ * You should have received a copy of the GNU Lesser General Public License along with Tokyo
+ * Cabinet; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307 USA.
+ *************************************************************************************************/
+
+
+#include "myconf.h"
+
+
+
+/*************************************************************************************************
+ * common settings
+ *************************************************************************************************/
+
+
+int _tc_dummy_cnt = 0;
+
+
+int _tc_dummyfunc(void){
+  return 0;
+}
+
+
+int _tc_dummyfuncv(int a, ...){
+  return 0;
+}
+
+
+
+/*************************************************************************************************
+ * for ZLIB
+ *************************************************************************************************/
+
+
+#if TCUSEZLIB
+
+
+#include <zlib.h>
+
+#define ZLIBBUFSIZ     8192
+
+
+static char *_tc_deflate_impl(const char *ptr, int size, int *sp, int mode);
+static char *_tc_inflate_impl(const char *ptr, int size, int *sp, int mode);
+static unsigned int _tc_getcrc_impl(const char *ptr, int size);
+
+
+char *(*_tc_deflate)(const char *, int, int *, int) = _tc_deflate_impl;
+char *(*_tc_inflate)(const char *, int, int *, int) = _tc_inflate_impl;
+unsigned int (*_tc_getcrc)(const char *, int) = _tc_getcrc_impl;
+
+
+static char *_tc_deflate_impl(const char *ptr, int size, int *sp, int mode){
+  assert(ptr && size >= 0 && sp);
+  z_stream zs;
+  zs.zalloc = Z_NULL;
+  zs.zfree = Z_NULL;
+  zs.opaque = Z_NULL;
+  switch(mode){
+    case _TCZMRAW:
+      if(deflateInit2(&zs, 5, Z_DEFLATED, -15, 7, Z_DEFAULT_STRATEGY) != Z_OK)
+        return NULL;
+      break;
+    case _TCZMGZIP:
+      if(deflateInit2(&zs, 6, Z_DEFLATED, 15 + 16, 9, Z_DEFAULT_STRATEGY) != Z_OK)
+        return NULL;
+      break;
+    default:
+      if(deflateInit2(&zs, 6, Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY) != Z_OK)
+        return NULL;
+      break;
+  }
+  int asiz = size + 16;
+  if(asiz < ZLIBBUFSIZ) asiz = ZLIBBUFSIZ;
+  char *buf;
+  if(!(buf = MYMALLOC(asiz))){
+    deflateEnd(&zs);
+    return NULL;
+  }
+  unsigned char obuf[ZLIBBUFSIZ];
+  int bsiz = 0;
+  zs.next_in = (unsigned char *)ptr;
+  zs.avail_in = size;
+  zs.next_out = obuf;
+  zs.avail_out = ZLIBBUFSIZ;
+  int rv;
+  while((rv = deflate(&zs, Z_FINISH)) == Z_OK){
+    int osiz = ZLIBBUFSIZ - zs.avail_out;
+    if(bsiz + osiz > asiz){
+      asiz = asiz * 2 + osiz;
+      char *swap;
+      if(!(swap = MYREALLOC(buf, asiz))){
+        MYFREE(buf);
+        deflateEnd(&zs);
+        return NULL;
+      }
+      buf = swap;
+    }
+    memcpy(buf + bsiz, obuf, osiz);
+    bsiz += osiz;
+    zs.next_out = obuf;
+    zs.avail_out = ZLIBBUFSIZ;
+  }
+  if(rv != Z_STREAM_END){
+    MYFREE(buf);
+    deflateEnd(&zs);
+    return NULL;
+  }
+  int osiz = ZLIBBUFSIZ - zs.avail_out;
+  if(bsiz + osiz + 1 > asiz){
+    asiz = asiz * 2 + osiz;
+    char *swap;
+    if(!(swap = MYREALLOC(buf, asiz))){
+      MYFREE(buf);
+      deflateEnd(&zs);
+      return NULL;
+    }
+    buf = swap;
+  }
+  memcpy(buf + bsiz, obuf, osiz);
+  bsiz += osiz;
+  buf[bsiz] = '\0';
+  if(mode == _TCZMRAW) bsiz++;
+  *sp = bsiz;
+  deflateEnd(&zs);
+  return buf;
+}
+
+
+static char *_tc_inflate_impl(const char *ptr, int size, int *sp, int mode){
+  assert(ptr && size >= 0 && sp);
+  z_stream zs;
+  zs.zalloc = Z_NULL;
+  zs.zfree = Z_NULL;
+  zs.opaque = Z_NULL;
+  switch(mode){
+    case _TCZMRAW:
+      if(inflateInit2(&zs, -15) != Z_OK) return NULL;
+      break;
+    case _TCZMGZIP:
+      if(inflateInit2(&zs, 15 + 16) != Z_OK) return NULL;
+      break;
+    default:
+      if(inflateInit2(&zs, 15) != Z_OK) return NULL;
+      break;
+  }
+  int asiz = size * 2 + 16;
+  if(asiz < ZLIBBUFSIZ) asiz = ZLIBBUFSIZ;
+  char *buf;
+  if(!(buf = MYMALLOC(asiz))){
+    inflateEnd(&zs);
+    return NULL;
+  }
+  unsigned char obuf[ZLIBBUFSIZ];
+  int bsiz = 0;
+  zs.next_in = (unsigned char *)ptr;
+  zs.avail_in = size;
+  zs.next_out = obuf;
+  zs.avail_out = ZLIBBUFSIZ;
+  int rv;
+  while((rv = inflate(&zs, Z_NO_FLUSH)) == Z_OK){
+    int osiz = ZLIBBUFSIZ - zs.avail_out;
+    if(bsiz + osiz >= asiz){
+      asiz = asiz * 2 + osiz;
+      char *swap;
+      if(!(swap = MYREALLOC(buf, asiz))){
+        MYFREE(buf);
+        inflateEnd(&zs);
+        return NULL;
+      }
+      buf = swap;
+    }
+    memcpy(buf + bsiz, obuf, osiz);
+    bsiz += osiz;
+    zs.next_out = obuf;
+    zs.avail_out = ZLIBBUFSIZ;
+  }
+  if(rv != Z_STREAM_END){
+    MYFREE(buf);
+    inflateEnd(&zs);
+    return NULL;
+  }
+  int osiz = ZLIBBUFSIZ - zs.avail_out;
+  if(bsiz + osiz >= asiz){
+    asiz = asiz * 2 + osiz;
+    char *swap;
+    if(!(swap = MYREALLOC(buf, asiz))){
+      MYFREE(buf);
+      inflateEnd(&zs);
+      return NULL;
+    }
+    buf = swap;
+  }
+  memcpy(buf + bsiz, obuf, osiz);
+  bsiz += osiz;
+  buf[bsiz] = '\0';
+  *sp = bsiz;
+  inflateEnd(&zs);
+  return buf;
+}
+
+
+static unsigned int _tc_getcrc_impl(const char *ptr, int size){
+  assert(ptr && size >= 0);
+  int crc = crc32(0, Z_NULL, 0);
+  return crc32(crc, (unsigned char *)ptr, size);
+}
+
+
+#else
+
+
+char *(*_tc_deflate)(const char *, int, int *, int) = NULL;
+char *(*_tc_inflate)(const char *, int, int *, int) = NULL;
+unsigned int (*_tc_getcrc)(const char *, int) = NULL;
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for BZIP2
+ *************************************************************************************************/
+
+
+#if TCUSEBZIP
+
+
+#include <bzlib.h>
+
+#define BZIPBUFSIZ     8192
+
+
+static char *_tc_bzcompress_impl(const char *ptr, int size, int *sp);
+static char *_tc_bzdecompress_impl(const char *ptr, int size, int *sp);
+
+
+char *(*_tc_bzcompress)(const char *, int, int *) = _tc_bzcompress_impl;
+char *(*_tc_bzdecompress)(const char *, int, int *) = _tc_bzdecompress_impl;
+
+
+static char *_tc_bzcompress_impl(const char *ptr, int size, int *sp){
+  assert(ptr && size >= 0 && sp);
+  bz_stream zs;
+  zs.bzalloc = NULL;
+  zs.bzfree = NULL;
+  zs.opaque = NULL;
+  if(BZ2_bzCompressInit(&zs, 9, 0, 0) != BZ_OK) return NULL;
+  int asiz = size + 16;
+  if(asiz < BZIPBUFSIZ) asiz = BZIPBUFSIZ;
+  char *buf;
+  if(!(buf = MYMALLOC(asiz))){
+    BZ2_bzCompressEnd(&zs);
+    return NULL;
+  }
+  char obuf[BZIPBUFSIZ];
+  int bsiz = 0;
+  zs.next_in = (char *)ptr;
+  zs.avail_in = size;
+  zs.next_out = obuf;
+  zs.avail_out = BZIPBUFSIZ;
+  int rv;
+  while((rv = BZ2_bzCompress(&zs, BZ_FINISH)) == BZ_FINISH_OK){
+    int osiz = BZIPBUFSIZ - zs.avail_out;
+    if(bsiz + osiz > asiz){
+      asiz = asiz * 2 + osiz;
+      char *swap;
+      if(!(swap = MYREALLOC(buf, asiz))){
+        MYFREE(buf);
+        BZ2_bzCompressEnd(&zs);
+        return NULL;
+      }
+      buf = swap;
+    }
+    memcpy(buf + bsiz, obuf, osiz);
+    bsiz += osiz;
+    zs.next_out = obuf;
+    zs.avail_out = BZIPBUFSIZ;
+  }
+  if(rv != BZ_STREAM_END){
+    MYFREE(buf);
+    BZ2_bzCompressEnd(&zs);
+    return NULL;
+  }
+  int osiz = BZIPBUFSIZ - zs.avail_out;
+  if(bsiz + osiz + 1 > asiz){
+    asiz = asiz * 2 + osiz;
+    char *swap;
+    if(!(swap = MYREALLOC(buf, asiz))){
+      MYFREE(buf);
+      BZ2_bzCompressEnd(&zs);
+      return NULL;
+    }
+    buf = swap;
+  }
+  memcpy(buf + bsiz, obuf, osiz);
+  bsiz += osiz;
+  buf[bsiz] = '\0';
+  *sp = bsiz;
+  BZ2_bzCompressEnd(&zs);
+  return buf;
+}
+
+
+static char *_tc_bzdecompress_impl(const char *ptr, int size, int *sp){
+  assert(ptr && size >= 0 && sp);
+  bz_stream zs;
+  zs.bzalloc = NULL;
+  zs.bzfree = NULL;
+  zs.opaque = NULL;
+  if(BZ2_bzDecompressInit(&zs, 0, 0) != BZ_OK) return NULL;
+  int asiz = size * 2 + 16;
+  if(asiz < BZIPBUFSIZ) asiz = BZIPBUFSIZ;
+  char *buf;
+  if(!(buf = MYMALLOC(asiz))){
+    BZ2_bzDecompressEnd(&zs);
+    return NULL;
+  }
+  char obuf[BZIPBUFSIZ];
+  int bsiz = 0;
+  zs.next_in = (char *)ptr;
+  zs.avail_in = size;
+  zs.next_out = obuf;
+  zs.avail_out = BZIPBUFSIZ;
+  int rv;
+  while((rv = BZ2_bzDecompress(&zs)) == BZ_OK){
+    int osiz = BZIPBUFSIZ - zs.avail_out;
+    if(bsiz + osiz >= asiz){
+      asiz = asiz * 2 + osiz;
+      char *swap;
+      if(!(swap = MYREALLOC(buf, asiz))){
+        MYFREE(buf);
+        BZ2_bzDecompressEnd(&zs);
+        return NULL;
+      }
+      buf = swap;
+    }
+    memcpy(buf + bsiz, obuf, osiz);
+    bsiz += osiz;
+    zs.next_out = obuf;
+    zs.avail_out = BZIPBUFSIZ;
+  }
+  if(rv != BZ_STREAM_END){
+    MYFREE(buf);
+    BZ2_bzDecompressEnd(&zs);
+    return NULL;
+  }
+  int osiz = BZIPBUFSIZ - zs.avail_out;
+  if(bsiz + osiz >= asiz){
+    asiz = asiz * 2 + osiz;
+    char *swap;
+    if(!(swap = MYREALLOC(buf, asiz))){
+      MYFREE(buf);
+      BZ2_bzDecompressEnd(&zs);
+      return NULL;
+    }
+    buf = swap;
+  }
+  memcpy(buf + bsiz, obuf, osiz);
+  bsiz += osiz;
+  buf[bsiz] = '\0';
+  *sp = bsiz;
+  BZ2_bzDecompressEnd(&zs);
+  return buf;
+}
+
+
+#else
+
+
+char *(*_tc_bzcompress)(const char *, int, int *) = NULL;
+char *(*_tc_bzdecompress)(const char *, int, int *) = NULL;
+
+
+#endif
+
+
+
+/*************************************************************************************************
+ * for test of custom codec functions
+ *************************************************************************************************/
+
+
+#if TCUSEEXLZMA
+
+
+#include <lzmalib.h>
+
+
+void *_tc_recencode(const void *ptr, int size, int *sp, void *op){
+  return lzma_compress(ptr, size, sp);
+}
+
+
+void *_tc_recdecode(const void *ptr, int size, int *sp, void *op){
+  return lzma_decompress(ptr, size, sp);
+}
+
+
+#elif TCUSEEXLZO
+
+
+#include <lzo/lzo1x.h>
+
+
+bool _tc_lzo_init = false;
+
+
+void *_tc_recencode(const void *ptr, int size, int *sp, void *op){
+  if(!_tc_lzo_init){
+    if(lzo_init() != LZO_E_OK) return NULL;
+    _tc_lzo_init = false;
+  }
+  lzo_bytep buf = MYMALLOC(size + (size >> 4) + 80);
+  if(!buf) return NULL;
+  lzo_uint bsiz;
+  char wrkmem[LZO1X_1_MEM_COMPRESS];
+  if(lzo1x_1_compress((lzo_bytep)ptr, size, buf, &bsiz, wrkmem) != LZO_E_OK){
+    MYFREE(buf);
+    return NULL;
+  }
+  buf[bsiz] = '\0';
+  *sp = bsiz;
+  return (char *)buf;
+}
+
+
+void *_tc_recdecode(const void *ptr, int size, int *sp, void *op){
+  if(!_tc_lzo_init){
+    if(lzo_init() != LZO_E_OK) return NULL;
+    _tc_lzo_init = false;
+  }
+  lzo_bytep buf;
+  lzo_uint bsiz;
+  int rat = 6;
+  while(true){
+    bsiz = (size + 256) * rat + 3;
+    buf = MYMALLOC(bsiz + 1);
+    if(!buf) return NULL;
+    int rv = lzo1x_decompress_safe((lzo_bytep)ptr, size, buf, &bsiz, NULL);
+    if(rv == LZO_E_OK){
+      break;
+    } else if(rv == LZO_E_OUTPUT_OVERRUN){
+      MYFREE(buf);
+      rat *= 2;
+    } else {
+      MYFREE(buf);
+      return NULL;
+    }
+  }
+  buf[bsiz] = '\0';
+  if(sp) *sp = bsiz;
+  return (char *)buf;
+}
+
+
+#else
+
+
+void *_tc_recencode(const void *ptr, int size, int *sp, void *op){
+  char *res = MYMALLOC(size + 1);
+  if(!res) return NULL;
+  memcpy(res, ptr, size);
+  *sp = size;
+  return res;
+}
+
+
+void *_tc_recdecode(const void *ptr, int size, int *sp, void *op){
+  char *res = MYMALLOC(size + 1);
+  if(!res) return NULL;
+  memcpy(res, ptr, size);
+  *sp = size;
+  return res;
+}
+
+
+#endif
+
+
+
+// END OF FILE