Merge lp:~thomir-deactivatedaccount/drizzle/drizzle-struct-class-conversion into lp:drizzle/7.0

[Thomi Richards]

Changed the vio_st structure (found in plugins/mysql_protocol/vio.h) to a proper C++ class.

[Lee Bieber (kalebral-deactivatedaccount)]

Build failures:

 CXX plugin/mysql_unix_socket_protocol/plugin_libmysql_unix_socket_protocol_plugin_la-protocol.lo
../plugin/mysql_protocol/vio.h: In function ‘uint32_t my_real_read(NET*, size_t*)’:
../plugin/mysql_protocol/vio.h:130: error: ‘int Vio::sd’ is private
../plugin/mysql_protocol/net_serv.cc:681: error: within this context
make[3]: *** [plugin/mysql_protocol/plugin_libmysql_protocol_plugin_la-net_serv.lo] Error 1

[Thomi Richards (thomir-deactivatedaccount)]

> Build failures:

This confuses me somewhat, for several reasons:

First, I made sure that my branch built (and worked) before submitting it. Second, I can't find the problem.

I did have to change code in net_serv.cc from accessing the 'sd' member directly - it should now call Vio::get_fd() instead. However, in trunk (rev 1878) I can't find anywhere in 'my_real_read' that attempts to access the member variable in question.

Is it possible that somehow the changes in my branch aren't being applied correctly? Or have I missed something? I'm new to bzr & launchpad, so maybe I've overlooked something obvious...

> CXX plugin/mysql_unix_socket_protocol
> /plugin_libmysql_unix_socket_protocol_plugin_la-protocol.lo
> ../plugin/mysql_protocol/vio.h: In function ‘uint32_t my_real_read(NET*,
> size_t*)’:
> ../plugin/mysql_protocol/vio.h:130: error: ‘int Vio::sd’ is private
> ../plugin/mysql_protocol/net_serv.cc:681: error: within this context
> make[3]: *** [plugin/mysql_protocol/plugin_libmysql_protocol_plugin_la-
> net_serv.lo] Error 1

review: Needs Information

[Andrew Hutchings (linuxjedi)]

Hi Thomi,

Can you please merge trunk into your branch and re-commit/push? This is due to some changes I made to vio in the last few days that are in trunk which when merged with yours cause this.

[Thomi Richards (thomir-deactivatedaccount)]

> Hi Thomi,
>
> Can you please merge trunk into your branch and re-commit/push? This is due
> to some changes I made to vio in the last few days that are in trunk which
> when merged with yours cause this.

Done. Hopefully it should work now. Let me know if there are still problems.

Cheers.

review: Needs Resubmitting

=== modified file 'plugin/mysql_protocol/mysql_protocol.cc'
--- plugin/mysql_protocol/mysql_protocol.cc	2010-10-27 18:03:49 +0000
+++ plugin/mysql_protocol/mysql_protocol.cc	2010-10-30 00:46:01 +0000
@@ -103,7 +103,7 @@
 ClientMySQLProtocol::~ClientMySQLProtocol()
 {
   if (net.vio)
-    vio_close(net.vio);
+    net.vio->close();
 }
 
 int ClientMySQLProtocol::getFileDescriptor(void)
@@ -884,7 +884,7 @@
   uint32_t pointer_seed;
   memcpy(&pointer_seed, &pointer, 4);
   uint32_t random1= (seed + pointer_seed) % random_max;
-  uint32_t random2= (seed + session->variables.pseudo_thread_id + net.vio->sd) % random_max;
+  uint32_t random2= (seed + session->variables.pseudo_thread_id + net.vio->get_fd()) % random_max;
 
   for (char *end= scramble + SCRAMBLE_LENGTH; scramble != end; scramble++)
   {
 
=== modified file 'plugin/mysql_protocol/net_serv.cc'
--- plugin/mysql_protocol/net_serv.cc	2010-10-27 06:36:38 +0000
+++ plugin/mysql_protocol/net_serv.cc	2010-10-30 00:46:01 +0000
@@ -82,15 +82,15 @@
 
   if (vio != 0)                    /* If real connection */
   {
-    net->fd  = vio_fd(vio);            /* For perl DBI/DBD */
-    vio_fastsend(vio);
+    net->fd  = vio->get_fd();            /* For perl DBI/DBD */
+    vio->fastsend();
   }
   return(0);
 }
 
 bool drizzleclient_net_init_sock(NET * net, int sock, uint32_t buffer_length)
 {
-  Vio *vio_tmp= mysql_protocol_vio_new(sock);
+  Vio *vio_tmp= new Vio(sock);
   if (vio_tmp == NULL)
     return true;
   else
@@ -100,7 +100,7 @@
        * NET object.
        */
       if (vio_tmp && (net->vio != vio_tmp))
-        vio_delete(vio_tmp);
+        delete vio_tmp;
       else
       {
         (void) shutdown(sock, SHUT_RDWR);
@@ -123,29 +123,29 @@
 {
   if (net->vio != NULL)
   {
-    vio_delete(net->vio);
+    delete net->vio;
     net->vio= 0;
   }
 }
 
 bool drizzleclient_net_peer_addr(NET *net, char *buf, uint16_t *port, size_t buflen)
 {
-  return vio_peer_addr(net->vio, buf, port, buflen);
+  return net->vio->peer_addr(buf, port, buflen);
 }
 
 void drizzleclient_net_keepalive(NET *net, bool flag)
 {
-  vio_keepalive(net->vio, flag);
+  net->vio->keepalive(flag);
 }
 
 int drizzleclient_net_get_sd(NET *net)
 {
-  return net->vio->sd;
+  return net->vio->get_fd();
 }
 
 bool drizzleclient_net_more_data(NET *net)
 {
-  return (net->vio == 0 || net->vio->read_pos < net->vio->read_end);
+  return (net->vio == 0 || net->vio->get_read_pos() < net->vio->get_read_end());
 }
 
 /** Realloc the packet buffer. */
@@ -232,10 +232,10 @@
 {
   if (clear_buffer)
   {
-    while (net_data_is_ready(net->vio->sd) > 0)
+    while (net_data_is_ready(net->vio->get_fd()) > 0)
     {
       /* The socket is ready */
-      if (vio_read(net->vio, net->buff, (size_t) net->max_packet) <= 0)
+      if (net->vio->read(net->buff, (size_t) net->max_packet) <= 0)
       {
         net->error= 2;
         break;
@@ -527,7 +527,8 @@
   while (pos != end)
   {
     assert(pos);
-    if ((long) (length= vio_write(net->vio, pos, (size_t) (end-pos))) <= 0)
+    // TODO - see bug comment below - will we crash now?
+    if ((long) (length= net->vio->write( pos, (size_t) (end-pos))) <= 0)
     {
      /*
       * We could end up here with net->vio == NULL
@@ -537,7 +538,7 @@
       if (net->vio == NULL)
         break;
       
-      const bool interrupted= vio_should_retry(net->vio);
+      const bool interrupted= net->vio->should_retry();
       /*
         If we read 0, or we were interrupted this means that
         we need to switch to blocking mode and wait until the timeout
@@ -547,9 +548,9 @@
       {
         bool old_mode;
 
-        while (vio_blocking(net->vio, true, &old_mode) < 0)
+        while (net->vio->blocking(true, &old_mode) < 0)
         {
-          if (vio_should_retry(net->vio) && retry_count++ < net->retry_count)
+          if (net->vio->should_retry() && retry_count++ < net->retry_count)
             continue;
           net->error= 2;                     /* Close socket */
           net->last_errno= ER_NET_PACKET_TOO_LARGE;
@@ -565,7 +566,7 @@
           continue;
       }
 
-      if (vio_errno(net->vio) == EINTR)
+      if (net->vio->get_errno() == EINTR)
       {
         continue;
       }
@@ -617,25 +618,25 @@
     while (remain > 0)
     {
       /* First read is done with non blocking mode */
-      if ((long) (length= vio_read(net->vio, pos, remain)) <= 0L)
+      if ((long) (length= net->vio->read(pos, remain)) <= 0L)
       {
         if (net->vio == NULL)
           goto end;
 
-        const bool interrupted = vio_should_retry(net->vio);
+        const bool interrupted = net->vio->should_retry();
 
         if (interrupted)
         {                    /* Probably in MIT threads */
           if (retry_count++ < net->retry_count)
             continue;
         }
-        if (vio_errno(net->vio) == EINTR)
+        if (net->vio->get_errno() == EINTR)
         {
           continue;
         }
         len= packet_error;
         net->error= 2;                /* Close socket */
-        net->last_errno= (vio_was_interrupted(net->vio) ?
+        net->last_errno= (net->vio->was_interrupted() ?
                           CR_NET_READ_INTERRUPTED :
                           CR_NET_READ_ERROR);
         goto end;
@@ -677,7 +678,7 @@
           /* Clear the buffer so libdrizzle doesn't keep retrying */
           while (len > 0)
           {
-            length= read(net->vio->sd, net->buff, min((size_t)net->max_packet, len));
+            length= read(net->vio->get_fd(), net->buff, min((size_t)net->max_packet, len));
             assert((long)length > 0L);
             len-= length;
           }
@@ -870,7 +871,7 @@
   net->read_timeout= timeout;
 #ifndef __sun
   if (net->vio)
-    vio_timeout(net->vio, 0, timeout);
+    net->vio->timeout(0, timeout);
 #endif
   return;
 }
@@ -881,7 +882,7 @@
   net->write_timeout= timeout;
 #ifndef __sun
   if (net->vio)
-    vio_timeout(net->vio, 1, timeout);
+    net->vio->timeout(1, timeout);
 #endif
   return;
 }
 
=== modified file 'plugin/mysql_protocol/vio.cc'
--- plugin/mysql_protocol/vio.cc	2010-10-28 01:51:45 +0000
+++ plugin/mysql_protocol/vio.cc	2010-10-30 00:46:01 +0000
@@ -19,7 +19,6 @@
   we are working on.  In this case we should just return read errors from
   the file descriptior.
 */
-
 #include "config.h"
 #include "vio.h"
 #include <string.h>
@@ -41,61 +40,97 @@
 
 using namespace std;
 
-static void _vio_delete(Vio* vio)
-{
-  if (!vio)
-    return; /* It must be safe to delete null pointers. */
-
-  if (!vio->closed)
-    vio->vioclose(vio);
-  free((unsigned char*) vio);
-}
-
-static int _vio_errno(Vio *vio)
-{
-  (void)vio;
-  return errno;
-}
-
-static size_t _vio_read(Vio * vio, unsigned char* buf, size_t size)
+Vio::Vio(int nsd)
+: closed(false),
+sd(nsd),
+fcntl_mode(0),
+read_pos(NULL),
+read_end(NULL)
+{
+  closed= false;
+  sd= nsd;
+
+  /*
+    We call fcntl() to set the flags and then immediately read them back
+    to make sure that we and the system are in agreement on the state of
+    things.
+
+    An example of why we need to do this is FreeBSD (and apparently some
+    other BSD-derived systems, like Mac OS X), where the system sometimes
+    reports that the socket is set for non-blocking when it really will
+    block.
+  */
+  fcntl(sd, F_SETFL, 0);
+  fcntl_mode= fcntl(sd, F_GETFL);
+
+  memset(&local, 0, sizeof(local));
+  memset(&remote, 0, sizeof(remote));
+}
+
+Vio::~Vio()
+{
+ if (!closed)
+    close();
+}
+
+int Vio::close()
+{
+  int r=0;
+  if (!closed)
+  {
+    assert(sd >= 0);
+    if (shutdown(sd, SHUT_RDWR))
+      r= -1;
+    if (::close(sd))
+      r= -1;
+  }
+  closed= true;
+  sd=   -1;
+
+  return r;
+}
+
+size_t Vio::read(unsigned char* buf, size_t size)
 {
   size_t r;
 
   /* Ensure nobody uses vio_read_buff and vio_read simultaneously */
-  assert(vio->read_end == vio->read_pos);
-  r= read(vio->sd, buf, size);
+  assert(read_end == read_pos);
+  r= ::read(sd, buf, size);
 
   return r;
 }
 
-static size_t _vio_write(Vio * vio, const unsigned char* buf, size_t size)
+size_t Vio::write(const unsigned char* buf, size_t size)
 {
   size_t r;
 
-  r = write(vio->sd, buf, size);
+  r = ::write(sd, buf, size);
 
   return r;
 }
 
-static int _vio_blocking(Vio * vio, bool set_blocking_mode, bool *old_mode)
+int Vio::blocking(bool set_blocking_mode, bool *old_mode)
 {
   int r=0;
 
-  *old_mode= drizzled::test(!(vio->fcntl_mode & O_NONBLOCK));
+  // make sure ptr is not NULL:
+  if (NULL != old_mode)
+    *old_mode= drizzled::test(!(fcntl_mode & O_NONBLOCK));
 
-  if (vio->sd >= 0)
+  if (sd >= 0)
   {
-    int old_fcntl=vio->fcntl_mode;
+    int old_fcntl=fcntl_mode;
     if (set_blocking_mode)
-      vio->fcntl_mode &= ~O_NONBLOCK; /* clear bit */
+      fcntl_mode &= ~O_NONBLOCK; /* clear bit */
     else
-      vio->fcntl_mode |= O_NONBLOCK; /* set bit */
-    if (old_fcntl != vio->fcntl_mode)
+      fcntl_mode |= O_NONBLOCK; /* set bit */
+    if (old_fcntl != fcntl_mode)
     {
-      r= fcntl(vio->sd, F_SETFL, vio->fcntl_mode);
+      r= fcntl(sd, F_SETFL, fcntl_mode);
       if (r == -1)
       {
-        vio->fcntl_mode= old_fcntl;
+        fcntl_mode= old_fcntl;
       }
     }
   }
@@ -103,13 +138,12 @@
   return r;
 }
 
-static int _vio_fastsend(Vio * vio)
+int Vio::fastsend()
 {
-  (void)vio;
   int nodelay = 1;
   int error;
 
-  error= setsockopt(vio->sd, IPPROTO_TCP, TCP_NODELAY,
+  error= setsockopt(sd, IPPROTO_TCP, TCP_NODELAY,
                     &nodelay, sizeof(nodelay));
   if (error != 0)
   {
@@ -119,7 +153,7 @@
   return error;
 }
 
-static int32_t _vio_keepalive(Vio* vio, bool set_keep_alive)
+int32_t Vio::keepalive(bool set_keep_alive)
 {
   int r= 0;
   uint32_t opt= 0;
@@ -127,7 +161,7 @@
   if (set_keep_alive)
     opt= 1;
 
-  r= setsockopt(vio->sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt));
+  r= setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof(opt));
   if (r != 0)
   {
     perror("setsockopt");
@@ -137,54 +171,34 @@
   return r;
 }
 
-static bool _vio_should_retry(Vio * vio)
+bool Vio::should_retry() const
 {
-  (void)vio;
   int en = errno;
   return (en == EAGAIN || en == EINTR ||
-	  en == EWOULDBLOCK);
+          en == EWOULDBLOCK);
 }
 
-static bool _vio_was_interrupted(Vio *vio)
+bool Vio::was_interrupted() const
 {
-  (void)vio;
   int en= errno;
   return (en == EAGAIN || en == EINTR ||
-	  en == EWOULDBLOCK || en == ETIMEDOUT);
-}
-
-static int _vio_close(Vio * vio)
-{
-  int r=0;
- if (!vio->closed)
-  {
-    assert(vio->sd >= 0);
-    if (shutdown(vio->sd, SHUT_RDWR))
-      r= -1;
-    if (close(vio->sd))
-      r= -1;
-  }
-  vio->closed= true;
-  vio->sd=   -1;
-
-  return r;
-}
-
-static bool _vio_peer_addr(Vio *vio, char *buf, uint16_t *port, size_t buflen)
+          en == EWOULDBLOCK || en == ETIMEDOUT);
+}
+
+bool Vio::peer_addr(char *buf, uint16_t *port, size_t buflen) const
 {
   int error;
   char port_buf[NI_MAXSERV];
-  socklen_t addrLen = sizeof(vio->remote);
+  socklen_t al = sizeof(remote);
 
-  if (getpeername(vio->sd, (struct sockaddr *) (&vio->remote),
-                  &addrLen) != 0)
+  if (getpeername(sd, (struct sockaddr *) (&remote),
+                  &al) != 0)
   {
     return true;
   }
-  vio->addrLen= (int)addrLen;
 
-  if ((error= getnameinfo((struct sockaddr *)(&vio->remote),
-                          addrLen,
+  if ((error= getnameinfo((struct sockaddr *)(&remote),
+                          al,
                           buf, buflen,
                           port_buf, NI_MAXSERV, NI_NUMERICHOST|NI_NUMERICSERV)))
   {
@@ -196,18 +210,18 @@
   return false;
 }
 
-static void _vio_timeout(Vio *vio, bool is_sndtimeo, int32_t timeout)
+void Vio::timeout(bool is_sndtimeo, int32_t t)
 {
   int error;
 
   /* POSIX specifies time as struct timeval. */
   struct timeval wait_timeout;
-  wait_timeout.tv_sec= timeout;
+  wait_timeout.tv_sec= t;
   wait_timeout.tv_usec= 0;
 
-  assert(timeout >= 0 && timeout <= INT32_MAX);
-  assert(vio->sd != -1);
-  error= setsockopt(vio->sd, SOL_SOCKET, is_sndtimeo ? SO_SNDTIMEO : SO_RCVTIMEO,
+  assert(t >= 0 && t <= INT32_MAX);
+  assert(sd != -1);
+  error= setsockopt(sd, SOL_SOCKET, is_sndtimeo ? SO_SNDTIMEO : SO_RCVTIMEO,
                     &wait_timeout,
                     (socklen_t)sizeof(struct timeval));
   if (error == -1 && errno != ENOPROTOOPT)
@@ -217,41 +231,24 @@
   }
 }
 
-/* Open the socket or TCP/IP connection and read the fnctl() status */
-Vio *mysql_protocol_vio_new(int sd)
-{
-  Vio *vio = (Vio*) malloc(sizeof(Vio));
-  if (vio == NULL)
-    return NULL;
-
-  memset(vio, 0, sizeof(*vio));
-  vio->closed= false;
-  vio->sd= sd;
-  vio->viodelete= _vio_delete;
-  vio->vioerrno= _vio_errno;
-  vio->read= _vio_read;
-  vio->write= _vio_write;
-  vio->fastsend= _vio_fastsend;
-  vio->viokeepalive= _vio_keepalive;
-  vio->should_retry= _vio_should_retry;
-  vio->was_interrupted= _vio_was_interrupted;
-  vio->vioclose= _vio_close;
-  vio->peer_addr= _vio_peer_addr;
-  vio->vioblocking= _vio_blocking;
-  vio->timeout= _vio_timeout;
-
-  /*
-    We call fcntl() to set the flags and then immediately read them back
-    to make sure that we and the system are in agreement on the state of
-    things.
-
-    An example of why we need to do this is FreeBSD (and apparently some
-    other BSD-derived systems, like Mac OS X), where the system sometimes
-    reports that the socket is set for non-blocking when it really will
-    block.
-  */
-  fcntl(sd, F_SETFL, 0);
-  vio->fcntl_mode= fcntl(sd, F_GETFL);
-
-  return vio;
-}
+int Vio::get_errno() const
+{
+  return errno;
+}
+
+int Vio::get_fd() const
+{
+  return sd;
+}
+
+
+char *Vio::get_read_pos() const
+{
+  return read_pos;
+}
+
+char *Vio::get_read_end() const
+{
+  return read_end;
+}
+
 
=== modified file 'plugin/mysql_protocol/vio.h'
--- plugin/mysql_protocol/vio.h	2010-10-02 21:15:42 +0000
+++ plugin/mysql_protocol/vio.h	2010-10-30 00:46:01 +0000
@@ -13,9 +13,6 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
-/*
- * Virtual I/O layer, only used with TCP/IP sockets at the moment.
- */
 
 #ifndef PLUGIN_MYSQL_PROTOCOL_VIO_H
 #define PLUGIN_MYSQL_PROTOCOL_VIO_H
@@ -23,49 +20,121 @@
 #include <sys/socket.h>
 #include <errno.h>
 
-typedef struct st_vio Vio;
-
-struct st_vio
+/**
+ *@brief Virtual I/O layer, only used with TCP/IP sockets at the moment.
+ */
+class Vio
 {
+public:
+  /**
+   * Constructor. 
+   * @param[in] sd Descriptor to use.
+   */
+  Vio(int sd);
+  ~Vio();
+
+  /**
+   *Close the connection.
+   *@returns 0 on success.
+   */
+  int close();
+
+  /**
+   * Read some data from the remote end.
+   *@param[out] buf A buffer to write the new data to.
+   *@param[in] size The size of the buffer
+   *@returns The number of bytes read.
+   */
+  size_t read(unsigned char* buf, size_t size);
+  
+  /**
+   * Write some data to the remote end.
+   *@param[in] buf A buffer that contains the data to send.
+   *@param[in] size The size of the buffer
+   *@returns The number of bytes written.
+   */
+  size_t write(const unsigned char* buf, size_t size);
+
+  /**
+   * Set device blocking mode.
+   *@param[in] set_blocking_mode Whether the device should block. true sets blocking mode, false clears it.
+   *@param[out] old_mode This will be set to the previous blocking mode.
+   *@returns 0 on success.
+   */
+  int blocking(bool set_blocking_mode, bool *old_mode);
+
+  /**
+   * Enables fast sending.
+   * Setting this sets the TCP_NODELAY socket option.
+   *@returns 0 on succcess.
+   */
+  int fastsend();
+
+  /**
+   * Sets or clears the keepalive option.
+   *@param[in] set_keep_alive Whether to set or clear the flag. True Sets keepalive, false clears it.
+   *@returns 0 on success.
+   */
+  int32_t keepalive(bool set_keep_alive);
+
+  /**
+   *@returns true if the caller should retry the last operation.
+   */
+  bool should_retry() const;
+
+  /**
+   *@returns true if the last operation was interrupted.
+   */
+  bool was_interrupted() const;
+
+  /**
+   *Gets the address details of the peer.
+   @param[out] buf Buffer that will recieve the peer address.
+   @param[out] port Port of remote end.
+   @param[in] buflen Size of buf.
+   @returns True on success, false otherwise.
+   */
+  bool peer_addr(char *buf, uint16_t *port, size_t buflen) const;
+
+  /**
+   * Sets either the send, or recieve timeouts for the socket.
+   *@param[in] is_sndtimeo Set to true to change the send timeout, false to change the recieve timeout.
+   *@param[in] timeout The new timeout to set, in seconds.
+   */
+  void timeout(bool is_sndtimeo, int32_t timeout);
+
+  /**
+   * Returns the last error code.
+   *@returns the last error code, as described in errno.h
+   */
+  int get_errno() const;
+
+  /**
+   * Get the underlying descriptor this class is using.
+   *@returns The descriptor passed in to the constructor of this class.
+   */
+  int get_fd() const;
+
+  /**
+   * Returns the current read position.
+   */
+  char *get_read_pos() const;
+
+  /**
+   * Returns the current write position.
+   */
+  char *get_read_end() const;
+
+private:
   bool closed;
   int sd;
   int fcntl_mode; /* Buffered fcntl(sd,F_GETFL) */
   struct sockaddr_storage local; /* Local internet address */
   struct sockaddr_storage remote; /* Remote internet address */
-  int addrLen; /* Length of remote address */
   char *read_pos; /* start of unfetched data in the read buffer */
   char *read_end; /* end of unfetched data */
 
-  /* function pointers. They are similar for socket/SSL/whatever */
-  void (*viodelete)(Vio*);
-  int32_t (*vioerrno)(Vio*);
-  size_t (*read)(Vio*, unsigned char *, size_t);
-  size_t (*write)(Vio*, const unsigned char *, size_t);
-  int32_t (*vioblocking)(Vio*, bool, bool *);
-  int32_t (*viokeepalive)(Vio*, bool);
-  int32_t (*fastsend)(Vio*);
-  bool (*peer_addr)(Vio*, char *, uint16_t *, size_t);
-  void (*in_addr)(Vio*, struct sockaddr_storage*);
-  bool (*should_retry)(Vio*);
-  bool (*was_interrupted)(Vio*);
-  int32_t (*vioclose)(Vio*);
-  void (*timeout)(Vio*, bool is_sndtimeo, int32_t timeout);
 };
 
-Vio* mysql_protocol_vio_new(int sd);
-
-#define vio_fd(vio) (vio)->sd
-#define vio_delete(vio) (vio)->viodelete(vio)
-#define vio_errno(vio) (vio)->vioerrno(vio)
-#define vio_read(vio, buf, size) ((vio)->read)(vio,buf,size)
-#define vio_write(vio, buf, size) ((vio)->write)(vio, buf, size)
-#define vio_blocking(vio, set_blocking_mode, old_mode) (vio)->vioblocking(vio, set_blocking_mode, old_mode)
-#define vio_fastsend(vio) (vio)->fastsend(vio)
-#define vio_keepalive(vio, set_keep_alive) (vio)->viokeepalive(vio, set_keep_alive)
-#define vio_should_retry(vio) (vio)->should_retry(vio)
-#define vio_was_interrupted(vio) (vio)->was_interrupted(vio)
-#define vio_close(vio) ((vio)->vioclose)(vio)
-#define vio_peer_addr(vio, buf, prt, buflen) (vio)->peer_addr(vio, buf, prt, buflen)
-#define vio_timeout(vio, which, seconds) (vio)->timeout(vio, which, seconds)
 
 #endif /* PLUGIN_MYSQL_PROTOCOL_VIO_H */