Removed more then a handfull of memset() calls.

[awesomized/libmemcached] / lib / memcached_io.c

diff --git a/lib/memcached_io.c b/lib/memcached_io.c
index 45a12199e5241d40e749ec0a8f0b6b2fe4139fed..06ac2e9b51862f3929429d754ea12ba30b272075 100644 (file)
--- a/lib/memcached_io.c
+++ b/lib/memcached_io.c
@@ -7,7 +7,7 @@
 #include <sys/select.h>
 #include <poll.h>
 
-int io_wait(memcached_st *ptr, unsigned int server_key, unsigned read_or_write)
+static int io_wait(memcached_st *ptr, unsigned int server_key, unsigned read_or_write)
 {
   struct pollfd fds[1];
   short flags= 0;
@@ -25,37 +25,6 @@ int io_wait(memcached_st *ptr, unsigned int server_key, unsigned read_or_write)
     return MEMCACHED_FAILURE;
 
   return MEMCACHED_SUCCESS;
-#ifdef OLD
-  while (1)
-  {
-    int select_return;
-    struct timeval local_tv;
-    fd_set set;
-
-    memset(&local_tv, 0, sizeof(struct timeval));
-
-    local_tv.tv_sec= 0;
-    local_tv.tv_usec= 300;
-
-    FD_ZERO(&set);
-    FD_SET(ptr->hosts[server_key].fd, &set);
-
-    if (read_or_write)
-      select_return= select(1, &set, NULL, NULL, &local_tv);
-    else
-      select_return= select(1, NULL, &set, NULL, &local_tv);
-
-    if (select_return == -1)
-    {
-      ptr->my_errno= errno;
-      return MEMCACHED_FAILURE;
-    }
-    else if (!select_return)
-      break;
-  }
-
-  return MEMCACHED_SUCCESS;
-#endif
 }
 
 ssize_t memcached_io_read(memcached_st *ptr, unsigned  int server_key,
@@ -67,7 +36,7 @@ ssize_t memcached_io_read(memcached_st *ptr, unsigned  int server_key,
 
   while (length)
   {
-    if (!ptr->read_buffer_length)
+    if (!ptr->hosts[server_key].read_buffer_length)
     {
       size_t data_read;
 
@@ -82,9 +51,9 @@ ssize_t memcached_io_read(memcached_st *ptr, unsigned  int server_key,
             return -1;
         }
 
-        data_read= recv(ptr->hosts[server_key].fd, 
-                        ptr->read_buffer, 
-                        MEMCACHED_MAX_BUFFER, 0);
+        data_read= read(ptr->hosts[server_key].fd, 
+                        ptr->hosts[server_key].read_buffer, 
+                        MEMCACHED_MAX_BUFFER);
         if (data_read == -1)
         {
           switch (errno)
@@ -93,7 +62,7 @@ ssize_t memcached_io_read(memcached_st *ptr, unsigned  int server_key,
             break;
           default:
             {
-              ptr->my_errno= errno;
+              ptr->cached_errno= errno;
               return -1;
             }
           }
@@ -103,14 +72,14 @@ ssize_t memcached_io_read(memcached_st *ptr, unsigned  int server_key,
         /* If zero, just keep looping */
       }
 
-      ptr->read_buffer_length= data_read;
-      ptr->read_ptr= ptr->read_buffer;
+      ptr->hosts[server_key].read_buffer_length= data_read;
+      ptr->hosts[server_key].read_ptr= ptr->hosts[server_key].read_buffer;
     }
 
-    *buffer_ptr= *ptr->read_ptr;
+    *buffer_ptr= *ptr->hosts[server_key].read_ptr;
     length--;
-    ptr->read_ptr++;
-    ptr->read_buffer_length--;
+    ptr->hosts[server_key].read_ptr++;
+    ptr->hosts[server_key].read_buffer_length--;
     buffer_ptr++;
   }
 
@@ -124,17 +93,22 @@ ssize_t memcached_io_write(memcached_st *ptr, unsigned int server_key,
 
   for (x= 0; x < length; x++)
   {
-    ptr->write_buffer[ptr->write_buffer_offset]= buffer[x];
-    ptr->write_buffer_offset++;
-
-    if (ptr->write_buffer_offset == MEMCACHED_MAX_BUFFER)
+    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)
     {
       size_t sent_length;
 
       sent_length= memcached_io_flush(ptr, server_key);
 
-      assert(sent_length == MEMCACHED_MAX_BUFFER);
-      ptr->write_buffer_offset= 0;
+      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;
     }
   }
 
@@ -150,13 +124,15 @@ ssize_t memcached_io_write(memcached_st *ptr, unsigned int server_key,
 ssize_t memcached_io_flush(memcached_st *ptr, unsigned int server_key)
 {
   size_t sent_length;
-  char *write_ptr= ptr->write_buffer;
-  size_t write_length= ptr->write_buffer_offset;
+  size_t return_length;
+  char *write_ptr= ptr->hosts[server_key].write_buffer;
+  size_t write_length= ptr->hosts[server_key].write_buffer_offset;
   unsigned int loop= 1;
 
-  if (ptr->write_buffer_offset == 0)
+  if (ptr->hosts[server_key].write_buffer_offset == 0)
     return 0;
 
+  return_length= 0;
   while (write_length)
   {
     if (ptr->flags & MEM_NO_BLOCK)
@@ -169,38 +145,48 @@ ssize_t memcached_io_flush(memcached_st *ptr, unsigned int server_key)
     }
 
     sent_length= 0;
-#ifdef orig
-    if ((sent_length= send(ptr->hosts[server_key].fd, write_ptr, 
-                           write_length, 0)) == -1)
-#endif
-      if ((sent_length= write(ptr->hosts[server_key].fd, write_ptr, 
-                              write_length)) == -1)
+    if (ptr->hosts[server_key].type == MEMCACHED_CONNECTION_UDP)
     {
-      switch (errno)
+      sent_length= sendto(ptr->hosts[server_key].fd, 
+                          write_ptr, write_length, 0, 
+                          (struct sockaddr *)&ptr->hosts[server_key].servAddr, 
+                          sizeof(struct sockaddr));
+    }
+    else
+    {
+      if ((ssize_t)(sent_length= write(ptr->hosts[server_key].fd, write_ptr, 
+                                       write_length)) == -1)
       {
-      case ENOBUFS:
-      case EAGAIN:
-        if (loop < 10)
+        switch (errno)
         {
-          loop++;
-          break;
+        case ENOBUFS:
+        case EAGAIN:
+          WATCHPOINT;
+          continue;
+          if (loop < 100)
+          {
+            loop++;
+            break;
+          }
+          /* Yes, we want to fall through */
+        default:
+          ptr->cached_errno= errno;
+          return -1;
         }
-        /* Yes, we want to fall through */
-      default:
-        ptr->my_errno= errno;
-        return -1;
       }
     }
-    else
-    {
-      write_ptr+= sent_length;
-      write_length-= sent_length;
-    }
+
+    write_ptr+= sent_length;
+    write_length-= sent_length;
+    return_length+= sent_length;
   }
 
-  ptr->write_buffer_offset= 0;
+  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 sent_length;
+  return return_length;
 }
 
 /* 
@@ -208,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->write_buffer_offset= 0;
+  ptr->hosts[server_key].write_ptr= ptr->hosts[server_key].write_buffer;
+  ptr->hosts[server_key].write_buffer_offset= 0;
   memcached_quit(ptr);
 }