Merge 1.0 tree

48 files changed, 621 insertions, 366 deletions

diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc
index b8187a05..111445fb 100644
--- a/libmemcached/auto.cc
+++ b/libmemcached/auto.cc
@@ -37,7 +37,7 @@
 
 #include <libmemcached/common.h>
 
-static void auto_response(org::libmemcached::Instance* instance, const bool reply,  memcached_return_t& rc, uint64_t* value)
+static void auto_response(memcached_instance_st* instance, const bool reply,  memcached_return_t& rc, uint64_t* value)
 {
   // If the message was successfully sent, then get the response, otherwise
   // fail.
@@ -63,7 +63,7 @@ static void auto_response(org::libmemcached::Instance* instance, const bool repl
   }
 }
 
-static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance,
+static memcached_return_t text_incr_decr(memcached_instance_st* instance,
                                          const bool is_incr,
                                          const char *key, size_t key_length,
                                          const uint64_t offset,
@@ -97,7 +97,7 @@ static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance,
   return memcached_vdo(instance, vector, 7, true);
 }
 
-static memcached_return_t binary_incr_decr(org::libmemcached::Instance* instance,
+static memcached_return_t binary_incr_decr(memcached_instance_st* instance,
                                            protocol_binary_command cmd,
                                            const char *key, const size_t key_length,
                                            const uint64_t offset,
@@ -180,7 +180,7 @@ static memcached_return_t increment_decrement_by_key(const protocol_binary_comma
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
   bool reply= memcached_is_replying(instance->root);
 
@@ -239,7 +239,7 @@ static memcached_return_t increment_decrement_with_initial_by_key(const protocol
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
   bool reply= memcached_is_replying(instance->root);
 
diff --git a/libmemcached/behavior.cc b/libmemcached/behavior.cc
index 7a8b9853..2675e236 100644
--- a/libmemcached/behavior.cc
+++ b/libmemcached/behavior.cc
@@ -413,7 +413,7 @@ uint64_t memcached_behavior_get(memcached_st *shell,
         return (uint64_t) ptr->send_size;
       }
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, 0);
 
       if (instance) // If we have an instance we test, otherwise we just set and pray
       {
@@ -447,7 +447,7 @@ uint64_t memcached_behavior_get(memcached_st *shell,
       if (ptr->recv_size != -1) // If value is -1 then we are using the default
         return (uint64_t) ptr->recv_size;
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, 0);
 
       /**
         @note REFACTOR
diff --git a/libmemcached/common.h b/libmemcached/common.h
index 0180baca..8e899b70 100644
--- a/libmemcached/common.h
+++ b/libmemcached/common.h
@@ -107,7 +107,7 @@
 # include <dlfcn.h>
 #endif
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 # include "libmemcached/windows.hpp"
 #endif
 
@@ -124,7 +124,7 @@ typedef struct memcached_st Memcached;
 #endif
 
 #ifdef __cplusplus
-org::libmemcached::Instance* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key);
+memcached_instance_st* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key);
 #endif
 
 /* These are private not to be installed headers */
@@ -199,7 +199,7 @@ extern "C" {
 memcached_return_t run_distribution(memcached_st *ptr);
 
 #ifdef __cplusplus
-static inline void memcached_server_response_increment(org::libmemcached::Instance* instance)
+static inline void memcached_server_response_increment(memcached_instance_st* instance)
 {
   instance->events(POLLIN);
   instance->cursor_active_++;
@@ -218,6 +218,6 @@ static inline void memcached_server_response_increment(org::libmemcached::Instan
 #endif
 
 #ifdef __cplusplus
-bool memcached_purge(org::libmemcached::Instance*);
-org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key);
+bool memcached_purge(memcached_instance_st*);
+memcached_instance_st* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key);
 #endif
diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index 2ec9975c..cb88c13b 100644
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -64,7 +64,7 @@
 # define TCP_KEEPIDLE 0
 #endif
 
-static memcached_return_t connect_poll(org::libmemcached::Instance* server, const int connection_error)
+static memcached_return_t connect_poll(memcached_instance_st* server, const int connection_error)
 {
   struct pollfd fds[1];
   fds[0].fd= server->fd;
@@ -87,7 +87,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
       int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno
       switch (local_errno)
       {
-#ifdef TARGET_OS_LINUX
+#ifdef __linux__
       case ERESTART:
 #endif
       case EINTR:
@@ -103,22 +103,6 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
 
       default: // This should not happen
         break;
-#if 0
-        if (fds[0].revents & POLLERR)
-        {
-          int err;
-          socklen_t len= sizeof(err);
-          if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
-          {
-            if (err == 0)
-            {
-              // This should never happen, if it does? Punt.  
-              continue;
-            }
-            local_errno= err;
-          }
-        }
-#endif
       }
 
       assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
@@ -146,13 +130,9 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
         }
       }
 
-      return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+      return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("(number_of == 0)"));
     }
 
-#if 0
-    server->revents(fds[0].revents);
-#endif
-
     assert (number_of == 1);
 
     if (fds[0].revents & POLLERR or
@@ -201,7 +181,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
   return memcached_set_errno(*server, connection_error, MEMCACHED_AT, memcached_literal_param("connect_poll() was exhausted"));
 }
 
-static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
+static memcached_return_t set_hostinfo(memcached_instance_st* server)
 {
   assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
   server->clear_addrinfo();
@@ -265,9 +245,9 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
   return MEMCACHED_SUCCESS;
 }
 
-static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
+static inline void set_socket_nonblocking(memcached_instance_st* server)
 {
-#ifdef WIN32
+#if defined(_WIN32)
   u_long arg= 1;
   if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR)
   {
@@ -305,7 +285,7 @@ static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 #endif
 }
 
-static bool set_socket_options(org::libmemcached::Instance* server)
+static bool set_socket_options(memcached_instance_st* server)
 {
   assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
 
@@ -372,7 +352,7 @@ static bool set_socket_options(org::libmemcached::Instance* server)
 
 #if defined(_WIN32)
 #else
-#if defined(SO_NOSIGPIPE)
+# if defined(SO_NOSIGPIPE)
   if (SO_NOSIGPIPE)
   {
     int set= 1;
@@ -388,7 +368,7 @@ static bool set_socket_options(org::libmemcached::Instance* server)
 #endif
     }
   }
-#endif // SO_NOSIGPIPE
+# endif // SO_NOSIGPIPE
 #endif // _WIN32
 
   if (server->root->flags.no_block)
@@ -459,9 +439,9 @@ static bool set_socket_options(org::libmemcached::Instance* server)
   return true;
 }
 
-static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server)
+static memcached_return_t unix_socket_connect(memcached_instance_st* server)
 {
-#ifndef WIN32
+#ifndef _WIN32
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 
   do {
@@ -525,7 +505,7 @@ static memcached_return_t unix_socket_connect(org::libmemcached::Instance* serve
 #endif
 }
 
-static memcached_return_t network_connect(org::libmemcached::Instance* server)
+static memcached_return_t network_connect(memcached_instance_st* server)
 {
   bool timeout_error_occured= false;
 
@@ -663,7 +643,8 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
 
   if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
   {
-    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT,
+                               memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)"));
   }
 
   return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
@@ -676,7 +657,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
   we get caught spending cycles just waiting.
 */
-static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout)
+static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout)
 {
   struct timeval curr_time;
   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
@@ -743,7 +724,7 @@ static memcached_return_t backoff_handling(org::libmemcached::Instance* server,
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected)
+static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected)
 {
   assert(server);
   if (server->fd != INVALID_SOCKET)
@@ -830,7 +811,7 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server
   return rc;
 }
 
-memcached_return_t memcached_connect(org::libmemcached::Instance* server)
+memcached_return_t memcached_connect(memcached_instance_st* server)
 {
   return _memcached_connect(server, true);
 }
diff --git a/libmemcached/connect.hpp b/libmemcached/connect.hpp
index de1c8df5..d1dafe5e 100644
--- a/libmemcached/connect.hpp
+++ b/libmemcached/connect.hpp
@@ -37,4 +37,4 @@
 
 #pragma once
 
-memcached_return_t memcached_connect(org::libmemcached::Instance*);
+memcached_return_t memcached_connect(memcached_instance_st*);
diff --git a/libmemcached/csl/parser.yy b/libmemcached/csl/parser.yy
index 6d4ccd55..dd9c720b 100644
--- a/libmemcached/csl/parser.yy
+++ b/libmemcached/csl/parser.yy
@@ -53,7 +53,7 @@ class Context;
 %parse-param { class Context *context }
 %parse-param { yyscan_t *scanner }
 %pure-parser
-%require "2.4"
+%require "2.5"
 %start begin
 %verbose
 
@@ -66,13 +66,14 @@ class Context;
 #include <libmemcached/csl/scanner.h>
 
 #ifndef __INTEL_COMPILER
-#pragma GCC diagnostic ignored "-Wold-style-cast"
+# pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
 #ifndef __INTEL_COMPILER
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wlogical-op"
-#endif
+# ifndef __clang__
+#  pragma GCC diagnostic ignored "-Wlogical-op"
+#  pragma GCC diagnostic ignored "-Wunsafe-loop-optimizations"
+# endif
 #endif
 
 int conf_lex(YYSTYPE* lvalp, void* scanner);
diff --git a/libmemcached/delete.cc b/libmemcached/delete.cc
index 67957f45..55a8b4ca 100644
--- a/libmemcached/delete.cc
+++ b/libmemcached/delete.cc
@@ -44,7 +44,7 @@ memcached_return_t memcached_delete(memcached_st *shell, const char *key, size_t
   return memcached_delete_by_key(shell, key, key_length, key, key_length, expiration);
 }
 
-static inline memcached_return_t ascii_delete(org::libmemcached::Instance* instance,
+static inline memcached_return_t ascii_delete(memcached_instance_st* instance,
                                               uint32_t ,
                                               const char *key,
                                               const size_t key_length,
@@ -65,7 +65,7 @@ static inline memcached_return_t ascii_delete(org::libmemcached::Instance* insta
   return memcached_vdo(instance, vector, 6, is_buffering ? false : true);
 }
 
-static inline memcached_return_t binary_delete(org::libmemcached::Instance* instance,
+static inline memcached_return_t binary_delete(memcached_instance_st* instance,
                                                uint32_t server_key,
                                                const char *key,
                                                const size_t key_length,
@@ -118,7 +118,7 @@ static inline memcached_return_t binary_delete(org::libmemcached::Instance* inst
         server_key= 0;
       }
 
-      org::libmemcached::Instance* replica= memcached_instance_fetch(instance->root, server_key);
+      memcached_instance_st* replica= memcached_instance_fetch(instance->root, server_key);
 
       if (memcached_fatal(memcached_vdo(replica, vector, 4, should_flush)))
       {
@@ -161,7 +161,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
   
   bool is_buffering= memcached_is_buffering(instance->root);
   bool is_replying= memcached_is_replying(instance->root);
diff --git a/libmemcached/do.cc b/libmemcached/do.cc
index c9d8e7e5..9ba513f2 100644
--- a/libmemcached/do.cc
+++ b/libmemcached/do.cc
@@ -11,7 +11,7 @@
 
 #include <libmemcached/common.h>
 
-static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
+static memcached_return_t _vdo_udp(memcached_instance_st* instance,
                                    libmemcached_io_vector_st vector[],
                                    const size_t count)
 {
@@ -30,7 +30,7 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
   vector[0].length= UDP_DATAGRAM_HEADER_LENGTH;
 
   msg.msg_iov= (struct iovec*)vector;
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
+#ifdef __APPLE__
   msg.msg_iovlen= int(count);
 #else
   msg.msg_iovlen= count;
@@ -64,7 +64,7 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
 #endif
 }
 
-memcached_return_t memcached_vdo(org::libmemcached::Instance* instance,
+memcached_return_t memcached_vdo(memcached_instance_st* instance,
                                  libmemcached_io_vector_st vector[],
                                  const size_t count,
                                  const bool with_flush)
diff --git a/libmemcached/do.hpp b/libmemcached/do.hpp
index 109c0ac1..d2dc6671 100644
--- a/libmemcached/do.hpp
+++ b/libmemcached/do.hpp
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
  *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
  *
  *  Redistribution and use in source and binary forms, with or without
@@ -37,7 +37,7 @@
 
 #pragma once
 
-memcached_return_t memcached_vdo(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_vdo(memcached_instance_st*,
                                  libmemcached_io_vector_st vector[],
                                  const size_t count,
                                  const bool with_flush);
diff --git a/libmemcached/dump.cc b/libmemcached/dump.cc
index 35da13f5..8ddb2eef 100644
--- a/libmemcached/dump.cc
+++ b/libmemcached/dump.cc
@@ -68,7 +68,7 @@ static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callbac
     // Send message to all servers
     for (uint32_t server_key= 0; server_key < memcached_server_count(memc); server_key++)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+      memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
       memcached_return_t vdo_rc;
       if (memcached_success((vdo_rc= memcached_vdo(instance, vector, 3, true))))
@@ -82,7 +82,7 @@ static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callbac
     }
 
     // Collect the returned items
-    org::libmemcached::Instance* instance;
+    memcached_instance_st* instance;
     memcached_return_t read_ret= MEMCACHED_SUCCESS;
     while ((instance= memcached_io_get_readable_server(memc, read_ret)))
     {
diff --git a/libmemcached/error.cc b/libmemcached/error.cc
index 64aefa03..266f78b5 100644
--- a/libmemcached/error.cc
+++ b/libmemcached/error.cc
@@ -52,7 +52,7 @@ struct memcached_error_t
   char message[MAX_ERROR_LENGTH];
 };
 
-static void _set(org::libmemcached::Instance& server, Memcached& memc)
+static void _set(memcached_instance_st& server, Memcached& memc)
 {
   if (server.error_messages and server.error_messages->query_id != server.root->query_id)
   {
@@ -215,7 +215,7 @@ memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, c
   return memcached_set_error(memc, rc, at, tmp);
 }
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
   assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance");
@@ -255,7 +255,7 @@ memcached_return_t memcached_set_parser_error(Memcached& memc,
   return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length);
 }
 
-static inline size_t append_host_to_string(org::libmemcached::Instance& self, char* buffer, const size_t buffer_length)
+static inline size_t append_host_to_string(memcached_instance_st& self, char* buffer, const size_t buffer_length)
 {
   size_t size= 0;
   switch (self.type)
@@ -275,10 +275,10 @@ static inline size_t append_host_to_string(org::libmemcached::Instance& self, ch
   return size;
 }
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
   if (memcached_fatal(rc) == false and rc != MEMCACHED_CLIENT_ERROR)
   {
     return rc;
@@ -313,9 +313,9 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac
   return rc;
 }
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at)
 {
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
   if (memcached_fatal(rc) == false)
   {
     return rc;
@@ -356,7 +356,7 @@ memcached_return_t memcached_set_errno(Memcached& self, int local_errno, const c
   return memcached_set_errno(self, local_errno, at, tmp);
 }
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, const char *str, size_t length)
 {
   memcached_string_t tmp= { str, length };
   return memcached_set_errno(self, local_errno, at, tmp);
@@ -388,7 +388,7 @@ memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const c
   return rc;
 }
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, memcached_string_t& str)
 {
   if (local_errno == 0)
   {
@@ -427,7 +427,7 @@ memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int lo
   return rc;
 }
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at)
 {
   if (local_errno == 0)
   {
@@ -482,7 +482,7 @@ void memcached_error_print(const Memcached *shell)
 
   for (uint32_t x= 0; x < memcached_server_count(self); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_by_position(self, x);
+    memcached_instance_st* instance= memcached_instance_by_position(self, x);
 
     _error_print(instance->error_messages);
   }
@@ -504,7 +504,7 @@ void memcached_error_free(Memcached& self)
   self.error_messages= NULL;
 }
 
-void memcached_error_free(org::libmemcached::Instance& self)
+void memcached_error_free(memcached_instance_st& self)
 {
   _error_free(self.error_messages);
   self.error_messages= NULL;
@@ -554,7 +554,7 @@ bool memcached_has_current_error(Memcached &memc)
   return false;
 }
 
-bool memcached_has_current_error(org::libmemcached::Instance& server)
+bool memcached_has_current_error(memcached_instance_st& server)
 {
   return memcached_has_current_error(*(server.root));
 }
@@ -591,7 +591,7 @@ int memcached_last_error_errno(const memcached_st *shell)
   return memc->error_messages->local_errno;
 }
 
-const char *memcached_server_error(const memcached_server_instance_st server)
+const char *memcached_server_error(const memcached_instance_st * server)
 {
   if (server == NULL)
   {
@@ -612,7 +612,7 @@ const char *memcached_server_error(const memcached_server_instance_st server)
 }
 
 
-memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server)
+memcached_error_t *memcached_error_copy(const memcached_instance_st& server)
 {
   if (server.error_messages == NULL)
   {
@@ -626,7 +626,7 @@ memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& serve
   return error;
 }
 
-memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr)
+memcached_return_t memcached_server_error_return(const memcached_instance_st * ptr)
 {
   if (ptr == NULL)
   {
@@ -641,7 +641,7 @@ memcached_return_t memcached_server_error_return(memcached_server_instance_st pt
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance)
+memcached_return_t memcached_instance_error_return(memcached_instance_st* instance)
 {
   if (instance == NULL)
   {
diff --git a/libmemcached/error.hpp b/libmemcached/error.hpp
index 733f7686..847dbc24 100644
--- a/libmemcached/error.hpp
+++ b/libmemcached/error.hpp
@@ -51,40 +51,40 @@ memcached_return_t memcached_set_parser_error(Memcached& memc,
 
 memcached_return_t memcached_set_error(Memcached&, memcached_return_t rc, const char *at);
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at);
+memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at);
 
 memcached_return_t memcached_set_error(Memcached&, memcached_return_t rc, const char *at, const char *str, size_t length);
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
 
 memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, const char *at, memcached_string_t& str);
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, memcached_string_t& str);
 
 memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at, memcached_string_t& str);
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, memcached_string_t& str);
 
 memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at, const char *str, size_t length);
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, const char *str, size_t length);
 
 memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at);
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at);
+memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at);
 
 bool memcached_has_current_error(Memcached&);
 
-bool memcached_has_current_error(org::libmemcached::Instance&);
+bool memcached_has_current_error(memcached_instance_st&);
 
 void memcached_error_free(Memcached&);
 
 void memcached_error_free(memcached_server_st&);
 
-void memcached_error_free(org::libmemcached::Instance& self);
+void memcached_error_free(memcached_instance_st& self);
 
-memcached_error_t *memcached_error_copy(const org::libmemcached::Instance&);
+memcached_error_t *memcached_error_copy(const memcached_instance_st&);
 
-memcached_return_t memcached_instance_error_return(org::libmemcached::Instance*);
+memcached_return_t memcached_instance_error_return(memcached_instance_st*);
 
 #endif
diff --git a/libmemcached/exist.cc b/libmemcached/exist.cc
index 8ed60545..3afb42d4 100644
--- a/libmemcached/exist.cc
+++ b/libmemcached/exist.cc
@@ -36,7 +36,7 @@
 
 #include <libmemcached/common.h>
 
-static memcached_return_t ascii_exist(Memcached *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length)
+static memcached_return_t ascii_exist(Memcached *memc, memcached_instance_st* instance, const char *key, size_t key_length)
 {
   libmemcached_io_vector_st vector[]=
   {
@@ -74,7 +74,7 @@ static memcached_return_t ascii_exist(Memcached *memc, org::libmemcached::Instan
   return rc;
 }
 
-static memcached_return_t binary_exist(Memcached *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length)
+static memcached_return_t binary_exist(Memcached *memc, memcached_instance_st* instance, const char *key, size_t key_length)
 {
   protocol_binary_request_set request= {};
   size_t send_length= sizeof(request.bytes);
@@ -144,7 +144,7 @@ memcached_return_t memcached_exist_by_key(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
   if (memcached_is_binary(memc))
   {
diff --git a/libmemcached/fetch.cc b/libmemcached/fetch.cc
index 2843e973..f6fefe66 100644
--- a/libmemcached/fetch.cc
+++ b/libmemcached/fetch.cc
@@ -192,7 +192,7 @@ memcached_result_st *memcached_fetch_result(memcached_st *memc,
   }
 
   *error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop
-  org::libmemcached::Instance *server;
+  memcached_instance_st *server;
   memcached_return_t read_ret= MEMCACHED_SUCCESS;
   while ((server= memcached_io_get_readable_server(memc, read_ret)))
   {
diff --git a/libmemcached/flush.cc b/libmemcached/flush.cc
index 521515ac..cbb66bfe 100644
--- a/libmemcached/flush.cc
+++ b/libmemcached/flush.cc
@@ -52,7 +52,7 @@ static memcached_return_t memcached_flush_binary(Memcached *ptr,
 
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
     initialize_binary_request(instance, request.message.header);
 
     if (reply)
@@ -84,7 +84,7 @@ static memcached_return_t memcached_flush_binary(Memcached *ptr,
 
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     if (instance->response_count() > 0)
     {
@@ -115,7 +115,7 @@ static memcached_return_t memcached_flush_textual(Memcached *ptr,
   memcached_return_t rc= MEMCACHED_SUCCESS;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     libmemcached_io_vector_st vector[]=
     {
diff --git a/libmemcached/flush_buffers.cc b/libmemcached/flush_buffers.cc
index 3fa935c8..24f7c0df 100644
--- a/libmemcached/flush_buffers.cc
+++ b/libmemcached/flush_buffers.cc
@@ -46,7 +46,7 @@ memcached_return_t memcached_flush_buffers(memcached_st *shell)
 
     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+      memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
       if (instance->write_buffer_offset != 0) 
       {
diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index 79e1d832..65a1dcad 100644
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
  *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
  *
  *  Redistribution and use in source and binary forms, with or without
@@ -50,13 +50,13 @@ char *memcached_get(memcached_st *ptr, const char *key,
                               flags, error);
 }
 
-static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
-                                                     const char *group_key,
-                                                     size_t group_key_length,
-                                                     const char * const *keys,
-                                                     const size_t *key_length,
-                                                     size_t number_of_keys,
-                                                     bool mget_mode);
+static memcached_return_t __mget_by_key_real(memcached_st *ptr,
+                                             const char *group_key,
+                                             size_t group_key_length,
+                                             const char * const *keys,
+                                             const size_t *key_length,
+                                             size_t number_of_keys,
+                                             const bool mget_mode);
 char *memcached_get_by_key(memcached_st *shell,
                            const char *group_key,
                            size_t group_key_length,
@@ -79,9 +79,9 @@ char *memcached_get_by_key(memcached_st *shell,
   }
 
   /* Request the key */
-  *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
-                                     (const char * const *)&key, &key_length, 
-                                     1, false);
+  *error= __mget_by_key_real(ptr, group_key, group_key_length,
+                             (const char * const *)&key, &key_length, 
+                             1, false);
   if (ptr)
   {
     assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
@@ -186,20 +186,20 @@ memcached_return_t memcached_mget(memcached_st *ptr,
 }
 
 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
-                                             uint32_t master_server_key,
-                                             bool is_group_key_set,
+                                             const uint32_t master_server_key,
+                                             const bool is_group_key_set,
+                                             const char * const *keys,
+                                             const size_t *key_length,
+                                             const size_t number_of_keys,
+                                             const bool mget_mode);
+
+static memcached_return_t __mget_by_key_real(memcached_st *ptr,
+                                             const char *group_key,
+                                             const size_t group_key_length,
                                              const char * const *keys,
                                              const size_t *key_length,
                                              size_t number_of_keys,
-                                             bool mget_mode);
-
-static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
-                                                     const char *group_key,
-                                                     size_t group_key_length,
-                                                     const char * const *keys,
-                                                     const size_t *key_length,
-                                                     size_t number_of_keys,
-                                                     bool mget_mode)
+                                             const bool mget_mode)
 {
   bool failures_occured_in_sending= false;
   const char *get_command= "get";
@@ -244,7 +244,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   */
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     if (instance->response_count())
     {
@@ -293,7 +293,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
     libmemcached_io_vector_st vector[]=
     {
@@ -354,7 +354,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   bool success_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     if (instance->response_count())
     {
@@ -393,8 +393,7 @@ memcached_return_t memcached_mget_by_key(memcached_st *shell,
                                          size_t number_of_keys)
 {
   Memcached* ptr= memcached2Memcached(shell);
-  return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys,
-                                    key_length, number_of_keys, true);
+  return __mget_by_key_real(ptr, group_key, group_key_length, keys, key_length, number_of_keys, true);
 }
 
 memcached_return_t memcached_mget_execute(memcached_st *ptr,
@@ -449,15 +448,16 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *shell,
   rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys,
                             key_length, number_of_keys);
   ptr->callbacks= original_callbacks;
+
   return rc;
 }
 
 static memcached_return_t simple_binary_mget(memcached_st *ptr,
-                                             uint32_t master_server_key,
+                                             const uint32_t master_server_key,
                                              bool is_group_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,
-                                             size_t number_of_keys, bool mget_mode)
+                                             const size_t number_of_keys, const bool mget_mode)
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
 
@@ -480,7 +480,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
     if (instance->response_count() == 0)
     {
@@ -502,17 +502,17 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
     }
 
-    memcached_return_t vk;
-    vk= memcached_validate_key_length(key_length[x],
-                                      ptr->flags.binary_protocol);
-    if (vk != MEMCACHED_SUCCESS)
     {
-      if (x > 0)
+      memcached_return_t vk= memcached_validate_key_length(key_length[x], ptr->flags.binary_protocol);
+      if (vk != MEMCACHED_SUCCESS)
       {
-        memcached_io_reset(instance);
-      }
+        if (x > 0)
+        {
+          memcached_io_reset(instance);
+        }
 
-      return vk;
+        return vk;
+      }
     }
 
     request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
@@ -553,20 +553,13 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
 
     for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
-      initialize_binary_request(instance, request.message.header);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
       if (instance->response_count())
       {
-        if (memcached_io_write(instance) == false)
-        {
-          memcached_instance_response_reset(instance);
-          memcached_io_reset(instance);
-          rc= MEMCACHED_SOME_ERRORS;
-        }
-
-        if (memcached_io_write(instance, request.bytes,
-                               sizeof(request.bytes), true) == -1)
+        initialize_binary_request(instance, request.message.header);
+        if ((memcached_io_write(instance) == false) or
+            (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1))
         {
           memcached_instance_response_reset(instance);
           memcached_io_reset(instance);
@@ -576,7 +569,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     }
   }
 
-
   return rc;
 }
 
@@ -585,7 +577,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
                                                   bool* dead_servers,
                                                   const char *const *keys,
                                                   const size_t *key_length,
-                                                  size_t number_of_keys)
+                                                  const size_t number_of_keys)
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
   uint32_t start= 0;
@@ -604,9 +596,11 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
     for (uint32_t x= 0; x < number_of_keys; ++x)
     {
       if (hash[x] == memcached_server_count(ptr))
+      {
         continue; /* Already successfully sent */
+      }
 
-      uint32_t server= hash[x] + replica;
+      uint32_t server= hash[x] +replica;
 
       /* In case of randomized reads */
       if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas)))
@@ -624,7 +618,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         continue;
       }
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, server);
 
       if (instance->response_count() == 0)
       {
@@ -685,12 +679,12 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
 }
 
 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
-                                             uint32_t master_server_key,
+                                             const uint32_t master_server_key,
                                              bool is_group_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,
-                                             size_t number_of_keys,
-                                             bool mget_mode)
+                                             const size_t number_of_keys,
+                                             const bool mget_mode)
 {
   if (ptr->number_of_replicas == 0)
   {
diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc
index 747245f9..121e8f7c 100644
--- a/libmemcached/hosts.cc
+++ b/libmemcached/hosts.cc
@@ -46,8 +46,8 @@ static memcached_return_t update_continuum(Memcached *ptr);
 
 static int compare_servers(const void *p1, const void *p2)
 {
-  memcached_server_instance_st a= (memcached_server_instance_st)p1;
-  memcached_server_instance_st b= (memcached_server_instance_st)p2;
+  const memcached_instance_st * a= (const memcached_instance_st *)p1;
+  const memcached_instance_st * b= (const memcached_instance_st *)p2;
 
   int return_value= strcmp(a->_hostname, b->_hostname);
 
@@ -63,7 +63,7 @@ static void sort_hosts(Memcached *ptr)
 {
   if (memcached_server_count(ptr))
   {
-    qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(org::libmemcached::Instance), compare_servers);
+    qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(memcached_instance_st), compare_servers);
   }
 }
 
@@ -146,7 +146,7 @@ static memcached_return_t update_continuum(Memcached *ptr)
     return memcached_set_errno(*ptr, errno, MEMCACHED_AT);
   }
 
-  org::libmemcached::Instance* list= memcached_instance_list(ptr);
+  memcached_instance_st* list= memcached_instance_list(ptr);
 
   /* count live servers (those without a retry delay set) */
   bool is_auto_ejecting= _is_auto_eject_host(ptr);
@@ -365,7 +365,7 @@ static memcached_return_t server_add(Memcached *memc,
   }
 
   uint32_t host_list_size= memc->number_of_hosts +1;
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(memc, memcached_instance_list(memc), host_list_size, org::libmemcached::Instance);
+  memcached_instance_st* new_host_list= libmemcached_xrealloc(memc, memcached_instance_list(memc), host_list_size, memcached_instance_st);
 
   if (new_host_list == NULL)
   {
@@ -376,7 +376,7 @@ static memcached_return_t server_add(Memcached *memc,
   assert(memc->number_of_hosts == host_list_size);
 
   /* TODO: Check return type */
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, memcached_server_count(memc) -1);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, memcached_server_count(memc) -1);
 
   if (__instance_create_with(memc, instance, hostname, port, weight, type) == NULL)
   {
@@ -409,7 +409,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se
     uint32_t count= memcached_server_list_count(list);
     uint32_t host_list_size= count +original_host_size;
 
-    org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
+    memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, memcached_instance_st);
 
     if (new_host_list == NULL)
     {
@@ -424,7 +424,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se
       WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
       // We have extended the array, and now we will find it, and use it.
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, original_host_size);
       WATCHPOINT_ASSERT(instance);
 
       memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) };
@@ -449,7 +449,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se
   return MEMCACHED_INVALID_ARGUMENTS;
 }
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::libmemcached::Instance* list, uint32_t number_of_hosts)
+memcached_return_t memcached_instance_push(memcached_st *ptr, const struct memcached_instance_st* list, uint32_t number_of_hosts)
 {
   if (list == NULL)
   {
@@ -458,7 +458,7 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
 
   uint32_t original_host_size= memcached_server_count(ptr);
   uint32_t host_list_size= number_of_hosts +original_host_size;
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
+  memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, memcached_instance_st);
 
   if (new_host_list == NULL)
   {
@@ -477,7 +477,7 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
     WATCHPOINT_ASSERT(list[x]._hostname[0] != 0);
 
     // We have extended the array, and now we will find it, and use it.
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, original_host_size);
     WATCHPOINT_ASSERT(instance);
 
     memcached_string_t hostname= { memcached_string_make_from_cstr(list[x]._hostname) };
diff --git a/libmemcached/include.am b/libmemcached/include.am
index a09a0066..c6e1c6d6 100644
--- a/libmemcached/include.am
+++ b/libmemcached/include.am
@@ -46,6 +46,7 @@ noinst_HEADERS+= libmemcached/udp.hpp
 noinst_HEADERS+= libmemcached/version.hpp 
 noinst_HEADERS+= libmemcached/virtual_bucket.h 
 noinst_HEADERS+= libmemcached/watchpoint.h
+noinst_HEADERS+= libmemcached/windows.hpp
 
 lib_LTLIBRARIES+= libmemcached/libmemcached.la
 EXTRA_libmemcached_libmemcached_la_DEPENDENCIES=
@@ -57,8 +58,8 @@ libmemcached_libmemcached_la_CXXFLAGS= -DBUILDING_LIBMEMCACHED
 if BUILD_WIN32
 libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_HASHKIT
 libmemcached_libmemcached_la_CXXFLAGS+= -DBUILDING_HASHKIT
-libmemcached_libmemcached_la_LIBADD+= -lmingw64
-libmemcached_libmemcached_la_LIBADD+= -lws2_64
+libmemcached_libmemcached_la_LIBADD+= -lmingw32
+libmemcached_libmemcached_la_LIBADD+= -lws2_32
 endif
 
 libmemcached_libmemcached_la_SOURCES+= libmemcached/instance.cc
diff --git a/libmemcached/instance.cc b/libmemcached/instance.cc
index ca3a30d8..82621f7a 100644
--- a/libmemcached/instance.cc
+++ b/libmemcached/instance.cc
@@ -37,7 +37,7 @@
 
 #include <libmemcached/common.h>
 
-static inline void _server_init(org::libmemcached::Instance* self, Memcached *root,
+static inline void _server_init(memcached_instance_st* self, Memcached *root,
                                 const memcached_string_t& hostname,
                                 in_port_t port,
                                 uint32_t weight, memcached_connection_t type)
@@ -87,11 +87,11 @@ static inline void _server_init(org::libmemcached::Instance* self, Memcached *ro
   self->hostname(hostname);
 }
 
-static org::libmemcached::Instance* _server_create(org::libmemcached::Instance* self, const memcached_st *memc)
+static memcached_instance_st* _server_create(memcached_instance_st* self, const memcached_st *memc)
 {
   if (self == NULL)
   {
-   self= libmemcached_xmalloc(memc, org::libmemcached::Instance);
+   self= libmemcached_xmalloc(memc, memcached_instance_st);
 
     if (self == NULL)
     {
@@ -110,7 +110,7 @@ static org::libmemcached::Instance* _server_create(org::libmemcached::Instance*
   return self;
 }
 
-void org::libmemcached::Instance::events(short arg)
+void memcached_instance_st::events(short arg)
 {
   if ((_events | arg) == _events)
   {
@@ -120,7 +120,7 @@ void org::libmemcached::Instance::events(short arg)
   _events|= arg;
 }
 
-void org::libmemcached::Instance::revents(short arg)
+void memcached_instance_st::revents(short arg)
 {
   if (arg)
   {
@@ -131,8 +131,8 @@ void org::libmemcached::Instance::revents(short arg)
   _events&= short(~arg);
 }
 
-org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
-                                                    org::libmemcached::Instance* self,
+memcached_instance_st* __instance_create_with(memcached_st *memc,
+                                                    memcached_instance_st* self,
                                                     const memcached_string_t& hostname,
                                                     const in_port_t port,
                                                     uint32_t weight, 
@@ -162,7 +162,7 @@ org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
   return self;
 }
 
-void __instance_free(org::libmemcached::Instance* self)
+void __instance_free(memcached_instance_st* self)
 {
   memcached_quit_server(self, false);
 
@@ -181,7 +181,7 @@ void __instance_free(org::libmemcached::Instance* self)
   }
 }
 
-void memcached_instance_free(org::libmemcached::Instance* self)
+void memcached_instance_free(memcached_instance_st* self)
 {
   if (self)
   {
@@ -204,7 +204,7 @@ memcached_return_t memcached_server_cursor(const memcached_st* shell,
   size_t errors= 0;
   for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_by_position(memc, x);
+    memcached_instance_st* instance= memcached_instance_by_position(memc, x);
 
     for (uint32_t y= 0; y < number_of_callbacks; y++)
     {
@@ -233,7 +233,7 @@ memcached_return_t memcached_server_execute(memcached_st *memc,
   bool some_errors= false;;
   for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     memcached_return_t rc= (*callback)(memc, instance, context);
     if (rc == MEMCACHED_INVALID_ARGUMENTS)
@@ -250,7 +250,7 @@ memcached_return_t memcached_server_execute(memcached_st *memc,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_server_instance_st memcached_server_by_key(memcached_st *shell,
+const memcached_instance_st * memcached_server_by_key(memcached_st *shell,
                                                      const char *key,
                                                      size_t key_length,
                                                      memcached_return_t *error)
@@ -283,7 +283,7 @@ memcached_server_instance_st memcached_server_by_key(memcached_st *shell,
 /*
   If we do not have a valid object to clone from, we toss an error.
 */
-static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::Instance* source)
+static memcached_instance_st* memcached_instance_clone(memcached_instance_st* source)
 {
   /* We just do a normal create if source is missing */
   if (source == NULL)
@@ -299,7 +299,7 @@ static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::
                                 source->type);
 }
 
-void set_last_disconnected_host(org::libmemcached::Instance* self)
+void set_last_disconnected_host(memcached_instance_st* self)
 {
   assert(self->root);
   if (self->root)
@@ -313,54 +313,48 @@ void set_last_disconnected_host(org::libmemcached::Instance* self)
     // const_cast
     memcached_st *root= (memcached_st *)self->root;
 
-    memcached_instance_free((org::libmemcached::Instance*)(root->last_disconnected_server));
+    memcached_instance_free((memcached_instance_st*)(root->last_disconnected_server));
 
     // We set is_parsing so that no lookup happens
     root->state.is_parsing= true;
     root->last_disconnected_server= memcached_instance_clone(self);
     root->state.is_parsing= false;
 
-    ((org::libmemcached::Instance*)memcached_server_get_last_disconnect(root))->version= self->version;
+    ((memcached_instance_st*)memcached_server_get_last_disconnect(root))->version= self->version;
   }
 }
 
-memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *shell)
+const memcached_instance_st * memcached_server_get_last_disconnect(const memcached_st *shell)
 {
   const Memcached* self= memcached2Memcached(shell);
   if (self)
   {
-    return (memcached_server_instance_st)self->last_disconnected_server;
+    return (const memcached_instance_st *)self->last_disconnected_server;
   }
 
   return 0;
 }
 
-void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time)
+void memcached_instance_next_retry(const memcached_instance_st * self, const time_t absolute_time)
 {
   WATCHPOINT_ASSERT(self);
   if (self)
   {
-    ((org::libmemcached::Instance*)self)->next_retry= absolute_time;
+    ((memcached_instance_st*)self)->next_retry= absolute_time;
   }
 }
 
-namespace org {
-namespace libmemcached {
-
-  bool Instance::valid() const
+bool memcached_instance_st::valid() const
+{
+  if (fd == INVALID_SOCKET)
   {
-    if (fd == INVALID_SOCKET)
-    {
-      return false;
-    }
-
-    return true;
+    return false;
   }
 
-  bool Instance::is_shutting_down() const
-  {
-    return options.is_shutting_down;
-  }
+  return true;
+}
 
-} // namespace libmemcached
-} // namespace org
+bool memcached_instance_st::is_shutting_down() const
+{
+  return options.is_shutting_down;
+}
diff --git a/libmemcached/instance.hpp b/libmemcached/instance.hpp
index d0a772b9..c76dc7ee 100644
--- a/libmemcached/instance.hpp
+++ b/libmemcached/instance.hpp
@@ -58,11 +58,8 @@
 
 #include "libmemcached/string.hpp"
 
-namespace org {
-namespace libmemcached {
-
 // @todo Complete class transformation
-struct Instance {
+struct memcached_instance_st {
   in_port_t port() const
   {
     return port_;
@@ -188,16 +185,13 @@ struct Instance {
   }
 };
 
-} // namespace libmemcached
-} // namespace org
-
-org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
-                                                    org::libmemcached::Instance* self,
-                                                    const memcached_string_t& _hostname,
-                                                    const in_port_t port,
-                                                    uint32_t weight, 
-                                                    const memcached_connection_t type);
+memcached_instance_st* __instance_create_with(memcached_st *memc,
+                                              memcached_instance_st* self,
+                                              const memcached_string_t& _hostname,
+                                              const in_port_t port,
+                                              uint32_t weight, 
+                                              const memcached_connection_t type);
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const org::libmemcached::Instance*, uint32_t);
+memcached_return_t memcached_instance_push(memcached_st *ptr, const memcached_instance_st*, uint32_t);
 
-void __instance_free(org::libmemcached::Instance *);
+void __instance_free(memcached_instance_st *);
diff --git a/libmemcached/io.cc b/libmemcached/io.cc
index f6cc3696..cb8ed5c2 100644
--- a/libmemcached/io.cc
+++ b/libmemcached/io.cc
@@ -40,10 +40,10 @@
 #include <libmemcached/common.h>
 
 #ifdef HAVE_SYS_SOCKET_H
-#  include <sys/socket.h>
+# include <sys/socket.h>
 #endif
 
-void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header& header)
+void initialize_binary_request(memcached_instance_st* server, protocol_binary_request_header& header)
 {
   server->request_id++;
   header.request.magic= PROTOCOL_BINARY_REQ;
@@ -61,7 +61,7 @@ enum memc_read_or_write {
  *
  * @param instance the server to pack
  */
-static bool repack_input_buffer(org::libmemcached::Instance* instance)
+static bool repack_input_buffer(memcached_instance_st* instance)
 {
   if (instance->read_ptr != instance->read_buffer)
   {
@@ -134,7 +134,7 @@ static bool repack_input_buffer(org::libmemcached::Instance* instance)
  * @param instance the server to star processing iput messages for
  * @return true if we processed anything, false otherwise
  */
-static bool process_input_buffer(org::libmemcached::Instance* instance)
+static bool process_input_buffer(memcached_instance_st* instance)
 {
   /*
    ** We might be able to process some of the response messages if we
@@ -176,7 +176,7 @@ static bool process_input_buffer(org::libmemcached::Instance* instance)
   return false;
 }
 
-static memcached_return_t io_wait(org::libmemcached::Instance* instance,
+static memcached_return_t io_wait(memcached_instance_st* instance,
                                   const memc_read_or_write read_or_write)
 {
   /*
@@ -212,7 +212,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance,
 
   if (instance->root->poll_timeout == 0) // Mimic 0 causes timeout behavior (not all platforms do this)
   {
-    return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+    return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("poll_timeout() was set to zero"));
   }
 
   size_t loop_max= 5;
@@ -257,7 +257,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance,
 
     if (active_fd == 0)
     {
-      return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+      return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("No active_fd were found"));
     }
 
     // Only an error should result in this code being called.
@@ -296,7 +296,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance,
                              memcached_literal_param("number of attempts to call io_wait() failed"));
 }
 
-static bool io_flush(org::libmemcached::Instance* instance,
+static bool io_flush(memcached_instance_st* instance,
                      const bool with_flush,
                      memcached_return_t& error)
 {
@@ -407,12 +407,12 @@ static bool io_flush(org::libmemcached::Instance* instance,
   return true;
 }
 
-memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* instance)
+memcached_return_t memcached_io_wait_for_write(memcached_instance_st* instance)
 {
   return io_wait(instance, MEM_WRITE);
 }
 
-static memcached_return_t _io_fill(org::libmemcached::Instance* instance)
+static memcached_return_t _io_fill(memcached_instance_st* instance)
 {
   ssize_t data_read;
   do
@@ -488,7 +488,7 @@ static memcached_return_t _io_fill(org::libmemcached::Instance* instance)
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_read(org::libmemcached::Instance* instance,
+memcached_return_t memcached_io_read(memcached_instance_st* instance,
                                      void *buffer, size_t length, ssize_t& nread)
 {
   assert(memcached_is_udp(instance->root) == false);
@@ -540,7 +540,7 @@ memcached_return_t memcached_io_read(org::libmemcached::Instance* instance,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance)
+memcached_return_t memcached_io_slurp(memcached_instance_st* instance)
 {
   assert_msg(instance, "Programmer error, invalid Instance");
   assert(memcached_is_udp(instance->root) == false);
@@ -597,7 +597,7 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance)
   return MEMCACHED_CONNECTION_FAILURE;
 }
 
-static bool _io_write(org::libmemcached::Instance* instance,
+static bool _io_write(memcached_instance_st* instance,
                       const void *buffer, size_t length, bool with_flush,
                       size_t& written)
 {
@@ -650,13 +650,13 @@ static bool _io_write(org::libmemcached::Instance* instance,
   return true;
 }
 
-bool memcached_io_write(org::libmemcached::Instance* instance)
+bool memcached_io_write(memcached_instance_st* instance)
 {
   size_t written;
   return _io_write(instance, NULL, 0, true, written);
 }
 
-ssize_t memcached_io_write(org::libmemcached::Instance* instance,
+ssize_t memcached_io_write(memcached_instance_st* instance,
                            const void *buffer, const size_t length, const bool with_flush)
 {
   size_t written;
@@ -669,7 +669,7 @@ ssize_t memcached_io_write(org::libmemcached::Instance* instance,
   return ssize_t(written);
 }
 
-bool memcached_io_writev(org::libmemcached::Instance* instance,
+bool memcached_io_writev(memcached_instance_st* instance,
                          libmemcached_io_vector_st vector[],
                          const size_t number_of, const bool with_flush)
 {
@@ -701,7 +701,7 @@ bool memcached_io_writev(org::libmemcached::Instance* instance,
   return (complete_total == total);
 }
 
-void org::libmemcached::Instance::start_close_socket()
+void memcached_instance_st::start_close_socket()
 {
   if (fd != INVALID_SOCKET)
   {
@@ -710,7 +710,7 @@ void org::libmemcached::Instance::start_close_socket()
   }
 }
 
-void org::libmemcached::Instance::reset_socket()
+void memcached_instance_st::reset_socket()
 {
   if (fd != INVALID_SOCKET)
   {
@@ -719,7 +719,7 @@ void org::libmemcached::Instance::reset_socket()
   }
 }
 
-void org::libmemcached::Instance::close_socket()
+void memcached_instance_st::close_socket()
 {
   if (fd != INVALID_SOCKET)
   {
@@ -755,7 +755,7 @@ void org::libmemcached::Instance::close_socket()
   major_version= minor_version= micro_version= UINT8_MAX;
 }
 
-org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, memcached_return_t&)
+memcached_instance_st* memcached_io_get_readable_server(Memcached *memc, memcached_return_t&)
 {
 #define MAX_SERVERS_TO_POLL 100
   struct pollfd fds[MAX_SERVERS_TO_POLL];
@@ -763,7 +763,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
 
   for (uint32_t x= 0; x < memcached_server_count(memc) and host_index < MAX_SERVERS_TO_POLL; ++x)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     if (instance->read_buffer_length > 0) /* I have data in the buffer */
     {
@@ -784,7 +784,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
     /* We have 0 or 1 server with pending events.. */
     for (uint32_t x= 0; x< memcached_server_count(memc); ++x)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+      memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
       if (instance->response_count() > 0)
       {
@@ -811,7 +811,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
       {
         for (uint32_t y= 0; y < memcached_server_count(memc); ++y)
         {
-          org::libmemcached::Instance* instance= memcached_instance_fetch(memc, y);
+          memcached_instance_st* instance= memcached_instance_fetch(memc, y);
 
           if (instance->fd == fds[x].fd)
           {
@@ -828,7 +828,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
 /*
   Eventually we will just kill off the server with the problem.
 */
-void memcached_io_reset(org::libmemcached::Instance* instance)
+void memcached_io_reset(memcached_instance_st* instance)
 {
   memcached_quit_server(instance, true);
 }
@@ -837,7 +837,7 @@ void memcached_io_reset(org::libmemcached::Instance* instance)
  * Read a given number of bytes from the server and place it into a specific
  * buffer. Reset the IO channel on this server if an error occurs.
  */
-memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance,
+memcached_return_t memcached_safe_read(memcached_instance_st* instance,
                                        void *dta,
                                        const size_t size)
 {
@@ -862,7 +862,7 @@ memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_readline(org::libmemcached::Instance* instance,
+memcached_return_t memcached_io_readline(memcached_instance_st* instance,
                                          char *buffer_ptr,
                                          size_t size,
                                          size_t& total_nr)
diff --git a/libmemcached/io.hpp b/libmemcached/io.hpp
index bf2133e8..f3fed345 100644
--- a/libmemcached/io.hpp
+++ b/libmemcached/io.hpp
@@ -38,35 +38,35 @@
 
 #pragma once
 
-void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header&);
+void initialize_binary_request(memcached_instance_st* server, protocol_binary_request_header&);
 
-bool memcached_io_write(org::libmemcached::Instance* ptr);
+bool memcached_io_write(memcached_instance_st* ptr);
 
-ssize_t memcached_io_write(org::libmemcached::Instance* ptr,
+ssize_t memcached_io_write(memcached_instance_st* ptr,
                            const void *buffer, size_t length, bool with_flush);
 
-bool memcached_io_writev(org::libmemcached::Instance* ptr,
+bool memcached_io_writev(memcached_instance_st* ptr,
                          libmemcached_io_vector_st vector[],
                          const size_t number_of, const bool with_flush);
 
-memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* ptr);
+memcached_return_t memcached_io_wait_for_write(memcached_instance_st* ptr);
 
-void memcached_io_reset(org::libmemcached::Instance* ptr);
+void memcached_io_reset(memcached_instance_st* ptr);
 
-memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_io_read(memcached_instance_st* ptr,
                                      void *buffer, size_t length, ssize_t& nread);
 
 /* Read a line (terminated by '\n') into the buffer */
-memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_io_readline(memcached_instance_st* ptr,
                                          char *buffer_ptr,
                                          size_t size,
                                          size_t& total);
 
 /* Read n bytes of data from the server and store them in dta */
-memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_safe_read(memcached_instance_st* ptr,
                                        void *dta,
                                        const size_t size);
 
-org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&);
+memcached_instance_st* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&);
 
-memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr);
+memcached_return_t memcached_io_slurp(memcached_instance_st* ptr);
diff --git a/libmemcached/memcached.cc b/libmemcached/memcached.cc
index 41c058cd..e1519d1e 100644
--- a/libmemcached/memcached.cc
+++ b/libmemcached/memcached.cc
@@ -136,7 +136,7 @@ static void __memcached_free(Memcached *ptr, bool release_st)
 
   memcached_virtual_bucket_free(ptr);
 
-  memcached_instance_free((org::libmemcached::Instance*)ptr->last_disconnected_server);
+  memcached_instance_free((memcached_instance_st*)ptr->last_disconnected_server);
 
   if (ptr->on_cleanup)
   {
@@ -297,7 +297,7 @@ void memcached_reset_last_disconnected_server(memcached_st *shell)
   Memcached* self= memcached2Memcached(shell);
   if (self)
   {
-    memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server);
+    memcached_instance_free((memcached_instance_st*)self->last_disconnected_server);
     self->last_disconnected_server= NULL;
   }
 }
@@ -432,10 +432,10 @@ void *memcached_set_user_data(memcached_st *shell, void *data)
 
 memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source)
 {
-  return memcached_instance_push(destination, (org::libmemcached::Instance*)source->servers, source->number_of_hosts);
+  return memcached_instance_push(destination, (memcached_instance_st*)source->servers, source->number_of_hosts);
 }
 
-org::libmemcached::Instance* memcached_instance_fetch(Memcached *ptr, uint32_t server_key)
+memcached_instance_st* memcached_instance_fetch(Memcached *ptr, uint32_t server_key)
 {
   if (ptr == NULL)
   {
@@ -445,7 +445,7 @@ org::libmemcached::Instance* memcached_instance_fetch(Memcached *ptr, uint32_t s
   return &ptr->servers[server_key];
 }
 
-memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *shell, uint32_t server_key)
+const memcached_instance_st * memcached_server_instance_by_position(const memcached_st *shell, uint32_t server_key)
 {
   const Memcached* memc= memcached2Memcached(shell);
   if (memc)
@@ -456,7 +456,7 @@ memcached_server_instance_st memcached_server_instance_by_position(const memcach
   return NULL;
 }
 
-org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *shell, uint32_t server_key)
+memcached_instance_st* memcached_instance_by_position(const memcached_st *shell, uint32_t server_key)
 {
   const Memcached* memc= memcached2Memcached(shell);
   if (memc)
@@ -478,12 +478,12 @@ uint64_t memcached_query_id(const memcached_st *shell)
   return 0;
 }
 
-org::libmemcached::Instance* memcached_instance_list(const memcached_st *shell)
+memcached_instance_st* memcached_instance_list(const memcached_st *shell)
 {
   const Memcached* memc= memcached2Memcached(shell);
   if (memc)
   {
-    return (org::libmemcached::Instance*)memc->servers;
+    return (memcached_instance_st*)memc->servers;
   }
 
   return NULL;
diff --git a/libmemcached/parse.cc b/libmemcached/parse.cc
index 3284a4f6..7665b731 100644
--- a/libmemcached/parse.cc
+++ b/libmemcached/parse.cc
@@ -87,7 +87,13 @@ memcached_server_list_st memcached_servers_parse(const char *server_strings)
 
       ptr++;
 
+      errno= 0;
       port= (in_port_t) strtoul(ptr, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        memcached_server_free(servers);
+        return NULL;
+      }
 
       ptr2= index(ptr, ' ');
       if (! ptr2)
@@ -96,14 +102,22 @@ memcached_server_list_st memcached_servers_parse(const char *server_strings)
       if (ptr2)
       {
         ptr2++;
-        weight = (uint32_t) strtoul(ptr2, (char **)NULL, 10);
+        errno= 0;
+        weight= uint32_t(strtoul(ptr2, (char **)NULL, 10));
+        if (errno != 0)
+        {
+          memcached_server_free(servers);
+          return NULL;
+        }
       }
     }
 
     servers= memcached_server_list_append_with_weight(servers, buffer, port, weight, &rc);
 
     if (isspace(*begin_ptr))
+    {
       begin_ptr++;
+    }
   }
 
   return servers;
diff --git a/libmemcached/poll.cc b/libmemcached/poll.cc
index abd15d4c..6fdf242c 100644
--- a/libmemcached/poll.cc
+++ b/libmemcached/poll.cc
@@ -12,7 +12,7 @@
 
 #include "libmemcached/common.h"
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 #include "libmemcached/poll.h"
 
 #include <sys/time.h>
@@ -31,7 +31,7 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo)
   {
     if (fds[x].events & (POLLIN | POLLOUT))
     {
-#ifndef WIN32
+#ifndef _WIN32
       if (fds[x].fd > maxfd)
       {
         maxfd= fds[x].fd;
@@ -82,4 +82,4 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo)
    return ret;
 }
 
-#endif // defined(WIN32) || defined(__MINGW32__)
+#endif // defined(_WIN32)
diff --git a/libmemcached/poll.h b/libmemcached/poll.h
index 8445f009..46636c40 100644
--- a/libmemcached/poll.h
+++ b/libmemcached/poll.h
@@ -12,7 +12,7 @@
 
 #pragma once
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 
 #include <winsock2.h>
 
@@ -22,7 +22,7 @@ extern "C" {
 
 typedef struct pollfd
 {
-#ifdef WIN32
+#if defined(_WIN32)
   SOCKET fd;
 #else
   int fd;
@@ -45,4 +45,4 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo);
 }
 #endif
 
-#endif // defined(WIN32) || defined(__MINGW32__)
+#endif // defined(_WIN32)
diff --git a/libmemcached/purge.cc b/libmemcached/purge.cc
index b1390d9c..5f6d4bb7 100644
--- a/libmemcached/purge.cc
+++ b/libmemcached/purge.cc
@@ -79,7 +79,7 @@ private:
   int32_t& _origin;
 };
 
-bool memcached_purge(org::libmemcached::Instance* ptr)
+bool memcached_purge(memcached_instance_st* ptr)
 {
   Memcached *root= (Memcached *)ptr->root;
 
diff --git a/libmemcached/quit.cc b/libmemcached/quit.cc
index 61930beb..7ece03b9 100644
--- a/libmemcached/quit.cc
+++ b/libmemcached/quit.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 
 namespace {
-  memcached_return_t send_quit_message(org::libmemcached::Instance* instance)
+  memcached_return_t send_quit_message(memcached_instance_st* instance)
   {
     memcached_return_t rc;
     if (instance->root->flags.binary_protocol)
@@ -70,7 +70,7 @@ namespace {
     return rc;
   }
 
-  void drain_instance(org::libmemcached::Instance* instance)
+  void drain_instance(memcached_instance_st* instance)
   {
     /* read until socket is closed, or there is an error
      * closing the socket before all data is read
@@ -105,7 +105,7 @@ namespace {
   will force data to be completed.
 */
 
-void memcached_quit_server(org::libmemcached::Instance* instance, bool io_death)
+void memcached_quit_server(memcached_instance_st* instance, bool io_death)
 {
   if (instance->valid())
   {
@@ -130,7 +130,7 @@ void send_quit(Memcached *memc)
 {
   for (uint32_t x= 0; x < memcached_server_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     memcached_quit_server(instance, false);
   }
diff --git a/libmemcached/quit.hpp b/libmemcached/quit.hpp
index 76737b95..a48a8a7e 100644
--- a/libmemcached/quit.hpp
+++ b/libmemcached/quit.hpp
@@ -36,6 +36,6 @@
 
 #pragma once
 
-void memcached_quit_server(org::libmemcached::Instance* ptr, bool io_death);
+void memcached_quit_server(memcached_instance_st* ptr, bool io_death);
 
 void send_quit(memcached_st *ptr);
diff --git a/libmemcached/response.cc b/libmemcached/response.cc
index c3d7f2c8..f382671d 100644
--- a/libmemcached/response.cc
+++ b/libmemcached/response.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 #include <libmemcached/string.hpp>
 
-static memcached_return_t textual_value_fetch(org::libmemcached::Instance* instance,
+static memcached_return_t textual_value_fetch(memcached_instance_st* instance,
                                               char *buffer,
                                               memcached_result_st *result)
 {
@@ -90,9 +90,11 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta
   }
 
   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+
+  errno= 0;
   result->impl()->item_flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
 
-  if (end_ptr == string_ptr)
+  if (errno != 0 or end_ptr == string_ptr)
   {
     goto read_error;
   }
@@ -105,9 +107,10 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta
   }
 
   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+  errno= 0;
   value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
 
-  if (end_ptr == string_ptr)
+  if (errno != 0 or end_ptr == string_ptr)
   {
     goto read_error;
   }
@@ -121,11 +124,14 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta
   else
   {
     string_ptr++;
+
     for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+
+    errno= 0;
     result->impl()->item_cas= strtoull(next_ptr, &string_ptr, 10);
   }
 
-  if (end_ptr < string_ptr)
+  if (errno != 0 or end_ptr < string_ptr)
   {
     goto read_error;
   }
@@ -207,7 +213,7 @@ read_error:
   return MEMCACHED_PARTIAL_READ;
 }
 
-static memcached_return_t textual_read_one_response(org::libmemcached::Instance* instance,
+static memcached_return_t textual_read_one_response(memcached_instance_st* instance,
                                                     char *buffer, const size_t buffer_length,
                                                     memcached_result_st *result)
 {
@@ -238,8 +244,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         char *response_ptr= index(buffer, ' ');
 
         char *endptr;
+        errno= 0;
         long int version= strtol(response_ptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version"));
@@ -247,8 +254,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         instance->major_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version"));
@@ -256,8 +264,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         instance->minor_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
@@ -442,6 +451,7 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
   case '8': /* INCR/DECR response */
   case '9': /* INCR/DECR response */
     {
+      errno= 0;
       unsigned long long int auto_return_value= strtoull(buffer, (char **)NULL, 10);
 
       if (auto_return_value == ULLONG_MAX and errno == ERANGE)
@@ -456,6 +466,12 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT,
                                    memcached_literal_param("Numeric response was out of range"));
       }
+      else if (errno != 0)
+      {
+        result->impl()->numeric_value= UINT64_MAX;
+        return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT,
+                                   memcached_literal_param("Numeric response was out of range"));
+      }
 
       result->impl()->numeric_value= uint64_t(auto_return_value);
 
@@ -480,7 +496,7 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
                              buffer, total_read);
 }
 
-static memcached_return_t binary_read_one_response(org::libmemcached::Instance* instance,
+static memcached_return_t binary_read_one_response(memcached_instance_st* instance,
                                                    char *buffer, const size_t buffer_length,
                                                    memcached_result_st *result)
 {
@@ -620,8 +636,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
         }
 
         char *endptr;
+        errno= 0;
         long int version= strtol(version_buffer, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version"));
@@ -629,8 +646,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
         instance->major_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version"));
@@ -638,8 +656,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
         instance->minor_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
@@ -648,6 +667,25 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
       }
       break;
 
+    case PROTOCOL_BINARY_CMD_TOUCH:
+      {
+        rc= MEMCACHED_SUCCESS;
+        if (bodylen == 4) // The four byte read is a bug?
+        {
+          char touch_buffer[4]; // @todo document this number
+          rc= memcached_safe_read(instance, touch_buffer, sizeof(touch_buffer));
+#if 0
+          fprintf(stderr, "%s:%d %d %d %d %d %.*s(%d)\n", __FILE__, __LINE__,
+                  int(touch_buffer[0]),
+                  int(touch_buffer[1]),
+                  int(touch_buffer[2]),
+                  int(touch_buffer[3]),
+                  int(bodylen), touch_buffer, int(bodylen));
+#endif
+        }
+        return memcached_set_error(*instance, rc, MEMCACHED_AT);
+      }
+
     case PROTOCOL_BINARY_CMD_FLUSH:
     case PROTOCOL_BINARY_CMD_QUIT:
     case PROTOCOL_BINARY_CMD_SET:
@@ -656,13 +694,8 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
     case PROTOCOL_BINARY_CMD_APPEND:
     case PROTOCOL_BINARY_CMD_PREPEND:
     case PROTOCOL_BINARY_CMD_DELETE:
-    case PROTOCOL_BINARY_CMD_TOUCH:
       {
-        if (bodylen != 0)
-        {
-          char touch_buffer[32]; // @todo document this number
-          rc= memcached_safe_read(instance, buffer, sizeof(touch_buffer));
-        }
+        WATCHPOINT_ASSERT(bodylen == 0);
         return MEMCACHED_SUCCESS;
       }
 
@@ -801,7 +834,7 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
   return rc;
 }
 
-static memcached_return_t _read_one_response(org::libmemcached::Instance* instance,
+static memcached_return_t _read_one_response(memcached_instance_st* instance,
                                              char *buffer, const size_t buffer_length,
                                              memcached_result_st *result)
 {
@@ -831,7 +864,7 @@ static memcached_return_t _read_one_response(org::libmemcached::Instance* instan
   return rc;
 }
 
-memcached_return_t memcached_read_one_response(org::libmemcached::Instance* instance,
+memcached_return_t memcached_read_one_response(memcached_instance_st* instance,
                                                memcached_result_st *result)
 {
   char buffer[SMALL_STRING_LEN];
@@ -845,7 +878,7 @@ memcached_return_t memcached_read_one_response(org::libmemcached::Instance* inst
   return _read_one_response(instance, buffer, sizeof(buffer), result);
 }
 
-memcached_return_t memcached_response(org::libmemcached::Instance* instance,
+memcached_return_t memcached_response(memcached_instance_st* instance,
                                       memcached_result_st *result)
 {
   char buffer[1024];
@@ -853,7 +886,7 @@ memcached_return_t memcached_response(org::libmemcached::Instance* instance,
   return memcached_response(instance, buffer, sizeof(buffer), result);
 }
 
-memcached_return_t memcached_response(org::libmemcached::Instance* instance,
+memcached_return_t memcached_response(memcached_instance_st* instance,
                                       char *buffer, size_t buffer_length,
                                       memcached_result_st *result)
 {
diff --git a/libmemcached/response.h b/libmemcached/response.h
index 6d6d5644..c066f3b3 100644
--- a/libmemcached/response.h
+++ b/libmemcached/response.h
@@ -38,12 +38,12 @@
 #pragma once
 
 /* Read a single response from the server */
-memcached_return_t memcached_read_one_response(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_read_one_response(memcached_instance_st* ptr,
                                                memcached_result_st *result);
 
-memcached_return_t memcached_response(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_response(memcached_instance_st* ptr,
                                       memcached_result_st *result);
 
-memcached_return_t memcached_response(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_response(memcached_instance_st* ptr,
                                       char *buffer, size_t buffer_length,
                                       memcached_result_st *result);
diff --git a/libmemcached/sasl.cc b/libmemcached/sasl.cc
index 8e180d6f..ee225868 100644
--- a/libmemcached/sasl.cc
+++ b/libmemcached/sasl.cc
@@ -75,7 +75,7 @@ sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *shell)
  * @param raddr remote address (out)
  * @return true on success false otherwise (errno contains more info)
  */
-static memcached_return_t resolve_names(org::libmemcached::Instance& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
+static memcached_return_t resolve_names(memcached_instance_st& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
 {
   char host[MEMCACHED_NI_MAXHOST];
   char port[MEMCACHED_NI_MAXSERV];
@@ -133,7 +133,7 @@ static void sasl_startup_function(void)
 
 } // extern "C"
 
-memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server)
+memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server)
 {
   if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
   {
diff --git a/libmemcached/sasl.hpp b/libmemcached/sasl.hpp
index c990cfb8..bda6b227 100644
--- a/libmemcached/sasl.hpp
+++ b/libmemcached/sasl.hpp
@@ -39,4 +39,4 @@
 
 memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st *source);
 
-memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server);
+memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server);
diff --git a/libmemcached/server.cc b/libmemcached/server.cc
index ba40a6ee..b38120ad 100644
--- a/libmemcached/server.cc
+++ b/libmemcached/server.cc
@@ -191,7 +191,7 @@ uint32_t memcached_server_count(const memcached_st *self)
   return self->number_of_hosts;
 }
 
-const char *memcached_server_name(const memcached_server_instance_st self)
+const char *memcached_server_name(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);
   if (self)
@@ -202,7 +202,7 @@ const char *memcached_server_name(const memcached_server_instance_st self)
   return NULL;
 }
 
-in_port_t memcached_server_port(const memcached_server_instance_st self)
+in_port_t memcached_server_port(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);
   if (self == NULL)
@@ -213,7 +213,7 @@ in_port_t memcached_server_port(const memcached_server_instance_st self)
   return self->port();
 }
 
-uint32_t memcached_server_response_count(const memcached_server_instance_st self)
+uint32_t memcached_server_response_count(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);
   if (self == NULL)
@@ -224,7 +224,7 @@ uint32_t memcached_server_response_count(const memcached_server_instance_st self
   return self->cursor_active_;
 }
 
-const char *memcached_server_type(const memcached_server_instance_st ptr)
+const char *memcached_server_type(const memcached_instance_st * ptr)
 {
   if (ptr)
   {
@@ -244,7 +244,7 @@ const char *memcached_server_type(const memcached_server_instance_st ptr)
   return "UNKNOWN";
 }
 
-uint8_t memcached_server_major_version(const memcached_server_instance_st instance)
+uint8_t memcached_server_major_version(const memcached_instance_st * instance)
 {
   if (instance)
   {
@@ -254,7 +254,7 @@ uint8_t memcached_server_major_version(const memcached_server_instance_st instan
   return UINT8_MAX;
 }
 
-uint8_t memcached_server_minor_version(const memcached_server_instance_st instance)
+uint8_t memcached_server_minor_version(const memcached_instance_st * instance)
 {
   if (instance)
   {
@@ -264,7 +264,7 @@ uint8_t memcached_server_minor_version(const memcached_server_instance_st instan
   return UINT8_MAX;
 }
 
-uint8_t memcached_server_micro_version(const memcached_server_instance_st instance)
+uint8_t memcached_server_micro_version(const memcached_instance_st * instance)
 {
   if (instance)
   {
diff --git a/libmemcached/server.hpp b/libmemcached/server.hpp
index 8cbdc151..0c6ac798 100644
--- a/libmemcached/server.hpp
+++ b/libmemcached/server.hpp
@@ -68,11 +68,11 @@ static inline bool memcached_is_valid_filename(const memcached_string_t& arg)
   return arg.c_str != NULL and arg.size > 0 and arg.size < MEMCACHED_NI_MAXHOST;
 }
 
-void memcached_instance_free(org::libmemcached::Instance *);
+void memcached_instance_free(memcached_instance_st *);
 
-void set_last_disconnected_host(org::libmemcached::Instance* self);
+void set_last_disconnected_host(memcached_instance_st* self);
 
-static inline void memcached_mark_server_for_timeout(org::libmemcached::Instance* server)
+static inline void memcached_mark_server_for_timeout(memcached_instance_st* server)
 {
   if (server->state != MEMCACHED_SERVER_STATE_IN_TIMEOUT)
   {
diff --git a/libmemcached/server_instance.h b/libmemcached/server_instance.h
index 3b69b77b..187f2744 100644
--- a/libmemcached/server_instance.h
+++ b/libmemcached/server_instance.h
@@ -38,8 +38,7 @@
 #pragma once
 
 #ifdef __cplusplus
-namespace org { namespace libmemcached { struct Instance; } }
-typedef struct org::libmemcached::Instance* memcached_server_write_instance_st;
+typedef struct memcached_instance_st* memcached_server_write_instance_st;
 #else
 typedef void* memcached_server_write_instance_st;
 #endif
diff --git a/libmemcached/server_list.cc b/libmemcached/server_list.cc
index b42a9095..b5d5b72e 100644
--- a/libmemcached/server_list.cc
+++ b/libmemcached/server_list.cc
@@ -127,7 +127,7 @@ uint32_t memcached_instance_list_count(const memcached_st* self)
     : self->number_of_hosts;
 }
 
-void memcached_instance_set(memcached_st* memc, org::libmemcached::Instance* list, const uint32_t host_list_size)
+void memcached_instance_set(memcached_st* memc, memcached_instance_st* list, const uint32_t host_list_size)
 {
   assert(memc);
   memc->servers= list;
@@ -148,7 +148,7 @@ void memcached_server_list_free(memcached_server_list_st self)
   }
 }
 
-void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t instance_count)
+void memcached_instance_list_free(memcached_instance_st* self, uint32_t instance_count)
 {
   if (self)
   {
diff --git a/libmemcached/server_list.hpp b/libmemcached/server_list.hpp
index ffbb6a36..0280332c 100644
--- a/libmemcached/server_list.hpp
+++ b/libmemcached/server_list.hpp
@@ -36,12 +36,12 @@
 
 #pragma once
 
-org::libmemcached::Instance* memcached_instance_list(const memcached_st *);
+memcached_instance_st* memcached_instance_list(const memcached_st *);
 
 uint32_t memcached_instance_list_count(const memcached_st*);
 
 uint32_t memcached_servers_set_count(memcached_server_list_st servers, uint32_t count);
 
-void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t count);
+void memcached_instance_list_free(memcached_instance_st* self, uint32_t count);
 
-void memcached_instance_set(memcached_st*, org::libmemcached::Instance*, const uint32_t host_list_size);
+void memcached_instance_set(memcached_st*, memcached_instance_st*, const uint32_t host_list_size);
diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc
index 89d5be52..d70972ef 100644
--- a/libmemcached/stats.cc
+++ b/libmemcached/stats.cc
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are
@@ -91,7 +91,12 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
   }
   else if (strcmp("pid", key) == 0)
   {
+    errno= 0;
     int64_t temp= strtoll(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
 
     if (temp <= INT32_MAX and ( sizeof(pid_t) == sizeof(int32_t) ))
     {
@@ -109,11 +114,21 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
   }
   else if (not strcmp("uptime", key))
   {
+    errno= 0;
     memc_stat->uptime= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("time", key))
   {
+    errno= 0;
     memc_stat->time= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("version", key))
   {
@@ -122,7 +137,12 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
   }
   else if (not strcmp("pointer_size", key))
   {
+    errno= 0;
     memc_stat->pointer_size= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("rusage_user", key))
   {
@@ -130,8 +150,20 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
     for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
     *walk_ptr= 0;
     walk_ptr++;
+
+    errno= 0;
     memc_stat->rusage_user_seconds= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
+
+    errno= 0;
     memc_stat->rusage_user_microseconds= strtoul(walk_ptr, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("rusage_system", key))
   {
@@ -139,85 +171,172 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
     for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
     *walk_ptr= 0;
     walk_ptr++;
+
+    errno= 0;
     memc_stat->rusage_system_seconds= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
+
+    errno= 0;
     memc_stat->rusage_system_microseconds= strtoul(walk_ptr, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("curr_items", key))
   {
+    errno= 0;
     memc_stat->curr_items= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("total_items", key))
   {
+    errno= 0;
     memc_stat->total_items= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("bytes_read", key))
   {
+    errno= 0;
     memc_stat->bytes_read= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("bytes_written", key))
   {
+    errno= 0;
     memc_stat->bytes_written= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("bytes", key))
   {
+    errno= 0;
     memc_stat->bytes= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("curr_connections", key))
   {
+    errno= 0;
     memc_stat->curr_connections= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("total_connections", key))
   {
+    errno= 0;
     memc_stat->total_connections= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("connection_structures", key))
   {
+    errno= 0;
     memc_stat->connection_structures= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("cmd_get", key))
   {
+    errno= 0;
     memc_stat->cmd_get= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("cmd_set", key))
   {
+    errno= 0;
     memc_stat->cmd_set= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("get_hits", key))
   {
+    errno= 0;
     memc_stat->get_hits= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("get_misses", key))
   {
+    errno= 0;
     memc_stat->get_misses= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("evictions", key))
   {
+    errno= 0;
     memc_stat->evictions= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("limit_maxbytes", key))
   {
+    errno= 0;
     memc_stat->limit_maxbytes= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("threads", key))
   {
+    errno= 0;
     memc_stat->threads= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
-  else if (not (strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */
-                strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */
-                strcmp("incr_misses", key) == 0 or
-                strcmp("incr_hits", key) == 0 or
-                strcmp("decr_misses", key) == 0 or
-                strcmp("decr_hits", key) == 0 or
-                strcmp("cas_misses", key) == 0 or
-                strcmp("cas_hits", key) == 0 or
-                strcmp("cas_badval", key) == 0 or
-                strcmp("cmd_flush", key) == 0 or
-                strcmp("accepting_conns", key) == 0 or
-                strcmp("listen_disabled_num", key) == 0 or
-                strcmp("conn_yields", key) == 0 or
-                strcmp("auth_cmds", key) == 0 or
-                strcmp("auth_errors", key) == 0 or
-                strcmp("reclaimed", key) == 0))
+  else if ((strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */
+            strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */
+            strcmp("incr_misses", key) == 0 or
+            strcmp("incr_hits", key) == 0 or
+            strcmp("decr_misses", key) == 0 or
+            strcmp("decr_hits", key) == 0 or
+            strcmp("cas_misses", key) == 0 or
+            strcmp("cas_hits", key) == 0 or
+            strcmp("cas_badval", key) == 0 or
+            strcmp("cmd_flush", key) == 0 or
+            strcmp("accepting_conns", key) == 0 or
+            strcmp("listen_disabled_num", key) == 0 or
+            strcmp("conn_yields", key) == 0 or
+            strcmp("auth_cmds", key) == 0 or
+            strcmp("auth_errors", key) == 0 or
+            strcmp("reclaimed", key) == 0) == 0)
   {
     WATCHPOINT_STRING(key);
     /* return MEMCACHED_UNKNOWN_STAT_KEY; */
@@ -358,7 +477,7 @@ char *memcached_stat_get_value(const memcached_st *, memcached_stat_st *memc_sta
 static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
                                              const char *args,
                                              const size_t args_length,
-                                             org::libmemcached::Instance* instance,
+                                             memcached_instance_st* instance,
                                              struct local_context *check)
 {
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
@@ -448,7 +567,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
 static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
                                             const char *args,
                                             const size_t args_length,
-                                            org::libmemcached::Instance* instance,
+                                            memcached_instance_st* instance,
                                             struct local_context *check)
 {
   libmemcached_io_vector_st vector[]=
@@ -565,7 +684,7 @@ memcached_stat_st *memcached_stat(memcached_st *shell, char *args, memcached_ret
     stat_instance->pid= -1;
     stat_instance->root= self;
 
-    org::libmemcached::Instance* instance= memcached_instance_fetch(self, x);
+    memcached_instance_st* instance= memcached_instance_fetch(self, x);
 
     memcached_return_t temp_return;
     if (memcached_is_binary(self))
@@ -632,7 +751,7 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
 
     if (memcached_success(rc))
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
+      memcached_instance_st* instance= memcached_instance_fetch(memc_ptr, 0);
       if (memc.flags.binary_protocol)
       {
         rc= binary_stats_fetch(memc_stat, args, args_length, instance, NULL);
@@ -694,7 +813,7 @@ void memcached_stat_free(const memcached_st *, memcached_stat_st *memc_stat)
 }
 
 static memcached_return_t call_stat_fn(memcached_st *memc,
-                                       org::libmemcached::Instance* instance,
+                                       memcached_instance_st* instance,
                                        void *context)
 {
   if (memc)
diff --git a/libmemcached/storage.cc b/libmemcached/storage.cc
index 558d2ed5..80b5a7f1 100644
--- a/libmemcached/storage.cc
+++ b/libmemcached/storage.cc
@@ -139,7 +139,7 @@ static inline uint8_t get_com_code(const memcached_storage_action_t verb, const
 }
 
 static memcached_return_t memcached_send_binary(Memcached *ptr,
-                                                org::libmemcached::Instance* server,
+                                                memcached_instance_st* server,
                                                 uint32_t server_key,
                                                 const char *key,
                                                 const size_t key_length,
@@ -218,7 +218,7 @@ static memcached_return_t memcached_send_binary(Memcached *ptr,
         server_key= 0;
       }
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
       if (memcached_vdo(instance, vector, 5, false) != MEMCACHED_SUCCESS)
       {
@@ -246,7 +246,7 @@ static memcached_return_t memcached_send_binary(Memcached *ptr,
 }
 
 static memcached_return_t memcached_send_ascii(Memcached *ptr,
-                                               org::libmemcached::Instance* instance,
+                                               memcached_instance_st* instance,
                                                const char *key,
                                                const size_t key_length,
                                                const char *value,
@@ -373,7 +373,7 @@ static inline memcached_return_t memcached_send(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
   WATCHPOINT_SET(instance->io_wait_count.read= 0);
   WATCHPOINT_SET(instance->io_wait_count.write= 0);
diff --git a/libmemcached/touch.cc b/libmemcached/touch.cc
index 0c24aed1..1f793c55 100644
--- a/libmemcached/touch.cc
+++ b/libmemcached/touch.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 #include <libmemcached/memcached/protocol_binary.h>
 
-static memcached_return_t ascii_touch(org::libmemcached::Instance* instance,
+static memcached_return_t ascii_touch(memcached_instance_st* instance,
                                       const char *key, size_t key_length,
                                       time_t expiration)
 {
@@ -70,7 +70,7 @@ static memcached_return_t ascii_touch(org::libmemcached::Instance* instance,
   return rc;
 }
 
-static memcached_return_t binary_touch(org::libmemcached::Instance* instance,
+static memcached_return_t binary_touch(memcached_instance_st* instance,
                                        const char *key, size_t key_length,
                                        time_t expiration)
 {
@@ -130,7 +130,7 @@ memcached_return_t memcached_touch_by_key(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
   if (ptr->flags.binary_protocol)
   {
diff --git a/libmemcached/udp.cc b/libmemcached/udp.cc
index 923e2734..5d21f9ff 100644
--- a/libmemcached/udp.cc
+++ b/libmemcached/udp.cc
@@ -48,7 +48,7 @@
  * extracts the message number from message_id, increments it and then
  * writes the new value back into the header
  */
-void increment_udp_message_id(org::libmemcached::Instance* ptr)
+void increment_udp_message_id(memcached_instance_st* ptr)
 {
   struct udp_datagram_header_st *header= (struct udp_datagram_header_st *)ptr->write_buffer;
   uint16_t cur_req= get_udp_datagram_request_id(header);
@@ -61,7 +61,7 @@ void increment_udp_message_id(org::libmemcached::Instance* ptr)
   header->request_id= htons((uint16_t) (thread_id | msg_num));
 }
 
-bool memcached_io_init_udp_header(org::libmemcached::Instance* ptr, const uint16_t thread_id)
+bool memcached_io_init_udp_header(memcached_instance_st* ptr, const uint16_t thread_id)
 {
   if (thread_id > UDP_REQUEST_ID_MAX_THREAD_ID)
   {
diff --git a/libmemcached/udp.hpp b/libmemcached/udp.hpp
index b2d2e9e9..7442c597 100644
--- a/libmemcached/udp.hpp
+++ b/libmemcached/udp.hpp
@@ -55,5 +55,5 @@ struct udp_datagram_header_st
   uint16_t reserved;
 };
 
-bool memcached_io_init_udp_header(org::libmemcached::Instance*, const uint16_t thread_id);
-void increment_udp_message_id(org::libmemcached::Instance*);
+bool memcached_io_init_udp_header(memcached_instance_st*, const uint16_t thread_id);
+void increment_udp_message_id(memcached_instance_st*);
diff --git a/libmemcached/verbosity.cc b/libmemcached/verbosity.cc
index 7f3a16e4..ed0e2440 100644
--- a/libmemcached/verbosity.cc
+++ b/libmemcached/verbosity.cc
@@ -44,7 +44,7 @@ struct context_st
 };
 
 static memcached_return_t _set_verbosity(const Memcached *,
-                                         const memcached_server_instance_st server,
+                                         const memcached_instance_st * server,
                                          void *context)
 {
  libmemcached_io_vector_st *vector= (libmemcached_io_vector_st *)context;
@@ -56,7 +56,7 @@ static memcached_return_t _set_verbosity(const Memcached *,
 
   if (rc == MEMCACHED_SUCCESS)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
+    memcached_instance_st* instance= memcached_instance_fetch(memc_ptr, 0);
 
 
     rc= memcached_vdo(instance, vector, 4, true);
diff --git a/libmemcached/version.cc b/libmemcached/version.cc
index bbe46cc5..5f074912 100644
--- a/libmemcached/version.cc
+++ b/libmemcached/version.cc
@@ -52,7 +52,7 @@ static inline memcached_return_t memcached_version_textual(Memcached *memc)
   bool errors_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     // Optimization, we only fetch version once.
     if (instance->major_version != UINT8_MAX)
@@ -73,7 +73,7 @@ static inline memcached_return_t memcached_version_textual(Memcached *memc)
   if (success)
   {
     // Collect the returned items
-    org::libmemcached::Instance* instance;
+    memcached_instance_st* instance;
     memcached_return_t readable_error;
     while ((instance= memcached_io_get_readable_server(memc, readable_error)))
     {
@@ -105,7 +105,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc)
   bool errors_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(memc); x++) 
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     initialize_binary_request(instance, request.message.header);
 
@@ -128,7 +128,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc)
   if (success)
   {
     // Collect the returned items
-    org::libmemcached::Instance* instance;
+    memcached_instance_st* instance;
     memcached_return_t readable_error;
     while ((instance= memcached_io_get_readable_server(memc, readable_error)))
     {
@@ -145,7 +145,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc)
   return errors_happened ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS;
 }
 
-static inline void version_ascii_instance(org::libmemcached::Instance* instance)
+static inline void version_ascii_instance(memcached_instance_st* instance)
 {
   if (instance->major_version != UINT8_MAX)
   {
@@ -158,7 +158,7 @@ static inline void version_ascii_instance(org::libmemcached::Instance* instance)
   }
 }
 
-static inline void version_binary_instance(org::libmemcached::Instance* instance)
+static inline void version_binary_instance(memcached_instance_st* instance)
 {
   if (instance->major_version != UINT8_MAX)
   {
@@ -178,7 +178,7 @@ static inline void version_binary_instance(org::libmemcached::Instance* instance
   }
 }
 
-void memcached_version_instance(org::libmemcached::Instance* instance)
+void memcached_version_instance(memcached_instance_st* instance)
 {
   if (instance)
   {
diff --git a/libmemcached/version.hpp b/libmemcached/version.hpp
index b4a8234b..f420a262 100644
--- a/libmemcached/version.hpp
+++ b/libmemcached/version.hpp
@@ -41,4 +41,4 @@
 
 #pragma once
 
-void memcached_version_instance(org::libmemcached::Instance*);
+void memcached_version_instance(memcached_instance_st*);
diff --git a/libmemcached/windows.hpp b/libmemcached/windows.hpp
new file mode 100644
index 00000000..40564b1d
--- /dev/null
+++ b/libmemcached/windows.hpp
@@ -0,0 +1,125 @@
+/*
+ * Libmemcached library
+ *
+ * Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ *     * The names of its contributors may not be used to endorse or
+ * promote products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+# include <cerrno>
+#else
+# include <errno.h>
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifndef _WIN32_WINNT
+# define _WIN32_WINNT 0x0501
+#endif
+
+#ifdef __MINGW32__
+# if(_WIN32_WINNT >= 0x0501)
+# else
+#  undef _WIN32_WINNT
+#  define _WIN32_WINNT 0x0501
+# endif /* _WIN32_WINNT >= 0x0501 */
+#endif /* __MINGW32__ */
+
+#if defined(HAVE_WINSOCK2_H) && HAVE_WINSOCK2_H
+# include <winsock2.h>
+#endif
+
+#if defined(HAVE_WS2TCPIP_H) && HAVE_WS2TCPIP_H
+# include <ws2tcpip.h>
+#endif
+
+#if defined(HAVE_IO_H) && HAVE_IO_H
+# include <io.h>
+#endif
+
+struct sockaddr_un
+{
+  short int sun_family;
+  char sun_path[108];
+};
+
+static inline int translate_windows_error()
+{
+  int local_errno= WSAGetLastError();
+
+  switch(local_errno) {
+  case WSAEINVAL:
+    local_errno= EINPROGRESS;
+    break;
+  case WSAEALREADY:
+  case WSAEWOULDBLOCK:
+    local_errno= EAGAIN;
+    break;
+
+  case WSAECONNREFUSED:
+    local_errno= ECONNREFUSED;
+    break;
+
+  case WSAENETUNREACH:
+    local_errno= ENETUNREACH;
+    break;
+
+  case WSAETIMEDOUT:
+    local_errno= ETIMEDOUT;
+    break;
+
+  case WSAECONNRESET:
+    local_errno= ECONNRESET;
+    break;
+
+  case WSAEADDRINUSE:
+    local_errno= EADDRINUSE;
+    break;
+
+  case WSAEOPNOTSUPP:
+    local_errno= EOPNOTSUPP;
+    break;
+
+  case WSAENOPROTOOPT:
+    local_errno= ENOPROTOOPT;
+    break;
+
+  default:
+    break;
+  }
+
+  return local_errno;
+}