This creates memcached_htonll() to be used internally (we want to avoid conflicts...

Also, this version includes an update to the server startup so that we don't try to shutdown anything we didn't start.

diff --git a/clients/memcapable.cc b/clients/memcapable.cc
index baac28b2484f9c9983334a2b3cb06500d484855e..9c9feb52d5d46ffa7356ed4a55b9490f17602bc9 100644 (file)
--- a/clients/memcapable.cc
+++ b/clients/memcapable.cc
@@ -297,7 +297,7 @@ static enum test_return send_packet(command *cmd)
   cmd->plain.message.header.request.bodylen=
           ntohl(cmd->plain.message.header.request.bodylen);
   cmd->plain.message.header.request.cas=
-          ntohll(cmd->plain.message.header.request.cas);
+          memcached_ntohll(cmd->plain.message.header.request.cas);
 
   execute(resend_packet(cmd));
   return TEST_PASS;
@@ -343,7 +343,7 @@ static enum test_return recv_packet(response *rsp)
   rsp->plain.message.header.response.bodylen=
           ntohl(rsp->plain.message.header.response.bodylen);
   rsp->plain.message.header.response.cas=
-          ntohll(rsp->plain.message.header.response.cas);
+          memcached_ntohll(rsp->plain.message.header.response.cas);
 
   size_t bodysz= rsp->plain.message.header.response.bodylen;
   if (bodysz > 0)
@@ -472,8 +472,8 @@ static void arithmetic_command(command *cmd,
   cmd->incr.message.header.request.extlen= 20;
   cmd->incr.message.header.request.bodylen= (uint32_t)(keylen + 20);
   cmd->incr.message.header.request.opaque= 0xdeadbeef;
-  cmd->incr.message.body.delta= htonll(delta);
-  cmd->incr.message.body.initial= htonll(initial);
+  cmd->incr.message.body.delta= memcached_htonll(delta);
+  cmd->incr.message.body.initial= memcached_htonll(initial);
   cmd->incr.message.body.expiration= htonl(exptime);
 
   off_t key_offset= sizeof (protocol_binary_request_no_extras) + 20;
@@ -690,8 +690,7 @@ static enum test_return test_binary_set_impl(const char* key, uint8_t cc)
   }
 
   /* try to set with the correct CAS value */
-  cmd.plain.message.header.request.cas=
-          htonll(rsp.plain.message.header.response.cas);
+  cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas);
   execute(resend_packet(&cmd));
   if (cc == PROTOCOL_BINARY_CMD_SET)
   {
@@ -702,8 +701,7 @@ static enum test_return test_binary_set_impl(const char* key, uint8_t cc)
     execute(test_binary_noop());
 
   /* try to set with an incorrect CAS value */
-  cmd.plain.message.header.request.cas=
-          htonll(rsp.plain.message.header.response.cas - 1);
+  cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas - 1);
   execute(resend_packet(&cmd));
   execute(send_binary_noop());
   execute(recv_packet(&rsp));
@@ -819,8 +817,7 @@ static enum test_return test_binary_replace_impl(const char* key, uint8_t cc)
   }
 
   /* verify that replace with CAS value works! */
-  cmd.plain.message.header.request.cas=
-          htonll(rsp.plain.message.header.response.cas);
+  cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas);
   execute(resend_packet(&cmd));
 
   if (cc == PROTOCOL_BINARY_CMD_REPLACE)
@@ -832,8 +829,7 @@ static enum test_return test_binary_replace_impl(const char* key, uint8_t cc)
     execute(test_binary_noop());
 
   /* try to set with an incorrect CAS value */
-  cmd.plain.message.header.request.cas=
-          htonll(rsp.plain.message.header.response.cas - 1);
+  cmd.plain.message.header.request.cas= memcached_htonll(rsp.plain.message.header.response.cas - 1);
   execute(resend_packet(&cmd));
   execute(send_binary_noop());
   execute(recv_packet(&rsp));
@@ -956,7 +952,7 @@ static enum test_return test_binary_incr_impl(const char* key, uint8_t cc)
     {
       execute(recv_packet(&rsp));
       verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
-      verify(ntohll(rsp.incr.message.body.value) == ii);
+      verify(memcached_ntohll(rsp.incr.message.body.value) == ii);
     }
     else
       execute(test_binary_noop());
@@ -994,7 +990,7 @@ static enum test_return test_binary_decr_impl(const char* key, uint8_t cc)
     {
       execute(recv_packet(&rsp));
       verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
-      verify(ntohll(rsp.decr.message.body.value) == (uint64_t)ii);
+      verify(memcached_ntohll(rsp.decr.message.body.value) == (uint64_t)ii);
     }
     else
       execute(test_binary_noop());
@@ -1006,7 +1002,7 @@ static enum test_return test_binary_decr_impl(const char* key, uint8_t cc)
   {
     execute(recv_packet(&rsp));
     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
-    verify(ntohll(rsp.decr.message.body.value) == 0);
+    verify(memcached_ntohll(rsp.decr.message.body.value) == 0);
   }
   else
   {

diff --git a/example/interface_v0.c b/example/interface_v0.c
index 74a98eaf896867d9aa73edba673ea5bdabae5855..a5462734fb45ab3d60af9d17046f348f00d687f8 100644 (file)
--- a/example/interface_v0.c
+++ b/example/interface_v0.c
@@ -78,7 +78,7 @@ static protocol_binary_response_status get_command_handler(const void *cookie,
     msg.response.message.body.flags= htonl(item->flags);
     char *ptr= (char*)(msg.response.bytes + sizeof(*header) + 4);
     uint32_t bodysize= 4;
-    msg.response.message.header.response.cas= htonll(item->cas);
+    msg.response.message.header.response.cas= memcached_htonll(item->cas);
     if (opcode == PROTOCOL_BINARY_CMD_GETK || opcode == PROTOCOL_BINARY_CMD_GETKQ)
     {
       memcpy(ptr, item->key, item->nkey);
@@ -172,8 +172,8 @@ static protocol_binary_response_status arithmetic_command_handler(const void *co
   };
 
   uint16_t keylen= ntohs(header->request.keylen);
-  uint64_t initial= ntohll(req->message.body.initial);
-  uint64_t delta= ntohll(req->message.body.delta);
+  uint64_t initial= memcached_ntohll(req->message.body.initial);
+  uint64_t delta= memcached_ntohll(req->message.body.delta);
   uint32_t expiration= ntohl(req->message.body.expiration);
   uint32_t flags= 0;
   void *key= req->bytes + sizeof(req->bytes);
@@ -222,8 +222,8 @@ static protocol_binary_response_status arithmetic_command_handler(const void *co
   if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
   {
     response.message.header.response.bodylen= ntohl(8);
-    response.message.body.value= ntohll((*(uint64_t*)item->data));
-    response.message.header.response.cas= ntohll(item->cas);
+    response.message.body.value= memcached_ntohll((*(uint64_t*)item->data));
+    response.message.header.response.cas= memcached_ntohll(item->cas);
 
     release_item(item);
     if (header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENTQ ||
@@ -250,6 +250,7 @@ static protocol_binary_response_status version_command_handler(const void *cooki
       .opcode= PROTOCOL_BINARY_CMD_VERSION,
       .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
       .opaque= header->request.opaque,
+      .cas= 0,
       .bodylen= htonl((uint32_t)strlen(versionstring))
     }
   };
@@ -265,7 +266,7 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
 {
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
   uint16_t keylen= ntohs(header->request.keylen);
-  uint64_t cas= ntohll(header->request.cas);
+  uint64_t cas= memcached_ntohll(header->request.cas);
   void *key= header + 1;
   uint32_t vallen= ntohl(header->request.bodylen) - keylen;
   void *val= (char*)key + keylen;
@@ -316,7 +317,7 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
             .opcode= header->request.opcode,
             .status= htons(rval),
             .opaque= header->request.opaque,
-            .cas= htonll(cas),
+            .cas= memcached_htonll(cas),
           }
         }
       };
@@ -356,7 +357,7 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
     struct item* item= get_item(key, keylen);
     if (item != NULL)
     {
-      if (item->cas != ntohll(header->request.cas))
+      if (item->cas != memcached_ntohll(header->request.cas))
       {
         release_item(item);
         response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
@@ -378,7 +379,7 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
     /* SETQ shouldn't return a message */
     if (header->request.opcode == PROTOCOL_BINARY_CMD_SET)
     {
-      response.message.header.response.cas= htonll(item->cas);
+      response.message.header.response.cas= memcached_htonll(item->cas);
       release_item(item);
       return response_handler(cookie, header, (void*)&response);
     }
@@ -425,7 +426,7 @@ static protocol_binary_response_status add_command_handler(const void *cookie,
       /* ADDQ shouldn't return a message */
       if (header->request.opcode == PROTOCOL_BINARY_CMD_ADD)
       {
-        response.message.header.response.cas= htonll(item->cas);
+        response.message.header.response.cas= memcached_htonll(item->cas);
         release_item(item);
         return response_handler(cookie, header, (void*)&response);
       }
@@ -467,21 +468,26 @@ static protocol_binary_response_status replace_command_handler(const void *cooki
 
   struct item* item= get_item(key, keylen);
   if (item == NULL)
+  {
     response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
-  else if (header->request.cas == 0 || ntohll(header->request.cas) == item->cas)
+  }
+  else if (header->request.cas == 0 || memcached_ntohll(header->request.cas) == item->cas)
   {
     release_item(item);
     delete_item(key, keylen);
     item= create_item(key, keylen, data, datalen, flags, timeout);
+
     if (item == NULL)
+    {
       response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
+    }
     else
     {
       put_item(item);
       /* REPLACEQ shouldn't return a message */
       if (header->request.opcode == PROTOCOL_BINARY_CMD_REPLACE)
       {
-        response.message.header.response.cas= htonll(item->cas);
+        response.message.header.response.cas= memcached_htonll(item->cas);
         release_item(item);
         return response_handler(cookie, header, (void*)&response);
       }

diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc
index d7289f066a91bf225a6f14822237906d56dcbe03..2bfc5bbad711106cebf87a62999d0c0f4a203495 100644 (file)
--- a/libmemcached/auto.cc
+++ b/libmemcached/auto.cc
@@ -137,8 +137,8 @@ static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd,
   request.message.header.request.extlen= 20;
   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
   request.message.header.request.bodylen= htonl((uint32_t)(key_length + memcached_array_size(ptr->prefix_key) +request.message.header.request.extlen));
-  request.message.body.delta= htonll(offset);
-  request.message.body.initial= htonll(initial);
+  request.message.body.delta= memcached_htonll(offset);
+  request.message.body.initial= memcached_htonll(initial);
   request.message.body.expiration= htonl((uint32_t) expiration);
 
   struct libmemcached_io_vector_st vector[]=

diff --git a/libmemcached/byteorder.cc b/libmemcached/byteorder.cc
index ab35a9efef70e4200e39d55098c758f17124e194..80ea0210b9857dcab26a327bd815626829394404 100644 (file)
--- a/libmemcached/byteorder.cc
+++ b/libmemcached/byteorder.cc
@@ -35,7 +35,12 @@
  *
  */
 
-#include <libmemcached/common.h>
+#include <config.h>
+
+#include <sys/types.h>
+
+#include <libmemcached/visibility.h>
+#include <libmemcached/byteorder.h>
 
 /* Byte swap a 64-bit number. */
 #ifndef swap64
@@ -58,6 +63,20 @@ static inline uint64_t swap64(uint64_t in)
 }
 #endif
 
+#ifdef HAVE_HTONLL
+
+uint64_t memcached_ntohll(uint64_t value)
+{
+  return ntohll(value);
+}
+
+uint64_t memcached_htonll(uint64_t value)
+{
+  return htonll(value);
+}
+
+#else // HAVE_HTONLL
+
 uint64_t memcached_ntohll(uint64_t value)
 {
   return swap64(value);
@@ -67,3 +86,5 @@ uint64_t memcached_htonll(uint64_t value)
 {
   return swap64(value);
 }
+
+#endif // HAVE_HTONLL

diff --git a/libmemcached/byteorder.h b/libmemcached/byteorder.h
index f78790a83dce1822b196d4bd9f4c596d7955b5ed..92687c1d7b6430223250938c9480b9d52f7dc159 100644 (file)
--- a/libmemcached/byteorder.h
+++ b/libmemcached/byteorder.h
@@ -37,36 +37,16 @@
 
 #pragma once
 
-#if HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
-#ifndef HAVE_HTONLL
-#define ntohll(a) memcached_ntohll(a)
-#define htonll(a) memcached_htonll(a)
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 LIBMEMCACHED_LOCAL
 uint64_t memcached_ntohll(uint64_t);
+
 LIBMEMCACHED_LOCAL
 uint64_t memcached_htonll(uint64_t);
+
 #ifdef __cplusplus
 }
 #endif
-
-#endif
-
-#ifdef linux
-/* /usr/include/netinet/in.h defines macros from ntohs() to _bswap_nn to
- * optimize the conversion functions, but the prototypes generate warnings
- * from gcc. The conversion methods isn't the bottleneck for my app, so
- * just remove the warnings by undef'ing the optimization ..
- */
-#undef ntohs
-#undef ntohl
-#undef htons
-#undef htonl
-#endif

diff --git a/libmemcached/protocol/binary_handler.c b/libmemcached/protocol/binary_handler.c
index 93fb316222276bfc859c196b0da20194492e2e59..0997ebb03dcc96af572b3e5d85b40037e5abf60f 100644 (file)
--- a/libmemcached/protocol/binary_handler.c
+++ b/libmemcached/protocol/binary_handler.c
@@ -155,7 +155,7 @@ get_response_handler(const void *cookie,
       .opcode= opcode,
       .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
       .opaque= client->current_command->request.opaque,
-      .cas= htonll(cas),
+      .cas= memcached_htonll(cas),
       .keylen= htons(keylen),
       .extlen= 4,
       .bodylen= htonl(bodylen + keylen + 4),
@@ -184,12 +184,12 @@ get_response_handler(const void *cookie,
  * @param body the length of the body
  * @param bodylen the length of the body
  */
-static protocol_binary_response_status
-stat_response_handler(const void *cookie,
-                     const void *key,
-                     uint16_t keylen,
-                     const void *body,
-                     uint32_t bodylen) {
+static protocol_binary_response_status stat_response_handler(const void *cookie,
+                                                             const void *key,
+                                                             uint16_t keylen,
+                                                             const void *body,
+                                                             uint32_t bodylen)
+{
 
   memcached_protocol_client_st *client= (void*)cookie;
 
@@ -201,6 +201,7 @@ stat_response_handler(const void *cookie,
       .opaque= client->current_command->request.opaque,
       .keylen= htons(keylen),
       .bodylen= htonl(bodylen + keylen),
+      .cas= 0
     },
   };
 
@@ -236,6 +237,7 @@ version_response_handler(const void *cookie,
       .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
       .opaque= client->current_command->request.opaque,
       .bodylen= htonl(textlen),
+      .cas= 0
     },
   };
 
@@ -291,7 +293,7 @@ add_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_ADD,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(cas)
+            .cas= memcached_ntohll(cas)
           }
         }
       };
@@ -326,8 +328,8 @@ decrement_command_handler(const void *cookie,
   {
     uint16_t keylen= ntohs(header->request.keylen);
     protocol_binary_request_decr *request= (void*)header;
-    uint64_t init= ntohll(request->message.body.initial);
-    uint64_t delta= ntohll(request->message.body.delta);
+    uint64_t init= memcached_ntohll(request->message.body.initial);
+    uint64_t delta= memcached_ntohll(request->message.body.delta);
     uint32_t timeout= ntohl(request->message.body.expiration);
     void *key= request->bytes + sizeof(request->bytes);
     uint64_t result;
@@ -347,10 +349,10 @@ decrement_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_DECREMENT,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(cas),
+            .cas= memcached_ntohll(cas),
             .bodylen= htonl(8)
           },
-          .body.value= htonll(result)
+          .body.value= memcached_htonll(result)
         }
       };
       rval= response_handler(cookie, header, (void*)&response);
@@ -383,8 +385,8 @@ delete_command_handler(const void *cookie,
   if (client->root->callback->interface.v1.delete != NULL)
   {
     uint16_t keylen= ntohs(header->request.keylen);
-    void *key= (header + 1);
-    uint64_t cas= ntohll(header->request.cas);
+    void *key= (header +1);
+    uint64_t cas= memcached_ntohll(header->request.cas);
     rval= client->root->callback->interface.v1.delete(cookie, key, keylen, cas);
     if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
         header->request.opcode == PROTOCOL_BINARY_CMD_DELETE)
@@ -521,8 +523,8 @@ increment_command_handler(const void *cookie,
   {
     uint16_t keylen= ntohs(header->request.keylen);
     protocol_binary_request_incr *request= (void*)header;
-    uint64_t init= ntohll(request->message.body.initial);
-    uint64_t delta= ntohll(request->message.body.delta);
+    uint64_t init= memcached_ntohll(request->message.body.initial);
+    uint64_t delta= memcached_ntohll(request->message.body.delta);
     uint32_t timeout= ntohl(request->message.body.expiration);
     void *key= request->bytes + sizeof(request->bytes);
     uint64_t cas;
@@ -542,10 +544,10 @@ increment_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_INCREMENT,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(cas),
+            .cas= memcached_ntohll(cas),
             .bodylen= htonl(8)
           },
-          .body.value= htonll(result)
+          .body.value= memcached_htonll(result)
         }
       };
 
@@ -614,9 +616,9 @@ append_command_handler(const void *cookie,
   {
     uint16_t keylen= ntohs(header->request.keylen);
     uint32_t datalen= ntohl(header->request.bodylen) - keylen;
-    char *key= (void*)(header + 1);
-    char *data= key + keylen;
-    uint64_t cas= ntohll(header->request.cas);
+    char *key= (void*)(header +1);
+    char *data= key +keylen;
+    uint64_t cas= memcached_ntohll(header->request.cas);
     uint64_t result_cas;
 
     rval= client->root->callback->interface.v1.append(cookie, key, keylen,
@@ -633,7 +635,7 @@ append_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_APPEND,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(result_cas),
+            .cas= memcached_ntohll(result_cas),
           },
         }
       };
@@ -670,7 +672,7 @@ prepend_command_handler(const void *cookie,
     uint32_t datalen= ntohl(header->request.bodylen) - keylen;
     char *key= (char*)(header + 1);
     char *data= key + keylen;
-    uint64_t cas= ntohll(header->request.cas);
+    uint64_t cas= memcached_ntohll(header->request.cas);
     uint64_t result_cas;
     rval= client->root->callback->interface.v1.prepend(cookie, key, keylen,
                                                        data, datalen, cas,
@@ -686,7 +688,7 @@ prepend_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_PREPEND,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(result_cas),
+            .cas= memcached_ntohll(result_cas),
           },
         }
       };
@@ -764,7 +766,7 @@ replace_command_handler(const void *cookie,
     uint32_t timeout= ntohl(request->message.body.expiration);
     char *key= ((char*)header) + sizeof(*header) + 8;
     char *data= key + keylen;
-    uint64_t cas= ntohll(header->request.cas);
+    uint64_t cas= memcached_ntohll(header->request.cas);
     uint64_t result_cas;
 
     rval= client->root->callback->interface.v1.replace(cookie, key, keylen,
@@ -782,7 +784,7 @@ replace_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_REPLACE,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(result_cas),
+            .cas= memcached_ntohll(result_cas),
           },
         }
       };
@@ -822,7 +824,7 @@ set_command_handler(const void *cookie,
     uint32_t timeout= ntohl(request->message.body.expiration);
     char *key= ((char*)header) + sizeof(*header) + 8;
     char *data= key + keylen;
-    uint64_t cas= ntohll(header->request.cas);
+    uint64_t cas= memcached_ntohll(header->request.cas);
     uint64_t result_cas;
 
 
@@ -840,7 +842,7 @@ set_command_handler(const void *cookie,
             .opcode= PROTOCOL_BINARY_CMD_SET,
             .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
             .opaque= header->request.opaque,
-            .cas= ntohll(result_cas),
+            .cas= memcached_ntohll(result_cas),
           },
         }
       };

diff --git a/libmemcached/response.cc b/libmemcached/response.cc
index 6ee62af08ad86b67e2cf8ac2f3f4daf3bcc17197..d3d2510e688fcd920f34a3fa5834277ed00c0d1a 100644 (file)
--- a/libmemcached/response.cc
+++ b/libmemcached/response.cc
@@ -384,7 +384,7 @@ static memcached_return_t binary_read_one_response(memcached_server_write_instan
   header.response.keylen= ntohs(header.response.keylen);
   header.response.status= ntohs(header.response.status);
   header.response.bodylen= ntohl(header.response.bodylen);
-  header.response.cas= ntohll(header.response.cas);
+  header.response.cas= memcached_ntohll(header.response.cas);
   uint32_t bodylen= header.response.bodylen;
 
   if (header.response.status == PROTOCOL_BINARY_RESPONSE_SUCCESS ||
@@ -450,7 +450,7 @@ static memcached_return_t binary_read_one_response(memcached_server_write_instan
           return MEMCACHED_UNKNOWN_READ_FAILURE;
         }
 
-        val= ntohll(val);
+        val= memcached_ntohll(val);
         memcpy(buffer, &val, sizeof(val));
       }
       break;

diff --git a/libmemcached/storage.cc b/libmemcached/storage.cc
index c6d653c14717608535ab4c984a81cc393257a250..95d93c7605992584143be0b622c6e049aabd788a 100644 (file)
--- a/libmemcached/storage.cc
+++ b/libmemcached/storage.cc
@@ -493,7 +493,7 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr,
                                                             request.message.header.request.extlen));
 
   if (cas)
-    request.message.header.request.cas= htonll(cas);
+    request.message.header.request.cas= memcached_htonll(cas);
 
   flush= (bool) ((server->root->flags.buffer_requests && verb == SET_OP) ? 0 : 1);
 

diff --git a/libtest/server.c b/libtest/server.c
index 1c3ea100f263e1670a989b8107dbd72be26d4a2b..dac57c775c8bd5f40fc9740ffd9cbc6d7bd63341 100644 (file)
--- a/libtest/server.c
+++ b/libtest/server.c
@@ -178,6 +178,7 @@ void server_startup(server_startup_st *construct)
                 if (libmemcached_util_flush("localhost", construct->port[x], NULL))
                 { 
                   fprintf(stderr, "Found server on port %d, flushed it!\n", (int)construct->port[x]);
+                  construct->is_used[x]= true;
                 } // If we can flush it, we will just use it
                 else
                 {
@@ -202,15 +203,22 @@ void server_startup(server_startup_st *construct)
                    MEMCACHED_BINARY, construct->pid_file[x], construct->port[x], construct->port[x]);
         }
 
-       if (libmemcached_util_ping("localhost", construct->port[x], NULL))
-       {
-         fprintf(stderr, "Server on port %u already exists\n", construct->port[x]);
-       }
-       else
-       {
-         status= system(buffer);
-         fprintf(stderr, "STARTING SERVER: %s  status:%d\n", buffer, status);
-       }
+        if (construct->is_used[x])
+        {
+          fprintf(stderr, "USING SERVER: %s\n", buffer);
+        }
+        else
+        {
+          if (libmemcached_util_ping("localhost", construct->port[x], NULL))
+          {
+            fprintf(stderr, "Server on port %u already exists\n", construct->port[x]);
+          }
+          else
+          {
+            status= system(buffer);
+            fprintf(stderr, "STARTING SERVER: %s  status:%d\n", buffer, status);
+          }
+        }
 
         int count;
         size_t remaining_length= sizeof(server_string_buffer) - (size_t)(end_ptr -server_string_buffer);
@@ -237,6 +245,10 @@ void server_startup(server_startup_st *construct)
       for (uint32_t x= 0; x < construct->count; x++)
       {
         uint32_t counter= 3000; // Absurd, just to catch run away process
+
+        if (construct->is_used[x])
+          continue;
+
         while (construct->pids[x] <= 0  && --counter)
         {
           FILE *file= fopen(construct->pid_file[x], "r");
@@ -255,12 +267,13 @@ void server_startup(server_startup_st *construct)
             }
             fclose(file);
           }
+
           switch (errno)
           {
           default:
-            fprintf(stderr, "Could not open pid file %s -> fopen(%s) -> %s:%d\n", construct->pid_file[x], strerror(errno),
-                    __FILE__, __LINE__);
+            fprintf(stderr, "Could not open pid file %s -> fopen(%s) -> %s:%d\n", construct->pid_file[x], strerror(errno), __FILE__, __LINE__);
             abort();
+
           case ENOENT:
           case EINTR:
           case EACCES:
@@ -331,6 +344,9 @@ void server_shutdown(server_startup_st *construct)
   {
     for (uint32_t x= 0; x < construct->count; x++)
     {
+      if (construct->is_used[x])
+        continue;
+
       kill_file(construct->pid_file[x]);
     }
 

diff --git a/libtest/server.h b/libtest/server.h
index 454f69ca81e1266824c6cd7d5d3e58a0f36380b2..581cf8596b30297af084fe554cef729838ac33e8 100644 (file)
--- a/libtest/server.h
+++ b/libtest/server.h
@@ -32,6 +32,7 @@ struct server_startup_st
   char pid_file[SERVERS_TO_CREATE][FILENAME_MAX];
   in_port_t port[SERVERS_TO_CREATE];
   int pids[SERVERS_TO_CREATE];
+  bool is_used[SERVERS_TO_CREATE]; // Did we start it, or was it just sitting there?
 };
 
 void server_startup(server_startup_st *construct);

diff --git a/tests/mem_functions.cc b/tests/mem_functions.cc
index c74b6b1ed78d46291122b1bff54ccde4e673ca5a..338e23c80b99b47031e461fde54394dbca44e32a 100644 (file)
--- a/tests/mem_functions.cc
+++ b/tests/mem_functions.cc
@@ -2581,34 +2581,34 @@ static test_return_t user_supplied_bug9(memcached_st *memc)
 static test_return_t user_supplied_bug10(memcached_st *memc)
 {
   const char *key= "foo";
-  char *value;
   size_t value_length= 512;
-  unsigned int x;
   size_t key_len= 3;
   unsigned int set= 1;
   memcached_st *mclone= memcached_clone(NULL, memc);
-  int32_t timeout;
 
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
-  timeout= 2;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
-                         (uint64_t)timeout);
+  int32_t timeout= 0;
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (uint64_t)timeout);
 
-  value = (char*)malloc(value_length * sizeof(char));
+  char *value= (char*)malloc(value_length * sizeof(char));
 
-  for (x= 0; x < value_length; x++)
+  for (unsigned int x= 0; x < value_length; x++)
+  {
     value[x]= (char) (x % 127);
+  }
 
-  for (x= 1; x <= 100000; ++x)
+  for (unsigned int x= 1; x <= 100000; ++x)
   {
     memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
 
-    test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
-           rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
+    test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE, 
+                  memcached_strerror(NULL, rc));
 
-    if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
+    if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
+    {
       x--;
+    }
   }
 
   free(value);
@@ -2623,33 +2623,31 @@ static test_return_t user_supplied_bug10(memcached_st *memc)
 static test_return_t user_supplied_bug11(memcached_st *memc)
 {
   const char *key= "foo";
-  char *value;
   size_t value_length= 512;
-  unsigned int x;
   size_t key_len= 3;
-  memcached_return_t rc;
   unsigned int set= 1;
-  int32_t timeout;
   memcached_st *mclone= memcached_clone(NULL, memc);
 
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
-  timeout= -1;
-  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
-                         (size_t)timeout);
+  int32_t timeout= -1;
+  memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, (size_t)timeout);
 
   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
   test_true(timeout == -1);
 
-  value = (char*)malloc(value_length * sizeof(char));
+  char *value= (char*)malloc(value_length * sizeof(char));
 
-  for (x= 0; x < value_length; x++)
+  for (unsigned int x= 0; x < value_length; x++)
+  {
     value[x]= (char) (x % 127);
+  }
 
-  for (x= 1; x <= 100000; ++x)
+  for (unsigned int x= 1; x <= 100000; ++x)
   {
-    rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+    memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+    (void)rc;
   }
 
   free(value);
@@ -4065,15 +4063,13 @@ static test_return_t pre_settimer(memcached_st *memc)
 
 static test_return_t poll_timeout(memcached_st *memc)
 {
-  size_t timeout;
-
-  timeout= 100;
+  size_t timeout= 100; // Not using, just checking that it sets
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
 
   timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
 
-  test_true(timeout == 100);
+  test_compare(100, timeout);
 
   return TEST_SUCCESS;
 }