MDEV-23238 - remove async client from server code.

It is already in libmariadb, and server (also that client in server)
does not need it.

It does not work in embedded either since it relies on non-blocking sockets

2 files changed, 5 insertions, 2109 deletions

diff --git a/sql-common/client.c b/sql-common/client.c
index c12b3ef5c0a..5e072a8b538 100644
--- a/sql-common/client.c
+++ b/sql-common/client.c
@@ -100,8 +100,6 @@ my_bool	net_flush(NET *net);
 #include <ssl_compat.h>
 #include <sql_common.h>
 #include <mysql/client_plugin.h>
-#include <my_context.h>
-#include <mysql_async.h>
 
 typedef enum {
   ALWAYS_ACCEPT,       /* heuristics is disabled, use CLIENT_LOCAL_FILES */
@@ -2607,20 +2605,11 @@ int run_plugin_auth(MYSQL *mysql, char *data, uint data_len,
 
 
 static int
-connect_sync_or_async(MYSQL *mysql, NET *net, my_socket fd,
+connect_sync(MYSQL *mysql, NET *net, my_socket fd,
                       struct sockaddr *name, uint namelen)
 {
   int vio_timeout = get_vio_connect_timeout(mysql);
 
-  if (mysql->options.extension && mysql->options.extension->async_context &&
-      mysql->options.extension->async_context->active)
-  {
-    my_bool old_mode;
-    vio_blocking(net->vio, FALSE, &old_mode);
-    return my_connect_async(mysql->options.extension->async_context, fd,
-                            name, namelen, vio_timeout);
-  }
-
   return vio_socket_connect(net->vio, name, namelen, vio_timeout);
 }
 
@@ -2787,7 +2776,7 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
     bzero((char*) &UNIXaddr, sizeof(UNIXaddr));
     UNIXaddr.sun_family= AF_UNIX;
     strmake_buf(UNIXaddr.sun_path, unix_socket);
-    if (connect_sync_or_async(mysql, net, sock,
+    if (connect_sync(mysql, net, sock,
                               (struct sockaddr *) &UNIXaddr, sizeof(UNIXaddr)))
     {
       DBUG_PRINT("error",("Got error %d on connect to local server",
@@ -2902,7 +2891,7 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
       }
 
       DBUG_PRINT("info", ("Connect socket"));
-      status= connect_sync_or_async(mysql, net, sock,
+      status= connect_sync(mysql, net, sock,
                                     t_res->ai_addr, (uint)t_res->ai_addrlen);
       /*
         Here we rely on my_connect() to return success only if the
@@ -2952,9 +2941,6 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
     goto error;
   }
 
-  if (mysql->options.extension && mysql->options.extension->async_context)
-    net->vio->async_context= mysql->options.extension->async_context;
-
   if (my_net_init(net, net->vio, _current_thd(), MYF(0)))
   {
     vio_delete(net->vio);
@@ -3195,42 +3181,16 @@ error:
     /* Free alloced memory */
     end_server(mysql);
     mysql_close_free(mysql);
-    if (!(client_flag & CLIENT_REMEMBER_OPTIONS) &&
-        !(mysql->options.extension && mysql->options.extension->async_context))
+    if (!(client_flag & CLIENT_REMEMBER_OPTIONS))
       mysql_close_free_options(mysql);
   }
   DBUG_RETURN(0);
 }
 
 
-struct my_hook_data {
-  MYSQL *orig_mysql;
-  MYSQL *new_mysql;
-  /* This is always NULL currently, but restoring does not hurt just in case. */
-  Vio *orig_vio;
-};
-/*
-  Callback hook to make the new VIO accessible via the old MYSQL to calling
-  application when suspending a non-blocking call during automatic reconnect.
-*/
-static void
-my_suspend_hook(my_bool suspend, void *data)
-{
-  struct my_hook_data *hook_data= (struct my_hook_data *)data;
-  if (suspend)
-  {
-    hook_data->orig_vio= hook_data->orig_mysql->net.vio;
-    hook_data->orig_mysql->net.vio= hook_data->new_mysql->net.vio;
-  }
-  else
-    hook_data->orig_mysql->net.vio= hook_data->orig_vio;
-}
-
 my_bool mysql_reconnect(MYSQL *mysql)
 {
   MYSQL tmp_mysql;
-  struct my_hook_data hook_data;
-  struct mysql_async_context *ctxt= NULL;
   DBUG_ENTER("mysql_reconnect");
   DBUG_ASSERT(mysql);
   DBUG_PRINT("enter", ("mysql->reconnect: %d", mysql->reconnect));
@@ -3247,31 +3207,11 @@ my_bool mysql_reconnect(MYSQL *mysql)
   tmp_mysql.options= mysql->options;
   tmp_mysql.options.my_cnf_file= tmp_mysql.options.my_cnf_group= 0;
 
-  /*
-    If we are automatically re-connecting inside a non-blocking API call, we
-    may need to suspend and yield to the user application during the reconnect.
-    If so, the user application will need access to the new VIO already then
-    so that it can correctly wait for I/O to become ready.
-    To achieve this, we temporarily install a hook that will temporarily put in
-    the VIO while we are suspended.
-    (The vio will be put in the original MYSQL permanently once we successfully
-    reconnect, or be discarded if we fail to reconnect.)
-  */
-  if (mysql->options.extension &&
-      (ctxt= mysql->options.extension->async_context) &&
-      mysql->options.extension->async_context->active)
-  {
-    hook_data.orig_mysql= mysql;
-    hook_data.new_mysql= &tmp_mysql;
-    hook_data.orig_vio= mysql->net.vio;
-    my_context_install_suspend_resume_hook(ctxt, my_suspend_hook, &hook_data);
-  }
+
   if (!mysql_real_connect(&tmp_mysql,mysql->host,mysql->user,mysql->passwd,
 			  mysql->db, mysql->port, mysql->unix_socket,
 			  mysql->client_flag | CLIENT_REMEMBER_OPTIONS))
   {
-    if (ctxt)
-      my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
     mysql->net.last_errno= tmp_mysql.net.last_errno;
     strmov(mysql->net.last_error, tmp_mysql.net.last_error);
     strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
@@ -3282,15 +3222,11 @@ my_bool mysql_reconnect(MYSQL *mysql)
     DBUG_PRINT("error", ("mysql_set_character_set() failed"));
     bzero((char*) &tmp_mysql.options,sizeof(tmp_mysql.options));
     mysql_close(&tmp_mysql);
-    if (ctxt)
-      my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
     mysql->net.last_errno= tmp_mysql.net.last_errno;
     strmov(mysql->net.last_error, tmp_mysql.net.last_error);
     strmov(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
     DBUG_RETURN(1);
   }
-  if (ctxt)
-    my_context_install_suspend_resume_hook(ctxt, NULL, NULL);
 
   DBUG_PRINT("info", ("reconnect succeeded"));
   tmp_mysql.reconnect= 1;
@@ -3365,15 +3301,9 @@ static void mysql_close_free_options(MYSQL *mysql)
 #endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY */
   if (mysql->options.extension)
   {
-    struct mysql_async_context *ctxt= mysql->options.extension->async_context;
     my_free(mysql->options.extension->plugin_dir);
     my_free(mysql->options.extension->default_auth);
     my_hash_free(&mysql->options.extension->connection_attributes);
-    if (ctxt)
-    {
-      my_context_destroy(&ctxt->async_context);
-      my_free(ctxt);
-    }
     my_free(mysql->options.extension);
   }
   bzero((char*) &mysql->options,sizeof(mysql->options));
@@ -3806,15 +3736,9 @@ mysql_fetch_lengths(MYSQL_RES *res)
   return res->lengths;
 }
 
-
-#define ASYNC_CONTEXT_DEFAULT_STACK_SIZE (4096*15)
-
 int STDCALL
 mysql_options(MYSQL *mysql,enum mysql_option option, const void *arg)
 {
-  struct mysql_async_context *ctxt;
-  size_t stacksize;
-
   DBUG_ENTER("mysql_options");
   DBUG_PRINT("enter",("option: %d",(int) option));
   switch (option) {
@@ -3910,39 +3834,6 @@ mysql_options(MYSQL *mysql,enum mysql_option option, const void *arg)
         (void (*)(const MYSQL *, uint, uint, double, const char *, uint)) arg;
     break;
   case MYSQL_OPT_NONBLOCK:
-    if (mysql->options.extension &&
-        (ctxt = mysql->options.extension->async_context) != 0)
-    {
-      /*
-        We must not allow changing the stack size while a non-blocking call is
-        suspended (as the stack is then in use).
-      */
-      if (ctxt->suspended)
-        DBUG_RETURN(1);
-      my_context_destroy(&ctxt->async_context);
-      my_free(ctxt);
-    }
-    if (!(ctxt= (struct mysql_async_context *)
-          my_malloc(PSI_INSTRUMENT_ME, sizeof(*ctxt), MYF(MY_ZEROFILL))))
-    {
-      set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-      DBUG_RETURN(1);
-    }
-    stacksize= 0;
-    if (arg)
-      stacksize= *(const size_t *)arg;
-    if (!stacksize)
-      stacksize= ASYNC_CONTEXT_DEFAULT_STACK_SIZE;
-    if (my_context_init(&ctxt->async_context, stacksize))
-    {
-      set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-      my_free(ctxt);
-      DBUG_RETURN(1);
-    }
-    ENSURE_EXTENSIONS_PRESENT(&(mysql->options));
-    mysql->options.extension->async_context= ctxt;
-    if (mysql->net.vio)
-      mysql->net.vio->async_context= ctxt;
     break;
   case MYSQL_OPT_SSL_KEY:
     SET_SSL_PATH_OPTION(&mysql->options,ssl_key, arg);
diff --git a/sql-common/mysql_async.c b/sql-common/mysql_async.c
deleted file mode 100644
index a19955c49de..00000000000
--- a/sql-common/mysql_async.c
+++ /dev/null
@@ -1,1995 +0,0 @@
-/*
-  Copyright 2011 Kristian Nielsen and Monty Program Ab
-
-  This file is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
-  MySQL non-blocking client library functions.
-*/
-
-#include "my_global.h"
-#include "my_sys.h"
-#include "mysql.h"
-#include "errmsg.h"
-#include "sql_common.h"
-#include "my_context.h"
-#include "violite.h"
-#include "mysql_async.h"
-
-
-#ifdef __WIN__
-/*
-  Windows does not support MSG_DONTWAIT for send()/recv(). So we need to ensure
-  that the socket is non-blocking at the start of every operation.
-*/
-#define WIN_SET_NONBLOCKING(mysql) { \
-    my_bool old_mode; \
-    if ((mysql)->net.vio) vio_blocking((mysql)->net.vio, FALSE, &old_mode); \
-  }
-#else
-#define WIN_SET_NONBLOCKING(mysql)
-#endif
-
-
-void
-my_context_install_suspend_resume_hook(struct mysql_async_context *b,
-                                       void (*hook)(my_bool, void *),
-                                       void *user_data)
-{
-  b->suspend_resume_hook= hook;
-  b->suspend_resume_hook_user_data= user_data;
-}
-
-
-/* Asynchronous connect(); socket must already be set non-blocking. */
-int
-my_connect_async(struct mysql_async_context *b, my_socket fd,
-                 const struct sockaddr *name, uint namelen, int vio_timeout)
-{
-  int res;
-  size_socket s_err_size;
-
-  /* Make the socket non-blocking. */
-#ifdef __WIN__
-  ulong arg= 1;
-  ioctlsocket(fd, FIONBIO, (void *)&arg);
-#else
-  fcntl(fd, F_SETFL, O_NONBLOCK);
-#endif
-
-  b->events_to_wait_for= 0;
-  /*
-    Start to connect asynchronously.
-    If this will block, we suspend the call and return control to the
-    application context. The application will then resume us when the socket
-    polls ready for write, indicating that the connection attempt completed.
-  */
-  res= connect(fd, name, namelen);
-  if (res != 0)
-  {
-#ifdef __WIN__
-    int wsa_err= WSAGetLastError();
-    if (wsa_err != WSAEWOULDBLOCK)
-      return res;
-    b->events_to_wait_for|= MYSQL_WAIT_EXCEPT;
-#else
-    int err= errno;
-    if (err != EINPROGRESS && err != EALREADY && err != EAGAIN)
-      return res;
-#endif
-    b->events_to_wait_for|= MYSQL_WAIT_WRITE;
-    if (vio_timeout >= 0)
-    {
-      b->timeout_value= vio_timeout;
-      b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
-    }
-    else
-      b->timeout_value= 0;
-    if (b->suspend_resume_hook)
-      (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
-    my_context_yield(&b->async_context);
-    if (b->suspend_resume_hook)
-      (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
-    if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
-      return -1;
-
-    s_err_size= sizeof(res);
-    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*) &res, &s_err_size) != 0)
-      return -1;
-    if (res)
-    {
-      errno= res;
-      return -1;
-    }
-  }
-  return res;
-}
-
-#define IS_BLOCKING_ERROR()                   \
-  IF_WIN(WSAGetLastError() != WSAEWOULDBLOCK, \
-         (errno != EAGAIN && errno != EINTR))
-
-#ifdef _AIX
-#ifndef MSG_DONTWAIT
-#define MSG_DONTWAIT 0
-#endif
-#endif
-
-ssize_t
-my_recv_async(struct mysql_async_context *b, my_socket fd,
-              unsigned char *buf, size_t size, int timeout)
-{
-  ssize_t res;
-
-  for (;;)
-  {
-    res= recv(fd, buf, (int)size, IF_WIN(0, MSG_DONTWAIT));
-    if (res >= 0 || IS_BLOCKING_ERROR())
-      return res;
-    b->events_to_wait_for= MYSQL_WAIT_READ;
-    if (timeout >= 0)
-    {
-      b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
-      b->timeout_value= timeout;
-    }
-    if (b->suspend_resume_hook)
-      (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
-    my_context_yield(&b->async_context);
-    if (b->suspend_resume_hook)
-      (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
-    if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
-      return -1;
-  }
-}
-
-
-ssize_t
-my_send_async(struct mysql_async_context *b, my_socket fd,
-              const unsigned char *buf, size_t size, int timeout)
-{
-  ssize_t res;
-
-  for (;;)
-  {
-    res= send(fd, buf, (int)size, IF_WIN(0, MSG_DONTWAIT));
-    if (res >= 0 || IS_BLOCKING_ERROR())
-      return res;
-    b->events_to_wait_for= MYSQL_WAIT_WRITE;
-    if (timeout >= 0)
-    {
-      b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
-      b->timeout_value= timeout;
-    }
-    if (b->suspend_resume_hook)
-      (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
-    my_context_yield(&b->async_context);
-    if (b->suspend_resume_hook)
-      (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
-    if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
-      return -1;
-  }
-}
-
-
-my_bool
-my_io_wait_async(struct mysql_async_context *b, enum enum_vio_io_event event,
-                 int timeout)
-{
-  switch (event)
-  {
-  case VIO_IO_EVENT_READ:
-    b->events_to_wait_for = MYSQL_WAIT_READ;
-    break;
-  case VIO_IO_EVENT_WRITE:
-    b->events_to_wait_for = MYSQL_WAIT_WRITE;
-    break;
-  case VIO_IO_EVENT_CONNECT:
-    b->events_to_wait_for = MYSQL_WAIT_WRITE | IF_WIN(0, MYSQL_WAIT_EXCEPT);
-    break;
-  }
-
-  if (timeout >= 0)
-  {
-    b->events_to_wait_for |= MYSQL_WAIT_TIMEOUT;
-    b->timeout_value= timeout;
-  }
-  if (b->suspend_resume_hook)
-    (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
-  my_context_yield(&b->async_context);
-  if (b->suspend_resume_hook)
-    (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
-  return (b->events_occurred & MYSQL_WAIT_TIMEOUT) ? 0 : 1;
-}
-
-
-#ifdef HAVE_OPENSSL
-static my_bool
-my_ssl_async_check_result(int res, struct mysql_async_context *b, SSL *ssl)
-{
-  int ssl_err;
-  b->events_to_wait_for= 0;
-  if (res >= 0)
-    return 1;
-  ssl_err= SSL_get_error(ssl, res);
-  if (ssl_err == SSL_ERROR_WANT_READ)
-    b->events_to_wait_for|= MYSQL_WAIT_READ;
-  else if (ssl_err == SSL_ERROR_WANT_WRITE)
-    b->events_to_wait_for|= MYSQL_WAIT_WRITE;
-  else
-    return 1;
-  if (b->suspend_resume_hook)
-    (*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
-  my_context_yield(&b->async_context);
-  if (b->suspend_resume_hook)
-    (*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
-  return 0;
-}
-
-int
-my_ssl_read_async(struct mysql_async_context *b, SSL *ssl,
-                  void *buf, int size)
-{
-  int res;
-
-  for (;;)
-  {
-    res= SSL_read(ssl, buf, size);
-    if (my_ssl_async_check_result(res, b, ssl))
-      return res;
-  }
-}
-
-int
-my_ssl_write_async(struct mysql_async_context *b, SSL *ssl,
-                   const void *buf, int size)
-{
-  int res;
-
-  for (;;)
-  {
-    res= SSL_write(ssl, buf, size);
-    if (my_ssl_async_check_result(res, b, ssl))
-      return res;
-  }
-}
-#endif  /* HAVE_OPENSSL */
-
-/*
-  Legacy support of the MariaDB 5.5 version, where timeouts where only in
-  seconds resolution. Applications that use this will be asked to set a timeout
-  at the nearest higher whole-seconds value.
-*/
-unsigned int STDCALL
-mysql_get_timeout_value(const MYSQL *mysql)
-{
-  unsigned int timeout= mysql->options.extension->async_context->timeout_value;
-  /* Avoid overflow. */
-  if (timeout > UINT_MAX - 999)
-    return (timeout - 1)/1000 + 1;
-  else
-    return (timeout+999)/1000;
-}
-
-
-unsigned int STDCALL
-mysql_get_timeout_value_ms(const MYSQL *mysql)
-{
-  return mysql->options.extension->async_context->timeout_value;
-}
-
-
-/*
-  Now create non-blocking definitions for all the calls that may block.
-
-  Each call FOO gives rise to FOO_start() that prepares the MYSQL object for
-  doing non-blocking calls that can suspend operation mid-way, and then starts
-  the call itself. And a FOO_start_internal trampoline to assist with running
-  the real call in a co-routine that can be suspended. And a FOO_cont() that
-  can continue a suspended operation.
-*/
-
-#define MK_ASYNC_INTERNAL_BODY(call, invoke_args, mysql_val, ret_type, ok_val)\
-  struct call ## _params *parms= (struct call ## _params *)d;                 \
-  ret_type ret;                                                               \
-  struct mysql_async_context *b=                                              \
-    (mysql_val)->options.extension->async_context;                            \
-                                                                              \
-  ret= call invoke_args;                                                      \
-  b->ret_result. ok_val = ret;                                                \
-  b->events_to_wait_for= 0;
-
-#define MK_ASYNC_START_BODY(call, mysql_val, parms_assign, err_val, ok_val, extra1) \
-  int res;                                                                    \
-  struct mysql_async_context *b;                                              \
-  struct call ## _params parms;                                               \
-                                                                              \
-  extra1                                                                      \
-  b= mysql_val->options.extension->async_context;                             \
-  parms_assign                                                                \
-                                                                              \
-  b->active= 1;                                                               \
-  res= my_context_spawn(&b->async_context, call ## _start_internal, &parms);  \
-  b->active= b->suspended= 0;                                                 \
-  if (res > 0)                                                                \
-  {                                                                           \
-    /* Suspended. */                                                          \
-    b->suspended= 1;                                                          \
-    return b->events_to_wait_for;                                             \
-  }                                                                           \
-  if (res < 0)                                                                \
-  {                                                                           \
-    set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate);         \
-    *ret= err_val;                                                            \
-  }                                                                           \
-  else                                                                        \
-    *ret= b->ret_result. ok_val;                                              \
-  return 0;
-
-#define MK_ASYNC_CONT_BODY(mysql_val, err_val, ok_val) \
-  int res;                                                                    \
-  struct mysql_async_context *b=                                              \
-    (mysql_val)->options.extension->async_context;                            \
-  if (!b->suspended)                                                          \
-  {                                                                           \
-    set_mysql_error((mysql_val), CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);  \
-    *ret= err_val;                                                            \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-  b->active= 1;                                                               \
-  b->events_occurred= ready_status;                                            \
-  res= my_context_continue(&b->async_context);                                \
-  b->active= 0;                                                               \
-  if (res > 0)                                                                \
-    return b->events_to_wait_for;               /* (Still) suspended */       \
-  b->suspended= 0;                                                            \
-  if (res < 0)                                                                \
-  {                                                                           \
-    set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate);         \
-    *ret= err_val;                                                            \
-  }                                                                           \
-  else                                                                        \
-    *ret= b->ret_result. ok_val;                /* Finished. */               \
-  return 0;
-
-#define MK_ASYNC_INTERNAL_BODY_VOID_RETURN(call, invoke_args, mysql_val)      \
-  struct call ## _params *parms= (struct call ## _params *)d;                 \
-  struct mysql_async_context *b=                                              \
-    (mysql_val)->options.extension->async_context;                            \
-                                                                              \
-  call invoke_args;                                                           \
-  b->events_to_wait_for= 0;
-
-#define MK_ASYNC_START_BODY_VOID_RETURN(call, mysql_val, parms_assign, extra1)\
-  int res;                                                                    \
-  struct mysql_async_context *b;                                              \
-  struct call ## _params parms;                                               \
-                                                                              \
-  extra1                                                                      \
-  b= mysql_val->options.extension->async_context;                             \
-  parms_assign                                                                \
-                                                                              \
-  b->active= 1;                                                               \
-  res= my_context_spawn(&b->async_context, call ## _start_internal, &parms);  \
-  b->active= b->suspended= 0;                                                 \
-  if (res > 0)                                                                \
-  {                                                                           \
-    /* Suspended. */                                                          \
-    b->suspended= 1;                                                          \
-    return b->events_to_wait_for;                                             \
-  }                                                                           \
-  if (res < 0)                                                                \
-    set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate);         \
-  return 0;
-
-#define MK_ASYNC_CONT_BODY_VOID_RETURN(mysql_val)                             \
-  int res;                                                                    \
-  struct mysql_async_context *b=                                              \
-    (mysql_val)->options.extension->async_context;                            \
-  if (!b->suspended)                                                          \
-  {                                                                           \
-    set_mysql_error((mysql_val), CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);  \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-  b->active= 1;                                                               \
-  b->events_occurred= ready_status;                                            \
-  res= my_context_continue(&b->async_context);                                \
-  b->active= 0;                                                               \
-  if (res > 0)                                                                \
-    return b->events_to_wait_for;               /* (Still) suspended */       \
-  b->suspended= 0;                                                            \
-  if (res < 0)                                                                \
-    set_mysql_error((mysql_val), CR_OUT_OF_MEMORY, unknown_sqlstate);         \
-  return 0;
-
-
-/* Structure used to pass parameters from mysql_real_connect_start(). */
-struct mysql_real_connect_params {
-  MYSQL *mysql;
-  const char *host;
-  const char *user;
-  const char *passwd;
-  const char *db;
-  unsigned int port;
-  const char *unix_socket;
-  unsigned long client_flags;
-};
-static void
-mysql_real_connect_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_real_connect,
-  (parms->mysql, parms->host, parms->user, parms->passwd, parms->db,
-   parms->port, parms->unix_socket, parms->client_flags),
-  parms->mysql,
-  MYSQL *,
-  r_ptr)
-}
-int STDCALL
-mysql_real_connect_start(MYSQL **ret, MYSQL *mysql, const char *host,
-                         const char *user, const char *passwd, const char *db,
-                         unsigned int port, const char *unix_socket,
-                         unsigned long client_flags)
-{
-MK_ASYNC_START_BODY(
-  mysql_real_connect,
-  mysql,
-  {
-    parms.mysql= mysql;
-    parms.host= host;
-    parms.user= user;
-    parms.passwd= passwd;
-    parms.db= db;
-    parms.port= port;
-    parms.unix_socket= unix_socket;
-    /*
-      async wrapper enforce the CLIENT_REMEMBER_OPTIONS flag to be
-      functional (otherwise it can't operate)
-    */
-    parms.client_flags= client_flags | CLIENT_REMEMBER_OPTIONS;
-  },
-  NULL,
-  r_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_real_connect_cont(MYSQL **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_real_query_start(). */
-struct mysql_real_query_params {
-  MYSQL *mysql;
-  const char *stmt_str;
-  unsigned long length;
-};
-static void
-mysql_real_query_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_real_query,
-  (parms->mysql, parms->stmt_str, parms->length),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_real_query_start(int *ret, MYSQL *mysql, const char *stmt_str, unsigned long length)
-{
-MK_ASYNC_START_BODY(
-  mysql_real_query,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.stmt_str= stmt_str;
-    parms.length= length;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_real_query_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_fetch_row_start(). */
-struct mysql_fetch_row_params {
-  MYSQL_RES *result;
-};
-static void
-mysql_fetch_row_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_fetch_row,
-  (parms->result),
-  parms->result->handle,
-  MYSQL_ROW,
-  r_ptr)
-}
-int STDCALL
-mysql_fetch_row_start(MYSQL_ROW *ret, MYSQL_RES *result)
-{
-MK_ASYNC_START_BODY(
-  mysql_fetch_row,
-  result->handle,
-  {
-    WIN_SET_NONBLOCKING(result->handle)
-    parms.result= result;
-  },
-  NULL,
-  r_ptr,
-  /*
-    If we already fetched all rows from server (eg. mysql_store_result()),
-    then result->handle will be NULL and we cannot suspend. But that is fine,
-    since in this case mysql_fetch_row cannot block anyway. Just return
-    directly.
-  */
-  if (!result->handle)
-  {
-    *ret= mysql_fetch_row(result);
-    return 0;
-  })
-}
-int STDCALL
-mysql_fetch_row_cont(MYSQL_ROW *ret, MYSQL_RES *result, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  result->handle,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_set_character_set_start(). */
-struct mysql_set_character_set_params {
-  MYSQL *mysql;
-  const char *csname;
-};
-static void
-mysql_set_character_set_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_set_character_set,
-  (parms->mysql, parms->csname),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_set_character_set_start(int *ret, MYSQL *mysql, const char *csname)
-{
-MK_ASYNC_START_BODY(
-  mysql_set_character_set,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.csname= csname;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_set_character_set_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_sekect_db_start(). */
-struct mysql_select_db_params {
-  MYSQL *mysql;
-  const char *db;
-};
-static void
-mysql_select_db_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_select_db,
-  (parms->mysql, parms->db),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_select_db_start(int *ret, MYSQL *mysql, const char *db)
-{
-MK_ASYNC_START_BODY(
-  mysql_select_db,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.db= db;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_select_db_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_send_query_start(). */
-struct mysql_send_query_params {
-  MYSQL *mysql;
-  const char *q;
-  unsigned long length;
-};
-static void
-mysql_send_query_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_send_query,
-  (parms->mysql, parms->q, parms->length),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_send_query_start(int *ret, MYSQL *mysql, const char *q, unsigned long length)
-{
-MK_ASYNC_START_BODY(
-  mysql_send_query,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.q= q;
-    parms.length= length;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_send_query_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_store_result_start(). */
-struct mysql_store_result_params {
-  MYSQL *mysql;
-};
-static void
-mysql_store_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_store_result,
-  (parms->mysql),
-  parms->mysql,
-  MYSQL_RES *,
-  r_ptr)
-}
-int STDCALL
-mysql_store_result_start(MYSQL_RES **ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_store_result,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  NULL,
-  r_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_store_result_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_free_result_start(). */
-struct mysql_free_result_params {
-  MYSQL_RES *result;
-};
-static void
-mysql_free_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY_VOID_RETURN(
-  mysql_free_result,
-  (parms->result),
-  parms->result->handle)
-}
-int STDCALL
-mysql_free_result_start(MYSQL_RES *result)
-{
-MK_ASYNC_START_BODY_VOID_RETURN(
-  mysql_free_result,
-  result->handle,
-  {
-    WIN_SET_NONBLOCKING(result->handle)
-    parms.result= result;
-  },
-  /*
-    mysql_free_result() can have NULL in result->handle (this happens when all
-    rows have been fetched and mysql_fetch_row() returned NULL.)
-    So we cannot suspend, but it does not matter, as in this case
-    mysql_free_result() cannot block.
-    It is also legitimate to have NULL result, which will do nothing.
-  */
-  if (!result || !result->handle)
-  {
-    mysql_free_result(result);
-    return 0;
-  })
-}
-int STDCALL
-mysql_free_result_cont(MYSQL_RES *result, int ready_status)
-{
-MK_ASYNC_CONT_BODY_VOID_RETURN(result->handle)
-}
-
-/* Structure used to pass parameters from mysql_close_slow_part_start(). */
-struct mysql_close_slow_part_params {
-  MYSQL *sock;
-};
-/*
-  We need special handling for mysql_close(), as the first part may block,
-  while the last part needs to free our extra library context stack.
-
-  So we do the first part (mysql_close_slow_part()) non-blocking, but the last
-  part blocking.
-*/
-static void
-mysql_close_slow_part_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY_VOID_RETURN(
-  mysql_close_slow_part,
-  (parms->sock),
-  parms->sock)
-}
-int STDCALL
-mysql_close_slow_part_start(MYSQL *sock)
-{
-MK_ASYNC_START_BODY_VOID_RETURN(
-  mysql_close_slow_part,
-  sock,
-  {
-    WIN_SET_NONBLOCKING(sock)
-    parms.sock= sock;
-  },
-  /* Nothing */)
-}
-int STDCALL
-mysql_close_slow_part_cont(MYSQL *sock, int ready_status)
-{
-MK_ASYNC_CONT_BODY_VOID_RETURN(sock)
-}
-int STDCALL
-mysql_close_start(MYSQL *sock)
-{
-  int res;
-
-  /* It is legitimate to have NULL sock argument, which will do nothing. */
-  if (sock)
-  {
-    res= mysql_close_slow_part_start(sock);
-    /* If we need to block, return now and do the rest in mysql_close_cont(). */
-    if (res)
-      return res;
-  }
-  mysql_close(sock);
-  return 0;
-}
-int STDCALL
-mysql_close_cont(MYSQL *sock, int ready_status)
-{
-  int res;
-
-  res= mysql_close_slow_part_cont(sock, ready_status);
-  if (res)
-    return res;
-  mysql_close(sock);
-  return 0;
-}
-
-/*
-  These following are not available inside the server (neither blocking or
-  non-blocking).
-*/
-#ifndef MYSQL_SERVER
-/* Structure used to pass parameters from mysql_change_user_start(). */
-struct mysql_change_user_params {
-  MYSQL *mysql;
-  const char *user;
-  const char *passwd;
-  const char *db;
-};
-static void
-mysql_change_user_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_change_user,
-  (parms->mysql, parms->user, parms->passwd, parms->db),
-  parms->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_change_user_start(my_bool *ret, MYSQL *mysql, const char *user, const char *passwd, const char *db)
-{
-MK_ASYNC_START_BODY(
-  mysql_change_user,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.user= user;
-    parms.passwd= passwd;
-    parms.db= db;
-  },
-  TRUE,
-  r_my_bool,
-  /* Nothing */)
-}
-int STDCALL
-mysql_change_user_cont(my_bool *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_query_start(). */
-struct mysql_query_params {
-  MYSQL *mysql;
-  const char *q;
-};
-static void
-mysql_query_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_query,
-  (parms->mysql, parms->q),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_query_start(int *ret, MYSQL *mysql, const char *q)
-{
-MK_ASYNC_START_BODY(
-  mysql_query,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.q= q;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_query_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_shutdown_start(). */
-struct mysql_shutdown_params {
-  MYSQL *mysql;
-  enum mysql_enum_shutdown_level shutdown_level;
-};
-static void
-mysql_shutdown_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_shutdown,
-  (parms->mysql, parms->shutdown_level),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_shutdown_start(int *ret, MYSQL *mysql, enum mysql_enum_shutdown_level shutdown_level)
-{
-MK_ASYNC_START_BODY(
-  mysql_shutdown,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.shutdown_level= shutdown_level;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_shutdown_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_dump_debug_info_start(). */
-struct mysql_dump_debug_info_params {
-  MYSQL *mysql;
-};
-static void
-mysql_dump_debug_info_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_dump_debug_info,
-  (parms->mysql),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_dump_debug_info_start(int *ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_dump_debug_info,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_dump_debug_info_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_refresh_start(). */
-struct mysql_refresh_params {
-  MYSQL *mysql;
-  unsigned int refresh_options;
-};
-static void
-mysql_refresh_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_refresh,
-  (parms->mysql, parms->refresh_options),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_refresh_start(int *ret, MYSQL *mysql, unsigned int refresh_options)
-{
-MK_ASYNC_START_BODY(
-  mysql_refresh,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.refresh_options= refresh_options;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_refresh_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_kill_start(). */
-struct mysql_kill_params {
-  MYSQL *mysql;
-  unsigned long pid;
-};
-static void
-mysql_kill_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_kill,
-  (parms->mysql, parms->pid),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_kill_start(int *ret, MYSQL *mysql, unsigned long pid)
-{
-MK_ASYNC_START_BODY(
-  mysql_kill,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.pid= pid;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_kill_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_set_server_option_start(). */
-struct mysql_set_server_option_params {
-  MYSQL *mysql;
-  enum enum_mysql_set_option option;
-};
-static void
-mysql_set_server_option_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_set_server_option,
-  (parms->mysql, parms->option),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_set_server_option_start(int *ret, MYSQL *mysql,
-                              enum enum_mysql_set_option option)
-{
-MK_ASYNC_START_BODY(
-  mysql_set_server_option,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.option= option;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_set_server_option_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_ping_start(). */
-struct mysql_ping_params {
-  MYSQL *mysql;
-};
-static void
-mysql_ping_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_ping,
-  (parms->mysql),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_ping_start(int *ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_ping,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_ping_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_stat_start(). */
-struct mysql_stat_params {
-  MYSQL *mysql;
-};
-static void
-mysql_stat_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stat,
-  (parms->mysql),
-  parms->mysql,
-  const char *,
-  r_const_ptr)
-}
-int STDCALL
-mysql_stat_start(const char **ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_stat,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  NULL,
-  r_const_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_stat_cont(const char **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_const_ptr)
-}
-
-/* Structure used to pass parameters from mysql_list_dbs_start(). */
-struct mysql_list_dbs_params {
-  MYSQL *mysql;
-  const char *wild;
-};
-static void
-mysql_list_dbs_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_list_dbs,
-  (parms->mysql, parms->wild),
-  parms->mysql,
-  MYSQL_RES *,
-  r_ptr)
-}
-int STDCALL
-mysql_list_dbs_start(MYSQL_RES **ret, MYSQL *mysql, const char *wild)
-{
-MK_ASYNC_START_BODY(
-  mysql_list_dbs,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.wild= wild;
-  },
-  NULL,
-  r_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_list_dbs_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_list_tables_start(). */
-struct mysql_list_tables_params {
-  MYSQL *mysql;
-  const char *wild;
-};
-static void
-mysql_list_tables_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_list_tables,
-  (parms->mysql, parms->wild),
-  parms->mysql,
-  MYSQL_RES *,
-  r_ptr)
-}
-int STDCALL
-mysql_list_tables_start(MYSQL_RES **ret, MYSQL *mysql, const char *wild)
-{
-MK_ASYNC_START_BODY(
-  mysql_list_tables,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.wild= wild;
-  },
-  NULL,
-  r_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_list_tables_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_list_processes_start(). */
-struct mysql_list_processes_params {
-  MYSQL *mysql;
-};
-static void
-mysql_list_processes_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_list_processes,
-  (parms->mysql),
-  parms->mysql,
-  MYSQL_RES *,
-  r_ptr)
-}
-int STDCALL
-mysql_list_processes_start(MYSQL_RES **ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_list_processes,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  NULL,
-  r_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_list_processes_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_list_fields_start(). */
-struct mysql_list_fields_params {
-  MYSQL *mysql;
-  const char *table;
-  const char *wild;
-};
-static void
-mysql_list_fields_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_list_fields,
-  (parms->mysql, parms->table, parms->wild),
-  parms->mysql,
-  MYSQL_RES *,
-  r_ptr)
-}
-int STDCALL
-mysql_list_fields_start(MYSQL_RES **ret, MYSQL *mysql, const char *table,
-                        const char *wild)
-{
-MK_ASYNC_START_BODY(
-  mysql_list_fields,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.table= table;
-    parms.wild= wild;
-  },
-  NULL,
-  r_ptr,
-  /* Nothing */)
-}
-int STDCALL
-mysql_list_fields_cont(MYSQL_RES **ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  NULL,
-  r_ptr)
-}
-
-/* Structure used to pass parameters from mysql_read_query_result_start(). */
-struct mysql_read_query_result_params {
-  MYSQL *mysql;
-};
-static void
-mysql_read_query_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_read_query_result,
-  (parms->mysql),
-  parms->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_read_query_result_start(my_bool *ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_read_query_result,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  TRUE,
-  r_my_bool,
-  /* Nothing */)
-}
-int STDCALL
-mysql_read_query_result_cont(my_bool *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_stmt_prepare_start(). */
-struct mysql_stmt_prepare_params {
-  MYSQL_STMT *stmt;
-  const char *query;
-  unsigned long length;
-};
-static void
-mysql_stmt_prepare_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_prepare,
-  (parms->stmt, parms->query, parms->length),
-  parms->stmt->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_stmt_prepare_start(int *ret, MYSQL_STMT *stmt, const char *query,
-                         unsigned long length)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_prepare,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-    parms.query= query;
-    parms.length= length;
-  },
-  1,
-  r_int,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_prepare(stmt, query, length);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_prepare_cont(int *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_stmt_execute_start(). */
-struct mysql_stmt_execute_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_execute_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_execute,
-  (parms->stmt),
-  parms->stmt->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_stmt_execute_start(int *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_execute,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  1,
-  r_int,
-  /*
-    If eg. mysql_change_user(), stmt->mysql will be NULL.
-    In this case, we cannot block.
-  */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_execute(stmt);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_execute_cont(int *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_stmt_fetch_start(). */
-struct mysql_stmt_fetch_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_fetch_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_fetch,
-  (parms->stmt),
-  parms->stmt->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_stmt_fetch_start(int *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_fetch,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  1,
-  r_int,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_fetch(stmt);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_fetch_cont(int *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_stmt_store_result_start(). */
-struct mysql_stmt_store_result_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_store_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_store_result,
-  (parms->stmt),
-  parms->stmt->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_stmt_store_result_start(int *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_store_result,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  1,
-  r_int,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_store_result(stmt);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_store_result_cont(int *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_stmt_close_start(). */
-struct mysql_stmt_close_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_close_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_close,
-  (parms->stmt),
-  parms->stmt->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_stmt_close_start(my_bool *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_close,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  TRUE,
-  r_my_bool,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_close(stmt);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_stmt_reset_start(). */
-struct mysql_stmt_reset_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_reset_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_reset,
-  (parms->stmt),
-  parms->stmt->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_stmt_reset_start(my_bool *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_reset,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  TRUE,
-  r_my_bool,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_reset(stmt);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_reset_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_stmt_free_result_start(). */
-struct mysql_stmt_free_result_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_free_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_free_result,
-  (parms->stmt),
-  parms->stmt->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_stmt_free_result_start(my_bool *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_free_result,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  TRUE,
-  r_my_bool,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_free_result(stmt);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_free_result_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_stmt_send_long_data_start(). */
-struct mysql_stmt_send_long_data_params {
-  MYSQL_STMT *stmt;
-  unsigned int param_number;
-  const char *data;
-  unsigned long length;
-};
-static void
-mysql_stmt_send_long_data_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_send_long_data,
-  (parms->stmt, parms->param_number, parms->data, parms->length),
-  parms->stmt->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_stmt_send_long_data_start(my_bool *ret, MYSQL_STMT *stmt,
-                                unsigned int param_number,
-                                const char *data, unsigned long length)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_send_long_data,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-    parms.param_number= param_number;
-    parms.data= data;
-    parms.length= length;
-  },
-  TRUE,
-  r_my_bool,
-  /* If stmt->mysql==NULL then we will not block so can call directly. */
-  if (!stmt->mysql)
-  {
-    *ret= mysql_stmt_send_long_data(stmt, param_number, data, length);
-    return 0;
-  })
-}
-int STDCALL
-mysql_stmt_send_long_data_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_commit_start(). */
-struct mysql_commit_params {
-  MYSQL *mysql;
-};
-static void
-mysql_commit_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_commit,
-  (parms->mysql),
-  parms->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_commit_start(my_bool *ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_commit,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  TRUE,
-  r_my_bool,
-  /* Nothing */)
-}
-int STDCALL
-mysql_commit_cont(my_bool *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_rollback_start(). */
-struct mysql_rollback_params {
-  MYSQL *mysql;
-};
-static void
-mysql_rollback_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_rollback,
-  (parms->mysql),
-  parms->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_rollback_start(my_bool *ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_rollback,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  TRUE,
-  r_my_bool,
-  /* Nothing */)
-}
-int STDCALL
-mysql_rollback_cont(my_bool *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_autocommit_start(). */
-struct mysql_autocommit_params {
-  MYSQL *mysql;
-  my_bool auto_mode;
-};
-static void
-mysql_autocommit_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_autocommit,
-  (parms->mysql, parms->auto_mode),
-  parms->mysql,
-  my_bool,
-  r_my_bool)
-}
-int STDCALL
-mysql_autocommit_start(my_bool *ret, MYSQL *mysql, my_bool auto_mode)
-{
-MK_ASYNC_START_BODY(
-  mysql_autocommit,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-    parms.auto_mode= auto_mode;
-  },
-  TRUE,
-  r_my_bool,
-  /* Nothing */)
-}
-int STDCALL
-mysql_autocommit_cont(my_bool *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  TRUE,
-  r_my_bool)
-}
-
-/* Structure used to pass parameters from mysql_next_result_start(). */
-struct mysql_next_result_params {
-  MYSQL *mysql;
-};
-static void
-mysql_next_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_next_result,
-  (parms->mysql),
-  parms->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_next_result_start(int *ret, MYSQL *mysql)
-{
-MK_ASYNC_START_BODY(
-  mysql_next_result,
-  mysql,
-  {
-    WIN_SET_NONBLOCKING(mysql)
-    parms.mysql= mysql;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_next_result_cont(int *ret, MYSQL *mysql, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  mysql,
-  1,
-  r_int)
-}
-
-/* Structure used to pass parameters from mysql_stmt_next_result_start(). */
-struct mysql_stmt_next_result_params {
-  MYSQL_STMT *stmt;
-};
-static void
-mysql_stmt_next_result_start_internal(void *d)
-{
-MK_ASYNC_INTERNAL_BODY(
-  mysql_stmt_next_result,
-  (parms->stmt),
-  parms->stmt->mysql,
-  int,
-  r_int)
-}
-int STDCALL
-mysql_stmt_next_result_start(int *ret, MYSQL_STMT *stmt)
-{
-MK_ASYNC_START_BODY(
-  mysql_stmt_next_result,
-  stmt->mysql,
-  {
-    WIN_SET_NONBLOCKING(stmt->mysql)
-    parms.stmt= stmt;
-  },
-  1,
-  r_int,
-  /* Nothing */)
-}
-int STDCALL
-mysql_stmt_next_result_cont(int *ret, MYSQL_STMT *stmt, int ready_status)
-{
-MK_ASYNC_CONT_BODY(
-  stmt->mysql,
-  1,
-  r_int)
-}
-#endif
-
-
-/*
-  The following functions are deprecated, and so have no non-blocking version:
-
-    mysql_connect
-    mysql_create_db
-    mysql_drop_db
-*/
-
-/*
-  The following functions can newer block, and so do not have special
-  non-blocking versions:
-
-    mysql_num_rows()
-    mysql_num_fields()
-    mysql_eof()
-    mysql_fetch_field_direct()
-    mysql_fetch_fields()
-    mysql_row_tell()
-    mysql_field_tell()
-    mysql_field_count()
-    mysql_affected_rows()
-    mysql_insert_id()
-    mysql_errno()
-    mysql_error()
-    mysql_sqlstate()
-    mysql_warning_count()
-    mysql_info()
-    mysql_thread_id()
-    mysql_character_set_name()
-    mysql_init()
-    mysql_ssl_set()
-    mysql_get_ssl_cipher()
-    mysql_use_result()
-    mysql_get_character_set_info()
-    mysql_set_local_infile_handler()
-    mysql_set_local_infile_default()
-    mysql_get_server_info()
-    mysql_get_server_name()
-    mysql_get_client_info()
-    mysql_get_client_version()
-    mysql_get_host_info()
-    mysql_get_server_version()
-    mysql_get_proto_info()
-    mysql_options()
-    mysql_data_seek()
-    mysql_row_seek()
-    mysql_field_seek()
-    mysql_fetch_lengths()
-    mysql_fetch_field()
-    mysql_escape_string()
-    mysql_hex_string()
-    mysql_real_escape_string()
-    mysql_debug()
-    myodbc_remove_escape()
-    mysql_thread_safe()
-    mysql_embedded()
-    mariadb_connection()
-    mysql_stmt_init()
-    mysql_stmt_fetch_column()
-    mysql_stmt_param_count()
-    mysql_stmt_attr_set()
-    mysql_stmt_attr_get()
-    mysql_stmt_bind_param()
-    mysql_stmt_bind_result()
-    mysql_stmt_result_metadata()
-    mysql_stmt_param_metadata()
-    mysql_stmt_errno()
-    mysql_stmt_error()
-    mysql_stmt_sqlstate()
-    mysql_stmt_row_seek()
-    mysql_stmt_row_tell()
-    mysql_stmt_data_seek()
-    mysql_stmt_num_rows()
-    mysql_stmt_affected_rows()
-    mysql_stmt_insert_id()
-    mysql_stmt_field_count()
-    mysql_more_results()
-    mysql_get_socket()
-    mysql_get_timeout_value()
-*/