Merge lp:~trond-norbye/libmemcached/mingw32 into lp:~tangent-org/libmemcached/trunk

[Trond Norbye]

Changes required to build libmemcached on win64 (using cross compiliation)

[lp:~trond-norbye/libmemcached/mingw32]

895. By Trond Norbye on 2010-08-02

Fix ntohll test.. we need to link, not just compile ;-)

896. By Trond Norbye on 2010-08-02

Remove impossible assert

The Sun Studio compiler generates an error because it's impossible to get
there.

897. By Trond Norbye on 2010-08-13

Add option -P and -T to memcapable

The two options come in handy if you're trying to debug a failing test case

898. By Trond Norbye on 2010-08-13

Update memcapable quiet command test to work with servers that cork

899. By Trond Norbye <trond@ubuntu> on 2010-08-24

Check the return code from fgets in memcapable

900. By Trond Norbye on 2010-09-11

Fixed test in memcached_set_sasl_auth_data

901. By Trond Norbye on 2010-09-13

Fixed SASL authentication bits

902. By Trond Norbye on 2010-09-13

Refactor: rename __write_vector_st

Symbol names with double underscores generate a compile warning on
some platforms causing a build break. Renamed to
libmemcached_io_vector_st.

903. By Trond Norbye on 2010-09-13

Don't include system headers within an extern C block

904. By Trond Norbye on 2010-09-13

Refactor: Renamed internal stack dump function

Some compilers generate a warning for symbols starting with double
underscores causing a build break. Renamed the function to
libmemcached_stack_dump instead, and added an implementation for
Solaris while I'm touching the code

905. By Trond Norbye on 2010-09-13

Update libmemcached version number due to change of struct size

906. By Trond Norbye on 2010-09-14

Fixed dtrace enabled compilations

=== modified file '.bzrignore'
--- .bzrignore	2010-08-01 21:13:16 +0000
+++ .bzrignore	2010-09-14 07:57:51 +0000
@@ -72,6 +72,7 @@
 libmemcached-?.??/
 libmemcached.pop
 libmemcached/configure.h
+libmemcached/dtrace_probes.h
 libmemcached/memcached_configure.h
 libmemcached_examples.pop
 libmemcachedutil.pop

=== modified file 'clients/memcapable.c'
--- clients/memcapable.c	2010-07-28 18:48:18 +0000
+++ clients/memcapable.c	2010-09-14 07:57:51 +0000
@@ -303,6 +303,7 @@
     ssize_t nr= timeout_io_op(sock, POLLIN, ((char*) buf) + offset, len - offset);
     switch (nr) {
     case -1 :
+       fprintf(stderr, "Errno: %d %s\n", get_socket_errno(), strerror(errno));
       verify(get_socket_errno() == EINTR || get_socket_errno() == EAGAIN);
       break;
     case 0:
@@ -321,7 +322,7 @@
  */
 static enum test_return recv_packet(response *rsp)
 {
-  execute(retry_read(rsp, sizeof (protocol_binary_response_no_extras)));
+  execute(retry_read(rsp, sizeof(protocol_binary_response_no_extras)));
 
   /* Fix the byte order in the packet header */
   rsp->plain.message.header.response.keylen=
@@ -693,10 +694,12 @@
   cmd.plain.message.header.request.cas=
           htonll(rsp.plain.message.header.response.cas - 1);
   execute(resend_packet(&cmd));
+  execute(send_binary_noop());
   execute(recv_packet(&rsp));
   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
+  execute(receive_binary_noop());
 
-  return test_binary_noop();
+  return TEST_PASS;
 }
 
 static enum test_return test_binary_set(void)
@@ -733,7 +736,9 @@
       else
         expected_result= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
 
+      execute(send_binary_noop());
       execute(recv_packet(&rsp));
+      execute(receive_binary_noop());
       verify(validate_response_header(&rsp, cc, expected_result));
     }
     else
@@ -790,7 +795,9 @@
       else
         expected_result=PROTOCOL_BINARY_RESPONSE_SUCCESS;
 
+      execute(send_binary_noop());
       execute(recv_packet(&rsp));
+      execute(receive_binary_noop());
       verify(validate_response_header(&rsp, cc, expected_result));
 
       if (ii == 0)
@@ -817,7 +824,9 @@
   cmd.plain.message.header.request.cas=
           htonll(rsp.plain.message.header.response.cas - 1);
   execute(resend_packet(&cmd));
+  execute(send_binary_noop());
   execute(recv_packet(&rsp));
+  execute(receive_binary_noop());
   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
 
   return TEST_PASS;
@@ -841,8 +850,10 @@
 
   /* The delete shouldn't work the first time, because the item isn't there */
   execute(send_packet(&cmd));
+  execute(send_binary_noop());
   execute(recv_packet(&rsp));
   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
+  execute(receive_binary_noop());
   execute(binary_set_item(key, key));
 
   /* The item should be present now, resend*/
@@ -1869,8 +1880,10 @@
   const char *hostname= "localhost";
   const char *port= "11211";
   int cmd;
+  bool prompt= false;
+  const char *testname= NULL;
 
-  while ((cmd= getopt(argc, argv, "t:vch:p:?")) != EOF)
+  while ((cmd= getopt(argc, argv, "t:vch:p:PT:?")) != EOF)
   {
     switch (cmd) {
     case 't':
@@ -1889,11 +1902,21 @@
       break;
     case 'p': port= optarg;
       break;
+    case 'P': prompt= true;
+      break;
+    case 'T': testname= optarg;
+       break;
     default:
-      fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n]\n"
+      fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n]"
+              " [-P] [-T testname]'\n"
               "\t-c\tGenerate coredump if a test fails\n"
               "\t-v\tVerbose test output (print out the assertion)\n"
-              "\t-t n\tSet the timeout for io-operations to n seconds\n",
+              "\t-t n\tSet the timeout for io-operations to n seconds\n"
+              "\t-P\tPrompt the user before starting a test.\n"
+              "\t\t\t\"skip\" will skip the test\n"
+              "\t\t\t\"quit\" will terminate memcapable\n"
+              "\t\t\tEverything else will start the test\n"
+              "\t-T n\tJust run the test named n\n",
               argv[0]);
       return 1;
     }
@@ -1910,10 +1933,33 @@
 
   for (int ii= 0; testcases[ii].description != NULL; ++ii)
   {
+    if (testname != NULL && strcmp(testcases[ii].description, testname) != 0)
+       continue;
+
     ++total;
     fprintf(stdout, "%-40s", testcases[ii].description);
     fflush(stdout);
 
+    if (prompt)
+    {
+      fprintf(stdout, "\nPress <return> when you are ready? ");
+      char buffer[80] = {0};
+      if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
+        if (strncmp(buffer, "skip", 4) == 0)
+        {
+          fprintf(stdout, "%-40s%s\n", testcases[ii].description,
+                  status_msg[TEST_SKIP]);
+          fflush(stdout);
+          continue;
+        }
+        if (strncmp(buffer, "quit", 4) == 0)
+          exit(0);
+      }
+
+      fprintf(stdout, "%-40s", testcases[ii].description);
+      fflush(stdout);
+    }
+
     bool reconnect= false;
     enum test_return ret= testcases[ii].function();
     if (ret == TEST_FAIL)

=== modified file 'configure.ac'
--- configure.ac	2010-08-02 18:33:16 +0000
+++ configure.ac	2010-09-14 07:57:51 +0000
@@ -16,7 +16,11 @@
 #shared library versioning
 MEMCACHED_UTIL_LIBRARY_VERSION=1:0:0
 MEMCACHED_PROTOCAL_LIBRARY_VERSION=0:0:0
+<<<<<<< TREE
 MEMCACHED_LIBRARY_VERSION=5:2:0
+=======
+MEMCACHED_LIBRARY_VERSION=6:0:0
+>>>>>>> MERGE-SOURCE
 #                         | | |
 #                  +------+ | +---+
 #                  |        |     |

=== modified file 'libhashkit/common.h'
--- libhashkit/common.h	2010-01-21 02:06:18 +0000
+++ libhashkit/common.h	2010-09-14 07:57:51 +0000
@@ -9,10 +9,6 @@
 #ifndef HASHKIT_COMMON_H
 #define HASHKIT_COMMON_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "config.h"
 
 #include <assert.h>
@@ -23,6 +19,10 @@
 
 #include "hashkit.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 HASHKIT_LOCAL
 void md5_signature(const unsigned char *key, unsigned int length, unsigned char *result);
 

=== modified file 'libmemcached/auto.c'
--- libmemcached/auto.c	2010-04-02 19:55:21 +0000
+++ libmemcached/auto.c	2010-09-14 07:57:51 +0000
@@ -60,7 +60,7 @@
   {
     *value= 0;
     rc= MEMCACHED_PROTOCOL_ERROR;
-  } 
+  }
   else if (! strncmp(buffer, "CLIENT_ERROR\r\n", 14))
   {
     *value= 0;
@@ -116,12 +116,12 @@
   request.message.body.initial= htonll(initial);
   request.message.body.expiration= htonl((uint32_t) expiration);
 
-  struct __write_vector_st vector[]= 
+  struct libmemcached_io_vector_st vector[]=
   {
     { .length= sizeof(request.bytes), .buffer= request.bytes },
     { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
     { .length= key_length, .buffer= key }
-  }; 
+  };
 
   memcached_return_t rc;
   if ((rc= memcached_vdo(instance, vector, 3, true)) != MEMCACHED_SUCCESS)

=== modified file 'libmemcached/connect.c'
--- libmemcached/connect.c	2010-07-27 22:38:51 +0000
+++ libmemcached/connect.c	2010-09-14 07:57:51 +0000
@@ -80,7 +80,6 @@
         return MEMCACHED_ERRNO;
       }
     }
-    WATCHPOINT_ASSERT(0); // Programming error
   }
 
   // This should only be possible from ERESTART or EINTR;
@@ -537,7 +536,7 @@
   case MEMCACHED_CONNECTION_TCP:
     rc= network_connect(ptr);
 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-    if (ptr->fd != INVALID_SOCKET && ptr->root->sasl && ptr->root->sasl->callbacks)
+    if (ptr->fd != INVALID_SOCKET && ptr->root->sasl.callbacks)
     {
       rc= memcached_sasl_authenticate_connection(ptr);
       if (rc != MEMCACHED_SUCCESS)

=== modified file 'libmemcached/delete.c'
--- libmemcached/delete.c	2010-06-29 06:06:33 +0000
+++ libmemcached/delete.c	2010-09-14 07:57:51 +0000
@@ -175,12 +175,12 @@
       memcached_io_write(instance, NULL, 0, true);
   }
 
-  struct __write_vector_st vector[]= 
+  struct libmemcached_io_vector_st vector[]=
   {
     { .length= sizeof(request.bytes), .buffer= request.bytes},
     { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
     { .length= key_length, .buffer= key },
-  }; 
+  };
 
   memcached_return_t rc= MEMCACHED_SUCCESS;
 

=== modified file 'libmemcached/do.c'
--- libmemcached/do.c	2010-04-21 03:14:19 +0000
+++ libmemcached/do.c	2010-09-14 07:57:51 +0000
@@ -5,13 +5,13 @@
  * Use and distribution licensed under the BSD license.  See
  * the COPYING file in the parent directory for full text.
  *
- * Summary: 
+ * Summary:
  *
  */
 
 #include "common.h"
 
-memcached_return_t memcached_do(memcached_server_write_instance_st ptr, const void *command, 
+memcached_return_t memcached_do(memcached_server_write_instance_st ptr, const void *command,
                                 size_t command_length, bool with_flush)
 {
   memcached_return_t rc;
@@ -51,7 +51,7 @@
 }
 
 memcached_return_t memcached_vdo(memcached_server_write_instance_st ptr,
-                                 const struct __write_vector_st *vector, size_t count,
+                                 const struct libmemcached_io_vector_st *vector, size_t count,
                                  bool with_flush)
 {
   memcached_return_t rc;

=== modified file 'libmemcached/do.h'
--- libmemcached/do.h	2010-04-02 19:55:21 +0000
+++ libmemcached/do.h	2010-09-14 07:57:51 +0000
@@ -17,14 +17,14 @@
 #endif
 
 LIBMEMCACHED_LOCAL
-memcached_return_t memcached_do(memcached_server_write_instance_st ptr, 
+memcached_return_t memcached_do(memcached_server_write_instance_st ptr,
                                 const void *commmand,
                                 size_t command_length,
                                 bool with_flush);
 
 LIBMEMCACHED_LOCAL
 memcached_return_t memcached_vdo(memcached_server_write_instance_st ptr,
-                                 const struct __write_vector_st *vector, size_t count,
+                                 const struct libmemcached_io_vector_st *vector, size_t count,
                                  bool with_flush);
 
 #ifdef __cplusplus

=== modified file 'libmemcached/get.c'
--- libmemcached/get.c	2010-04-02 05:40:32 +0000
+++ libmemcached/get.c	2010-09-14 07:57:51 +0000
@@ -1,5 +1,5 @@
 /* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker 
+ * Copyright (C) 2006-2009 Brian Aker
  * All rights reserved.
  *
  * Use and distribution licensed under the BSD license.  See
@@ -227,13 +227,13 @@
 
     instance= memcached_server_instance_fetch(ptr, server_key);
 
-    struct __write_vector_st vector[]=  
-    { 
-      { .length= get_command_length, .buffer= get_command }, 
-      { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key }, 
-      { .length= key_length[x], .buffer= keys[x] }, 
-      { .length= 1, .buffer= " " } 
-    };  
+    struct libmemcached_io_vector_st vector[]=
+    {
+      { .length= get_command_length, .buffer= get_command },
+      { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
+      { .length= key_length[x], .buffer= keys[x] },
+      { .length= 1, .buffer= " " }
+    };
 
 
     if (memcached_server_response_count(instance) == 0)
@@ -399,12 +399,12 @@
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
     request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + ptr->prefix_key_length));
 
-    struct __write_vector_st vector[]= 
+    struct libmemcached_io_vector_st vector[]=
     {
       { .length= sizeof(request.bytes), .buffer= request.bytes },
       { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
       { .length= key_length[x], .buffer= keys[x] }
-    }; 
+    };
 
     if (memcached_io_writev(instance, vector, 3, flush) == -1)
     {
@@ -533,12 +533,12 @@
        * that we might have processed some of the responses etc. For now,
        * just make sure we work _correctly_
      */
-      struct __write_vector_st vector[]= 
+      struct libmemcached_io_vector_st vector[]=
       {
         { .length= sizeof(request.bytes), .buffer= request.bytes },
         { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
         { .length= key_length[x], .buffer= keys[x] }
-      }; 
+      };
 
       if (memcached_io_writev(instance, vector, 3, true) == -1)
       {

=== modified file 'libmemcached/include.am'
--- libmemcached/include.am	2010-07-28 17:42:50 +0000
+++ libmemcached/include.am	2010-09-14 07:57:51 +0000
@@ -172,5 +172,5 @@
 libmemcached/libmemcached_probes.o: libmemcached/libmemcached_probes.d ${libmemcached_libmemcached_la_OBJECTS} config.h
 
 .d.o:
-	$(DTRACE) $(DTRACEFLAGS) -o libmemcached/libmemcached_probes.o -G -s ${top_srcdir}/libmemcached/libmemcached_probes.d `grep '^pic_object' ${top_builddir}/libmemcached/*.lo | cut -f 2 -d\' | sed "s/^/${top_builddir}\//"`
+	$(DTRACE) $(DTRACEFLAGS) -o libmemcached/libmemcached_probes.o -G -s ${top_srcdir}/libmemcached/libmemcached_probes.d `grep '^pic_object' ${top_builddir}/libmemcached/*.lo | cut -f 2 -d\' | sed "s/^/${top_builddir}\/libmemcached\//"`
 

=== modified file 'libmemcached/io.c'
--- libmemcached/io.c	2010-08-03 03:54:30 +0000
+++ libmemcached/io.c	2010-09-14 07:57:51 +0000
@@ -440,7 +440,7 @@
 }
 
 ssize_t memcached_io_writev(memcached_server_write_instance_st ptr,
-                            const struct __write_vector_st *vector,
+                            const struct libmemcached_io_vector_st *vector,
                             size_t number_of, bool with_flush)
 {
   ssize_t total= 0;

=== modified file 'libmemcached/io.h'
--- libmemcached/io.h	2010-04-22 00:49:09 +0000
+++ libmemcached/io.h	2010-09-14 07:57:51 +0000
@@ -40,7 +40,7 @@
   uint16_t reserved;
 };
 
-struct __write_vector_st
+struct libmemcached_io_vector_st
 {
   size_t length;
   const void *buffer;
@@ -48,7 +48,7 @@
 
 LIBMEMCACHED_LOCAL
 ssize_t memcached_io_writev(memcached_server_write_instance_st ptr,
-                            const struct __write_vector_st *vector,
+                            const struct libmemcached_io_vector_st *vector,
                             size_t number_of, bool with_flush);
 
 LIBMEMCACHED_LOCAL

=== modified file 'libmemcached/memcached.c'
--- libmemcached/memcached.c	2010-04-21 03:14:19 +0000
+++ libmemcached/memcached.c	2010-09-14 07:57:51 +0000
@@ -92,7 +92,8 @@
   self->get_key_failure= NULL;
   self->delete_trigger= NULL;
   self->callbacks= NULL;
-  self->sasl= NULL;
+  self->sasl.callbacks= NULL;
+  self->sasl.is_allocated= false;
 
   return true;
 }
@@ -176,7 +177,7 @@
   if (ptr->continuum)
     libmemcached_free(ptr, ptr->continuum);
 
-  if (ptr->sasl)
+  if (ptr->sasl.callbacks)
   {
 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
     memcached_destroy_sasl_auth_data(ptr);
@@ -273,7 +274,7 @@
   }
 
 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-  if (source->sasl && source->sasl->callbacks)
+  if (source->sasl.callbacks)
   {
     if (memcached_clone_sasl(new_clone, source) != MEMCACHED_SUCCESS)
     {

=== modified file 'libmemcached/memcached.h'
--- libmemcached/memcached.h	2010-07-27 22:38:51 +0000
+++ libmemcached/memcached.h	2010-09-14 07:57:51 +0000
@@ -124,7 +124,7 @@
   memcached_trigger_key_fn get_key_failure;
   memcached_trigger_delete_key_fn delete_trigger;
   memcached_callback_st *callbacks;
-  struct memcached_sasl_st *sasl;
+  struct memcached_sasl_st sasl;
   char prefix_key[MEMCACHED_PREFIX_KEY_MAX_SIZE];
   struct {
     bool is_allocated:1;

=== modified file 'libmemcached/sasl.c'
--- libmemcached/sasl.c	2010-06-13 21:04:20 +0000
+++ libmemcached/sasl.c	2010-09-14 07:57:51 +0000
@@ -14,16 +14,13 @@
 void memcached_set_sasl_callbacks(memcached_st *ptr,
                                   const sasl_callback_t *callbacks)
 {
-  ptr->sasl->callbacks= callbacks;
-  ptr->sasl->is_allocated= false;
+  ptr->sasl.callbacks= callbacks;
+  ptr->sasl.is_allocated= false;
 }
 
 const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
 {
-  if (ptr->sasl)
-    return ptr->sasl->callbacks;
-
-  return NULL;
+  return ptr->sasl.callbacks;
 }
 
 /**
@@ -119,7 +116,7 @@
 
   sasl_conn_t *conn;
   int ret= sasl_client_new("memcached", server->hostname, laddr, raddr,
-			   server->root->sasl->callbacks, 0, &conn);
+			   server->root->sasl.callbacks, 0, &conn);
   if (ret != SASL_OK)
   {
     return MEMCACHED_AUTH_PROBLEM;
@@ -144,12 +141,12 @@
   do {
     /* send the packet */
 
-    struct __write_vector_st vector[]=  
-    { 
-      { .length= sizeof(request.bytes), .buffer= request.bytes }, 
-      { .length= keylen, .buffer= chosenmech }, 
-      { .length= len, .buffer= data } 
-    };  
+    struct libmemcached_io_vector_st vector[]=
+    {
+      { .length= sizeof(request.bytes), .buffer= request.bytes },
+      { .length= keylen, .buffer= chosenmech },
+      { .length= len, .buffer= data }
+    };
 
     if (memcached_io_writev(server, vector, 3, true) == -1)
     {
@@ -221,7 +218,7 @@
                                                 const char *password)
 {
   if (ptr == NULL || username == NULL ||
-      password == NULL || ptr->sasl->callbacks != NULL)
+      password == NULL || ptr->sasl.callbacks != NULL)
   {
     return MEMCACHED_FAILURE;
   }
@@ -252,62 +249,52 @@
   cb[2].context= secret;
   cb[3].id= SASL_CB_LIST_END;
 
-  ptr->sasl->callbacks= cb;
-  ptr->sasl->is_allocated= true;
+  ptr->sasl.callbacks= cb;
+  ptr->sasl.is_allocated= true;
 
   return MEMCACHED_SUCCESS;
 }
 
 memcached_return_t memcached_destroy_sasl_auth_data(memcached_st *ptr)
 {
-   if (ptr == NULL || ptr->sasl->callbacks == NULL)
+   if (ptr == NULL || ptr->sasl.callbacks == NULL)
    {
      return MEMCACHED_FAILURE;
    }
 
-   if (ptr->sasl->is_allocated)
+   if (ptr->sasl.is_allocated)
    {
-     libmemcached_free(ptr, ptr->sasl->callbacks[0].context);
-     libmemcached_free(ptr, ptr->sasl->callbacks[2].context);
-     libmemcached_free(ptr, (void*)ptr->sasl->callbacks);
-     ptr->sasl->is_allocated= false;
+     libmemcached_free(ptr, ptr->sasl.callbacks[0].context);
+     libmemcached_free(ptr, ptr->sasl.callbacks[2].context);
+     libmemcached_free(ptr, (void*)ptr->sasl.callbacks);
+     ptr->sasl.is_allocated= false;
    }
 
-   ptr->sasl->callbacks= NULL;
-   libmemcached_free(ptr, ptr->sasl);
-   ptr->sasl= NULL;
+   ptr->sasl.callbacks= NULL;
 
    return MEMCACHED_SUCCESS;
 }
 
 memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st *source)
 {
-  if (source->sasl == NULL)
+
+  if (source->sasl.callbacks == NULL)
   {
     return MEMCACHED_SUCCESS;
   }
-  else
-  {
-    clone->sasl= libmemcached_malloc(source, sizeof(struct memcached_sasl_st));
-
-    if (clone->sasl == NULL)
-    {
-      return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-    }
-  }
 
   /* Hopefully we are using our own callback mechanisms.. */
-  if (source->sasl->callbacks[0].id == SASL_CB_USER &&
-      source->sasl->callbacks[0].proc == get_username &&
-      source->sasl->callbacks[1].id == SASL_CB_AUTHNAME &&
-      source->sasl->callbacks[1].proc == get_username &&
-      source->sasl->callbacks[2].id == SASL_CB_PASS &&
-      source->sasl->callbacks[2].proc == get_password &&
-      source->sasl->callbacks[3].id == SASL_CB_LIST_END)
+  if (source->sasl.callbacks[0].id == SASL_CB_USER &&
+      source->sasl.callbacks[0].proc == get_username &&
+      source->sasl.callbacks[1].id == SASL_CB_AUTHNAME &&
+      source->sasl.callbacks[1].proc == get_username &&
+      source->sasl.callbacks[2].id == SASL_CB_PASS &&
+      source->sasl.callbacks[2].proc == get_password &&
+      source->sasl.callbacks[3].id == SASL_CB_LIST_END)
   {
-    sasl_secret_t *secret= source->sasl->callbacks[2].context;
+    sasl_secret_t *secret= source->sasl.callbacks[2].context;
     return memcached_set_sasl_auth_data(clone,
-                                        source->sasl->callbacks[0].context,
+                                        source->sasl.callbacks[0].context,
                                         (const char*)secret->data);
   }
 
@@ -318,9 +305,9 @@
    */
   size_t total= 0;
 
-  while (source->sasl->callbacks[total].id != SASL_CB_LIST_END)
+  while (source->sasl.callbacks[total].id != SASL_CB_LIST_END)
   {
-    switch (source->sasl->callbacks[total].id)
+    switch (source->sasl.callbacks[total].id)
     {
     case SASL_CB_USER:
     case SASL_CB_AUTHNAME:
@@ -339,38 +326,38 @@
   {
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
   }
-  memcpy(cb, source->sasl->callbacks, (total + 1) * sizeof(sasl_callback_t));
+  memcpy(cb, source->sasl.callbacks, (total + 1) * sizeof(sasl_callback_t));
 
   /* Now update the context... */
   for (size_t x= 0; x < total; ++x)
   {
     if (cb[x].id == SASL_CB_USER || cb[x].id == SASL_CB_AUTHNAME)
     {
-      cb[x].context= libmemcached_malloc(clone, strlen(source->sasl->callbacks[x].context));
+      cb[x].context= libmemcached_malloc(clone, strlen(source->sasl.callbacks[x].context));
 
       if (cb[x].context == NULL)
       {
         /* Failed to allocate memory, clean up previously allocated memory */
         for (size_t y= 0; y < x; ++y)
         {
-          libmemcached_free(clone, clone->sasl->callbacks[y].context);
+          libmemcached_free(clone, clone->sasl.callbacks[y].context);
         }
 
         libmemcached_free(clone, cb);
         return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
       }
-      strcpy(cb[x].context, source->sasl->callbacks[x].context);
+      strcpy(cb[x].context, source->sasl.callbacks[x].context);
     }
     else
     {
-      sasl_secret_t *src = source->sasl->callbacks[x].context;
+      sasl_secret_t *src = source->sasl.callbacks[x].context;
       sasl_secret_t *n = libmemcached_malloc(clone, src->len + 1 + sizeof(*n));
       if (n == NULL)
       {
         /* Failed to allocate memory, clean up previously allocated memory */
         for (size_t y= 0; y < x; ++y)
         {
-          libmemcached_free(clone, clone->sasl->callbacks[y].context);
+          libmemcached_free(clone, clone->sasl.callbacks[y].context);
         }
 
         libmemcached_free(clone, cb);
@@ -381,8 +368,8 @@
     }
   }
 
-  clone->sasl->callbacks= cb;
-  clone->sasl->is_allocated= true;
+  clone->sasl.callbacks= cb;
+  clone->sasl.is_allocated= true;
 
   return MEMCACHED_SUCCESS;
 }

=== modified file 'libmemcached/stats.c'
--- libmemcached/stats.c	2010-07-16 02:33:19 +0000
+++ libmemcached/stats.c	2010-09-14 07:57:51 +0000
@@ -258,11 +258,11 @@
     request.message.header.request.keylen= htons((uint16_t)len);
     request.message.header.request.bodylen= htonl((uint32_t) len);
 
-    struct __write_vector_st vector[]= 
+    struct libmemcached_io_vector_st vector[]=
     {
       { .length= sizeof(request.bytes), .buffer= request.bytes },
       { .length= len, .buffer= args }
-    }; 
+    };
 
     if (memcached_vdo(instance, vector, 2, true) != MEMCACHED_SUCCESS)
     {
@@ -302,7 +302,7 @@
         WATCHPOINT_ASSERT(0);
       }
     }
-    
+
     if (check && check->func)
     {
       size_t key_length= strlen(buffer);

=== modified file 'libmemcached/storage.c'
--- libmemcached/storage.c	2010-04-22 00:49:09 +0000
+++ libmemcached/storage.c	2010-09-14 07:57:51 +0000
@@ -155,12 +155,12 @@
     }
     else
     {
-      struct __write_vector_st vector[]= 
+      struct libmemcached_io_vector_st vector[]=
       {
         { .length= write_length, .buffer= buffer },
         { .length= value_length, .buffer= value },
         { .length= 2, .buffer= "\r\n" }
-      }; 
+      };
 
       if (ptr->flags.buffer_requests && verb == SET_OP)
       {
@@ -492,13 +492,13 @@
     }
   }
 
-  struct __write_vector_st vector[]= 
+  struct libmemcached_io_vector_st vector[]=
   {
     { .length= send_length, .buffer= request.bytes },
     { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
     { .length= key_length, .buffer= key },
     { .length= value_length, .buffer= value }
-  }; 
+  };
 
   /* write the header */
   memcached_return_t rc;

=== modified file 'libmemcached/watchpoint.h'
--- libmemcached/watchpoint.h	2010-04-22 00:49:09 +0000
+++ libmemcached/watchpoint.h	2010-09-14 07:57:51 +0000
@@ -16,7 +16,7 @@
 #if defined(DEBUG)
 
 #ifdef TARGET_OS_LINUX
-static inline void __stack_dump(void)
+static inline void libmemcached_stack_dump(void)
 {
   void *array[10];
   int size;
@@ -35,12 +35,21 @@
   fflush(stderr);
 }
 
+#elif defined(__sun)
+#include <ucontext.h>
+
+static inline void libmemcached_stack_dump(void)
+{
+   fflush(stderr);
+   printstack(fileno(stderr));
+}
+
 #else
 
-static inline void __stack_dump(void)
+static inline void libmemcached_stack_dump(void)
 { }
 
-#endif // __stack_dump()
+#endif // libmemcached_stack_dump()
 
 #include <assert.h>
 
@@ -53,9 +62,9 @@
 #define WATCHPOINT_LABELED_NUMBER(A,B) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s:%zu\n", __FILE__, __LINE__,__func__,(A),(size_t)(B));fflush(stdout); } while (0)
 #define WATCHPOINT_IF_LABELED_NUMBER(A,B,C) do { if(A) {fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s:%zu\n", __FILE__, __LINE__,__func__,(B),(size_t)(C));fflush(stdout);} } while (0)
 #define WATCHPOINT_ERRNO(A) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s\n", __FILE__, __LINE__,__func__, strerror(A));fflush(stdout); } while (0)
-#define WATCHPOINT_ASSERT_PRINT(A,B,C) do { if(!(A)){fprintf(stderr, "\nWATCHPOINT ASSERT %s:%d (%s) ", __FILE__, __LINE__,__func__);fprintf(stderr, (B),(C));fprintf(stderr,"\n");fflush(stdout); __stack_dump(); } assert((A)); } while (0)
-#define WATCHPOINT_ASSERT(A) do { if (! (A)) {__stack_dump();} assert((A)); } while (0)
-#define WATCHPOINT_ASSERT_INITIALIZED(A) do { if (! (A)) { __stack_dump(); } assert(memcached_is_initialized((A))); } while (0);
+#define WATCHPOINT_ASSERT_PRINT(A,B,C) do { if(!(A)){fprintf(stderr, "\nWATCHPOINT ASSERT %s:%d (%s) ", __FILE__, __LINE__,__func__);fprintf(stderr, (B),(C));fprintf(stderr,"\n");fflush(stdout); libmemcached_stack_dump(); } assert((A)); } while (0)
+#define WATCHPOINT_ASSERT(A) do { if (! (A)) {libmemcached_stack_dump();} assert((A)); } while (0)
+#define WATCHPOINT_ASSERT_INITIALIZED(A) do { if (! (A)) { libmemcached_stack_dump(); } assert(memcached_is_initialized((A))); } while (0);
 #define WATCHPOINT_SET(A) do { A; } while(0);
 
 #else

=== modified file 'tests/include.am'
--- tests/include.am	2010-07-28 00:27:30 +0000
+++ tests/include.am	2010-09-14 07:57:51 +0000
@@ -47,7 +47,11 @@
 			    tests/libtest.la \
 			    libmemcached/libmemcachedinternal.la \
 			    $(TESTS_LDADDS)
-tests_testapp_LDADD= $(tests_testapp_DEPENDENCIES) $(LIBSASL)
+tests_testapp_LDADD= clients/libgenexec.la \
+		     tests/libserver.la \
+		     tests/libtest.la \
+		     libmemcached/libmemcachedinternal.la \
+		     $(TESTS_LDADDS) $(LIBSASL)
 
 tests_testplus_SOURCES= tests/plus.cpp
 tests_testplus_CXXFLAGS = $(AM_CXXFLAGS) $(NO_EFF_CXX)