memcached 0.18.0 → 0.19.pre

data/CHANGELOG

@@ -1,5 +1,7 @@
 
-v0.18.0. Make Memcached::Rails compatible with Rails 2.3.2 (Ian Fung).
+v0.19.pre. Support dynamic setting of the namespace (mhat). Support SASL (seanlynch).
+
+v0.18. Make Memcached::Rails compatible with Rails 2.3.2 (Ian Fung).
 
 v0.17.7. Disable dependency tracking.
 

data/Manifest

@@ -10,7 +10,9 @@ ext/libmemcached-0.32.tar.gz
 ext/libmemcached.patch
 ext/rlibmemcached.i
 ext/rlibmemcached_wrap.c
+ext/sasl.patch
 lib/memcached.rb
+lib/memcached/auth.rb
 lib/memcached/behaviors.rb
 lib/memcached/exceptions.rb
 lib/memcached/integer.rb

data/README

@@ -7,7 +7,7 @@ An interface to the libmemcached C client.
 
 Copyright 2009 Cloudburst, LLC. Licensed under the AFL 3. See the included LICENSE file. Portions copyright 2007-2009 TangentOrg, Brian Aker, licensed under the BSD license, and used with permission.
 
-The public certificate for this gem is here[http://rubyforge.org/frs/download.php/25331/evan_weaver-original-public_cert.pem]. 
+The public certificate for this gem is here[http://blog.evanweaver.com/files/evan_weaver-original-public_cert.pem]. 
 
 If you use this software, please {make a donation}[http://blog.evanweaver.com/donate/], or {recommend Evan}[http://www.workingwithrails.com/person/7739-evan-weaver] at Working with Rails.
 
@@ -101,7 +101,7 @@ There is a compatibility wrapper for legacy applications called Memcached::Rails
 
 == Reporting problems
 
-The support forum is here[http://rubyforge.org/forum/forum.php?forum_id=20894].
+The support forum is here[http://github.com/fauna/memcached/issues].
 
 Patches and contributions are very welcome. Please note that contributors are required to assign copyright for their additions to Cloudburst, LLC.
 

data/ext/extconf.rb

@@ -5,19 +5,20 @@ HERE = File.expand_path(File.dirname(__FILE__))
 BUNDLE = Dir.glob("libmemcached-*.tar.gz").first
 BUNDLE_PATH = BUNDLE.sub(".tar.gz", "")
 
+$CFLAGS = "#{RbConfig::CONFIG['CFLAGS']} #{$CFLAGS}".gsub("$(cflags)", "").gsub("-fno-common", "")
+$LDFLAGS = "#{RbConfig::CONFIG['LDFLAGS']} #{$LDFLAGS}".gsub("$(ldflags)", "").gsub("-fno-common", "")
+$CXXFLAGS = " -std=gnu++98 #{$CFLAGS}"
+$CPPFLAGS = $ARCH_FLAG = $DLDFLAGS = ""
+
 if ENV['DEBUG']
   puts "Setting debug flags."
   $CFLAGS << " -O0 -ggdb -DHAVE_DEBUG"
-  $EXTRA_CONF = " --enable-debug"
+  $EXTRA_CONF = ""
 end
 
-$CFLAGS = "#{RbConfig::CONFIG['CFLAGS']} #{$CFLAGS}".gsub("$(cflags)", "")
-$LDFLAGS = "#{RbConfig::CONFIG['LDFLAGS']} #{$LDFLAGS}".gsub("$(ldflags)", "")
-$CXXFLAGS = " -std=gnu++98"
-$CPPFLAGS = $ARCH_FLAG = $DLDFLAGS = ""
-
 if !ENV["EXTERNAL_LIB"]
   $includes = " -I#{HERE}/include"
+  $defines = " -DLIBMEMCACHED_WITH_SASL_SUPPORT"
   $libraries = " -L#{HERE}/lib"
   $CFLAGS = "#{$includes} #{$libraries} #{$CFLAGS}"
   $LDFLAGS = "#{$libraries} #{$LDFLAGS}"
@@ -31,17 +32,22 @@ if !ENV["EXTERNAL_LIB"]
       puts "Building libmemcached."
       puts(cmd = "tar xzf #{BUNDLE} 2>&1")
       raise "'#{cmd}' failed" unless system(cmd)
-      
-      puts "Patching libmemcached."
+
+      puts "Patching libmemcached source."
       puts(cmd = "patch -p1 < libmemcached.patch")
       raise "'#{cmd}' failed" unless system(cmd)
 
+      puts "Patching libmemcached with SASL support."
+      puts(cmd = "patch -p1 < sasl.patch")
+      raise "'#{cmd}' failed" unless system(cmd)
+
       Dir.chdir(BUNDLE_PATH) do        
         puts(cmd = "env CFLAGS='-fPIC #{$CFLAGS}' LDFLAGS='-fPIC #{$LDFLAGS}' ./configure --prefix=#{HERE} --without-memcached --disable-shared --disable-utils --disable-dependency-tracking #{$EXTRA_CONF} 2>&1")
-        
         raise "'#{cmd}' failed" unless system(cmd)
+
         puts(cmd = "make CXXFLAGS='#{$CXXFLAGS}' || true 2>&1")
         raise "'#{cmd}' failed" unless system(cmd)
+        
         puts(cmd = "make install || true 2>&1")
         raise "'#{cmd}' failed" unless system(cmd)
       end
@@ -55,12 +61,14 @@ if !ENV["EXTERNAL_LIB"]
     system("cp -f libmemcached.a libmemcached_gem.a") 
     system("cp -f libmemcached.la libmemcached_gem.la") 
   end
-  $LIBS << " -lmemcached_gem"
+  $LIBS << " -lmemcached_gem -lsasl2"
 end
 
 if ENV['SWIG']
   puts "Running SWIG."
-  puts(cmd = "swig #{$includes} -ruby -autorename rlibmemcached.i")
+  puts(cmd = "swig #{$defines} #{$includes} -ruby -autorename rlibmemcached.i")
+  raise "'#{cmd}' failed" unless system(cmd)
+  puts(cmd = "sed -i '' 's/STR2CSTR/StringValuePtr/' rlibmemcached_wrap.c")
   raise "'#{cmd}' failed" unless system(cmd)
 end
 

data/ext/rlibmemcached.i

@@ -64,7 +64,11 @@
 
 // Void type strings without lengths for prefix_key callback
 %typemap(in) (void *data) {
- $1 = STR2CSTR($input);
+  if ( (size_t) RSTRING_LEN($input) == 0) {
+    $1 = NULL;
+  } else {
+    $1 = STR2CSTR($input);
+  }
 };
 
 %apply (const char *str, size_t len) {
@@ -98,6 +102,12 @@
  $result = UINT2NUM($1);
 };
 
+// Void type strings without lengths for prefix_key callback
+// Currently not used by the gem
+%typemap(out) (void *) {
+ $result = rb_str_new2($1);
+};
+
 // String for memcached_fetch
 %typemap(in, numinputs=0) (char *key, size_t *key_length) {
   char string[256];
@@ -133,6 +143,7 @@
 %include "libmemcached/memcached_storage.h"
 %include "libmemcached/memcached_result.h"
 %include "libmemcached/memcached_server.h"
+%include "libmemcached/memcached_sasl.h"
 
 //// Custom C functions
 
@@ -210,3 +221,10 @@ VALUE memcached_generate_hash_rvalue(const char *key, size_t key_length,memcache
 };
 %}
 
+// Initialization for SASL
+%init %{
+  if (sasl_client_init(NULL) != SASL_OK) {
+    fprintf(stderr, "Failed to initialized SASL.\n");
+  }
+%}
+

data/ext/rlibmemcached_wrap.c

@@ -1814,11 +1814,11 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_memcached_trigger_delete_key swig_types[25]
 #define SWIGTYPE_p_memcached_trigger_key swig_types[26]
 #define SWIGTYPE_p_p_char swig_types[27]
-#define SWIGTYPE_p_size_t swig_types[28]
-#define SWIGTYPE_p_time_t swig_types[29]
-#define SWIGTYPE_p_uint32_t swig_types[30]
-#define SWIGTYPE_p_uint64_t swig_types[31]
-#define SWIGTYPE_p_void swig_types[32]
+#define SWIGTYPE_p_sasl_callback_t swig_types[28]
+#define SWIGTYPE_p_size_t swig_types[29]
+#define SWIGTYPE_p_time_t swig_types[30]
+#define SWIGTYPE_p_uint32_t swig_types[31]
+#define SWIGTYPE_p_uint64_t swig_types[32]
 static swig_type_info *swig_types[34];
 static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
@@ -1978,7 +1978,7 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
     #if defined(StringValuePtr)
     char *cstr = StringValuePtr(obj); 
     #else
-    char *cstr = STR2CSTR(obj);
+    char *cstr = StringValuePtr(obj);
     #endif
     size_t size = RSTRING_LEN(obj) + 1;
     if (cptr)  {
@@ -5645,7 +5645,9 @@ _wrap_MemcachedSt_user_data_get(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (struct memcached_st *)(argp1);
   result = (void *) ((arg1)->user_data);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  {
+    vresult = rb_str_new2(result);
+  }
   return vresult;
 fail:
   return Qnil;
@@ -6692,6 +6694,59 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_MemcachedSt_sasl_callbacks_set(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  sasl_callback_t *arg2 = (sasl_callback_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","sasl_callbacks", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_sasl_callback_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "sasl_callback_t const *","sasl_callbacks", 2, argv[0] )); 
+  }
+  arg2 = (sasl_callback_t *)(argp2);
+  if (arg1) (arg1)->sasl_callbacks = (sasl_callback_t const *)arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MemcachedSt_sasl_callbacks_get(int argc, VALUE *argv, VALUE self) {
+  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  sasl_callback_t *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","sasl_callbacks", 1, self )); 
+  }
+  arg1 = (struct memcached_st *)(argp1);
+  result = (sasl_callback_t *) ((arg1)->sasl_callbacks);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sasl_callback_t, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
 _wrap_MemcachedSt_allocate(VALUE self) {
@@ -6861,7 +6916,7 @@ _wrap_memcached_delete(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
@@ -6904,7 +6959,7 @@ _wrap_memcached_increment(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
@@ -6952,7 +7007,7 @@ _wrap_memcached_decrement(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
@@ -7004,7 +7059,7 @@ _wrap_memcached_increment_with_initial(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
@@ -7079,7 +7134,7 @@ _wrap_memcached_decrement_with_initial(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
@@ -7456,7 +7511,7 @@ _wrap_memcached_generate_hash_value(int argc, VALUE *argv, VALUE self) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   {
-    arg1 = STR2CSTR(argv[0]);
+    arg1 = StringValuePtr(argv[0]);
     arg2 = (size_t) RSTRING_LEN(argv[0]);
   }
   ecode3 = SWIG_AsVal_int(argv[1], &val3);
@@ -7493,7 +7548,7 @@ _wrap_memcached_generate_hash(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   result = memcached_generate_hash(arg1,(char const *)arg2,arg3);
@@ -8141,7 +8196,7 @@ _wrap_memcached_delete_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
@@ -8230,7 +8285,11 @@ _wrap_memcached_callback_set(int argc, VALUE *argv, VALUE self) {
   } 
   arg2 = (memcached_callback)(val2);
   {
-    arg3 = STR2CSTR(argv[2]);
+    if ( (size_t) RSTRING_LEN(argv[2]) == 0) {
+      arg3 = NULL;
+    } else {
+      arg3 = StringValuePtr(argv[2]);
+    }
   }
   result = (memcached_return)memcached_callback_set(arg1,arg2,arg3);
   vresult = SWIG_From_int((int)(result));
@@ -8269,7 +8328,9 @@ _wrap_memcached_callback_get(int argc, VALUE *argv, VALUE self) {
   } 
   arg2 = (memcached_callback)(val2);
   result = (void *)memcached_callback_get(arg1,arg2,arg3);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  {
+    vresult = rb_str_new2(result);
+  }
   if (SWIG_IsTmpObj(res3)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_unsigned_SS_short((*arg3)));
   } else {
@@ -8484,7 +8545,9 @@ _wrap_memcached_get_user_data(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   result = (void *)memcached_get_user_data(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  {
+    vresult = rb_str_new2(result);
+  }
   return vresult;
 fail:
   return Qnil;
@@ -8509,10 +8572,16 @@ _wrap_memcached_set_user_data(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    if ( (size_t) RSTRING_LEN(argv[1]) == 0) {
+      arg2 = NULL;
+    } else {
+      arg2 = StringValuePtr(argv[1]);
+    }
   }
   result = (void *)memcached_set_user_data(arg1,arg2);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  {
+    vresult = rb_str_new2(result);
+  }
   return vresult;
 fail:
   return Qnil;
@@ -8574,7 +8643,7 @@ _wrap_memcached_get(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   result = (char *)memcached_get(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
@@ -8675,7 +8744,7 @@ _wrap_memcached_get_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   result = (char *)memcached_get_by_key(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8);
@@ -8895,11 +8964,11 @@ _wrap_memcached_set(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg4 = STR2CSTR(argv[2]);
+    arg4 = StringValuePtr(argv[2]);
     arg5 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -8946,11 +9015,11 @@ _wrap_memcached_add(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg4 = STR2CSTR(argv[2]);
+    arg4 = StringValuePtr(argv[2]);
     arg5 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -8997,11 +9066,11 @@ _wrap_memcached_replace(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg4 = STR2CSTR(argv[2]);
+    arg4 = StringValuePtr(argv[2]);
     arg5 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9048,11 +9117,11 @@ _wrap_memcached_append(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg4 = STR2CSTR(argv[2]);
+    arg4 = StringValuePtr(argv[2]);
     arg5 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9099,11 +9168,11 @@ _wrap_memcached_prepend(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg4 = STR2CSTR(argv[2]);
+    arg4 = StringValuePtr(argv[2]);
     arg5 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9153,11 +9222,11 @@ _wrap_memcached_cas(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg4 = STR2CSTR(argv[2]);
+    arg4 = StringValuePtr(argv[2]);
     arg5 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9211,11 +9280,11 @@ _wrap_memcached_set_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg6 = STR2CSTR(argv[2]);
+    arg6 = StringValuePtr(argv[2]);
     arg7 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9264,11 +9333,11 @@ _wrap_memcached_add_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg6 = STR2CSTR(argv[2]);
+    arg6 = StringValuePtr(argv[2]);
     arg7 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9317,11 +9386,11 @@ _wrap_memcached_replace_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg6 = STR2CSTR(argv[2]);
+    arg6 = StringValuePtr(argv[2]);
     arg7 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9370,11 +9439,11 @@ _wrap_memcached_prepend_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg6 = STR2CSTR(argv[2]);
+    arg6 = StringValuePtr(argv[2]);
     arg7 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9423,11 +9492,11 @@ _wrap_memcached_append_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg6 = STR2CSTR(argv[2]);
+    arg6 = StringValuePtr(argv[2]);
     arg7 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -9479,11 +9548,11 @@ _wrap_memcached_cas_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg4 = arg2 = STR2CSTR(argv[1]);
+    arg4 = arg2 = StringValuePtr(argv[1]);
     arg5 = arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   {
-    arg6 = STR2CSTR(argv[2]);
+    arg6 = StringValuePtr(argv[2]);
     arg7 = (size_t) RSTRING_LEN(argv[2]);
   }
   {
@@ -11697,7 +11766,7 @@ _wrap_memcached_server_by_key(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   result = (memcached_server_st *)memcached_server_by_key(arg1,(char const *)arg2,arg3,arg4);
@@ -11977,6 +12046,153 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_memcached_set_sasl_callbacks(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  sasl_callback_t *arg2 = (sasl_callback_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set_sasl_callbacks", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_sasl_callback_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "sasl_callback_t const *","memcached_set_sasl_callbacks", 2, argv[1] )); 
+  }
+  arg2 = (sasl_callback_t *)(argp2);
+  memcached_set_sasl_callbacks(arg1,(sasl_callback_t const *)arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_memcached_set_sasl_auth_data(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  memcached_return result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_set_sasl_auth_data", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","memcached_set_sasl_auth_data", 2, argv[1] ));
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","memcached_set_sasl_auth_data", 3, argv[2] ));
+  }
+  arg3 = (char *)(buf3);
+  result = (memcached_return)memcached_set_sasl_auth_data(arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  return vresult;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_memcached_destroy_sasl_auth_data(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  memcached_return result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_destroy_sasl_auth_data", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  result = (memcached_return)memcached_destroy_sasl_auth_data(arg1);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_memcached_get_sasl_callbacks(int argc, VALUE *argv, VALUE self) {
+  memcached_st *arg1 = (memcached_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  sasl_callback_t *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_st *","memcached_get_sasl_callbacks", 1, argv[0] )); 
+  }
+  arg1 = (memcached_st *)(argp1);
+  result = (sasl_callback_t *)memcached_get_sasl_callbacks(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sasl_callback_t, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_memcached_sasl_authenticate_connection(int argc, VALUE *argv, VALUE self) {
+  memcached_server_st *arg1 = (memcached_server_st *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  memcached_return result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_memcached_server_st, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "memcached_server_st *","memcached_sasl_authenticate_connection", 1, argv[0] )); 
+  }
+  arg1 = (memcached_server_st *)(argp1);
+  result = (memcached_return)memcached_sasl_authenticate_connection(arg1);
+  vresult = SWIG_From_int((int)(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_memcached_get_rvalue(int argc, VALUE *argv, VALUE self) {
   memcached_st *arg1 = (memcached_st *) 0 ;
@@ -12004,7 +12220,7 @@ _wrap_memcached_get_rvalue(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = (memcached_st *)(argp1);
   {
-    arg2 = STR2CSTR(argv[1]);
+    arg2 = StringValuePtr(argv[1]);
     arg3 = (size_t) RSTRING_LEN(argv[1]);
   }
   result = (VALUE)memcached_get_rvalue(arg1,(char const *)arg2,arg3,arg4,arg5);
@@ -12222,7 +12438,7 @@ _wrap_memcached_generate_hash_rvalue(int argc, VALUE *argv, VALUE self) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   {
-    arg1 = STR2CSTR(argv[0]);
+    arg1 = StringValuePtr(argv[0]);
     arg2 = (size_t) RSTRING_LEN(argv[0]);
   }
   ecode3 = SWIG_AsVal_int(argv[1], &val3);
@@ -12269,11 +12485,11 @@ static swig_type_info _swigt__p_memcached_string_st = {"_p_memcached_string_st",
 static swig_type_info _swigt__p_memcached_trigger_delete_key = {"_p_memcached_trigger_delete_key", "memcached_trigger_delete_key *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_memcached_trigger_key = {"_p_memcached_trigger_key", "memcached_trigger_key *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_sasl_callback_t = {"_p_sasl_callback_t", "sasl_callback_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_addrinfo,
@@ -12304,11 +12520,11 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_memcached_trigger_delete_key,
   &_swigt__p_memcached_trigger_key,
   &_swigt__p_p_char,
+  &_swigt__p_sasl_callback_t,
   &_swigt__p_size_t,
   &_swigt__p_time_t,
   &_swigt__p_uint32_t,
   &_swigt__p_uint64_t,
-  &_swigt__p_void,
 };
 
 static swig_cast_info _swigc__p_addrinfo[] = {  {&_swigt__p_addrinfo, 0, 0, 0},{0, 0, 0, 0}};
@@ -12339,11 +12555,11 @@ static swig_cast_info _swigc__p_memcached_string_st[] = {  {&_swigt__p_memcached
 static swig_cast_info _swigc__p_memcached_trigger_delete_key[] = {  {&_swigt__p_memcached_trigger_delete_key, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_memcached_trigger_key[] = {  {&_swigt__p_memcached_trigger_key, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_sasl_callback_t[] = {  {&_swigt__p_sasl_callback_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_time_t[] = {  {&_swigt__p_time_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_uint32_t[] = {  {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_uint64_t[] = {  {&_swigt__p_uint64_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_addrinfo,
@@ -12374,11 +12590,11 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_memcached_trigger_delete_key,
   _swigc__p_memcached_trigger_key,
   _swigc__p_p_char,
+  _swigc__p_sasl_callback_t,
   _swigc__p_size_t,
   _swigc__p_time_t,
   _swigc__p_uint32_t,
   _swigc__p_uint64_t,
-  _swigc__p_void,
 };
 
 
@@ -12808,6 +13024,8 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices", _wrap_MemcachedSt_live_host_indices_get, -1);
   rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices_size=", _wrap_MemcachedSt_live_host_indices_size_set, -1);
   rb_define_method(SwigClassMemcachedSt.klass, "live_host_indices_size", _wrap_MemcachedSt_live_host_indices_size_get, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "sasl_callbacks=", _wrap_MemcachedSt_sasl_callbacks_set, -1);
+  rb_define_method(SwigClassMemcachedSt.klass, "sasl_callbacks", _wrap_MemcachedSt_sasl_callbacks_get, -1);
   SwigClassMemcachedSt.mark = 0;
   SwigClassMemcachedSt.destroy = (void (*)(void *)) memcached_free;
   SwigClassMemcachedSt.trackObjects = 0;
@@ -12907,6 +13125,9 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_const(mRlibmemcached, "MEMCACHED_INVALID_HOST_PROTOCOL", SWIG_From_int((int)(MEMCACHED_INVALID_HOST_PROTOCOL)));
   rb_define_const(mRlibmemcached, "MEMCACHED_SERVER_MARKED_DEAD", SWIG_From_int((int)(MEMCACHED_SERVER_MARKED_DEAD)));
   rb_define_const(mRlibmemcached, "MEMCACHED_UNKNOWN_STAT_KEY", SWIG_From_int((int)(MEMCACHED_UNKNOWN_STAT_KEY)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_AUTH_PROBLEM", SWIG_From_int((int)(MEMCACHED_AUTH_PROBLEM)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_AUTH_FAILURE", SWIG_From_int((int)(MEMCACHED_AUTH_FAILURE)));
+  rb_define_const(mRlibmemcached, "MEMCACHED_AUTH_CONTINUE", SWIG_From_int((int)(MEMCACHED_AUTH_CONTINUE)));
   rb_define_const(mRlibmemcached, "MEMCACHED_MAXIMUM_RETURN", SWIG_From_int((int)(MEMCACHED_MAXIMUM_RETURN)));
   rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_MODULA", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_MODULA)));
   rb_define_const(mRlibmemcached, "MEMCACHED_DISTRIBUTION_CONSISTENT", SWIG_From_int((int)(MEMCACHED_DISTRIBUTION_CONSISTENT)));
@@ -13080,11 +13301,21 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_module_function(mRlibmemcached, "memcached_server_clone", _wrap_memcached_server_clone, -1);
   rb_define_module_function(mRlibmemcached, "memcached_analyze", _wrap_memcached_analyze, -1);
   rb_define_module_function(mRlibmemcached, "memcached_server_remove", _wrap_memcached_server_remove, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_set_sasl_callbacks", _wrap_memcached_set_sasl_callbacks, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_set_sasl_auth_data", _wrap_memcached_set_sasl_auth_data, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_destroy_sasl_auth_data", _wrap_memcached_destroy_sasl_auth_data, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_get_sasl_callbacks", _wrap_memcached_get_sasl_callbacks, -1);
+  rb_define_module_function(mRlibmemcached, "memcached_sasl_authenticate_connection", _wrap_memcached_sasl_authenticate_connection, -1);
   rb_define_module_function(mRlibmemcached, "memcached_get_rvalue", _wrap_memcached_get_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_fetch_rvalue", _wrap_memcached_fetch_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_stat_get_rvalue", _wrap_memcached_stat_get_rvalue, -1);
   rb_define_module_function(mRlibmemcached, "memcached_select_server_at", _wrap_memcached_select_server_at, -1);
   rb_define_module_function(mRlibmemcached, "memcached_select_stat_at", _wrap_memcached_select_stat_at, -1);
   rb_define_module_function(mRlibmemcached, "memcached_generate_hash_rvalue", _wrap_memcached_generate_hash_rvalue, -1);
+  
+  if (sasl_client_init(NULL) != SASL_OK) {
+    fprintf(stderr, "Failed to initialized SASL.\n");
+  }
+  
 }