Merge in library/udp fixes.

[m6w6/libmemcached] / libmemcached / io.cc

diff --git a/libmemcached/io.cc b/libmemcached/io.cc
index 0ed565d7e28a436e7d3bd9b26ba6598175253430..8642c18755b8f13c0b1959e89a44418c47a0ff57 100644 (file)
--- a/libmemcached/io.cc
+++ b/libmemcached/io.cc
@@ -306,7 +306,6 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
       return -1;
     }
   }
-  ssize_t sent_length;
   size_t return_length;
   char *local_write_ptr= ptr->write_buffer;
   size_t write_length= ptr->write_buffer_offset;
@@ -316,14 +315,13 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
   WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
 
   // UDP Sanity check, make sure that we are not sending somthing too big
-  if (ptr->type == MEMCACHED_CONNECTION_UDP && write_length > MAX_UDP_DATAGRAM_LENGTH)
+  if (memcached_is_udp(ptr->root) and write_length > MAX_UDP_DATAGRAM_LENGTH)
   {
     *error= MEMCACHED_WRITE_FAILURE;
     return -1;
   }
 
-  if (ptr->write_buffer_offset == 0 || (ptr->type == MEMCACHED_CONNECTION_UDP
-                                        && ptr->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH))
+  if (ptr->write_buffer_offset == 0 or (memcached_is_udp(ptr->root) and ptr->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH))
   {
     return 0;
   }
@@ -340,10 +338,12 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
   {
     WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
     WATCHPOINT_ASSERT(write_length > 0);
-    sent_length= 0;
-    if (ptr->type == MEMCACHED_CONNECTION_UDP)
+    if (memcached_is_udp(ptr->root))
+    {
       increment_udp_message_id(ptr);
+    }
 
+    ssize_t sent_length= 0;
     WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
     if (with_flush)
     {
@@ -376,8 +376,7 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
            * buffer for more data and retry the write before
            * waiting..
          */
-          if (repack_input_buffer(ptr) or
-              process_input_buffer(ptr))
+          if (repack_input_buffer(ptr) or process_input_buffer(ptr))
           {
             continue;
           }
@@ -407,19 +406,18 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
       }
     }
 
-    if (ptr->type == MEMCACHED_CONNECTION_UDP and
-        (size_t)sent_length != write_length)
+    if (memcached_is_udp(ptr->root) and size_t(sent_length) != write_length)
     {
       memcached_quit_server(ptr, true);
       *error= memcached_set_error(*ptr, MEMCACHED_WRITE_FAILURE, MEMCACHED_AT);
       return -1;
     }
 
-    ptr->io_bytes_sent += (uint32_t) sent_length;
+    ptr->io_bytes_sent+= uint32_t(sent_length);
 
     local_write_ptr+= sent_length;
-    write_length-= (uint32_t) sent_length;
-    return_length+= (uint32_t) sent_length;
+    write_length-= uint32_t(sent_length);
+    return_length+= uint32_t(sent_length);
   }
 
   WATCHPOINT_ASSERT(write_length == 0);
@@ -428,10 +426,14 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
 
   // if we are a udp server, the begining of the buffer is reserverd for
   // the upd frame header
-  if (ptr->type == MEMCACHED_CONNECTION_UDP)
+  if (memcached_is_udp(ptr->root))
+  {
     ptr->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH;
+  }
   else
+  {
     ptr->write_buffer_offset= 0;
+  }
 
   return (ssize_t) return_length;
 }
@@ -547,8 +549,8 @@ memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
     }
   }
 
-  ptr->server_failure_counter= 0;
   *nread = (ssize_t)(buffer_ptr - (char*)buffer);
+
   return MEMCACHED_SUCCESS;
 }
 
@@ -611,13 +613,10 @@ memcached_return_t memcached_io_slurp(memcached_server_write_instance_st ptr)
 static ssize_t _io_write(memcached_server_write_instance_st ptr,
                          const void *buffer, size_t length, bool with_flush)
 {
-  size_t original_length;
-  const char* buffer_ptr;
-
   WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
 
-  original_length= length;
-  buffer_ptr= static_cast<const char *>(buffer);
+  size_t original_length= length;
+  const char *buffer_ptr= static_cast<const char *>(buffer);
 
   while (length)
   {
@@ -625,7 +624,7 @@ static ssize_t _io_write(memcached_server_write_instance_st ptr,
     size_t should_write;
     size_t buffer_end;
 
-    if (ptr->type == MEMCACHED_CONNECTION_UDP)
+    if (memcached_is_udp(ptr->root))
     {
       //UDP does not support partial writes
       buffer_end= MAX_UDP_DATAGRAM_LENGTH;
@@ -648,7 +647,7 @@ static ssize_t _io_write(memcached_server_write_instance_st ptr,
     buffer_ptr+= should_write;
     length-= should_write;
 
-    if (ptr->write_buffer_offset == buffer_end && ptr->type != MEMCACHED_CONNECTION_UDP)
+    if (ptr->write_buffer_offset == buffer_end and memcached_is_udp(ptr->root) == false)
     {
       WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);