Removed more then a handfull of memset() calls.

Also reworked multiget to not need to call malloc().

diff --git a/include/memcached.h b/include/memcached.h
index 29195de09076ca69fe9bcc2a658a3f0383dc3902..7cb057d2b31703dc1a18cbcd318f6aa2a6ed021f 100644 (file)
--- a/include/memcached.h
+++ b/include/memcached.h
@@ -105,6 +105,7 @@ struct memcached_server_st {
   unsigned int cursor_active;
   char write_buffer[MEMCACHED_MAX_BUFFER];
   size_t write_buffer_offset;
+  char *write_ptr;
   char read_buffer[MEMCACHED_MAX_BUFFER];
   size_t read_buffer_length;
   char *read_ptr;

diff --git a/lib/memcached_auto.c b/lib/memcached_auto.c
index 61ad91259377f3670614642789ae97f47e27a5c9..f2ed0b8ff2dc924290987db2af2fb85e70306b1f 100644 (file)
--- a/lib/memcached_auto.c
+++ b/lib/memcached_auto.c
@@ -30,8 +30,6 @@ static memcached_return memcached_auto(memcached_st *ptr,
   if (rc != MEMCACHED_SUCCESS)
     return rc;
 
-  memset(buffer, 0, MEMCACHED_DEFAULT_COMMAND_SIZE);
-
   rc= memcached_response(ptr, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, server_key);
 
   /* 

diff --git a/lib/memcached_flush.c b/lib/memcached_flush.c
index f40c1a6b78c473a5145f53bfb63e50b73210b4df..af2303ca6d41a3657ad5a0ad3c4bbe5a8f753953 100644 (file)
--- a/lib/memcached_flush.c
+++ b/lib/memcached_flush.c
@@ -16,7 +16,6 @@ memcached_return memcached_flush(memcached_st *ptr, time_t expiration)
   if (rc != MEMCACHED_SUCCESS)
     rc= MEMCACHED_SOME_ERRORS;
 
-  memset(buffer, 0, MEMCACHED_DEFAULT_COMMAND_SIZE);
   for (x= 0; x < ptr->number_of_hosts; x++)
   {
     if (expiration)

diff --git a/lib/memcached_get.c b/lib/memcached_get.c
index cbe94926ba0f169d2b27e00bed9facb64f01e10f..db626f6fa07eefc54b9159c64adc51f05abb5e64 100644 (file)
--- a/lib/memcached_get.c
+++ b/lib/memcached_get.c
@@ -12,7 +12,6 @@ static memcached_return memcached_value_fetch(memcached_st *ptr, char *key, size
   char *string_ptr;
   char *end_ptr;
 
-  memset(buffer, 0, MEMCACHED_DEFAULT_COMMAND_SIZE);
   end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
 
   *flags= 0;
@@ -32,7 +31,6 @@ static memcached_return memcached_value_fetch(memcached_st *ptr, char *key, size
     /* We load the key */
     if (load_key)
     {
-      memset(key, 0, MEMCACHED_MAX_KEY);
       *key_length= 0;
 
       for (; end_ptr > string_ptr && *string_ptr != ' '; string_ptr++)
@@ -216,7 +214,6 @@ memcached_return memcached_mget(memcached_st *ptr,
 {
   unsigned int x;
   memcached_return rc= MEMCACHED_NOTFOUND;
-  char *cursor_key_exec;
   LIBMEMCACHED_MEMCACHED_MGET_START();
   ptr->cursor_server= 0;
 
@@ -226,41 +223,40 @@ memcached_return memcached_mget(memcached_st *ptr,
   if (ptr->number_of_hosts == 0)
     return MEMCACHED_NO_SERVERS;
 
-  cursor_key_exec= (char *)malloc(sizeof(char) * ptr->number_of_hosts);
-  memset(cursor_key_exec, 0, sizeof(char) * ptr->number_of_hosts);
-
   for (x= 0; x < number_of_keys; x++)
   {
     unsigned int server_key;
 
     server_key= memcached_generate_hash(ptr, keys[x], key_length[x]);
 
-    if (cursor_key_exec[server_key] == 0)
+    if (ptr->hosts[server_key].cursor_active == 0)
     {
       rc= memcached_connect(ptr, server_key);
 
       if ((memcached_io_write(ptr, server_key, "get ", 4, 0)) == -1)
       {
-        memcached_quit(ptr);
+        memcached_quit_server(ptr, server_key);
         rc= MEMCACHED_SOME_ERRORS;
-        break;
+        continue;
       }
+      ptr->hosts[server_key].cursor_active= 1;
     }
 
     if ((memcached_io_write(ptr, server_key, keys[x], key_length[x], 0)) == -1)
     {
-      memcached_quit(ptr);
+      ptr->hosts[server_key].cursor_active = 0;
+      memcached_quit_server(ptr, server_key);
       rc= MEMCACHED_SOME_ERRORS;
-      break;
+      continue;
     }
 
     if ((memcached_io_write(ptr, server_key, " ", 1, 0)) == -1)
     {
-      memcached_quit(ptr);
+      ptr->hosts[server_key].cursor_active = 0;
+      memcached_quit_server(ptr, server_key);
       rc= MEMCACHED_SOME_ERRORS;
-      break;
+      continue;
     }
-    cursor_key_exec[server_key]= 1;
   }
 
 
@@ -269,24 +265,17 @@ memcached_return memcached_mget(memcached_st *ptr,
   */
   for (x= 0; x < ptr->number_of_hosts; x++)
   {
-    if (cursor_key_exec[x])
+    if (ptr->hosts[x].cursor_active == 1)
     {
       /* We need to doo something about non-connnected hosts in the future */
       if ((memcached_io_write(ptr, x, "\r\n", 2, 1)) == -1)
       {
-        memcached_quit(ptr);
+        memcached_quit_server(ptr, x);
         rc= MEMCACHED_SOME_ERRORS;
-        break;
       }
-
-      ptr->hosts[x].cursor_active= 1;
     }
-    else
-      ptr->hosts[x].cursor_active= 0;
   }
 
-  free(cursor_key_exec);
-
   LIBMEMCACHED_MEMCACHED_MGET_END();
   return rc;
 }
@@ -312,18 +301,28 @@ char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length,
     *value_length= memcached_string_length(result_buffer);
     
     if (*error == MEMCACHED_NOTFOUND)
+    {
+      ptr->hosts[ptr->cursor_server].cursor_active = 0;
       ptr->cursor_server++;
+    }
     else if (*error == MEMCACHED_END && *value_length == 0)
+    {
       return NULL;
+    }
     else if (*error == MEMCACHED_END)
     {
       WATCHPOINT_ASSERT(0); /* If this happens we have somehow messed up the fetch */
+      *value_length= 0;
       return NULL;
     }
     else if (*error != MEMCACHED_SUCCESS)
+    {
       return NULL;
+    }
     else
+    {
       return  memcached_string_c_copy(result_buffer);
+    }
 
   }
 
@@ -352,18 +351,27 @@ memcached_result_st *memcached_fetch_result(memcached_st *ptr,
                                        1, ptr->cursor_server);
     
     if (*error == MEMCACHED_NOTFOUND)
+    {
+      ptr->hosts[ptr->cursor_server].cursor_active = 0;
       ptr->cursor_server++;
+    }
     else if (*error == MEMCACHED_END && memcached_string_length((memcached_string_st *)(&result->value)) == 0)
+    {
       return NULL;
+    }
     else if (*error == MEMCACHED_END)
     {
       WATCHPOINT_ASSERT(0); /* If this happens we have somehow messed up the fetch */
       return NULL;
     }
     else if (*error != MEMCACHED_SUCCESS)
+    {
       return NULL;
+    }
     else
+    {
       return result;
+    }
 
   }
 

diff --git a/lib/memcached_hosts.c b/lib/memcached_hosts.c
index f16052b345d627a67d2bba9b7f0245c065a7beac..d5ec56064534af7b1ff02de9797138eb59b3015a 100644 (file)
--- a/lib/memcached_hosts.c
+++ b/lib/memcached_hosts.c
@@ -15,6 +15,7 @@ static void host_reset(memcached_server_st *host, char *new_hostname, unsigned i
   host->fd= -1;
   host->type= type;
   host->read_ptr= host->read_buffer;
+  host->write_ptr= host->write_buffer;
 }
 
 memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
@@ -123,7 +124,6 @@ static memcached_return server_add(memcached_st *ptr, char *hostname,
   if (!new_hostname)
     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 
-  memset(new_hostname, 0, strlen(hostname)+1);
   memcpy(new_hostname, hostname, strlen(hostname));
   host_reset(&ptr->hosts[ptr->number_of_hosts], new_hostname, port, type);
   ptr->number_of_hosts++;

diff --git a/lib/memcached_io.c b/lib/memcached_io.c
index c0215ac08f917d83249a0c74dcfebd277d2a894d..06ac2e9b51862f3929429d754ea12ba30b272075 100644 (file)
--- a/lib/memcached_io.c
+++ b/lib/memcached_io.c
@@ -93,7 +93,11 @@ ssize_t memcached_io_write(memcached_st *ptr, unsigned int server_key,
 
   for (x= 0; x < length; x++)
   {
-    ptr->hosts[server_key].write_buffer[ptr->hosts[server_key].write_buffer_offset]= buffer[x];
+    if (ptr->hosts[server_key].write_ptr == 0)
+      ptr->hosts[server_key].write_ptr= ptr->hosts[server_key].write_buffer;
+    WATCHPOINT_ASSERT(ptr->hosts[server_key].write_ptr);
+    *ptr->hosts[server_key].write_ptr= buffer[x];
+    ptr->hosts[server_key].write_ptr++;
     ptr->hosts[server_key].write_buffer_offset++;
 
     if (ptr->hosts[server_key].write_buffer_offset == MEMCACHED_MAX_BUFFER)
@@ -103,6 +107,7 @@ ssize_t memcached_io_write(memcached_st *ptr, unsigned int server_key,
       sent_length= memcached_io_flush(ptr, server_key);
 
       WATCHPOINT_ASSERT(sent_length == MEMCACHED_MAX_BUFFER);
+      ptr->hosts[server_key].write_ptr= ptr->hosts[server_key].write_buffer;
       ptr->hosts[server_key].write_buffer_offset= 0;
     }
   }
@@ -142,14 +147,10 @@ ssize_t memcached_io_flush(memcached_st *ptr, unsigned int server_key)
     sent_length= 0;
     if (ptr->hosts[server_key].type == MEMCACHED_CONNECTION_UDP)
     {
-
-      sent_length= sendto(ptr->hosts[server_key].fd, write_ptr, write_length,
-                          0, 0, 0);
-      /*
-      rc = sendto(sd, argv[i], strlen(argv[i])+1, 0,
-                  (struct sockaddr *) &remoteServAddr,
-                  sizeof(remoteServAddr));
-                */
+      sent_length= sendto(ptr->hosts[server_key].fd, 
+                          write_ptr, write_length, 0, 
+                          (struct sockaddr *)&ptr->hosts[server_key].servAddr, 
+                          sizeof(struct sockaddr));
     }
     else
     {
@@ -182,6 +183,7 @@ ssize_t memcached_io_flush(memcached_st *ptr, unsigned int server_key)
 
   WATCHPOINT_ASSERT(write_length == 0);
   WATCHPOINT_ASSERT(return_length == ptr->hosts[server_key].write_buffer_offset);
+  ptr->hosts[server_key].write_ptr= ptr->hosts[server_key].write_buffer;
   ptr->hosts[server_key].write_buffer_offset= 0;
 
   return return_length;
@@ -192,6 +194,7 @@ ssize_t memcached_io_flush(memcached_st *ptr, unsigned int server_key)
 */
 void memcached_io_reset(memcached_st *ptr, unsigned int server_key)
 {
+  ptr->hosts[server_key].write_ptr= ptr->hosts[server_key].write_buffer;
   ptr->hosts[server_key].write_buffer_offset= 0;
   memcached_quit(ptr);
 }

diff --git a/lib/memcached_parse.c b/lib/memcached_parse.c
index 069593e5ec191d21208b586e632d7e8848d82826..521542153725af9da5ca6df18fca3dffab57fbf6 100644 (file)
--- a/lib/memcached_parse.c
+++ b/lib/memcached_parse.c
@@ -29,16 +29,17 @@ memcached_server_st *memcached_servers_parse(char *server_strings)
     char *ptr;
     port= 0;
 
-    memset(buffer, 0, HUGE_STRING_LEN);
     if (string)
     {
       memcpy(buffer, begin_ptr, string - begin_ptr);
+      buffer[(unsigned int)(string - begin_ptr)]= 0;
       begin_ptr= string+1;
     }
     else
     {
       size_t length= strlen(begin_ptr);
       memcpy(buffer, begin_ptr, length);
+      buffer[length]= 0;
       begin_ptr= end_ptr;
     }
 

diff --git a/lib/memcached_quit.c b/lib/memcached_quit.c
index e51692fcd7fbf9fc99170f818a03f01321145c4a..a0cc617299962c4eacaeda28609c5d5e04d342cb 100644 (file)
--- a/lib/memcached_quit.c
+++ b/lib/memcached_quit.c
@@ -30,6 +30,7 @@ void memcached_quit_server(memcached_st *ptr, unsigned int server_key)
     ptr->hosts[server_key].write_buffer_offset= 0;
     ptr->hosts[server_key].read_buffer_length= 0;
     ptr->hosts[server_key].read_ptr= ptr->hosts[server_key].read_buffer;
+    ptr->hosts[server_key].write_ptr= ptr->hosts[server_key].write_buffer;
   }
 
   ptr->connected--;

diff --git a/lib/memcached_response.c b/lib/memcached_response.c
index 19fa640076045faa1bdf0cdd5cbfbbad092e9cd1..b90d861d9f3f194c5505ecaea82bd5c0d9fc6601 100644 (file)
--- a/lib/memcached_response.c
+++ b/lib/memcached_response.c
@@ -18,7 +18,6 @@ memcached_return memcached_response(memcached_st *ptr,
   unsigned int max_messages;
 
 
-  memset(buffer, 0, buffer_length);
   send_length= 0;
 
   max_messages= memcached_server_response_count(ptr, server_key);

diff --git a/lib/memcached_stats.c b/lib/memcached_stats.c
index cbfdef3503b4009cd608dd4e987a129e52f854d3..a2dc17a3e0e56fc0a444893c103fa673b3eb996e 100644 (file)
--- a/lib/memcached_stats.c
+++ b/lib/memcached_stats.c
@@ -152,9 +152,6 @@ char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *stat,
   char buffer[SMALL_STRING_LEN];
   *error= MEMCACHED_SUCCESS;
 
-
-  memset(buffer, 0, SMALL_STRING_LEN);
-
   if (!memcmp("pid", key, strlen("pid")))
     snprintf(buffer, SMALL_STRING_LEN,"%u", stat->pid);
   else if (!memcmp("uptime", key, strlen("uptime")))

diff --git a/lib/memcached_string.c b/lib/memcached_string.c
index 2bbda3fa1b8aee6be4e7199d48ef224f4d07d806..42f3c326767f112c3ed071fd9a8b215bff85a7df 100644 (file)
--- a/lib/memcached_string.c
+++ b/lib/memcached_string.c
@@ -27,10 +27,6 @@ memcached_return memcached_string_check(memcached_string_st *string, size_t need
     string->end= string->string + current_offset;
 
     string->current_size+= (string->block_size * adjust);
-
-    /* We zero the block structure we just realloced */
-    memset((string->string + current_offset), 0, 
-           sizeof(char) * string->block_size);
   }
 
   return MEMCACHED_SUCCESS;