Next part of merge. See TODO for details

1 files changed, 526 insertions, 554 deletions

diff --git a/vio/viosocket.c b/vio/viosocket.c
index baefa1c6d06..96cf5c195e3 100644
--- a/vio/viosocket.c
+++ b/vio/viosocket.c
@@ -24,12 +24,12 @@
   the file descriptior.
 */
 
+#include "vio_priv.h"
 #ifdef __WIN__
   #include <winsock2.h>
   #include <MSWSock.h>
   #pragma comment(lib, "ws2_32.lib")
 #endif
-#include "vio_priv.h"
 #include "my_context.h"
 #include <mysql_async.h>
 
@@ -39,21 +39,92 @@
 
 int vio_errno(Vio *vio __attribute__((unused)))
 {
-  return socket_errno;		/* On Win32 this mapped to WSAGetLastError() */
+  /* These transport types are not Winsock based. */
+#ifdef _WIN32
+  if (vio->type == VIO_TYPE_NAMEDPIPE ||
+      vio->type == VIO_TYPE_SHARED_MEMORY)
+    return GetLastError();
+#endif
+
+  /* Mapped to WSAGetLastError() on Win32. */
+  return socket_errno;
 }
 
 
-size_t vio_read(Vio * vio, uchar* buf, size_t size)
+/**
+  Attempt to wait for an I/O event on a socket.
+
+  @param vio      VIO object representing a connected socket.
+  @param event    The type of I/O event (read or write) to wait for.
+
+  @return Return value is -1 on failure, 0 on success.
+*/
+
+int vio_socket_io_wait(Vio *vio, enum enum_vio_io_event event)
 {
-  size_t r;
+  int timeout, ret;
+
+  DBUG_ASSERT(event == VIO_IO_EVENT_READ || event == VIO_IO_EVENT_WRITE);
+
+  /* Choose an appropriate timeout. */
+  if (event == VIO_IO_EVENT_READ)
+    timeout= vio->read_timeout;
+  else
+    timeout= vio->write_timeout;
+
+  /* Wait for input data to become available. */
+  switch (vio_io_wait(vio, event, timeout))
+  {
+  case -1:
+    /* Upon failure, vio_read/write() shall return -1. */
+    ret= -1;
+    break;
+  case  0:
+    /* The wait timed out. */
+    ret= -1;
+    break;
+  default:
+    /* A positive value indicates an I/O event. */
+    ret= 0;
+    break;
+  }
+
+  return ret;
+}
+
+
+/*
+  Define a stub MSG_DONTWAIT if unavailable. In this case, fcntl
+  (or a equivalent) is used to enable non-blocking operations.
+  The flag must be supported in both send and recv operations.
+*/
+#if defined(__linux__)
+#define VIO_USE_DONTWAIT  1
+#define VIO_DONTWAIT      MSG_DONTWAIT
+#else
+#define VIO_DONTWAIT 0
+#endif
+
+size_t vio_read(Vio *vio, uchar *buf, size_t size)
+{
+  ssize_t ret;
+  int flags= 0;
   DBUG_ENTER("vio_read");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
-                       (uint) size));
+  DBUG_PRINT("enter", ("sd: %d  buf: %p  size: %d",
+                       mysql_socket_getfd(vio->mysql_socket), buf,
+                       (int) size));
 
-  /* Ensure nobody uses vio_read_buff and vio_read simultaneously */
+  /* Ensure nobody uses vio_read_buff and vio_read simultaneously. */
   DBUG_ASSERT(vio->read_end == vio->read_pos);
+
+  /* If timeout is enabled, do not block if data is unavailable. */
+  if (vio->read_timeout >= 0)
+    flags= VIO_DONTWAIT;
+
   if (vio->async_context && vio->async_context->active)
-    r= my_recv_async(vio->async_context, vio->sd, buf, size, vio->read_timeout);
+    ret= my_recv_async(vio->async_context,
+                       mysql_socket_getfd(vio->mysql_socket),
+                       buf, size, vio->read_timeout);
   else
   {
     if (vio->async_context)
@@ -65,21 +136,28 @@ size_t vio_read(Vio * vio, uchar* buf, size_t size)
       my_bool old_mode;
       vio_blocking(vio, TRUE, &old_mode);
     }
-#ifdef __WIN__
-    r = recv(vio->sd, buf, size,0);
-#else
-    errno=0;					/* For linux */
-    r = read(vio->sd, buf, size);
-#endif /* __WIN__ */
+    while ((ret= mysql_socket_recv(vio->mysql_socket, (SOCKBUF_T *)buf, size,
+                                   flags)) == -1)
+    {
+      int error= socket_errno;
+
+      /* The operation would block? */
+      if (error != SOCKET_EAGAIN && error != SOCKET_EWOULDBLOCK)
+        break;
+
+      /* Wait for input data to become available. */
+      if ((ret= vio_socket_io_wait(vio, VIO_IO_EVENT_READ)))
+        break;
+    }
   }
 #ifndef DBUG_OFF
-  if (r == (size_t) -1)
+  if (ret == -1)
   {
-    DBUG_PRINT("vio_error", ("Got error %d during read",errno));
+    DBUG_PRINT("vio_error", ("Got error %d during read", errno));
   }
 #endif /* DBUG_OFF */
-  DBUG_PRINT("exit", ("%ld", (long) r));
-  DBUG_RETURN(r);
+  DBUG_PRINT("exit", ("%d", (int) ret));
+  DBUG_RETURN(ret);
 }
 
 
@@ -93,12 +171,13 @@ size_t vio_read_buff(Vio *vio, uchar* buf, size_t size)
   size_t rc;
 #define VIO_UNBUFFERED_READ_MIN_SIZE 2048
   DBUG_ENTER("vio_read_buff");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
-                       (uint) size));
+  DBUG_PRINT("enter", ("sd: %d  buf: %p  size: %d",
+                       mysql_socket_getfd(vio->mysql_socket),
+                       buf, (int) size));
 
   if (vio->read_pos < vio->read_end)
   {
-    rc= min((size_t) (vio->read_end - vio->read_pos), size);
+    rc= MY_MIN((size_t) (vio->read_end - vio->read_pos), size);
     memcpy(buf, vio->read_pos, rc);
     vio->read_pos+= rc;
     /*
@@ -127,19 +206,29 @@ size_t vio_read_buff(Vio *vio, uchar* buf, size_t size)
 #undef VIO_UNBUFFERED_READ_MIN_SIZE
 }
 
+
 my_bool vio_buff_has_data(Vio *vio)
 {
   return (vio->read_pos != vio->read_end);
 }
 
-size_t vio_write(Vio * vio, const uchar* buf, size_t size)
+
+size_t vio_write(Vio *vio, const uchar* buf, size_t size)
 {
-  size_t r;
+  ssize_t ret;
+  int flags= 0;
   DBUG_ENTER("vio_write");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
-                       (uint) size));
+  DBUG_PRINT("enter", ("sd: %d  buf: %p  size: %d",
+                       mysql_socket_getfd(vio->mysql_socket), buf,
+                       (int) size));
+
+  /* If timeout is enabled, do not block. */
+  if (vio->write_timeout >= 0)
+    flags= VIO_DONTWAIT;
+
   if (vio->async_context && vio->async_context->active)
-    r= my_send_async(vio->async_context, vio->sd, buf, size,
+    ret= my_send_async(vio->async_context,
+                     mysql_socket_getfd(vio->mysql_socket), buf, size,
                      vio->write_timeout);
   else
   {
@@ -152,20 +241,27 @@ size_t vio_write(Vio * vio, const uchar* buf, size_t size)
       my_bool old_mode;
       vio_blocking(vio, TRUE, &old_mode);
     }
-#ifdef __WIN__
-    r = send(vio->sd, buf, size,0);
-#else
-    r = write(vio->sd, buf, size);
-#endif /* __WIN__ */
+    while ((ret= mysql_socket_send(vio->mysql_socket, (SOCKBUF_T *)buf, size,
+                                   flags)) == -1)
+    {
+      int error= socket_errno;
+      /* The operation would block? */
+      if (error != SOCKET_EAGAIN && error != SOCKET_EWOULDBLOCK)
+        break;
+
+      /* Wait for the output buffer to become writable.*/
+      if ((ret= vio_socket_io_wait(vio, VIO_IO_EVENT_WRITE)))
+        break;
+    }
   }
 #ifndef DBUG_OFF
-  if (r == (size_t) -1)
+  if (ret == -1)
   {
     DBUG_PRINT("vio_error", ("Got error on write: %d",socket_errno));
   }
 #endif /* DBUG_OFF */
-  DBUG_PRINT("exit", ("%u", (uint) r));
-  DBUG_RETURN(r);
+  DBUG_PRINT("exit", ("%d", (int) ret));
+  DBUG_RETURN(ret);
 }
 
 #ifdef _WIN32
@@ -177,8 +273,9 @@ static void CALLBACK cancel_io_apc(ULONG_PTR data)
 /*
   Cancel IO on Windows.
 
-  On XP, issue CancelIo as asynchronous procedure call to the thread that started
-  IO. On Vista+, simpler cancelation is done with CancelIoEx. 
+  On XP, issue CancelIo as asynchronous procedure call to the thread
+  that started IO. On Vista+, simpler cancelation is done with
+  CancelIoEx.
 */
 
 int cancel_io(HANDLE handle, DWORD thread_id)
@@ -212,21 +309,25 @@ int cancel_io(HANDLE handle, DWORD thread_id)
 }
 #endif
 
+
 int vio_socket_shutdown(Vio *vio, int how)
 {
-  int ret= shutdown(vio->sd, how);
+  int ret= shutdown(mysql_socket_getfd(vio->mysql_socket), how);
 #ifdef  _WIN32
   /* Cancel possible IO in progress (shutdown does not do that on Windows). */
-  (void) cancel_io((HANDLE)vio->sd, vio->thread_id);
+  (void) cancel_io((HANDLE) mysql_socket_getfd(vio->mysql_socket),
+                   vio->thread_id);
 #endif
   return ret;
 }
 
 
-int vio_blocking(Vio * vio __attribute__((unused)), my_bool set_blocking_mode,
-		 my_bool *old_mode)
+int vio_blocking(Vio *vio, my_bool set_blocking_mode, my_bool *old_mode)
 {
-  int r=0;
+  int r= 0;
+#if defined(__WIN__) || !defined(NO_FCNTL_NONBLOCK)
+  my_socket sd= mysql_socket_getfd(vio->mysql_socket);
+#endif
   DBUG_ENTER("vio_blocking");
 
   *old_mode= test(!(vio->fcntl_mode & O_NONBLOCK));
@@ -235,16 +336,16 @@ int vio_blocking(Vio * vio __attribute__((unused)), my_bool set_blocking_mode,
 
 #if !defined(__WIN__)
 #if !defined(NO_FCNTL_NONBLOCK)
-  if (vio->sd >= 0)
+  if (sd >= 0)
   {
-    int old_fcntl=vio->fcntl_mode;
+    int old_fcntl= vio->fcntl_mode;
     if (set_blocking_mode)
       vio->fcntl_mode &= ~O_NONBLOCK; /* clear bit */
     else
       vio->fcntl_mode |= O_NONBLOCK; /* set bit */
     if (old_fcntl != vio->fcntl_mode)
     {
-      r= fcntl(vio->sd, F_SETFL, vio->fcntl_mode);
+      r= fcntl(sd, F_SETFL, vio->fcntl_mode);
       if (r == -1)
       {
         DBUG_PRINT("info", ("fcntl failed, errno %d", errno));
@@ -271,7 +372,7 @@ int vio_blocking(Vio * vio __attribute__((unused)), my_bool set_blocking_mode,
       vio->fcntl_mode |= O_NONBLOCK; /* set bit */
     }
     if (old_fcntl != vio->fcntl_mode)
-      r = ioctlsocket(vio->sd,FIONBIO,(void*) &arg);
+      r = ioctlsocket(sd,FIONBIO,(void*) &arg);
   }
   else
     r=  test(!(vio->fcntl_mode & O_NONBLOCK)) != set_blocking_mode;
@@ -291,6 +392,75 @@ vio_is_blocking(Vio * vio)
 }
 
 
+int vio_socket_timeout(Vio *vio,
+                       uint which __attribute__((unused)),
+                       my_bool old_mode __attribute__((unused)))
+{
+  int ret= 0;
+  DBUG_ENTER("vio_socket_timeout");
+
+#if defined(_WIN32)
+  {
+    int optname;
+    DWORD timeout= 0;
+    const char *optval= (const char *) &timeout;
+
+    /*
+      The default socket timeout value is zero, which means an infinite
+      timeout. Values less than 500 milliseconds are interpreted to be of
+      500 milliseconds. Hence, the VIO behavior for zero timeout, which is
+      intended to cause the send or receive operation to fail immediately
+      if no data is available, is not supported on WIN32 and neither is
+      necessary as it's not possible to set the VIO timeout value to zero.
+
+      Assert that the VIO timeout is either positive or set to infinite.
+    */
+    DBUG_ASSERT(which || vio->read_timeout);
+    DBUG_ASSERT(!which || vio->write_timeout);
+
+    if (which)
+    {
+      optname= SO_SNDTIMEO;
+      if (vio->write_timeout > 0)
+        timeout= vio->write_timeout;
+    }
+    else
+    {
+      optname= SO_RCVTIMEO;
+      if (vio->read_timeout > 0)
+        timeout= vio->read_timeout;
+    }
+
+    ret= mysql_socket_setsockopt(vio->mysql_socket, SOL_SOCKET, optname,
+	                             optval, sizeof(timeout));
+  }
+#else
+  /*
+    The MSG_DONTWAIT trick is not used with SSL sockets as the send and
+    receive I/O operations are wrapped through SSL-specific functions
+    (SSL_read and SSL_write) which are not equivalent to the standard
+    recv(2) and send(2) used in vio_read() and vio_write(). Hence, the
+    socket blocking mode is changed and vio_io_wait() is used to wait
+    for I/O or timeout.
+  */
+#ifdef VIO_USE_DONTWAIT
+  if (vio->type == VIO_TYPE_SSL)
+#endif
+  {
+    /* Deduce what should be the new blocking mode of the socket. */
+    my_bool new_mode= vio->write_timeout < 0 && vio->read_timeout < 0;
+    my_bool not_used;
+
+    /* If necessary, update the blocking mode. */
+    if (new_mode != old_mode)
+      ret= vio_blocking(vio, new_mode, &not_used);
+  }
+#endif
+
+  DBUG_RETURN(ret);
+}
+
+
 int vio_fastsend(Vio * vio __attribute__((unused)))
 {
   int r=0;
@@ -304,7 +474,8 @@ int vio_fastsend(Vio * vio __attribute__((unused)))
 #if defined(IPTOS_THROUGHPUT)
   {
     int tos = IPTOS_THROUGHPUT;
-    r= setsockopt(vio->sd, IPPROTO_IP, IP_TOS, (void *) &tos, sizeof(tos));
+    r= mysql_socket_setsockopt(vio->mysql_socket, IPPROTO_IP, IP_TOS,
+	                           (void *)&tos, sizeof(tos));
   }
 #endif                                    /* IPTOS_THROUGHPUT */
   if (!r)
@@ -315,7 +486,7 @@ int vio_fastsend(Vio * vio __attribute__((unused)))
     int nodelay = 1;
 #endif
 
-    r= setsockopt(vio->sd, IPPROTO_TCP, TCP_NODELAY,
+    r= mysql_socket_setsockopt(vio->mysql_socket, IPPROTO_TCP, TCP_NODELAY,
                   IF_WIN((const char*), (void*)) &nodelay,
                   sizeof(nodelay));
 
@@ -334,78 +505,56 @@ int vio_keepalive(Vio* vio, my_bool set_keep_alive)
   int r=0;
   uint opt = 0;
   DBUG_ENTER("vio_keepalive");
-  DBUG_PRINT("enter", ("sd: %d  set_keep_alive: %d", vio->sd, (int)
-		       set_keep_alive));
+  DBUG_PRINT("enter", ("sd: %d  set_keep_alive: %d",
+                       mysql_socket_getfd(vio->mysql_socket),
+                       (int)set_keep_alive));
+
   if (vio->type != VIO_TYPE_NAMEDPIPE && vio->type != VIO_TYPE_SHARED_MEMORY)
   {
     if (set_keep_alive)
       opt = 1;
-    r = setsockopt(vio->sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt,
-		   sizeof(opt));
+    r = mysql_socket_setsockopt(vio->mysql_socket, SOL_SOCKET, SO_KEEPALIVE,
+	                            (char *)&opt, sizeof(opt));
   }
   DBUG_RETURN(r);
 }
 
 
-my_bool
-vio_should_retry(Vio * vio)
-{
-  int en = socket_errno;
-  /*
-    man 2 read write
-      EAGAIN or EWOULDBLOCK when a socket is a non-blocking mode means
-      that the read/write would block.
-    man 7 socket
-      EAGAIN or EWOULDBLOCK when a socket is in a blocking mode means
-      that the corresponding receiving or sending timeout was reached.
-  */
-  return  en == SOCKET_EINTR ||
-          (!vio_is_blocking(vio) &&
-            (en == SOCKET_EAGAIN || en == SOCKET_EWOULDBLOCK));
-}
+/**
+  Indicate whether a I/O operation must be retried later.
+
+  @param vio  A VIO object
 
+  @return Whether a I/O operation should be deferred.
+  @retval TRUE    Temporary failure, retry operation.
+  @retval FALSE   Indeterminate failure.
+*/
 
 my_bool
-vio_was_interrupted(Vio *vio __attribute__((unused)))
+vio_should_retry(Vio *vio)
 {
-  int en= socket_errno;
-  return (en == SOCKET_EAGAIN || en == SOCKET_EINTR ||
-	  en == SOCKET_EWOULDBLOCK || en == SOCKET_ETIMEDOUT);
+  return (vio_errno(vio) == SOCKET_EINTR);
 }
 
 
-int
-mysql_socket_shutdown(my_socket mysql_socket, int how)
-{
-  int result;
+/**
+  Indicate whether a I/O operation timed out.
 
-#ifdef __WIN__
-  static LPFN_DISCONNECTEX DisconnectEx = NULL;
-  if (DisconnectEx == NULL)
-  {
-    DWORD dwBytesReturned;
-    GUID guidDisconnectEx = WSAID_DISCONNECTEX;
-    WSAIoctl(mysql_socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
-             &guidDisconnectEx, sizeof(GUID),
-             &DisconnectEx, sizeof(DisconnectEx), 
-             &dwBytesReturned, NULL, NULL);
-  }
-#endif
+  @param vio  A VIO object
 
-  /* Non instrumented code */
-#ifdef __WIN__
-  if (DisconnectEx)
-    result= (DisconnectEx(mysql_socket, (LPOVERLAPPED) NULL,
-                          (DWORD) 0, (DWORD) 0) == TRUE) ? 0 : -1;
-  else
-#endif
-    result= shutdown(mysql_socket, how);
+  @return Whether a I/O operation timed out.
+  @retval TRUE    Operation timed out.
+  @retval FALSE   Not a timeout failure.
+*/
 
-  return result;
+my_bool
+vio_was_timeout(Vio *vio)
+{
+  return (vio_errno(vio) == SOCKET_ETIMEDOUT);
 }
 
 
-int vio_close(Vio * vio)
+int vio_close(Vio *vio)
 {
   int r=0;
   DBUG_ENTER("vio_close");
@@ -416,10 +565,10 @@ int vio_close(Vio * vio)
       vio->type == VIO_TYPE_SOCKET ||
       vio->type == VIO_TYPE_SSL);
 
-    DBUG_ASSERT(vio->sd >= 0);
-    if (mysql_socket_shutdown(vio->sd, SHUT_RDWR))
+    DBUG_ASSERT(mysql_socket_getfd(vio->mysql_socket) >= 0);
+    if (mysql_socket_shutdown(vio->mysql_socket, SHUT_RDWR))
       r= -1;
-    if (closesocket(vio->sd))
+    if (mysql_socket_close(vio->mysql_socket))
       r= -1;
   }
   if (r)
@@ -428,13 +577,19 @@ int vio_close(Vio * vio)
     /* FIXME: error handling (not critical for MySQL) */
   }
   vio->type= VIO_CLOSED;
-  vio->sd=   -1;
+  vio->mysql_socket= MYSQL_INVALID_SOCKET;
   DBUG_RETURN(r);
 }
 
 
 const char *vio_description(Vio * vio)
 {
+  if (!vio->desc[0])
+  {
+    my_snprintf(vio->desc, VIO_DESCRIPTION_SIZE,
+                (vio->type == VIO_TYPE_SOCKET ? "socket (%d)" : "TCP/IP (%d)"),
+                mysql_socket_getfd(vio->mysql_socket));
+  }
   return vio->desc;
 }
 
@@ -445,7 +600,7 @@ enum enum_vio_type vio_type(Vio* vio)
 
 my_socket vio_fd(Vio* vio)
 {
-  return vio->sd;
+  return mysql_socket_getfd(vio->mysql_socket);
 }
 
 /**
@@ -471,6 +626,7 @@ my_socket vio_fd(Vio* vio)
                           (sockaddr_storage).
   @param dst_length [out] actual length of the normalized IP address.
 */
+
 static void vio_get_normalized_ip(const struct sockaddr *src,
                                   int src_length,
                                   struct sockaddr *dst,
@@ -586,7 +742,8 @@ my_bool vio_peer_addr(Vio *vio, char *ip_buffer, uint16 *port,
                       size_t ip_buffer_size)
 {
   DBUG_ENTER("vio_peer_addr");
-  DBUG_PRINT("enter", ("Client socked fd: %d", (int) vio->sd));
+  DBUG_PRINT("enter", ("Client socked fd: %d",
+            (int)mysql_socket_getfd(vio->mysql_socket)));
 
   if (vio->localhost)
   {
@@ -617,7 +774,7 @@ my_bool vio_peer_addr(Vio *vio, char *ip_buffer, uint16 *port,
 
     /* Get sockaddr by socked fd. */
 
-    err_code= getpeername(vio->sd, addr, &addr_length);
+    err_code= mysql_socket_getpeername(vio->mysql_socket, addr, &addr_length);
 
     if (err_code)
     {
@@ -655,58 +812,6 @@ my_bool vio_peer_addr(Vio *vio, char *ip_buffer, uint16 *port,
 
 
 /**
-  Indicate whether there is data to read on a given socket.
-
-  @note An exceptional condition event and/or errors are
-        interpreted as if there is data to read.
-
-  @param sd       A connected socket.
-  @param timeout  Maximum time in seconds to poll.
-
-  @retval FALSE   There is data to read.
-  @retval TRUE    There is no data to read.
-*/
-
-static my_bool socket_poll_read(my_socket sd, uint timeout)
-{
-#ifdef __WIN__
-  int res;
-  my_socket fd= sd;
-  fd_set readfds, errorfds;
-  struct timeval tm;
-  DBUG_ENTER("socket_poll_read");
-  tm.tv_sec= timeout;
-  tm.tv_usec= 0;
-  FD_ZERO(&readfds);
-  FD_ZERO(&errorfds);
-  FD_SET(fd, &readfds);
-  FD_SET(fd, &errorfds);
-  /* The first argument is ignored on Windows, so a conversion to int is OK */
-  if ((res= select((int) fd, &readfds, NULL, &errorfds, &tm) <= 0))
-  {
-    DBUG_RETURN(res < 0 ? 0 : 1);
-  }
-  res= FD_ISSET(fd, &readfds) || FD_ISSET(fd, &errorfds);
-  DBUG_RETURN(!res);
-#elif defined(HAVE_POLL)
-  struct pollfd fds;
-  int res;
-  DBUG_ENTER("socket_poll_read");
-  fds.fd=sd;
-  fds.events=POLLIN;
-  fds.revents=0;
-  if ((res=poll(&fds,1,(int) timeout*1000)) <= 0)
-  {
-    DBUG_RETURN(res < 0 ? 0 : 1);		/* Don't return 1 on errors */
-  }
-  DBUG_RETURN(fds.revents & (POLLIN | POLLERR | POLLHUP) ? 0 : 1);
-#else
-  return 0;
-#endif
-}
-
-
-/**
   Retrieve the amount of data that can be read from a socket.
 
   @param vio          A VIO object.
@@ -715,510 +820,383 @@ static my_bool socket_poll_read(my_socket sd, uint timeout)
   @retval FALSE   Success.
   @retval TRUE    Failure.
 */
+// WL#4896: Not covered
 
 static my_bool socket_peek_read(Vio *vio, uint *bytes)
 {
+  my_socket sd= mysql_socket_getfd(vio->mysql_socket);
 #if defined(_WIN32)
   int len;
-  if (ioctlsocket(vio->sd, FIONREAD, &len))
+  if (ioctlsocket(sd, FIONREAD, &len))
     return TRUE;
   *bytes= len;
   return FALSE;
 #elif defined(FIONREAD_IN_SYS_IOCTL) || defined(FIONREAD_IN_SYS_FILIO)
   int len;
-  if (ioctl(vio->sd, FIONREAD, &len) < 0)
+  if (ioctl(sd, FIONREAD, &len) < 0)
     return TRUE;
   *bytes= len;
   return FALSE;
 #else
   char buf[1024];
-  ssize_t res= recv(vio->sd, &buf, sizeof(buf), MSG_PEEK);
+  ssize_t res= recv(sd, &buf, sizeof(buf), MSG_PEEK);
   if (res < 0)
     return TRUE;
   *bytes= res;
   return FALSE;
-#endif
+#endif /*_WIN32*/
 }
 
+#ifndef _WIN32
 
 /**
-  Indicate whether there is data to read on a given socket.
-
-  @remark Errors are interpreted as if there is data to read.
-
-  @param sd       A connected socket.
-  @param timeout  Maximum time in seconds to wait.
-
-  @retval FALSE   There is data (or EOF) to read. Also FALSE if error.
-  @retval TRUE    There is _NO_ data to read or timed out.
+  Set of event flags grouped by operations.
 */
 
-my_bool vio_poll_read(Vio *vio, uint timeout)
-{
-  my_socket sd= vio->sd;
-  DBUG_ENTER("vio_poll_read");
-  if (vio->async_context && vio->async_context->active)
-    DBUG_RETURN(my_poll_read_async(vio->async_context, timeout));
-#ifdef HAVE_OPENSSL
-  if (vio->type == VIO_TYPE_SSL)
-    sd= SSL_get_fd((SSL*) vio->ssl_arg);
+/*
+  Linux specific flag used to detect connection shutdown. The flag is
+  also used for half-closed notification, which here is interpreted as
+  if there is data available to be read from the socket.
+*/
+#ifndef POLLRDHUP
+#define POLLRDHUP 0
 #endif
-  DBUG_RETURN(socket_poll_read(sd, timeout));
-}
 
+/* Data may be read. */
+#define MY_POLL_SET_IN      (POLLIN | POLLPRI)
+/* Data may be written. */
+#define MY_POLL_SET_OUT     (POLLOUT)
+/* An error or hangup. */
+#define MY_POLL_SET_ERR     (POLLERR | POLLHUP | POLLNVAL)
+
+#endif /* _WIN32 */
 
 /**
-  Determine if the endpoint of a connection is still available.
+  Wait for an I/O event on a VIO socket.
 
-  @remark The socket is assumed to be disconnected if an EOF
-          condition is encountered.
+  @param vio      VIO object representing a connected socket.
+  @param event    The type of I/O event to wait for.
+  @param timeout  Interval (in milliseconds) to wait for an I/O event.
+                  A negative timeout value means an infinite timeout.
 
-  @param vio      The VIO object.
+  @remark sock_errno is set to SOCKET_ETIMEDOUT on timeout.
 
-  @retval TRUE    EOF condition not found.
-  @retval FALSE   EOF condition is signaled.
+  @return A three-state value which indicates the operation status.
+  @retval -1  Failure, socket_errno indicates the error.
+  @retval  0  The wait has timed out.
+  @retval  1  The requested I/O event has occurred.
 */
 
-my_bool vio_is_connected(Vio *vio)
+#ifndef _WIN32
+int vio_io_wait(Vio *vio, enum enum_vio_io_event event, int timeout)
 {
-  uint bytes= 0;
-  DBUG_ENTER("vio_is_connected");
+  int ret;
+  short revents= 0;
+  struct pollfd pfd;
+  my_socket sd= mysql_socket_getfd(vio->mysql_socket);
+  MYSQL_SOCKET_WAIT_VARIABLES(locker, state) /* no ';' */
+  DBUG_ENTER("vio_io_wait");
 
-  /* In the presence of errors the socket is assumed to be connected. */
+  memset(&pfd, 0, sizeof(pfd));
 
-  /*
-    The first step of detecting a EOF condition is veryfing
-    whether there is data to read. Data in this case would
-    be the EOF.
-  */
-  if (vio_poll_read(vio, 0))
-    DBUG_RETURN(TRUE);
+  pfd.fd= sd;
 
   /*
-    The second step is read() or recv() from the socket returning
-    0 (EOF). Unfortunelly, it's not possible to call read directly
-    as we could inadvertently read meaningful connection data.
-    Simulate a read by retrieving the number of bytes available to
-    read -- 0 meaning EOF.
+    Set the poll bitmask describing the type of events.
+    The error flags are only valid in the revents bitmask.
   */
-  if (socket_peek_read(vio, &bytes))
-    DBUG_RETURN(TRUE);
-
-#ifdef HAVE_OPENSSL
-  /* There might be buffered data at the SSL layer. */
-  if (!bytes && vio->type == VIO_TYPE_SSL)
-    bytes= SSL_pending((SSL*) vio->ssl_arg);
-#endif
-
-  DBUG_RETURN(bytes ? TRUE : FALSE);
-}
-
-
-void vio_timeout(Vio *vio, uint which, uint timeout)
-{
-#if defined(SO_SNDTIMEO) && defined(SO_RCVTIMEO)
-  int r;
-  DBUG_ENTER("vio_timeout");
-
+  switch (event)
   {
-#ifdef __WIN__
-  /* Windows expects time in milliseconds as int */
-  int wait_timeout= (int) timeout * 1000;
-#else
-  /* POSIX specifies time as struct timeval. */
-  struct timeval wait_timeout;
-  wait_timeout.tv_sec= timeout;
-  wait_timeout.tv_usec= 0;
-#endif
-
-  r= setsockopt(vio->sd, SOL_SOCKET, which ? SO_SNDTIMEO : SO_RCVTIMEO,
-                IF_WIN((const char*), (const void*))&wait_timeout,
-                sizeof(wait_timeout));
-
+  case VIO_IO_EVENT_READ:
+    pfd.events= MY_POLL_SET_IN;
+    revents= MY_POLL_SET_IN | MY_POLL_SET_ERR | POLLRDHUP;
+    break;
+  case VIO_IO_EVENT_WRITE:
+  case VIO_IO_EVENT_CONNECT:
+    pfd.events= MY_POLL_SET_OUT;
+    revents= MY_POLL_SET_OUT | MY_POLL_SET_ERR;
+    break;
   }
 
-  if (r != 0)
-    DBUG_PRINT("error", ("setsockopt failed: %d, errno: %d", r, socket_errno));
-
-  DBUG_VOID_RETURN;
-#else
-/*
-  Platforms not suporting setting of socket timeout should either use
-  thr_alarm or just run without read/write timeout(s)
-*/
-#endif
-  /* Make timeout values available for async operations. */
-  if (which)
-    vio->write_timeout= timeout;
-  else
-    vio->read_timeout= timeout;
-}
-
-
-#ifdef __WIN__
-/*
-  Disable posting IO completion event to the port.
-  In some cases (synchronous timed IO) we want to skip IOCP notifications.
-*/
-static void disable_iocp_notification(OVERLAPPED *overlapped)
-{
-  HANDLE *handle = &(overlapped->hEvent);
-  *handle = ((HANDLE)((ULONG_PTR) *handle|1));
-}
-
-/* Enable posting IO completion event to the port */
-static void enable_iocp_notification(OVERLAPPED *overlapped)
-{
-  HANDLE *handle = &(overlapped->hEvent);
-  *handle = (HANDLE)((ULONG_PTR) *handle & ~1);
-}
+  MYSQL_START_SOCKET_WAIT(locker, &state, vio->mysql_socket, PSI_SOCKET_SELECT, 0);
 
-/*
-  Finish pending IO on pipe. Honor wait timeout
-*/
-static size_t pipe_complete_io(Vio* vio, char* buf, size_t size, DWORD timeout_ms)
-{
-  DWORD length;
-  DWORD ret;
-
-  DBUG_ENTER("pipe_complete_io");
-
-  ret= WaitForSingleObjectEx(vio->pipe_overlapped.hEvent, timeout_ms, TRUE);
   /*
-    WaitForSingleObjects will normally return WAIT_OBJECT_O (success, IO completed)
-    or WAIT_TIMEOUT.
+    Wait for the I/O event and return early in case of
+    error or timeout.
   */
-  if(ret != WAIT_OBJECT_0)
+  switch ((ret= poll(&pfd, 1, timeout)))
   {
-    CancelIo(vio->hPipe);
-    DBUG_PRINT("error",("WaitForSingleObject() returned  %d", ret));
-    DBUG_RETURN((size_t)-1);
-  }
-
-  if (!GetOverlappedResult(vio->hPipe,&(vio->pipe_overlapped),&length, FALSE))
-  {
-    DBUG_PRINT("error",("GetOverlappedResult() returned last error  %d", 
-      GetLastError()));
-    DBUG_RETURN((size_t)-1);
+  case -1:
+    /* On error, -1 is returned. */
+    break;
+  case 0:
+    /*
+      Set errno to indicate a timeout error.
+      (This is not compiled in on WIN32.)
+    */
+    errno= SOCKET_ETIMEDOUT;
+    break;
+  default:
+    /* Ensure that the requested I/O event has completed. */
+    DBUG_ASSERT(pfd.revents & revents);
+    break;
   }
 
-  DBUG_RETURN(length);
+  MYSQL_END_SOCKET_WAIT(locker, 0);
+  DBUG_RETURN(ret);
 }
 
+#else
 
-size_t vio_read_pipe(Vio * vio, uchar *buf, size_t size)
+int vio_io_wait(Vio *vio, enum enum_vio_io_event event, int timeout)
 {
-  DWORD bytes_read;
-  size_t retval;
-  DBUG_ENTER("vio_read_pipe");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
-                       (uint) size));
-  
-  disable_iocp_notification(&vio->pipe_overlapped);
-  if (ReadFile(vio->hPipe, buf, (DWORD)size, &bytes_read,
-      &(vio->pipe_overlapped)))
-  {
-    retval= bytes_read;
-  }
-  else
+  int ret;
+  struct timeval tm;
+  my_socket fd= mysql_socket_getfd(vio->mysql_socket);
+  fd_set readfds, writefds, exceptfds;
+  MYSQL_SOCKET_WAIT_VARIABLES(locker, state) /* no ';' */
+  DBUG_ENTER("vio_io_wait");
+
+  /* Convert the timeout, in milliseconds, to seconds and microseconds. */
+  if (timeout >= 0)
   {
-    if (GetLastError() != ERROR_IO_PENDING)
-    {
-      enable_iocp_notification(&vio->pipe_overlapped);
-      DBUG_PRINT("error",("ReadFile() returned last error %d",
-        GetLastError()));
-      DBUG_RETURN((size_t)-1);
-    }
-    retval= pipe_complete_io(vio, buf, size,vio->read_timeout_ms);
+    tm.tv_sec= timeout / 1000;
+    tm.tv_usec= (timeout % 1000) * 1000;
   }
-  enable_iocp_notification(&vio->pipe_overlapped);
-  DBUG_PRINT("exit", ("%lld", (longlong)retval));
-  DBUG_RETURN(retval);
-}
 
+  FD_ZERO(&readfds);
+  FD_ZERO(&writefds);
+  FD_ZERO(&exceptfds);
 
-size_t vio_write_pipe(Vio * vio, const uchar* buf, size_t size)
-{
-  DWORD bytes_written;
-  size_t retval;
-  DBUG_ENTER("vio_write_pipe");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %u", vio->sd, (long) buf,
-                       (uint) size));
-  disable_iocp_notification(&vio->pipe_overlapped);
-  if (WriteFile(vio->hPipe, buf, (DWORD)size, &bytes_written, 
-      &(vio->pipe_overlapped)))
-  {
-    retval= bytes_written;
-  }
-  else
+  /* Always receive notification of exceptions. */
+  FD_SET(fd, &exceptfds);
+
+  switch (event)
   {
-    enable_iocp_notification(&vio->pipe_overlapped);
-    if (GetLastError() != ERROR_IO_PENDING)
-    {
-      DBUG_PRINT("vio_error",("WriteFile() returned last error %d",
-        GetLastError()));
-      DBUG_RETURN((size_t)-1);
-    }
-    retval= pipe_complete_io(vio, (char *)buf, size, vio->write_timeout_ms);
+  case VIO_IO_EVENT_READ:
+    /* Readiness for reading. */
+    FD_SET(fd, &readfds);
+    break;
+  case VIO_IO_EVENT_WRITE:
+  case VIO_IO_EVENT_CONNECT:
+    /* Readiness for writing. */
+    FD_SET(fd, &writefds);
+    break;
   }
-  enable_iocp_notification(&vio->pipe_overlapped);
-  DBUG_PRINT("exit", ("%lld", (longlong)retval));
-  DBUG_RETURN(retval);
-}
 
+  MYSQL_START_SOCKET_WAIT(locker, &state, vio->mysql_socket, PSI_SOCKET_SELECT, 0);
 
-my_bool vio_is_connected_pipe(Vio *vio)
-{
-  if (PeekNamedPipe(vio->hPipe, NULL, 0, NULL, NULL, NULL))
-    return TRUE;
-  else
-    return (GetLastError() != ERROR_BROKEN_PIPE);
-}
+  /* The first argument is ignored on Windows. */
+  ret= select(0, &readfds, &writefds, &exceptfds, (timeout >= 0) ? &tm : NULL);
 
+  MYSQL_END_SOCKET_WAIT(locker, 0);
 
-int vio_close_pipe(Vio * vio)
-{
-  int r;
-  DBUG_ENTER("vio_close_pipe");
+  /* Set error code to indicate a timeout error. */
+  if (ret == 0)
+    WSASetLastError(SOCKET_ETIMEDOUT);
 
-  CancelIo(vio->hPipe);
-  CloseHandle(vio->pipe_overlapped.hEvent);
-  DisconnectNamedPipe(vio->hPipe);
-  r= CloseHandle(vio->hPipe);
-  if (r)
+  /* Error or timeout? */
+  if (ret <= 0)
+    DBUG_RETURN(ret);
+
+  /* The requested I/O event is ready? */
+  switch (event)
   {
-    DBUG_PRINT("vio_error", ("close() failed, error: %d",GetLastError()));
-    /* FIXME: error handling (not critical for MySQL) */
+  case VIO_IO_EVENT_READ:
+    ret= test(FD_ISSET(fd, &readfds));
+    break;
+  case VIO_IO_EVENT_WRITE:
+  case VIO_IO_EVENT_CONNECT:
+    ret= test(FD_ISSET(fd, &writefds));
+    break;
   }
-  vio->type= VIO_CLOSED;
-  vio->sd=   -1;
-  DBUG_RETURN(r);
-}
 
+  /* Error conditions pending? */
+  ret|= test(FD_ISSET(fd, &exceptfds));
 
-void vio_win32_timeout(Vio *vio, uint which , uint timeout_sec)
-{
-    DWORD timeout_ms;
-    /*
-      Windows is measuring timeouts in milliseconds. Check for possible int 
-      overflow.
-    */
-    if (timeout_sec > UINT_MAX/1000)
-      timeout_ms= INFINITE;
-    else
-      timeout_ms= timeout_sec * 1000;
+  /* Not a timeout, ensure that a condition was met. */
+  DBUG_ASSERT(ret);
 
-    /* which == 1 means "write", which == 0 means "read".*/
-    if(which)
-      vio->write_timeout_ms= timeout_ms;
-    else
-      vio->read_timeout_ms= timeout_ms;
+  DBUG_RETURN(ret);
 }
 
+#endif /* _WIN32 */
 
-#ifdef HAVE_SMEM
-
-size_t vio_read_shared_memory(Vio * vio, uchar* buf, size_t size)
-{
-  size_t length;
-  size_t remain_local;
-  char *current_position;
-  HANDLE events[2];
 
-  DBUG_ENTER("vio_read_shared_memory");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %d", vio->sd, (long) buf,
-                       size));
+/**
+  Connect to a peer address.
 
-  remain_local = size;
-  current_position=buf;
+  @param vio       A VIO object.
+  @param addr      Socket address containing the peer address.
+  @param len       Length of socket address.
+  @param timeout   Interval (in milliseconds) to wait until a
+                   connection is established.
 
-  events[0]= vio->event_server_wrote;
-  events[1]= vio->event_conn_closed;
+  @retval FALSE   A connection was successfully established.
+  @retval TRUE    A fatal error. See socket_errno.
+*/
 
-  do
-  {
-    if (vio->shared_memory_remain == 0)
-    {
-      /*
-        WaitForMultipleObjects can return next values:
-         WAIT_OBJECT_0+0 - event from vio->event_server_wrote
-         WAIT_OBJECT_0+1 - event from vio->event_conn_closed. We can't read
-		           anything
-         WAIT_ABANDONED_0 and WAIT_TIMEOUT - fail.  We can't read anything
-      */
-      if (WaitForMultipleObjects(array_elements(events), events, FALSE,
-                                 vio->read_timeout_ms) != WAIT_OBJECT_0)
-      {
-        DBUG_RETURN(-1);
-      };
+my_bool
+vio_socket_connect(Vio *vio, struct sockaddr *addr, socklen_t len, int timeout)
+{
+  int ret, wait;
+  my_bool not_used;
+  DBUG_ENTER("vio_socket_connect");
 
-      vio->shared_memory_pos = vio->handle_map;
-      vio->shared_memory_remain = uint4korr((ulong*)vio->shared_memory_pos);
-      vio->shared_memory_pos+=4;
-    }
+  /* Only for socket-based transport types. */
+  DBUG_ASSERT(vio->type == VIO_TYPE_SOCKET || vio->type == VIO_TYPE_TCPIP);
 
-    length = size;
+  /* If timeout is not infinite, set socket to non-blocking mode. */
+  if ((timeout > -1) && vio_blocking(vio, FALSE, &not_used))
+    DBUG_RETURN(TRUE);
 
-    if (vio->shared_memory_remain < length)
-       length = vio->shared_memory_remain;
-    if (length > remain_local)
-       length = remain_local;
+  /* Initiate the connection. */
+  ret= mysql_socket_connect(vio->mysql_socket, addr, len);
 
-    memcpy(current_position,vio->shared_memory_pos,length);
+#ifdef _WIN32
+  wait= (ret == SOCKET_ERROR) &&
+        (WSAGetLastError() == WSAEINPROGRESS ||
+         WSAGetLastError() == WSAEWOULDBLOCK);
+#else
+  wait= (ret == -1) && (errno == EINPROGRESS || errno == EALREADY);
+#endif
 
-    vio->shared_memory_remain-=length;
-    vio->shared_memory_pos+=length;
-    current_position+=length;
-    remain_local-=length;
+  /*
+    The connection is in progress. The vio_io_wait() call can be used
+    to wait up to a specified period of time for the connection to
+    succeed.
+
+    If vio_io_wait() returns 0 (after waiting however many seconds),
+    the socket never became writable (host is probably unreachable.)
+    Otherwise, if vio_io_wait() returns 1, then one of two conditions
+    exist:
+
+    1. An error occurred. Use getsockopt() to check for this.
+    2. The connection was set up successfully: getsockopt() will
+       return 0 as an error.
+  */
+  if (wait && (vio_io_wait(vio, VIO_IO_EVENT_CONNECT, timeout) == 1))
+  {
+    int error;
+    IF_WIN(int, socklen_t) optlen= sizeof(error);
+    IF_WIN(char, void) *optval= (IF_WIN(char, void) *) &error;
 
-    if (!vio->shared_memory_remain)
+    /*
+      At this point, we know that something happened on the socket.
+      But this does not means that everything is alright. The connect
+      might have failed. We need to retrieve the error code from the
+      socket layer. We must return success only if we are sure that
+      it was really a success. Otherwise we might prevent the caller
+      from trying another address to connect to.
+    */
+    if (!(ret= mysql_socket_getsockopt(vio->mysql_socket, SOL_SOCKET,
+                                       SO_ERROR, optval, &optlen)))
     {
-      if (!SetEvent(vio->event_client_read))
-        DBUG_RETURN(-1);
+#ifdef _WIN32
+      WSASetLastError(error);
+#else
+      errno= error;
+#endif
+      ret= test(error);
     }
-  } while (remain_local);
-  length = size;
+  }
 
-  DBUG_PRINT("exit", ("%lu", (ulong) length));
-  DBUG_RETURN(length);
+  /* If necessary, restore the blocking mode, but only if connect succeeded. */
+  if ((timeout > -1) && (ret == 0))
+  {
+    my_bool not_used;
+    if (vio_blocking(vio, TRUE, &not_used))
+      DBUG_RETURN(TRUE);
+  }
+
+  DBUG_RETURN(test(ret));
 }
 
 
-size_t vio_write_shared_memory(Vio * vio, const uchar* buf, size_t size)
-{
-  size_t length, remain, sz;
-  HANDLE pos;
-  const uchar *current_position;
-  HANDLE events[2];
+/**
+  Determine if the endpoint of a connection is still available.
 
-  DBUG_ENTER("vio_write_shared_memory");
-  DBUG_PRINT("enter", ("sd: %d  buf: 0x%lx  size: %d", vio->sd, (long) buf,
-                       size));
+  @remark The socket is assumed to be disconnected if an EOF
+          condition is encountered.
 
-  remain = size;
-  current_position = buf;
+  @param vio      The VIO object.
 
-  events[0]= vio->event_server_read;
-  events[1]= vio->event_conn_closed;
+  @retval TRUE    EOF condition not found.
+  @retval FALSE   EOF condition is signaled.
+*/
 
-  while (remain != 0)
-  {
-    if (WaitForMultipleObjects(array_elements(events), events, FALSE,
-                               vio->write_timeout_ms) != WAIT_OBJECT_0)
-    {
-      DBUG_RETURN((size_t) -1);
-    }
+my_bool vio_is_connected(Vio *vio)
+{
+  uint bytes= 0;
+  DBUG_ENTER("vio_is_connected");
 
-    sz= (remain > shared_memory_buffer_length ? shared_memory_buffer_length :
-         remain);
+  /*
+    The first step of detecting an EOF condition is verifying
+    whether there is data to read. Data in this case would be
+    the EOF. An exceptional condition event and/or errors are
+    interpreted as if there is data to read.
+  */
+  if (!vio_io_wait(vio, VIO_IO_EVENT_READ, 0))
+    DBUG_RETURN(TRUE);
 
-    int4store(vio->handle_map,sz);
-    pos = vio->handle_map + 4;
-    memcpy(pos,current_position,sz);
-    remain-=sz;
-    current_position+=sz;
-    if (!SetEvent(vio->event_client_wrote))
-      DBUG_RETURN((size_t) -1);
+  /*
+    The second step is read() or recv() from the socket returning
+    0 (EOF). Unfortunately, it's not possible to call read directly
+    as we could inadvertently read meaningful connection data.
+    Simulate a read by retrieving the number of bytes available to
+    read -- 0 meaning EOF. In the presence of unrecoverable errors,
+    the socket is assumed to be disconnected.
+  */
+  while (socket_peek_read(vio, &bytes))
+  {
+    if (socket_errno != SOCKET_EINTR)
+      DBUG_RETURN(FALSE);
   }
-  length = size;
-
-  DBUG_PRINT("exit", ("%lu", (ulong) length));
-  DBUG_RETURN(length);
-}
 
+#ifdef HAVE_OPENSSL
+  /* There might be buffered data at the SSL layer. */
+  if (!bytes && vio->type == VIO_TYPE_SSL)
+    bytes= SSL_pending((SSL*) vio->ssl_arg);
+#endif
 
-my_bool vio_is_connected_shared_memory(Vio *vio)
-{
-  return (WaitForSingleObject(vio->event_conn_closed, 0) != WAIT_OBJECT_0);
+  DBUG_RETURN(bytes ? TRUE : FALSE);
 }
 
+#ifndef DBUG_OFF
 
 /**
- Close shared memory and DBUG_PRINT any errors that happen on closing.
- @return Zero if all closing functions succeed, and nonzero otherwise.
-*/
-int vio_close_shared_memory(Vio * vio)
-{
-  int error_count= 0;
-  DBUG_ENTER("vio_close_shared_memory");
-  if (vio->type != VIO_CLOSED)
-  {
-    /*
-      Set event_conn_closed for notification of both client and server that
-      connection is closed
-    */
-    SetEvent(vio->event_conn_closed);
-    /*
-      Close all handlers. UnmapViewOfFile and CloseHandle return non-zero
-      result if they are success.
-    */
-    if (UnmapViewOfFile(vio->handle_map) == 0) 
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("UnmapViewOfFile() failed"));
-    }
-    if (CloseHandle(vio->event_server_wrote) == 0)
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("CloseHandle(vio->esw) failed"));
-    }
-    if (CloseHandle(vio->event_server_read) == 0)
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("CloseHandle(vio->esr) failed"));
-    }
-    if (CloseHandle(vio->event_client_wrote) == 0)
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("CloseHandle(vio->ecw) failed"));
-    }
-    if (CloseHandle(vio->event_client_read) == 0)
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("CloseHandle(vio->ecr) failed"));
-    }
-    if (CloseHandle(vio->handle_file_map) == 0)
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("CloseHandle(vio->hfm) failed"));
-    }
-    if (CloseHandle(vio->event_conn_closed) == 0)
-    {
-      error_count++;
-      DBUG_PRINT("vio_error", ("CloseHandle(vio->ecc) failed"));
-    }
-  }
-  vio->type= VIO_CLOSED;
-  vio->sd=   -1;
-  DBUG_RETURN(error_count);
-}
-#endif /* HAVE_SMEM */
-#endif /* __WIN__ */
-
+  Number of bytes in the read or socket buffer
 
-/**
-  Number of bytes in the read buffer.
+  @remark An EOF condition might count as one readable byte.
 
-  @return number of bytes in the read buffer or < 0 if error.
+  @return number of bytes in one of the buffers or < 0 if error.
 */
 
 ssize_t vio_pending(Vio *vio)
 {
-#ifdef HAVE_OPENSSL
-  SSL *ssl= (SSL*) vio->ssl_arg;
-#endif
+  uint bytes= 0;
 
+  /* Data pending on the read buffer. */
   if (vio->read_pos < vio->read_end)
     return vio->read_end - vio->read_pos;
 
-#ifdef HAVE_OPENSSL
-  if (ssl)
-    return SSL_pending(ssl);
-#endif
+  /* Skip non-socket based transport types. */
+  if (vio->type == VIO_TYPE_TCPIP || vio->type == VIO_TYPE_SOCKET)
+  {
+    /* Obtain number of readable bytes in the socket buffer. */
+    if (socket_peek_read(vio, &bytes))
+      return -1;
+  }
+
+  /*
+    SSL not checked due to a yaSSL bug in SSL_pending that
+    causes it to attempt to read from the socket.
+  */
 
-  return 0;
+  return (ssize_t) bytes;
 }
 
+#endif /* DBUG_OFF */
 
 /**
   Checks if the error code, returned by vio_getnameinfo(), means it was the
@@ -1237,13 +1215,9 @@ ssize_t vio_pending(Vio *vio)
 my_bool vio_is_no_name_error(int err_code)
 {
 #ifdef _WIN32
-
   return err_code == WSANO_DATA || err_code == EAI_NONAME;
-
 #else
-
   return err_code == EAI_NONAME;
-
 #endif
 }
 
@@ -1282,8 +1256,6 @@ int vio_getnameinfo(const struct sockaddr *sa,
 #endif /* HAVE_IPV6 */
   }
 
-  return getnameinfo(sa, sa_length,
-                     hostname, hostname_size,
-                     port, port_size,
-                     flags);
+  return getnameinfo(sa, sa_length, hostname, hostname_size,
+                     port, port_size, flags);
 }