vinted-memcached 1.8.0

data/ext/libmemcached-0.32/libmemcached/byteorder.c

@@ -0,0 +1,31 @@
+#include "common.h"
+
+/* Byte swap a 64-bit number. */
+static inline uint64_t swap64(uint64_t in) 
+{
+#ifndef BYTEORDER_BIG_ENDIAN
+  /* Little endian, flip the bytes around until someone makes a faster/better
+   * way to do this. */
+  uint64_t rv= 0;
+  uint8_t x= 0;
+  for(x= 0; x < 8; x++) 
+  {
+    rv= (rv << 8) | (in & 0xff);
+    in >>= 8;
+  }
+  return rv;
+#else
+  /* big-endian machines don't need byte swapping */
+  return in;
+#endif
+}
+
+uint64_t ntohll(uint64_t value)
+{
+  return swap64(value);
+}
+
+uint64_t htonll(uint64_t value)
+{
+  return swap64(value);
+}

data/ext/libmemcached-0.32/libmemcached/common.h

@@ -0,0 +1,189 @@
+/*
+  Common include file for libmemached
+*/
+
+#ifndef LIBMEMCACHED_COMMON_H
+#define LIBMEMCACHED_COMMON_H
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/un.h>
+#include <netinet/tcp.h>
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+/* Note we need the 2 concats below because arguments to ##
+ * are not expanded, so we need to expand __LINE__ with one indirection
+ * before doing the actual concatenation.
+ * From: http://www.pixelbeat.org/programming/gcc/static_assert.html
+ */
+#define ASSERT_CONCAT_(a, b) a##b
+#define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b)
+#define assert_on_compile(e) enum { ASSERT_CONCAT(assert_line_, __LINE__) = 1/(!!(e)) }
+
+/* Define this here, which will turn on the visibilty controls while we're
+ * building libmemcached.
+ */
+#define BUILDING_LIBMEMCACHED 1
+
+
+#include "libmemcached/memcached.h"
+#include "libmemcached/memcached_watchpoint.h"
+
+/* These are private not to be installed headers */
+#include "libmemcached/memcached_io.h"
+#include "libmemcached/memcached_internal.h"
+#include "libmemcached/libmemcached_probes.h"
+#include "libmemcached/memcached/protocol_binary.h"
+
+/* string value */
+struct memcached_continuum_item_st {
+  uint32_t index;
+  uint32_t value;
+};
+
+
+#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
+
+#define likely(x)       if((x))
+#define unlikely(x)     if((x))
+
+#else
+
+#define likely(x)       if(__builtin_expect(!!(x), 1))
+#define unlikely(x)     if(__builtin_expect((x), 0))
+#endif
+
+
+#define MEMCACHED_BLOCK_SIZE 1024
+#define MEMCACHED_DEFAULT_COMMAND_SIZE 350
+#define SMALL_STRING_LEN 1024
+#define HUGE_STRING_LEN 8196
+
+
+typedef enum {
+  MEM_NO_BLOCK= (1 << 0),
+  MEM_TCP_NODELAY= (1 << 1),
+  MEM_REUSE_MEMORY= (1 << 2),
+  MEM_USE_MD5= (1 << 3),
+  /* 4 was once Ketama */
+  MEM_USE_CRC= (1 << 5),
+  MEM_USE_CACHE_LOOKUPS= (1 << 6),
+  MEM_SUPPORT_CAS= (1 << 7),
+  MEM_BUFFER_REQUESTS= (1 << 8),
+  MEM_USE_SORT_HOSTS= (1 << 9),
+  MEM_VERIFY_KEY= (1 << 10),
+  /* 11 used for weighted ketama */
+  MEM_KETAMA_WEIGHTED= (1 << 11),
+  MEM_BINARY_PROTOCOL= (1 << 12),
+  MEM_HASH_WITH_PREFIX_KEY= (1 << 13),
+  MEM_NOREPLY= (1 << 14),
+  MEM_USE_UDP= (1 << 15),
+  MEM_AUTO_EJECT_HOSTS= (1 << 16)
+} memcached_flags;
+
+/* Hashing algo */
+
+LIBMEMCACHED_LOCAL
+void md5_signature(const unsigned char *key, unsigned int length, unsigned char *result);
+LIBMEMCACHED_LOCAL
+uint32_t hash_crc32(const char *data,
+                    size_t data_len);
+#ifdef HAVE_HSIEH_HASH
+LIBMEMCACHED_LOCAL
+uint32_t hsieh_hash(const char *key, size_t key_length);
+#endif
+LIBMEMCACHED_LOCAL
+uint32_t murmur_hash(const char *key, size_t key_length);
+LIBMEMCACHED_LOCAL
+uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval);
+
+LIBMEMCACHED_LOCAL
+memcached_return memcached_connect(memcached_server_st *ptr);
+LIBMEMCACHED_LOCAL
+memcached_return memcached_response(memcached_server_st *ptr,
+                                    char *buffer, size_t buffer_length,
+                                    memcached_result_st *result);
+LIBMEMCACHED_LOCAL
+void memcached_quit_server(memcached_server_st *ptr, uint8_t io_death);
+
+#define memcached_server_response_increment(A) (A)->cursor_active++
+#define memcached_server_response_decrement(A) (A)->cursor_active--
+#define memcached_server_response_reset(A) (A)->cursor_active=0
+
+LIBMEMCACHED_LOCAL
+memcached_return memcached_do(memcached_server_st *ptr, const void *commmand,
+                              size_t command_length, uint8_t with_flush);
+
+LIBMEMCACHED_LOCAL
+memcached_return memcached_vdo(memcached_server_st *ptr,
+                               const struct libmemcached_io_vector_st *vector, size_t count,
+                               uint8_t with_flush);
+
+LIBMEMCACHED_LOCAL
+memcached_return value_fetch(memcached_server_st *ptr,
+                             char *buffer,
+                             memcached_result_st *result);
+LIBMEMCACHED_LOCAL
+void server_list_free(memcached_st *ptr, memcached_server_st *servers);
+
+LIBMEMCACHED_LOCAL
+memcached_return memcached_key_test(const char **keys, size_t *key_length,
+                                    size_t number_of_keys);
+
+
+LIBMEMCACHED_LOCAL
+uint32_t generate_hash(memcached_st *ptr, const char *key, size_t key_length);
+
+#ifndef HAVE_HTONLL
+LIBMEMCACHED_LOCAL
+extern uint64_t ntohll(uint64_t);
+LIBMEMCACHED_LOCAL
+extern uint64_t htonll(uint64_t);
+#endif
+
+LIBMEMCACHED_LOCAL
+memcached_return memcached_purge(memcached_server_st *ptr);
+
+static inline memcached_return memcached_validate_key_length(size_t key_length,
+                                                             bool binary) {
+  unlikely (key_length == 0)
+    return MEMCACHED_BAD_KEY_PROVIDED;
+
+  if (binary)
+  {
+    unlikely (key_length > 0xffff)
+      return MEMCACHED_BAD_KEY_PROVIDED;
+  }
+  else
+  {
+    unlikely (key_length >= MEMCACHED_MAX_KEY)
+      return MEMCACHED_BAD_KEY_PROVIDED;
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+#endif /* LIBMEMCACHED_COMMON_H */

data/ext/libmemcached-0.32/libmemcached/crc.c

@@ -0,0 +1,86 @@
+/* The crc32 functions and data was originally written by Spencer
+ * Garrett <srg@quick.com> and was gleaned from the PostgreSQL source
+ * tree via the files contrib/ltree/crc32.[ch] and from FreeBSD at
+ * src/usr.bin/cksum/crc32.c.
+ */
+
+#include "common.h"
+
+static const uint32_t crc32tab[256] = {
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
+};
+
+
+uint32_t hash_crc32(const char *key, size_t key_length)
+{
+  uint32_t x;
+  uint32_t crc= UINT32_MAX;
+
+  for (x= 0; x < key_length; x++)
+     crc= (crc >> 8) ^ crc32tab[(crc ^ (uint64_t)key[x]) & 0xff];
+
+  return ~crc;
+}

data/ext/libmemcached-0.32/libmemcached/hsieh_hash.c

@@ -0,0 +1,68 @@
+/* By Paul Hsieh (C) 2004, 2005.  Covered under the Paul Hsieh
+ * derivative license. 
+ * See: http://www.azillionmonkeys.com/qed/weblicense.html for license
+ * details.
+ * http://www.azillionmonkeys.com/qed/hash.html
+*/
+
+#include "common.h"
+
+#undef get16bits
+#if (defined(__GNUC__) && defined(__i386__))
+#define get16bits(d) (*((const uint16_t *) (d)))
+#endif
+
+#if !defined (get16bits)
+#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
+                      +(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+
+uint32_t hsieh_hash(const char *key, size_t key_length)
+{
+  uint32_t hash = 0, tmp;
+  int rem;
+
+  if (key_length <= 0 || key == NULL)
+    return 0;
+
+  rem = key_length & 3;
+  key_length >>= 2;
+
+  /* Main loop */
+  for (;key_length > 0; key_length--)
+  {
+    hash  += get16bits (key);
+    tmp    = (get16bits (key+2) << 11) ^ hash;
+    hash   = (hash << 16) ^ tmp;
+    key  += 2*sizeof (uint16_t);
+    hash  += hash >> 11;
+  }
+
+  /* Handle end cases */
+  switch (rem)
+  {
+  case 3: hash += get16bits (key);
+          hash ^= hash << 16;
+          hash ^= key[sizeof (uint16_t)] << 18;
+          hash += hash >> 11;
+          break;
+  case 2: hash += get16bits (key);
+          hash ^= hash << 11;
+          hash += hash >> 17;
+          break;
+  case 1: hash += *key;
+          hash ^= hash << 10;
+          hash += hash >> 1;
+  }
+
+  /* Force "avalanching" of final 127 bits */
+  hash ^= hash << 3;
+  hash += hash >> 5;
+  hash ^= hash << 4;
+  hash += hash >> 17;
+  hash ^= hash << 25;
+  hash += hash >> 6;
+
+  return hash;
+}
+

data/ext/libmemcached-0.32/libmemcached/jenkins_hash.c

@@ -0,0 +1,213 @@
+/*
+*
+* By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this
+* code any way you wish, private, educational, or commercial.  It's free.
+* Use for hash table lookup, or anything where one collision in 2^^32 is
+* acceptable.  Do NOT use for cryptographic purposes.
+* http://burtleburtle.net/bob/hash/index.html
+*
+* Modified by Brian Pontz for libmemcached
+* TODO:
+* Add big endian support
+*/
+
+#include "common.h"
+
+#define hashsize(n) ((uint32_t)1<<(n))
+#define hashmask(n) (hashsize(n)-1)
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+#define mix(a,b,c) \
+{ \
+  a -= c;  a ^= rot(c, 4);  c += b; \
+  b -= a;  b ^= rot(a, 6);  a += c; \
+  c -= b;  c ^= rot(b, 8);  b += a; \
+  a -= c;  a ^= rot(c,16);  c += b; \
+  b -= a;  b ^= rot(a,19);  a += c; \
+  c -= b;  c ^= rot(b, 4);  b += a; \
+}
+
+#define final(a,b,c) \
+{ \
+  c ^= b; c -= rot(b,14); \
+  a ^= c; a -= rot(c,11); \
+  b ^= a; b -= rot(a,25); \
+  c ^= b; c -= rot(b,16); \
+  a ^= c; a -= rot(c,4);  \
+  b ^= a; b -= rot(a,14); \
+  c ^= b; c -= rot(b,24); \
+}
+
+/*
+jenkins_hash() -- hash a variable-length key into a 32-bit value
+  k       : the key (the unaligned variable-length array of bytes)
+  length  : the length of the key, counting by bytes
+  initval : can be any 4-byte value
+Returns a 32-bit value.  Every bit of the key affects every bit of
+the return value.  Two keys differing by one or two bits will have
+totally different hash values.
+
+The best hash table sizes are powers of 2.  There is no need to do
+mod a prime (mod is sooo slow!).  If you need less than 32 bits,
+use a bitmask.  For example, if you need only 10 bits, do
+  h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+*/
+
+uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval)
+{
+  uint32_t a,b,c;                                          /* internal state */
+  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+  u.ptr = key;
+#ifdef BYTEORDER_LITTLE_ENDIAN
+  if ((u.i & 0x3) == 0)
+  {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /* 
+     * "k[2]&0xffffff" actually reads beyond the end of the string, but
+     * then masks off the part it's not allowed to read.  Because the
+     * string is aligned, the masked-off tail is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     */
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff; break;
+    case 2 : a+=k[0]&0xffff; break;
+    case 1 : a+=k[0]&0xff; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    default: return c;
+    }
+
+  } 
+  else if ((u.i & 0x1) == 0)
+  {
+    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
+    const uint8_t  *k8;
+
+    /*--------------- all but last block: aligned reads and different mixing */
+    while (length > 12)
+    {
+      a += k[0] + (((uint32_t)k[1])<<16);
+      b += k[2] + (((uint32_t)k[3])<<16);
+      c += k[4] + (((uint32_t)k[5])<<16);
+      mix(a,b,c);
+      length -= 12;
+      k += 6;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+    case 10: c+=k[4];
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 9 : c+=k8[8];                      /* fall through */
+    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+    case 6 : b+=k[2];
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 5 : b+=k8[4];                      /* fall through */
+    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+    case 2 : a+=k[0];
+             break;
+    case 1 : a+=k8[0];
+             break;
+    case 0 : return c;                     /* zero length requires no mixing */
+    default: return c;
+    }
+
+  } 
+  else
+  {                        /* need to read the key one byte at a time */
+#endif /* little endian */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      a += ((uint32_t)k[1])<<8;
+      a += ((uint32_t)k[2])<<16;
+      a += ((uint32_t)k[3])<<24;
+      b += k[4];
+      b += ((uint32_t)k[5])<<8;
+      b += ((uint32_t)k[6])<<16;
+      b += ((uint32_t)k[7])<<24;
+      c += k[8];
+      c += ((uint32_t)k[9])<<8;
+      c += ((uint32_t)k[10])<<16;
+      c += ((uint32_t)k[11])<<24;
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=((uint32_t)k[11])<<24;
+    case 11: c+=((uint32_t)k[10])<<16;
+    case 10: c+=((uint32_t)k[9])<<8;
+    case 9 : c+=k[8];
+    case 8 : b+=((uint32_t)k[7])<<24;
+    case 7 : b+=((uint32_t)k[6])<<16;
+    case 6 : b+=((uint32_t)k[5])<<8;
+    case 5 : b+=k[4];
+    case 4 : a+=((uint32_t)k[3])<<24;
+    case 3 : a+=((uint32_t)k[2])<<16;
+    case 2 : a+=((uint32_t)k[1])<<8;
+    case 1 : a+=k[0];
+             break;
+    case 0 : return c;
+    default : return c;
+    }
+#ifdef BYTEORDER_LITTLE_ENDIAN
+  }
+#endif
+
+  final(a,b,c);
+  return c;
+}
+
+

data/ext/libmemcached-0.32/libmemcached/libmemcached.ver

@@ -0,0 +1 @@
+libmemcached_2 { global: *; };

data/ext/libmemcached-0.32/libmemcached/libmemcached_probes.d

@@ -0,0 +1,30 @@
+provider libmemcached {
+	probe memcached_delete_start();
+	probe memcached_delete_end();
+	probe memcached_increment_with_initial_start();
+	probe memcached_increment_with_initial_end();
+	probe memcached_decrement_with_initial_start();
+	probe memcached_decrement_with_initial_end();
+	probe memcached_increment_start();
+	probe memcached_increment_end();
+	probe memcached_decrement_start();
+	probe memcached_decrement_end();
+	probe memcached_flush_start();
+	probe memcached_flush_end();
+	probe memcached_set_start();
+	probe memcached_set_end();
+	probe memcached_add_start();
+	probe memcached_add_end();
+	probe memcached_replace_start();
+	probe memcached_replace_end();
+	probe memcached_get_start();
+	probe memcached_get_end();
+	probe memcached_touch_start();
+	probe memcached_touch_end();
+	probe memcached_mget_start();
+	probe memcached_mget_end();
+	probe memcached_connect_start();
+	probe memcached_connect_end();
+	probe memcached_server_add_start();
+	probe memcached_server_add_end();
+};

data/ext/libmemcached-0.32/libmemcached/libmemcached_probes.h

@@ -0,0 +1,82 @@
+/*
+ * This file contains the definition of the various probes supported by
+ * libmemcached. Currently it only support DTRACE, but just create an
+ * implementation of the following macros to create your own sort of
+ * probing :)
+ */
+#ifndef	LIBMEMCACHED_PROBES_H
+#define	LIBMEMCACHED_PROBES_H
+
+#ifdef HAVE_DTRACE
+/*
+ * Create the DTrace probes on the system using it (to support both Solaris
+ * and MacOS X
+ */
+#include "dtrace_probes.h"
+
+#else
+/*
+ * Provide dummy macros so that we don't need to clutter the code with
+ * ifdefs when we want to use the probes.
+ */
+
+#define	LIBMEMCACHED_MEMCACHED_ADD_END()
+#define	LIBMEMCACHED_MEMCACHED_ADD_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_ADD_START()
+#define	LIBMEMCACHED_MEMCACHED_ADD_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_END()
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_START()
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_END()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_START()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_END()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_START()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DELETE_END()
+#define	LIBMEMCACHED_MEMCACHED_DELETE_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DELETE_START()
+#define	LIBMEMCACHED_MEMCACHED_DELETE_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_END()
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_START()
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_GET_END()
+#define	LIBMEMCACHED_MEMCACHED_GET_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_GET_START()
+#define	LIBMEMCACHED_MEMCACHED_GET_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_END()
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_START()
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_END()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_START()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_MGET_END()
+#define	LIBMEMCACHED_MEMCACHED_MGET_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_MGET_START()
+#define	LIBMEMCACHED_MEMCACHED_MGET_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_END()
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_START()
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_END()
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_START()
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SET_END()
+#define	LIBMEMCACHED_MEMCACHED_SET_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SET_START()
+#define	LIBMEMCACHED_MEMCACHED_SET_START_ENABLED() (0)
+
+#endif
+
+#endif	/* LIBMEMCACHED_PROBES_H */