Upgrade to 8.0.15

5 files changed, 0 insertions, 9277 deletions

diff --git a/mysql/sql-common/client.c b/mysql/sql-common/client.c
deleted file mode 100644
index 11c23b6..0000000
--- a/mysql/sql-common/client.c
+++ /dev/null
@@ -1,6241 +0,0 @@
-/* Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program 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 General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
-
-/*
-  This file is included by both libmysql.c (the MySQL client C API)
-  and the mysqld server to connect to another MYSQL server.
-
-  The differences for the two cases are:
-
-  - Things that only works for the client:
-  - Trying to automaticly determinate user name if not supplied to
-    mysql_real_connect()
-  - Support for reading local file with LOAD DATA LOCAL
-  - SHARED memory handling
-  - Prepared statements
-  - Things that only works for the server
-
-  In all other cases, the code should be idential for the client and
-  server.
-*/ 
-
-#include <my_global.h>
-#include "mysql.h"
-#include "hash.h"
-#include "mysql/client_authentication.h"
-
-#ifdef EMBEDDED_LIBRARY
-
-#undef MYSQL_SERVER
-
-#ifndef MYSQL_CLIENT
-#define MYSQL_CLIENT
-#endif
-
-#define CLI_MYSQL_REAL_CONNECT STDCALL cli_mysql_real_connect
-
-#undef net_flush
-my_bool	net_flush(NET *net);
-
-#else  /*EMBEDDED_LIBRARY*/
-#define CLI_MYSQL_REAL_CONNECT STDCALL mysql_real_connect
-#endif /*EMBEDDED_LIBRARY*/
-
-#include <my_sys.h>
-#include "my_default.h"
-#include <mysys_err.h>
-#include <m_string.h>
-#include <m_ctype.h>
-#include "mysql_version.h"
-#include "mysqld_error.h"
-#include "errmsg.h"
-#include <violite.h>
-
-#if !defined(_WIN32)
-#include <my_thread.h>				/* because of signal()	*/
-#endif /* !defined(_WIN32) */
-
-#include <sys/stat.h>
-#include <signal.h>
-#include <time.h>
-
-#ifdef	 HAVE_PWD_H
-#include <pwd.h>
-#endif
-
-#ifdef HAVE_SYS_SELECT_H
-#  include <sys/select.h>
-#endif
-
-#ifdef HAVE_SYS_UN_H
-#  include <sys/un.h>
-#endif
-
-#ifndef _WIN32
-#include <errno.h>
-#define SOCKET_ERROR -1
-#endif
-
-#include "client_settings.h"
-#include <sql_common.h>
-#include <mysql/client_plugin.h>
-#include "../libmysql/mysql_trace.h"  /* MYSQL_TRACE() instrumentation */
-
-#define STATE_DATA(M) \
-  (NULL != (M) ? &(MYSQL_EXTENSION_PTR(M)->state_change) : NULL)
-
-#define ADD_INFO(M, element, type)                                             \
-{                                                                              \
-  M= STATE_DATA(mysql);                                                       \
-  M->info_list[type].head_node= list_add(M->info_list[type].head_node,         \
-                                         element);                             \
-}
-
-#define native_password_plugin_name "mysql_native_password"
-
-PSI_memory_key key_memory_mysql_options;
-PSI_memory_key key_memory_MYSQL_DATA;
-PSI_memory_key key_memory_MYSQL;
-PSI_memory_key key_memory_MYSQL_RES;
-PSI_memory_key key_memory_MYSQL_ROW;
-PSI_memory_key key_memory_MYSQL_state_change_info;
-PSI_memory_key key_memory_MYSQL_HANDSHAKE;
-
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-PSI_memory_key key_memory_create_shared_memory;
-#endif /* _WIN32 && ! EMBEDDED_LIBRARY */
-
-#ifdef HAVE_PSI_INTERFACE
-/*
-  This code is common to the client and server,
-  and also used in the server when server A connects to server B,
-  for example with replication.
-  Therefore, the code is also instrumented.
-*/
-
-static PSI_memory_info all_client_memory[]=
-{
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-  { &key_memory_create_shared_memory, "create_shared_memory", 0},
-#endif /* _WIN32 && ! EMBEDDED_LIBRARY */
-
-  { &key_memory_mysql_options, "mysql_options", 0},
-  { &key_memory_MYSQL_DATA, "MYSQL_DATA", 0},
-  { &key_memory_MYSQL, "MYSQL", 0},
-  { &key_memory_MYSQL_RES, "MYSQL_RES", 0},
-  { &key_memory_MYSQL_ROW, "MYSQL_ROW", 0},
-  { &key_memory_MYSQL_state_change_info, "MYSQL_STATE_CHANGE_INFO", 0},
-  { &key_memory_MYSQL_HANDSHAKE, "MYSQL_HANDSHAKE", 0}
-};
-
-void init_client_psi_keys(void)
-{
-  const char *category= "client";
-  int count;
-
-  count= array_elements(all_client_memory);
-  mysql_memory_register(category, all_client_memory, count);
-}
-
-#endif /* HAVE_PSI_INTERFACE */
-
-uint		mysql_port=0;
-char		*mysql_unix_port= 0;
-const char	*unknown_sqlstate= "HY000";
-const char	*not_error_sqlstate= "00000";
-const char	*cant_connect_sqlstate= "08001";
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-char		 *shared_memory_base_name= 0;
-const char 	*def_shared_memory_base_name= default_shared_memory_base_name;
-#endif
-
-ulong g_net_buffer_length= 8192;
-ulong g_max_allowed_packet= 1024L*1024L*1024L;
-
-void mysql_close_free_options(MYSQL *mysql);
-void mysql_close_free(MYSQL *mysql);
-static void mysql_prune_stmt_list(MYSQL *mysql);
-
-CHARSET_INFO *default_client_charset_info = &my_charset_latin1;
-
-/* Server error code and message */
-unsigned int mysql_server_last_errno;
-char mysql_server_last_error[MYSQL_ERRMSG_SIZE];
-/* forward declaration */
-static int read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths);
-/**
-  Convert the connect timeout option to a timeout value for VIO
-  functions (vio_socket_connect() and vio_io_wait()).
-
-  @param mysql  Connection handle (client side).
-
-  @return The timeout value in milliseconds, or -1 if no timeout.
-*/
-
-static int get_vio_connect_timeout(MYSQL *mysql)
-{
-  int timeout_ms;
-  uint timeout_sec;
-
-  /*
-    A timeout of 0 means no timeout. Also, the connect_timeout
-    option value is in seconds, while VIO timeouts are measured
-    in milliseconds. Hence, check for a possible overflow. In
-    case of overflow, set to no timeout.
-  */
-  timeout_sec= mysql->options.connect_timeout;
-
-  if (!timeout_sec || (timeout_sec > INT_MAX/1000))
-    timeout_ms= -1;
-  else
-    timeout_ms= (int) (timeout_sec * 1000);
-
-  return timeout_ms;
-}
-
-
-#ifdef _WIN32
-
-/**
-  Convert the connect timeout option to a timeout value for WIN32
-  synchronization functions.
-
-  @remark Specific for WIN32 connection methods shared memory and
-          named pipe.
-
-  @param mysql  Connection handle (client side).
-
-  @return The timeout value in milliseconds, or INFINITE if no timeout.
-*/
-
-static DWORD get_win32_connect_timeout(MYSQL *mysql)
-{
-  DWORD timeout_ms;
-  uint timeout_sec;
-
-  /*
-    A timeout of 0 means no timeout. Also, the connect_timeout
-    option value is in seconds, while WIN32 timeouts are in
-    milliseconds. Hence, check for a possible overflow. In case
-    of overflow, set to no timeout.
-  */
-  timeout_sec= mysql->options.connect_timeout;
-
-  if (!timeout_sec || (timeout_sec > INT_MAX/1000))
-    timeout_ms= INFINITE;
-  else
-    timeout_ms= (DWORD) (timeout_sec * 1000);
-
-  return timeout_ms;
-}
-
-#endif
-
-
-/**
-  Set the internal error message to mysql handler
-
-  @param mysql    connection handle (client side)
-  @param errcode  CR_ error code, passed to ER macro to get
-                  error text
-  @parma sqlstate SQL standard sqlstate
-*/
-
-void set_mysql_error(MYSQL *mysql, int errcode, const char *sqlstate)
-{
-  NET *net;
-  DBUG_ENTER("set_mysql_error");
-  DBUG_PRINT("enter", ("error :%d '%s'", errcode, ER(errcode)));
-  DBUG_ASSERT(mysql != 0);
-
-  if (mysql)
-  {
-    net= &mysql->net;
-    net->last_errno= errcode;
-    my_stpcpy(net->last_error, ER(errcode));
-    my_stpcpy(net->sqlstate, sqlstate);
-    MYSQL_TRACE(ERROR, mysql, ());
-  }
-  else
-  {
-    mysql_server_last_errno= errcode;
-    my_stpcpy(mysql_server_last_error, ER(errcode));
-  }
-  DBUG_VOID_RETURN;
-}
-
-/**
-  Is this NET instance initialized?
-  @c my_net_init() and net_end()
- */
-
-my_bool my_net_is_inited(NET *net)
-{
-  return net->buff != NULL;
-}
-
-/**
-  Clear possible error state of struct NET
-
-  @param net  clear the state of the argument
-*/
-
-void net_clear_error(NET *net)
-{
-  net->last_errno= 0;
-  net->last_error[0]= '\0';
-  my_stpcpy(net->sqlstate, not_error_sqlstate);
-}
-
-/**
-  Set an error message on the client.
-
-  @param mysql     connection handle
-  @param errcode   CR_* errcode, for client errors
-  @param sqlstate  SQL standard sql state, unknown_sqlstate for the
-                   majority of client errors.
-  @param format    error message template, in sprintf format
-  @param ...       variable number of arguments
-*/
-
-void set_mysql_extended_error(MYSQL *mysql, int errcode,
-                                     const char *sqlstate,
-                                     const char *format, ...)
-{
-  NET *net;
-  va_list args;
-  DBUG_ENTER("set_mysql_extended_error");
-  DBUG_PRINT("enter", ("error :%d '%s'", errcode, format));
-  DBUG_ASSERT(mysql != 0);
-
-  net= &mysql->net;
-  net->last_errno= errcode;
-  va_start(args, format);
-  my_vsnprintf(net->last_error, sizeof(net->last_error)-1,
-               format, args);
-  va_end(args);
-  my_stpcpy(net->sqlstate, sqlstate);
-
-  MYSQL_TRACE(ERROR, mysql, ());
-
-  DBUG_VOID_RETURN;
-}
-
-
-
-/*
-  Create a named pipe connection
-*/
-
-#ifdef _WIN32
-
-static HANDLE create_named_pipe(MYSQL *mysql, DWORD connect_timeout,
-                                const char **arg_host,
-                                const char **arg_unix_socket)
-{
-  HANDLE hPipe=INVALID_HANDLE_VALUE;
-  char pipe_name[1024];
-  DWORD dwMode;
-  int i;
-  my_bool testing_named_pipes=0;
-  const char *host= *arg_host, *unix_socket= *arg_unix_socket;
-
-  if ( ! unix_socket || (unix_socket)[0] == 0x00)
-    unix_socket = mysql_unix_port;
-  if (!host || !strcmp(host,LOCAL_HOST))
-    host=LOCAL_HOST_NAMEDPIPE;
-
-  
-  pipe_name[sizeof(pipe_name)-1]= 0;		/* Safety if too long string */
-  strxnmov(pipe_name, sizeof(pipe_name)-1, "\\\\", host, "\\pipe\\",
-	   unix_socket, NullS);
-  DBUG_PRINT("info",("Server name: '%s'.  Named Pipe: %s", host, unix_socket));
-
-  for (i=0 ; i < 100 ; i++)			/* Don't retry forever */
-  {
-    if ((hPipe = CreateFile(pipe_name,
-			    GENERIC_READ | GENERIC_WRITE,
-			    0,
-			    NULL,
-			    OPEN_EXISTING,
-			    FILE_FLAG_OVERLAPPED,
-			    NULL )) != INVALID_HANDLE_VALUE)
-      break;
-    if (GetLastError() != ERROR_PIPE_BUSY)
-    {
-      set_mysql_extended_error(mysql, CR_NAMEDPIPEOPEN_ERROR,
-                               unknown_sqlstate, ER(CR_NAMEDPIPEOPEN_ERROR),
-                               host, unix_socket, (ulong) GetLastError());
-      return INVALID_HANDLE_VALUE;
-    }
-    /* wait for for an other instance */
-    if (!WaitNamedPipe(pipe_name, connect_timeout))
-    {
-      set_mysql_extended_error(mysql, CR_NAMEDPIPEWAIT_ERROR, unknown_sqlstate,
-                               ER(CR_NAMEDPIPEWAIT_ERROR),
-                               host, unix_socket, (ulong) GetLastError());
-      return INVALID_HANDLE_VALUE;
-    }
-  }
-  if (hPipe == INVALID_HANDLE_VALUE)
-  {
-    set_mysql_extended_error(mysql, CR_NAMEDPIPEOPEN_ERROR, unknown_sqlstate,
-                             ER(CR_NAMEDPIPEOPEN_ERROR), host, unix_socket,
-                             (ulong) GetLastError());
-    return INVALID_HANDLE_VALUE;
-  }
-  dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
-  if ( !SetNamedPipeHandleState(hPipe, &dwMode, NULL, NULL) )
-  {
-    CloseHandle( hPipe );
-    set_mysql_extended_error(mysql, CR_NAMEDPIPESETSTATE_ERROR,
-                             unknown_sqlstate, ER(CR_NAMEDPIPESETSTATE_ERROR),
-                             host, unix_socket, (ulong) GetLastError());
-    return INVALID_HANDLE_VALUE;
-  }
-  *arg_host=host ; *arg_unix_socket=unix_socket;	/* connect arg */
-  return (hPipe);
-}
-#endif
-
-
-/*
-  Create new shared memory connection, return handler of connection
-
-  @param mysql  Pointer of mysql structure
-  @param net    Pointer of net structure
-  @param connect_timeout  Timeout of connection (in milliseconds)
-
-  @return HANDLE to the shared memory area.
-*/
-
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-static HANDLE create_shared_memory(MYSQL *mysql, NET *net,
-                                   DWORD connect_timeout)
-{
-  ulong smem_buffer_length = shared_memory_buffer_length + 4;
-  /*
-    event_connect_request is event object for start connection actions
-    event_connect_answer is event object for confirm, that server put data
-    handle_connect_file_map is file-mapping object, use for create shared
-    memory
-    handle_connect_map is pointer on shared memory
-    handle_map is pointer on shared memory for client
-    event_server_wrote,
-    event_server_read,
-    event_client_wrote,
-    event_client_read are events for transfer data between server and client
-    handle_file_map is file-mapping object, use for create shared memory
-  */
-  HANDLE event_connect_request = NULL;
-  HANDLE event_connect_answer = NULL;
-  HANDLE handle_connect_file_map = NULL;
-  char *handle_connect_map = NULL;
-
-  char *handle_map = NULL;
-  HANDLE event_server_wrote = NULL;
-  HANDLE event_server_read = NULL;
-  HANDLE event_client_wrote = NULL;
-  HANDLE event_client_read = NULL;
-  HANDLE event_conn_closed = NULL;
-  HANDLE handle_file_map = NULL;
-  HANDLE connect_named_mutex = NULL;
-  ulong connect_number;
-  char connect_number_char[22], *p;
-  char *tmp= NULL;
-  char *suffix_pos;
-  DWORD error_allow = 0;
-  DWORD error_code = 0;
-  DWORD event_access_rights= SYNCHRONIZE | EVENT_MODIFY_STATE;
-  char *shared_memory_base_name = mysql->options.shared_memory_base_name;
-  static const char *name_prefixes[] = {"","Global\\"};
-  const char *prefix;
-  int i;
-
-  /*
-    If this is NULL, somebody freed the MYSQL* options.  mysql_close()
-    is a good candidate.  We don't just silently (re)set it to
-    def_shared_memory_base_name as that would create really confusing/buggy
-    behavior if the user passed in a different name on the command-line or
-    in a my.cnf.
-  */
-  DBUG_ASSERT(shared_memory_base_name != NULL);
-
-  /*
-     get enough space base-name + '_' + longest suffix we might ever send
-   */
-  if (!(tmp= (char *)my_malloc(key_memory_create_shared_memory,
-                               strlen(shared_memory_base_name) + 32L, MYF(MY_FAE))))
-    goto err;
-
-  /*
-    The name of event and file-mapping events create agree next rule:
-    shared_memory_base_name+unique_part
-    Where:
-    shared_memory_base_name is unique value for each server
-    unique_part is uniquel value for each object (events and file-mapping)
-  */
-  for (i = 0; i< array_elements(name_prefixes); i++)
-  {
-    prefix= name_prefixes[i];
-    suffix_pos = strxmov(tmp, prefix , shared_memory_base_name, "_", NullS);
-    my_stpcpy(suffix_pos, "CONNECT_REQUEST");
-    event_connect_request= OpenEvent(event_access_rights, FALSE, tmp);
-    if (event_connect_request)
-    {
-      break;
-    }
-  }
-  if (!event_connect_request)
-  {
-    error_allow = CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR;
-    goto err;
-  }
-  my_stpcpy(suffix_pos, "CONNECT_ANSWER");
-  if (!(event_connect_answer= OpenEvent(event_access_rights,FALSE,tmp)))
-  {
-    error_allow = CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR;
-    goto err;
-  }
-  my_stpcpy(suffix_pos, "CONNECT_DATA");
-  if (!(handle_connect_file_map= OpenFileMapping(FILE_MAP_WRITE,FALSE,tmp)))
-  {
-    error_allow = CR_SHARED_MEMORY_CONNECT_FILE_MAP_ERROR;
-    goto err;
-  }
-  if (!(handle_connect_map= MapViewOfFile(handle_connect_file_map,
-					  FILE_MAP_WRITE,0,0,sizeof(DWORD))))
-  {
-    error_allow = CR_SHARED_MEMORY_CONNECT_MAP_ERROR;
-    goto err;
-  }
-
-  my_stpcpy(suffix_pos, "CONNECT_NAMED_MUTEX");
-  connect_named_mutex= CreateMutex(NULL, TRUE, tmp);
-  if (connect_named_mutex == NULL)
-  {
-    error_allow= CR_SHARED_MEMORY_CONNECT_SET_ERROR;
-    goto err;
-  }
-
-  /* Send to server request of connection */
-  if (!SetEvent(event_connect_request))
-  {
-    error_allow = CR_SHARED_MEMORY_CONNECT_SET_ERROR;
-    goto err;
-  }
-
-  /* Wait of answer from server */
-  if (WaitForSingleObject(event_connect_answer, connect_timeout) !=
-      WAIT_OBJECT_0)
-  {
-    error_allow = CR_SHARED_MEMORY_CONNECT_ABANDONED_ERROR;
-    goto err;
-  }
-
-  ReleaseMutex(connect_named_mutex);
-  CloseHandle(connect_named_mutex);
-  connect_named_mutex = NULL;
-
-  /* Get number of connection */
-  connect_number = uint4korr(handle_connect_map);/*WAX2*/
-  p= int10_to_str(connect_number, connect_number_char, 10);
-
-  /*
-    The name of event and file-mapping events create agree next rule:
-    shared_memory_base_name+unique_part+number_of_connection
-
-    Where:
-    shared_memory_base_name is uniquel value for each server
-    unique_part is uniquel value for each object (events and file-mapping)
-    number_of_connection is number of connection between server and client
-  */
-  suffix_pos = strxmov(tmp, prefix , shared_memory_base_name, "_", connect_number_char,
-		       "_", NullS);
-  my_stpcpy(suffix_pos, "DATA");
-  if ((handle_file_map = OpenFileMapping(FILE_MAP_WRITE,FALSE,tmp)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_FILE_MAP_ERROR;
-    goto err2;
-  }
-  if ((handle_map = MapViewOfFile(handle_file_map,FILE_MAP_WRITE,0,0,
-				  smem_buffer_length)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_MAP_ERROR;
-    goto err2;
-  }
-
-  my_stpcpy(suffix_pos, "SERVER_WROTE");
-  if ((event_server_wrote = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
-    goto err2;
-  }
-
-  my_stpcpy(suffix_pos, "SERVER_READ");
-  if ((event_server_read = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
-    goto err2;
-  }
-
-  my_stpcpy(suffix_pos, "CLIENT_WROTE");
-  if ((event_client_wrote = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
-    goto err2;
-  }
-
-  my_stpcpy(suffix_pos, "CLIENT_READ");
-  if ((event_client_read = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
-    goto err2;
-  }
-
-  my_stpcpy(suffix_pos, "CONNECTION_CLOSED");
-  if ((event_conn_closed = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)
-  {
-    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;
-    goto err2;
-  }
-  /*
-    Set event that server should send data
-  */
-  SetEvent(event_server_read);
-
-err2:
-  if (error_allow == 0)
-  {
-    net->vio= vio_new_win32shared_memory(handle_file_map,handle_map,
-                                         event_server_wrote,
-                                         event_server_read,event_client_wrote,
-                                         event_client_read,event_conn_closed);
-  }
-  else
-  {
-    error_code = GetLastError();
-    if (event_server_read)
-      CloseHandle(event_server_read);
-    if (event_server_wrote)
-      CloseHandle(event_server_wrote);
-    if (event_client_read)
-      CloseHandle(event_client_read);
-    if (event_client_wrote)
-      CloseHandle(event_client_wrote);
-    if (event_conn_closed)
-      CloseHandle(event_conn_closed);
-    if (handle_map)
-      UnmapViewOfFile(handle_map);
-    if (handle_file_map)
-      CloseHandle(handle_file_map);
-  }
-err:
-  my_free(tmp);
-  if (error_allow)
-    error_code = GetLastError();
-  if (event_connect_request)
-    CloseHandle(event_connect_request);
-  if (event_connect_answer)
-    CloseHandle(event_connect_answer);
-  if (handle_connect_map)
-    UnmapViewOfFile(handle_connect_map);
-  if (handle_connect_file_map)
-    CloseHandle(handle_connect_file_map);
-  if (error_allow)
-  {
-    if (connect_named_mutex)
-    {
-      ReleaseMutex(connect_named_mutex);
-      CloseHandle(connect_named_mutex);
-    }
-
-    if (error_allow == CR_SHARED_MEMORY_EVENT_ERROR)
-      set_mysql_extended_error(mysql, error_allow, unknown_sqlstate,
-                               ER(error_allow), suffix_pos, error_code);
-    else
-      set_mysql_extended_error(mysql, error_allow, unknown_sqlstate,
-                               ER(error_allow), error_code);
-    return(INVALID_HANDLE_VALUE);
-  }
-  return(handle_map);
-}
-#endif
-
-/*
-  Free all memory acquired to store state change information.
-*/
-void free_state_change_info(MYSQL_EXTENSION *ext)
-{
-  STATE_INFO *info;
-  int i;
-
-  if (ext)
-    info= &ext->state_change;
-  else
-    return;
-
-  for (i= SESSION_TRACK_SYSTEM_VARIABLES; i <= SESSION_TRACK_END; i++)
-  {
-    if (list_length(info->info_list[i].head_node) != 0)
-    {
-      /*
-        Since nodes were multi-alloced, we don't need to free the data
-        separately. But the str member in data needs to be freed.
-      */
-      LIST *tmp_list= info->info_list[i].head_node;
-      while (tmp_list)
-      {
-	LEX_STRING *tmp= (LEX_STRING *)(tmp_list)->data;
-	if (tmp->str)
-	  my_free(tmp->str);
-	tmp_list= tmp_list->next;
-      }
-      list_free(info->info_list[i].head_node, (uint) 0);
-    }
-  }
-  memset(info, 0, sizeof(STATE_INFO));
-}
-
-
-/**
-  Read Ok packet along with the server state change information.
-*/
-void read_ok_ex(MYSQL *mysql, ulong length)
-{
-  size_t total_len, len;
-  uchar *pos, *saved_pos;
-  my_ulonglong affected_rows, insert_id;
-  char *db;
-
-  struct charset_info_st *saved_cs;
-  char charset_name[64];
-  my_bool is_charset;
-
-  STATE_INFO *info= NULL;
-  enum enum_session_state_type type;
-  LIST *element= NULL;
-  LEX_STRING *data=NULL;
-
-  pos= mysql->net.read_pos + 1;
-
-  affected_rows = net_field_length_ll(&pos); /* affected rows */
-  insert_id = net_field_length_ll(&pos); /* insert id */
-
-  /*
-   The following check ensures that we skip the assignment for the
-   above read fields (i.e. affected_rows and insert_id) wherein the
-   EOF packets are deprecated and the server sends OK packet instead
-   with a packet header of 0xFE (254) to identify it as an EOF packet.
-   We ignore this assignment as the valid contents of EOF packet include
-   packet marker, server status and warning count only. However, we would
-   assign these values to the connection handle if it was an OK packet
-   with a packet header of 0x00.
-  */
-  if (!((mysql->server_capabilities & CLIENT_DEPRECATE_EOF) &&
-        mysql->net.read_pos[0] == 254))
-  {
-    mysql->affected_rows= affected_rows;
-    mysql->insert_id= insert_id;
-
-    DBUG_PRINT("info",("affected_rows: %lu  insert_id: %lu",
-                       (ulong) mysql->affected_rows,
-                       (ulong) mysql->insert_id));
-  }
-  /* server status */
-  mysql->server_status= uint2korr(pos);
-  pos += 2;
-
-  if (protocol_41(mysql))
-  {
-    mysql->warning_count=uint2korr(pos);
-    pos += 2;
-  } else
-    mysql->warning_count= 0;                    /* MySQL 4.0 protocol */
-
-  DBUG_PRINT("info",("status: %u  warning_count: %u",
-                     mysql->server_status, mysql->warning_count));
-  if (mysql->server_capabilities & CLIENT_SESSION_TRACK)
-  {
-    free_state_change_info(mysql->extension);
-
-    if (pos < mysql->net.read_pos + length)
-    {
-      /* get the info field */
-      size_t length_msg_member= (size_t)net_field_length(&pos);
-      mysql->info= (length_msg_member ? (char *)pos : NULL);
-      pos += (length_msg_member);
-
-      /* read session state changes info */
-      if (mysql->server_status & SERVER_SESSION_STATE_CHANGED)
-      {
-        saved_pos= pos;
-        total_len= (size_t)net_field_length(&pos);
-        /* ensure that mysql->info is zero-terminated */
-        if (mysql->info)
-          *saved_pos= 0;
-
-        while (total_len > 0)
-        {
-          saved_pos= pos;
-          type= (enum enum_session_state_type) net_field_length(&pos);
-
-          switch (type)
-          {
-          case SESSION_TRACK_SYSTEM_VARIABLES:
-            /* Move past the total length of the changed entity. */
-            (void) net_field_length(&pos);
-
-            /* Name of the system variable. */
-            len= (size_t) net_field_length(&pos);
-
-            if (!my_multi_malloc(key_memory_MYSQL_state_change_info,
-              MYF(0),
-              &element, sizeof(LIST),
-              &data, sizeof(LEX_STRING),
-              NullS))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-
-            if(!(data->str= (char *)my_malloc(PSI_NOT_INSTRUMENTED, len, MYF(MY_WME))))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-            memcpy(data->str, (char *) pos, len);
-            data->length= len;
-            pos += len;
-
-            element->data= data;
-            ADD_INFO(info, element, SESSION_TRACK_SYSTEM_VARIABLES);
-
-            /*
-              Check if the changed variable was charset. In that case we need to
-              update mysql->charset.
-              */
-            if (!strncmp(data->str, "character_set_client", data->length))
-              is_charset= 1;
-            else
-              is_charset= 0;
-
-            if (!my_multi_malloc(key_memory_MYSQL_state_change_info,
-              MYF(0),
-              &element, sizeof(LIST),
-              &data, sizeof(LEX_STRING),
-              NullS))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-
-            /* Value of the system variable. */
-            len= (size_t) net_field_length(&pos);
-            if(!(data->str= (char *)my_malloc(PSI_NOT_INSTRUMENTED, len, MYF(MY_WME))))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-            memcpy(data->str, (char *) pos, len);
-            data->length= len;
-            pos += len;
-
-            element->data= data;
-            ADD_INFO(info, element, SESSION_TRACK_SYSTEM_VARIABLES);
-
-            if (is_charset == 1)
-            {
-              saved_cs= mysql->charset;
-
-              memcpy(charset_name, data->str, data->length);
-              charset_name[data->length]= 0;
-
-              if (!(mysql->charset= get_charset_by_csname(charset_name,
-                MY_CS_PRIMARY,
-                MYF(MY_WME))))
-              {
-                /* Ideally, the control should never reach her. */
-                DBUG_ASSERT(0);
-                mysql->charset= saved_cs;
-              }
-            }
-            break;
-          case SESSION_TRACK_TRANSACTION_STATE:
-          case SESSION_TRACK_TRANSACTION_CHARACTERISTICS:
-          case SESSION_TRACK_SCHEMA:
-
-            if (!my_multi_malloc(key_memory_MYSQL_state_change_info,
-              MYF(0),
-              &element, sizeof(LIST),
-              &data, sizeof(LEX_STRING),
-              NullS))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-
-            /* Move past the total length of the changed entity. */
-            (void) net_field_length(&pos);
-
-            len= (size_t) net_field_length(&pos);
-            if(!(data->str= (char *)my_malloc(PSI_NOT_INSTRUMENTED, len, MYF(MY_WME))))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-            memcpy(data->str, (char *) pos, len);
-            data->length= len;
-            pos += len;
-
-            element->data= data;
-            ADD_INFO(info, element, type);
-
-            if (type == SESSION_TRACK_SCHEMA)
-            {
-              if (!(db= (char *) my_malloc(key_memory_MYSQL_state_change_info,
-                                           data->length + 1, MYF(MY_WME))))
-              {
-                set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-                return;
-              }
-
-              if (mysql->db)
-                my_free(mysql->db);
-
-              memcpy(db, data->str, data->length);
-              db[data->length]= '\0';
-              mysql->db= db;
-            }
-
-            break;
-          case SESSION_TRACK_GTIDS:
-            if (!my_multi_malloc(key_memory_MYSQL_state_change_info,
-              MYF(0),
-              &element, sizeof(LIST),
-              &data, sizeof(LEX_STRING),
-              NullS))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-
-            /* Move past the total length of the changed entity. */
-            (void) net_field_length(&pos);
-
-            /* read (and ignore for now) the GTIDS encoding specification code */
-            (void) net_field_length(&pos);
-
-            /*
-               For now we ignore the encoding specification, since only one
-               is supported. In the future the decoding of what comes next
-               depends on the specification code.
-               */
-
-            /* read the length of the encoded string. */
-            len= (size_t) net_field_length(&pos);
-            if(!(data->str= (char *)my_malloc(PSI_NOT_INSTRUMENTED, len, MYF(MY_WME))))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-
-            memcpy(data->str, (char *) pos, len);
-            data->length= len;
-            pos += len;
-
-            element->data= data;
-            ADD_INFO(info, element, SESSION_TRACK_GTIDS);
-            break;
-          case SESSION_TRACK_STATE_CHANGE:
-            if (!my_multi_malloc(key_memory_MYSQL_state_change_info,
-              MYF(0),
-              &element, sizeof(LIST),
-              &data, sizeof(LEX_STRING),
-              NullS))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-
-            /* Get the length of the boolean tracker */
-            len= (size_t) net_field_length(&pos);
-            /* length for boolean tracker is always 1 */
-            DBUG_ASSERT(len == 1);
-            if(!(data->str= (char *)my_malloc(PSI_NOT_INSTRUMENTED, len, MYF(MY_WME))))
-            {
-              set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-              return;
-            }
-            memcpy(data->str, (char *) pos, len);
-            data->length= len;
-            pos += len;
-
-            element->data= data;
-            ADD_INFO(info, element, SESSION_TRACK_STATE_CHANGE);
-
-            break;
-          default:
-            DBUG_ASSERT(type <= SESSION_TRACK_END);
-            /*
-              Unknown/unsupported type received, get the total length and move
-              past it.
-              */
-            len= (size_t) net_field_length(&pos);
-            pos += len;
-            break;
-          }
-          total_len -= (pos - saved_pos);
-        }
-        if (info)
-        {
-          for (type= SESSION_TRACK_BEGIN; type < SESSION_TRACK_END; type++)
-          {
-            if (info->info_list[type].head_node)
-            {
-              info->info_list[type].current_node=
-                info->info_list[type].head_node=
-                  list_reverse(info->info_list[type].head_node);
-            }
-          }
-        }
-      }
-    }
-  }
-  else if (pos < mysql->net.read_pos + length && net_field_length(&pos))
-    mysql->info=(char*) pos;
-  else
-    mysql->info=NULL;
-  return;
-}
-
-
-/**
-  Read a packet from server. Give error message if socket was down
-  or packet is an error message
-
-  @param[IN]    mysql           connection handle
-  @param[IN]    parse_ok        if set to TRUE then parse OK packet
-                                if it is received
-  @param[OUT]   is_data_packet
-                                if set to TRUE then packet received is
-                                a "data packet", that is not OK or ERR
-                                packet or EOF in case of old servers
-
-  @retval  The length of the packet that was read or packet_error in
-           case of error. In case of error its description is stored
-            in mysql handle.
-*/
-
-ulong
-cli_safe_read_with_ok(MYSQL *mysql, my_bool parse_ok,
-                      my_bool *is_data_packet)
-{
-  NET *net= &mysql->net;
-  ulong len=0;
-
-  MYSQL_TRACE(READ_PACKET, mysql, ());
-
-  if (is_data_packet)
-    *is_data_packet= FALSE;
-
-  if (net->vio != 0)
-    len=my_net_read(net);
-
-  if (len == packet_error || len == 0)
-  {
-    DBUG_PRINT("error",("Wrong connection or packet. fd: %s  len: %lu",
-			vio_description(net->vio),len));
-#ifdef MYSQL_SERVER
-    if (net->vio && (net->last_errno == ER_NET_READ_INTERRUPTED))
-      return (packet_error);
-#endif /*MYSQL_SERVER*/
-    end_server(mysql);
-    set_mysql_error(mysql, net->last_errno == ER_NET_PACKET_TOO_LARGE ?
-                    CR_NET_PACKET_TOO_LARGE: CR_SERVER_LOST, unknown_sqlstate);
-    return (packet_error);
-  }
-
-  MYSQL_TRACE(PACKET_RECEIVED, mysql, (len, net->read_pos));
-  
-  if (net->read_pos[0] == 255)
-  {
-    /*
-      After server reprts an error, usually it is ready to accept new commands and
-      we set stage to READY_FOR_COMMAND. This can be modified by the caller of 
-      cli_safe_read().
-    */
-    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-
-    if (len > 3)
-    {
-      uchar *pos= net->read_pos+1;
-      net->last_errno=uint2korr(pos);
-      pos+=2;
-      len-=2;
-      if (protocol_41(mysql) && pos[0] == '#')
-      {
-	strmake(net->sqlstate, (char*)pos+1, SQLSTATE_LENGTH);
-	pos+= SQLSTATE_LENGTH+1;
-      }
-      else
-      {
-        /*
-          The SQL state hasn't been received -- it should be reset to HY000
-          (unknown error sql state).
-        */
-
-        my_stpcpy(net->sqlstate, unknown_sqlstate);
-      }
-
-      (void) strmake(net->last_error,(char*) pos,
-		     MY_MIN((uint) len,(uint) sizeof(net->last_error)-1));
-    }
-    else
-      set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
-    /*
-      Cover a protocol design error: error packet does not
-      contain the server status. Therefore, the client has no way
-      to find out whether there are more result sets of
-      a multiple-result-set statement pending. Luckily, in 5.0 an
-      error always aborts execution of a statement, wherever it is
-      a multi-statement or a stored procedure, so it should be
-      safe to unconditionally turn off the flag here.
-    */
-    mysql->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
-
-    DBUG_PRINT("error",("Got error: %d/%s (%s)",
-                        net->last_errno,
-                        net->sqlstate,
-                        net->last_error));
-    return(packet_error);
-  }
-  else
-  {
-    /* if it is OK packet irrespective of new/old server */
-    if (net->read_pos[0] == 0)
-    {
-      if (parse_ok)
-      {
-        read_ok_ex(mysql, len);
-        return len;
-      }
-    }
-    /*
-      Now we have a data packet, unless it is OK packet starting with
-      0xFE - we detect that case below.
-    */
-    if (is_data_packet)
-      *is_data_packet= TRUE;
-    /*
-       For a packet starting with 0xFE detect if it is OK packet or a
-       huge data packet. Note that old servers do not send OK packets
-       starting with 0xFE.
-    */
-    if ((mysql->server_capabilities & CLIENT_DEPRECATE_EOF) &&
-        (net->read_pos[0] == 254))
-    {
-      /* detect huge data packet */
-      if (len > MAX_PACKET_LENGTH)
-        return len;
-      /* otherwise we have OK packet starting with 0xFE */
-      if (is_data_packet)
-        *is_data_packet= FALSE;
-      /* parse it if requested */
-      if (parse_ok)
-        read_ok_ex(mysql, len);
-      return len;
-    }
-    /* for old client detect EOF packet */
-    if (!(mysql->server_capabilities & CLIENT_DEPRECATE_EOF) &&
-        (net->read_pos[0] == 254) && (len < 8))
-    {
-      if (is_data_packet)
-        *is_data_packet= FALSE;
-    }
-  }
-  return len;
-}
-
-
-/**
-  Read a packet from server. Give error message if connection was broken or
-  ERR packet was received. Detect if the packet received was an OK, ERR or
-  something else (a "data packet").
-
-  @param[IN]  mysql           connection handle
-  @param[OUT] is_data_packet
-                              if set to TRUE then the packet received
-                              was a "data packet".
-
-  @retval The length of the packet that was read or packet_error in case of
-          error. In case of error its description is stored in mysql handle.
-*/
-ulong cli_safe_read(MYSQL *mysql, my_bool *is_data_packet)
-{
-  return cli_safe_read_with_ok(mysql, 0, is_data_packet);
-}
-
-
-void free_rows(MYSQL_DATA *cur)
-{
-  if (cur)
-  {
-    free_root(&cur->alloc,MYF(0));
-    my_free(cur);
-  }
-}
-
-my_bool
-cli_advanced_command(MYSQL *mysql, enum enum_server_command command,
-		     const uchar *header, size_t header_length,
-		     const uchar *arg, size_t arg_length, my_bool skip_check,
-                     MYSQL_STMT *stmt)
-{
-  NET *net= &mysql->net;
-  my_bool result= 1;
-  my_bool stmt_skip= stmt ? stmt->state != MYSQL_STMT_INIT_DONE : FALSE;
-  DBUG_ENTER("cli_advanced_command");
-
-  if (mysql->net.vio == 0)
-  {						/* Do reconnect if possible */
-    if (mysql_reconnect(mysql) || stmt_skip)
-      DBUG_RETURN(1);
-  }
-  if (mysql->status != MYSQL_STATUS_READY ||
-      mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-  {
-    DBUG_PRINT("error",("state: %d", mysql->status));
-    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
-    DBUG_RETURN(1);
-  }
-
-  net_clear_error(net);
-  mysql->info=0;
-  mysql->affected_rows= ~(my_ulonglong) 0;
-  /*
-    Do not check the socket/protocol buffer on COM_QUIT as the
-    result of a previous command might not have been read. This
-    can happen if a client sends a query but does not reap the
-    result before attempting to close the connection.
-  */
-  net_clear(&mysql->net, (command != COM_QUIT));
-
-  MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-  MYSQL_TRACE(SEND_COMMAND, mysql, (command, header_length, arg_length, header, arg));
-
-#if !defined(EMBEDDED_LIBRARY)
-  /*
-    If auto-reconnect mode is enabled check if connection is still alive before
-    sending new command. Otherwise, send() might not notice that connection was
-    closed by the server (for example, due to KILL statement), and the fact that
-    connection is gone will be noticed only on attempt to read command's result,
-    when it is too late to reconnect. Note that such scenario can still occur if
-    connection gets killed after this check but before command is sent to
-    server. But this should be rare.
-  */
-  if ((command != COM_QUIT) && mysql->reconnect && !vio_is_connected(net->vio))
-    net->error= 2;
-#endif
-
-  if (net_write_command(net,(uchar) command, header, header_length,
-			arg, arg_length))
-  {
-    DBUG_PRINT("error",("Can't send command to server. Error: %d",
-			socket_errno));
-    if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
-    {
-      set_mysql_error(mysql, CR_NET_PACKET_TOO_LARGE, unknown_sqlstate);
-      goto end;
-    }
-    end_server(mysql);
-    if (mysql_reconnect(mysql) || stmt_skip)
-      goto end;
-    
-    MYSQL_TRACE(SEND_COMMAND, mysql, (command, header_length, arg_length, header, arg));
-    if (net_write_command(net,(uchar) command, header, header_length,
-			  arg, arg_length))
-    {
-      set_mysql_error(mysql, CR_SERVER_GONE_ERROR, unknown_sqlstate);
-      goto end;
-    }
-  }
-
-  MYSQL_TRACE(PACKET_SENT, mysql, (header_length + arg_length)); 
-
-#if defined(CLIENT_PROTOCOL_TRACING)
-  switch (command)
-  {
-  case COM_STMT_PREPARE:
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_PS_DESCRIPTION);
-    break;
-
-  case COM_STMT_FETCH:
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_ROW);
-    break;
-
-  /* 
-    No server reply is expected after these commands so we reamin ready
-    for the next command.
- */
-  case COM_STMT_SEND_LONG_DATA: 
-  case COM_STMT_CLOSE:
-  case COM_REGISTER_SLAVE:
-  case COM_QUIT:
-    break;
-
-  /*
-    These replication commands are not supported and we bail out
-    by pretending that connection has been closed.
-  */
-  case COM_BINLOG_DUMP:
-  case COM_BINLOG_DUMP_GTID:
-  case COM_TABLE_DUMP:
-    MYSQL_TRACE(DISCONNECTED, mysql, ());
-    break;
-
-  /*
-    After COM_CHANGE_USER a regular authentication exchange
-    is performed.
-  */
-  case COM_CHANGE_USER:
-    MYSQL_TRACE_STAGE(mysql, AUTHENTICATE);
-    break;
-
-  /*
-    Server replies to COM_STATISTICS with a single packet 
-    containing a string with statistics information.
-  */
-  case COM_STATISTICS:
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_PACKET);
-    break;
-
-  /*
-    For all other commands we expect server to send regular reply which
-    is either OK, ERR or a result-set header.
-  */
-  default: MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT); break;
-  }
-#endif
-
-  result=0;
-  if (!skip_check)
-  {
-    result= ((mysql->packet_length= cli_safe_read_with_ok(mysql, 1, NULL)) ==
-             packet_error ? 1 : 0);
-
-#if defined(CLIENT_PROTOCOL_TRACING)
-    /*
-      Return to READY_FOR_COMMAND protocol stage in case server reports error 
-      or sends OK packet.
-    */
-    if (!result || mysql->net.read_pos[0] == 0x00)
-      MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-#endif
-  }
-
-end:
-  DBUG_PRINT("exit",("result: %d", result));
-  DBUG_RETURN(result);
-}
-
-void free_old_query(MYSQL *mysql)
-{
-  DBUG_ENTER("free_old_query");
-  if (mysql->fields)
-    free_root(&mysql->field_alloc,MYF(0));
-  init_alloc_root(PSI_NOT_INSTRUMENTED,
-                  &mysql->field_alloc, 8192, 0); /* Assume rowlength < 8192 */
-  mysql->fields= 0;
-  mysql->field_count= 0;			/* For API */
-  mysql->warning_count= 0;
-  mysql->info= 0;
-  DBUG_VOID_RETURN;
-}
-
-
-/**
-  Finish reading of a partial result set from the server.
-  Get the EOF packet, and update mysql->status
-  and mysql->warning_count.
-
-  @return  TRUE if a communication or protocol error, an error
-           is set in this case, FALSE otherwise.
-*/
-
-my_bool flush_one_result(MYSQL *mysql)
-{
-  ulong packet_length;
-  my_bool is_data_packet;
-
-  DBUG_ASSERT(mysql->status != MYSQL_STATUS_READY);
-
-  do
-  {
-    packet_length= cli_safe_read(mysql, &is_data_packet);
-    /*
-      There is an error reading from the connection,
-      or (sic!) there were no error and no
-      data in the stream, i.e. no more data from the server.
-      Since we know our position in the stream (somewhere in
-      the middle of a result set), this latter case is an error too
-      -- each result set must end with a EOF packet.
-      cli_safe_read() has set an error for us, just return.
-    */
-    if (packet_length == packet_error)
-      return TRUE;
-  }
-  while (mysql->net.read_pos[0] == 0 || is_data_packet);
-
-  /* Analyse final OK packet (EOF packet if it is old client) */
-
-  if (protocol_41(mysql))
-  {
-    uchar *pos= mysql->net.read_pos + 1;
-    if (mysql->server_capabilities & CLIENT_DEPRECATE_EOF &&
-        !is_data_packet)
-      read_ok_ex(mysql, packet_length);
-    else
-    {
-      mysql->warning_count= uint2korr(pos);
-      pos+=2;
-      mysql->server_status=uint2korr(pos);
-    }
-    pos+=2;
-  }
-#if defined(CLIENT_PROTOCOL_TRACING)
-  if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
-  else
-    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-#endif
-  return FALSE;
-}
-
-
-/**
-  Read a packet from network. If it's an OK packet, flush it.
-
-  @return  TRUE if error, FALSE otherwise. In case of 
-           success, is_ok_packet is set to TRUE or FALSE,
-           based on what we got from network.
-*/
-
-my_bool opt_flush_ok_packet(MYSQL *mysql, my_bool *is_ok_packet)
-{
-  my_bool is_data_packet;
-  ulong packet_length= cli_safe_read(mysql, &is_data_packet);
-
-  if (packet_length == packet_error)
-    return TRUE;
-
-  /* cli_safe_read always reads a non-empty packet. */
-  DBUG_ASSERT(packet_length);
-
-  *is_ok_packet= ((mysql->net.read_pos[0] == 0) ||
-                  ((mysql->server_capabilities & CLIENT_DEPRECATE_EOF) &&
-                   mysql->net.read_pos[0] == 254 &&
-                   packet_length < MAX_PACKET_LENGTH));
-  if (*is_ok_packet)
-  {
-    read_ok_ex(mysql, packet_length);
-#if defined(CLIENT_PROTOCOL_TRACING)
-    if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-      MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
-    else
-      MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-#endif
-  }
-
-  return FALSE;
-}
-
-
-/*
-  Flush result set sent from server
-*/
-
-static void cli_flush_use_result(MYSQL *mysql, my_bool flush_all_results)
-{
-  /* Clear the current execution status */
-  DBUG_ENTER("cli_flush_use_result");
-  DBUG_PRINT("warning",("Not all packets read, clearing them"));
-
-  if (flush_one_result(mysql))
-    DBUG_VOID_RETURN;                           /* An error occurred */
-
-  if (! flush_all_results)
-    DBUG_VOID_RETURN;
-
-  while (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-  {
-    my_bool is_ok_packet;
-    if (opt_flush_ok_packet(mysql, &is_ok_packet))
-      DBUG_VOID_RETURN;                         /* An error occurred. */
-    if (is_ok_packet)
-    {
-      /*
-        Indeed what we got from network was an OK packet, and we
-        know that OK is the last one in a multi-result-set, so
-        just return.
-      */
-      DBUG_VOID_RETURN;
-    }
-
-    /*
-      It's a result set, not an OK packet. A result set contains
-      of two result set subsequences: field metadata, terminated
-      with EOF packet, and result set data, again terminated with
-      EOF packet. Read and flush them.
-    */
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_FIELD_DEF);
-    if (!(mysql->server_capabilities & CLIENT_DEPRECATE_EOF))
-    {
-      if (flush_one_result(mysql))
-        DBUG_VOID_RETURN;                         /* An error occurred. */
-    }
-    else
-    {
-      if ((mysql->fields= cli_read_metadata(mysql,
-                       mysql->net.read_pos[0], protocol_41(mysql) ? 7:5)))
-        free_root(&mysql->field_alloc,MYF(0));
-      else
-        DBUG_VOID_RETURN;
-    }
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_ROW);
-    if (flush_one_result(mysql))
-      DBUG_VOID_RETURN;
-  }
-  DBUG_VOID_RETURN;
-}
-
-
-#ifdef _WIN32
-static my_bool is_NT(void)
-{
-  char *os=getenv("OS");
-  return (os && !strcmp(os, "Windows_NT")) ? 1 : 0;
-}
-#endif
-
-
-#ifdef CHECK_LICENSE
-/**
-  Check server side variable 'license'.
-
-  If the variable does not exist or does not contain 'Commercial',
-  we're talking to non-commercial server from commercial client.
-
-  @retval  0   success
-  @retval  !0  network error or the server is not commercial.
-               Error code is saved in mysql->net.last_errno.
-*/
-
-static int check_license(MYSQL *mysql)
-{
-  MYSQL_ROW row;
-  MYSQL_RES *res;
-  NET *net= &mysql->net;
-  static const char query[]= "SELECT @@license";
-  static const char required_license[]= STRINGIFY_ARG(LICENSE);
-
-  if (mysql_real_query(mysql, query, (ulong)(sizeof(query)-1)))
-  {
-    if (net->last_errno == ER_UNKNOWN_SYSTEM_VARIABLE)
-    {
-      set_mysql_extended_error(mysql, CR_WRONG_LICENSE, unknown_sqlstate,
-                               ER(CR_WRONG_LICENSE), required_license);
-    }
-    return 1;
-  }
-  if (!(res= mysql_use_result(mysql)))
-    return 1;
-  row= mysql_fetch_row(res);
-  /* 
-    If no rows in result set, or column value is NULL (none of these
-    two is ever true for server variables now), or column value
-    mismatch, set wrong license error.
-  */
-  if (!net->last_errno &&
-      (!row || !row[0] ||
-       strncmp(row[0], required_license, sizeof(required_license))))
-  {
-    set_mysql_extended_error(mysql, CR_WRONG_LICENSE, unknown_sqlstate,
-                             ER(CR_WRONG_LICENSE), required_license);
-  }
-  mysql_free_result(res);
-  return net->last_errno;
-}
-#endif /* CHECK_LICENSE */
-
-
-/**************************************************************************
-  Shut down connection
-**************************************************************************/
-
-void end_server(MYSQL *mysql)
-{
-  int save_errno= errno;
-  DBUG_ENTER("end_server");
-  if (mysql->net.vio != 0)
-  {
-    DBUG_PRINT("info",("Net: %s", vio_description(mysql->net.vio)));
-#ifdef MYSQL_SERVER
-    slave_io_thread_detach_vio();
-#endif
-    vio_delete(mysql->net.vio);
-    mysql->net.vio= 0;          /* Marker */
-    mysql_prune_stmt_list(mysql);
-  }
-  net_end(&mysql->net);
-  free_old_query(mysql);
-  errno= save_errno;
-  MYSQL_TRACE(DISCONNECTED, mysql, ());
-  DBUG_VOID_RETURN;
-}
-
-
-void STDCALL
-mysql_free_result(MYSQL_RES *result)
-{
-  DBUG_ENTER("mysql_free_result");
-  DBUG_PRINT("enter",("mysql_res: 0x%lx", (long) result));
-  if (result)
-  {
-    MYSQL *mysql= result->handle;
-    if (mysql)
-    {
-      if (mysql->unbuffered_fetch_owner == &result->unbuffered_fetch_cancelled)
-        mysql->unbuffered_fetch_owner= 0;
-      if (mysql->status == MYSQL_STATUS_USE_RESULT)
-      {
-        (*mysql->methods->flush_use_result)(mysql, FALSE);
-        mysql->status=MYSQL_STATUS_READY;
-        if (mysql->unbuffered_fetch_owner)
-          *mysql->unbuffered_fetch_owner= TRUE;
-      }
-    }
-    free_rows(result->data);
-    if (result->fields)
-      free_root(&result->field_alloc,MYF(0));
-    my_free(result->row);
-    my_free(result);
-  }
-  DBUG_VOID_RETURN;
-}
-
-/****************************************************************************
-  Get options from my.cnf
-****************************************************************************/
-
-static const char *default_options[]=
-{
-  "port","socket","compress","password","pipe", "timeout", "user",
-  "init-command", "host", "database", "debug", "return-found-rows",
-  "ssl-key" ,"ssl-cert" ,"ssl-ca" ,"ssl-capath",
-  "character-sets-dir", "default-character-set", "interactive-timeout",
-  "connect-timeout", "local-infile", "disable-local-infile",
-  "ssl-cipher", "max-allowed-packet", "protocol", "shared-memory-base-name",
-  "multi-results", "multi-statements", "multi-queries", "secure-auth",
-  "report-data-truncation", "plugin-dir", "default-auth",
-  "bind-address", "ssl-crl", "ssl-crlpath", "enable-cleartext-plugin", "tls-version",
-  "ssl_mode",
-  NullS
-};
-enum option_id {
-  OPT_port=1, OPT_socket, OPT_compress, OPT_password, OPT_pipe, OPT_timeout, OPT_user, 
-  OPT_init_command, OPT_host, OPT_database, OPT_debug, OPT_return_found_rows, 
-  OPT_ssl_key, OPT_ssl_cert, OPT_ssl_ca, OPT_ssl_capath, 
-  OPT_character_sets_dir, OPT_default_character_set, OPT_interactive_timeout, 
-  OPT_connect_timeout, OPT_local_infile, OPT_disable_local_infile, 
-  OPT_ssl_cipher, OPT_max_allowed_packet, OPT_protocol, OPT_shared_memory_base_name, 
-  OPT_multi_results, OPT_multi_statements, OPT_multi_queries, OPT_secure_auth, 
-  OPT_report_data_truncation, OPT_plugin_dir, OPT_default_auth,
-  OPT_bind_address, OPT_ssl_crl, OPT_ssl_crlpath, OPT_enable_cleartext_plugin,
-  OPT_tls_version, OPT_ssl_mode,
-  OPT_keep_this_one_last
-};
-
-static TYPELIB option_types={array_elements(default_options)-1,
-			     "options",default_options, NULL};
-
-const char *sql_protocol_names_lib[] =
-{ "TCP", "SOCKET", "PIPE", "MEMORY", NullS };
-TYPELIB sql_protocol_typelib = {array_elements(sql_protocol_names_lib)-1,"",
-				sql_protocol_names_lib, NULL};
-
-static int add_init_command(struct st_mysql_options *options, const char *cmd)
-{
-  char *tmp;
-
-  if (!options->init_commands)
-  {
-    options->init_commands= (DYNAMIC_ARRAY*)my_malloc(key_memory_mysql_options,
-                                                      sizeof(DYNAMIC_ARRAY),
-						      MYF(MY_WME));
-    init_dynamic_array(options->init_commands,sizeof(char*),0,5);
-  }
-
-  if (!(tmp= my_strdup(key_memory_mysql_options,
-                       cmd,MYF(MY_WME))) ||
-      insert_dynamic(options->init_commands, &tmp))
-  {
-    my_free(tmp);
-    return 1;
-  }
-
-  return 0;
-}
-
-#define ALLOCATE_EXTENSIONS(OPTS)                                \
-      (OPTS)->extension= (struct st_mysql_options_extention *)   \
-        my_malloc(key_memory_mysql_options,                      \
-                  sizeof(struct st_mysql_options_extention),     \
-                  MYF(MY_WME | MY_ZEROFILL))                     \
-
-#define ENSURE_EXTENSIONS_PRESENT(OPTS)                          \
-    do {                                                         \
-      if (!(OPTS)->extension)                                    \
-        ALLOCATE_EXTENSIONS(OPTS);                               \
-    } while (0)
-
-
-#define EXTENSION_SET_STRING(OPTS, X, STR)                       \
-    do {                                                         \
-      if ((OPTS)->extension)                                     \
-        my_free((OPTS)->extension->X);                           \
-      else                                                       \
-        ALLOCATE_EXTENSIONS(OPTS);                               \
-      (OPTS)->extension->X= ((STR) != NULL) ?                    \
-        my_strdup(key_memory_mysql_options,                      \
-                  (STR), MYF(MY_WME)) : NULL;                    \
-    } while (0)
-
-#define SET_OPTION(opt_var,arg) \
-  do { \
-    if (mysql->options.opt_var) \
-      my_free(mysql->options.opt_var); \
-    mysql->options.opt_var = arg ? my_strdup(key_memory_mysql_options, arg, MYF(MY_WME)) : NULL; \
-  } while (0)
-
-
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-#define EXTENSION_SET_SSL_STRING(OPTS, X, STR, mode) \
-  do { \
-    EXTENSION_SET_STRING(OPTS, X, STR); \
-    if ((OPTS)->extension->X) \
-      (OPTS)->extension->ssl_mode= mode; \
-  } while (0)
-#else
-#define EXTENSION_SET_SSL_STRING(OPTS, X, STR, mode) \
-    do { \
-      ; \
-    } while(0)
-#endif
-
-static char *set_ssl_option_unpack_path(const char *arg)
-{
-  char *opt_var= NULL;
-  if (arg)
-  {
-    char *buff= (char *)my_malloc(key_memory_mysql_options, FN_REFLEN + 1,
-                                  MYF(MY_WME));
-    unpack_filename(buff, (char *)arg);
-    opt_var= my_strdup(key_memory_mysql_options, buff, MYF(MY_WME));
-    my_free(buff);
-  }
-  return opt_var;
-}
-
-
-void mysql_read_default_options(struct st_mysql_options *options,
-				const char *filename,const char *group)
-{
-  int argc;
-  char *argv_buff[1],**argv;
-  const char *groups[3];
-  DBUG_ENTER("mysql_read_default_options");
-  DBUG_PRINT("enter",("file: %s  group: %s",filename,group ? group :"NULL"));
-
-  compile_time_assert(OPT_keep_this_one_last ==
-                      array_elements(default_options));
-
-  argc=1; argv=argv_buff; argv_buff[0]= (char*) "client";
-  groups[0]= (char*) "client"; groups[1]= (char*) group; groups[2]=0;
-
-  my_load_defaults(filename, groups, &argc, &argv, NULL);
-  if (argc != 1)				/* If some default option */
-  {
-    char **option=argv;
-    while (*++option)
-    {
-      if (my_getopt_is_args_separator(option[0]))          /* skip arguments separator */
-        continue;
-      /* DBUG_PRINT("info",("option: %s",option[0])); */
-      if (option[0][0] == '-' && option[0][1] == '-')
-      {
-	char *end=strcend(*option,'=');
-	char *opt_arg=0;
-	if (*end)
-	{
-	  opt_arg=end+1;
-	  *end=0;				/* Remove '=' */
-	}
-	/* Change all '_' in variable name to '-' */
-	for (end= *option ; *(end= strcend(end,'_')) ; )
-	  *end= '-';
-	switch (find_type(*option + 2, &option_types, FIND_TYPE_BASIC)) {
-	case OPT_port:
-	  if (opt_arg)
-	    options->port=atoi(opt_arg);
-	  break;
-	case OPT_socket:
-	  if (opt_arg)
-	  {
-	    my_free(options->unix_socket);
-	    options->unix_socket=my_strdup(key_memory_mysql_options,
-                                           opt_arg,MYF(MY_WME));
-	  }
-	  break;
-	case OPT_compress:
-	  options->compress=1;
-	  options->client_flag|= CLIENT_COMPRESS;
-	  break;
-        case OPT_password:
-	  if (opt_arg)
-	  {
-	    my_free(options->password);
-	    options->password=my_strdup(key_memory_mysql_options,
-                                        opt_arg,MYF(MY_WME));
-	  }
-	  break;
-        case OPT_pipe:
-          options->protocol = MYSQL_PROTOCOL_PIPE;
-	case OPT_connect_timeout:
-	case OPT_timeout:
-	  if (opt_arg)
-	    options->connect_timeout=atoi(opt_arg);
-	  break;
-	case OPT_user:
-	  if (opt_arg)
-	  {
-	    my_free(options->user);
-	    options->user=my_strdup(key_memory_mysql_options,
-                                    opt_arg,MYF(MY_WME));
-	  }
-	  break;
-	case OPT_init_command:
-	  add_init_command(options,opt_arg);
-	  break;
-	case OPT_host:
-	  if (opt_arg)
-	  {
-	    my_free(options->host);
-	    options->host=my_strdup(key_memory_mysql_options,
-                                    opt_arg,MYF(MY_WME));
-	  }
-	  break;
-	case OPT_database:
-	  if (opt_arg)
-	  {
-	    my_free(options->db);
-	    options->db=my_strdup(key_memory_mysql_options,
-                                  opt_arg,MYF(MY_WME));
-	  }
-	  break;
-	case OPT_debug:
-#ifdef MYSQL_CLIENT
-	  mysql_debug(opt_arg ? opt_arg : "d:t:o,/tmp/client.trace");
-	  break;
-#endif
-	case OPT_return_found_rows:
-	  options->client_flag|=CLIENT_FOUND_ROWS;
-	  break;
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-	case OPT_ssl_key:
-	  my_free(options->ssl_key);
-          options->ssl_key = my_strdup(key_memory_mysql_options,
-                                       opt_arg, MYF(MY_WME));
-          break;
-	case OPT_ssl_cert:
-	  my_free(options->ssl_cert);
-          options->ssl_cert = my_strdup(key_memory_mysql_options,
-                                        opt_arg, MYF(MY_WME));
-          break;
-	case OPT_ssl_ca:
-	  my_free(options->ssl_ca);
-          options->ssl_ca = my_strdup(key_memory_mysql_options,
-                                      opt_arg, MYF(MY_WME));
-          break;
-	case OPT_ssl_capath:
-	  my_free(options->ssl_capath);
-          options->ssl_capath = my_strdup(key_memory_mysql_options,
-                                          opt_arg, MYF(MY_WME));
-          break;
-        case OPT_ssl_cipher:
-          my_free(options->ssl_cipher);
-          options->ssl_cipher= my_strdup(key_memory_mysql_options,
-                                         opt_arg, MYF(MY_WME));
-          break;
-        case OPT_tls_version:
-          EXTENSION_SET_SSL_STRING(options, tls_version, opt_arg, SSL_MODE_PREFERRED);
-          break;
-	case OPT_ssl_crl:
-          EXTENSION_SET_SSL_STRING(options, ssl_crl, opt_arg, SSL_MODE_PREFERRED);
-          break;
-	case OPT_ssl_crlpath:
-          EXTENSION_SET_SSL_STRING(options, ssl_crlpath, opt_arg, SSL_MODE_PREFERRED);
-          break;
-#else
-	case OPT_ssl_key:
-	case OPT_ssl_cert:
-	case OPT_ssl_ca:
-	case OPT_ssl_capath:
-        case OPT_ssl_cipher:
-        case OPT_ssl_crl:
-        case OPT_ssl_crlpath:
-        case OPT_tls_version :
-	  break;
-#endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY */
-	case OPT_character_sets_dir:
-	  my_free(options->charset_dir);
-          options->charset_dir = my_strdup(key_memory_mysql_options,
-                                           opt_arg, MYF(MY_WME));
-	  break;
-	case OPT_default_character_set:
-	  my_free(options->charset_name);
-          options->charset_name = my_strdup(key_memory_mysql_options,
-                                            opt_arg, MYF(MY_WME));
-	  break;
-	case OPT_interactive_timeout:
-	  options->client_flag|= CLIENT_INTERACTIVE;
-	  break;
-	case OPT_local_infile:
-	  if (!opt_arg || atoi(opt_arg) != 0)
-	    options->client_flag|= CLIENT_LOCAL_FILES;
-	  else
-	    options->client_flag&= ~CLIENT_LOCAL_FILES;
-	  break;
-	case OPT_disable_local_infile:
-	  options->client_flag&= ~CLIENT_LOCAL_FILES;
-          break;
-	case OPT_max_allowed_packet:
-          if (opt_arg)
-	    options->max_allowed_packet= atoi(opt_arg);
-	  break;
-        case OPT_protocol:
-          if ((options->protocol= find_type(opt_arg, &sql_protocol_typelib,
-                                            FIND_TYPE_BASIC)) <= 0)
-          {
-            my_message_local(ERROR_LEVEL,
-                             "Unknown option to protocol: %s", opt_arg);
-            exit(1);
-          }
-          break;
-        case OPT_shared_memory_base_name:
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-          if (options->shared_memory_base_name != def_shared_memory_base_name)
-            my_free(options->shared_memory_base_name);
-          options->shared_memory_base_name=my_strdup(key_memory_mysql_options,
-                                                     opt_arg,MYF(MY_WME));
-#endif
-          break;
-	case OPT_multi_results:
-	  options->client_flag|= CLIENT_MULTI_RESULTS;
-	  break;
-	case OPT_multi_statements:
-	case OPT_multi_queries:
-	  options->client_flag|= CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS;
-	  break;
-        case OPT_secure_auth:
-          /* this is a no-op */
-          break;
-        case OPT_report_data_truncation:
-          options->report_data_truncation= opt_arg ? MY_TEST(atoi(opt_arg)) : 1;
-          break;
-        case OPT_plugin_dir:
-          {
-            char buff[FN_REFLEN], buff2[FN_REFLEN];
-            if (strlen(opt_arg) >= FN_REFLEN)
-              opt_arg[FN_REFLEN]= '\0';
-            if (my_realpath(buff, opt_arg, 0))
-            {
-              DBUG_PRINT("warning",("failed to normalize the plugin path: %s",
-                                    opt_arg));
-              break;
-            }
-            convert_dirname(buff2, buff, NULL);
-            EXTENSION_SET_STRING(options, plugin_dir, buff2);
-          }
-          break;
-        case OPT_default_auth:
-          EXTENSION_SET_STRING(options, default_auth, opt_arg);
-          break;
-	case OPT_bind_address:
-          my_free(options->ci.bind_address);
-          options->ci.bind_address= my_strdup(key_memory_mysql_options,
-                                              opt_arg, MYF(MY_WME));
-          break;
-        case OPT_enable_cleartext_plugin:
-          ENSURE_EXTENSIONS_PRESENT(options);
-          options->extension->enable_cleartext_plugin= 
-            (!opt_arg || atoi(opt_arg) != 0) ? TRUE : FALSE;
-          break;
-
-	default:
-	  DBUG_PRINT("warning",("unknown option: %s",option[0]));
-	}
-      }
-    }
-  }
-  free_defaults(argv);
-  DBUG_VOID_RETURN;
-}
-
-
-/**************************************************************************
-  Get column lengths of the current row
-  If one uses mysql_use_result, res->lengths contains the length information,
-  else the lengths are calculated from the offset between pointers.
-**************************************************************************/
-
-static void cli_fetch_lengths(ulong *to, MYSQL_ROW column,
-			      unsigned int field_count)
-{ 
-  ulong *prev_length;
-  char *start=0;
-  MYSQL_ROW end;
-
-  prev_length=0;				/* Keep gcc happy */
-  for (end=column + field_count + 1 ; column != end ; column++, to++)
-  {
-    if (!*column)
-    {
-      *to= 0;					/* Null */
-      continue;
-    }
-    if (start)					/* Found end of prev string */
-      *prev_length= (ulong) (*column-start-1);
-    start= *column;
-    prev_length= to;
-  }
-}
-
-/**
-  Read field metadata from field descriptor and store it in MYSQL_FIELD structure.
-  String values in MYSQL_FIELD are allocated in a given allocator root.
-
-  @param mysql          connection handle
-  @param alloc          memory allocator root
-  @param default_value  flag telling if default values should be read from
-                        descriptor
-  @param server_capabilities  protocol capability flags which determine format of
-                              the descriptor
-  @param row            field descriptor
-  @param field          address of MYSQL_FIELD structure to store metadata in.
-
-  @returns 0 on success.
-*/
-
-int
-unpack_field(MYSQL *mysql, MEM_ROOT *alloc, my_bool default_value,
-             uint server_capabilities, MYSQL_ROWS *row, MYSQL_FIELD *field)
-{
-  ulong lengths[9];                      /* Max length of each field */
-  DBUG_ENTER("unpack_field");
-
-  if (!field)
-  {
-    set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
-    DBUG_RETURN(1);
-  }
-
-  memset(field, 0, sizeof(MYSQL_FIELD));
-
-  if (server_capabilities & CLIENT_PROTOCOL_41)
-  {
-    uchar *pos;
-    /* fields count may be wrong */
-    cli_fetch_lengths(&lengths[0], row->data, default_value ? 8 : 7);
-    field->catalog=   strmake_root(alloc,(char*) row->data[0], lengths[0]);
-    field->db=        strmake_root(alloc,(char*) row->data[1], lengths[1]);
-    field->table=     strmake_root(alloc,(char*) row->data[2], lengths[2]);
-    field->org_table= strmake_root(alloc,(char*) row->data[3], lengths[3]);
-    field->name=      strmake_root(alloc,(char*) row->data[4], lengths[4]);
-    field->org_name=  strmake_root(alloc,(char*) row->data[5], lengths[5]);
-
-    field->catalog_length=	lengths[0];
-    field->db_length=		lengths[1];
-    field->table_length=	lengths[2];
-    field->org_table_length=	lengths[3];
-    field->name_length=	lengths[4];
-    field->org_name_length=	lengths[5];
-
-    /* Unpack fixed length parts */
-    if (lengths[6] != 12)
-    {
-      /* malformed packet. signal an error. */
-      set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
-      DBUG_RETURN(1);
-    }
-
-    pos= (uchar*) row->data[6];
-    field->charsetnr= uint2korr(pos);
-    field->length=	(uint) uint4korr(pos+2);
-    field->type=	(enum enum_field_types) pos[6];
-    field->flags=	uint2korr(pos+7);
-    field->decimals=  (uint) pos[9];
-
-    if (IS_NUM(field->type))
-      field->flags|= NUM_FLAG;
-    if (default_value && row->data[7])
-    {
-      field->def=strmake_root(alloc,(char*) row->data[7], lengths[7]);
-      field->def_length= lengths[7];
-    }
-    else
-      field->def=0;
-    field->max_length= 0;
-  }
-#ifndef DELETE_SUPPORT_OF_4_0_PROTOCOL
-  else
-  {
-    cli_fetch_lengths(&lengths[0], row->data, default_value ? 6 : 5);
-    field->org_table= field->table=  strdup_root(alloc,(char*) row->data[0]);
-    field->name=   strdup_root(alloc,(char*) row->data[1]);
-    field->length= (uint) uint3korr((uchar*) row->data[2]);
-    field->type=   (enum enum_field_types) (uchar) row->data[3][0];
-
-    field->catalog=(char*)  "";
-    field->db=     (char*)  "";
-    field->catalog_length= 0;
-    field->db_length= 0;
-    field->org_table_length=	field->table_length=	lengths[0];
-    field->name_length=	lengths[1];
-
-    if (server_capabilities & CLIENT_LONG_FLAG)
-    {
-      field->flags=   uint2korr((uchar*) row->data[4]);
-      field->decimals=(uint) (uchar) row->data[4][2];
-    }
-    else
-    {
-      field->flags=   (uint) (uchar) row->data[4][0];
-      field->decimals=(uint) (uchar) row->data[4][1];
-    }
-    if (IS_NUM(field->type))
-      field->flags|= NUM_FLAG;
-    if (default_value && row->data[5])
-    {
-      field->def=strdup_root(alloc,(char*) row->data[5]);
-      field->def_length= lengths[5];
-    }
-    else
-      field->def=0;
-    field->max_length= 0;
-  }
-#endif /* DELETE_SUPPORT_OF_4_0_PROTOCOL */
-  DBUG_RETURN(0);
-}
-
-/***************************************************************************
-  Change field rows to field structs
-***************************************************************************/
-
-MYSQL_FIELD *
-unpack_fields(MYSQL *mysql, MYSQL_ROWS *data,MEM_ROOT *alloc,uint fields,
-	      my_bool default_value, uint server_capabilities)
-{
-  MYSQL_ROWS	*row;
-  MYSQL_FIELD	*field,*result;
-  DBUG_ENTER("unpack_fields");
-
-  field= result= (MYSQL_FIELD*) alloc_root(alloc,
-			   (uint) sizeof(*field)*fields);
-  if (!result)
-  {
-    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-  memset(field, 0, sizeof(MYSQL_FIELD)*fields);
-  for (row=data; row ; row = row->next,field++)
-  {
-    /* fields count may be wrong */
-    DBUG_ASSERT((uint) (field - result) < fields);
-    if (unpack_field(mysql, alloc, default_value, server_capabilities,
-                     row, field))
-    {
-      DBUG_RETURN(NULL);
-    }
-  }
-  DBUG_RETURN(result);
-}
-
-
-/**
-  Read metadata resultset from server
-  Memory allocated in a given allocator root.
-
-  @param[IN]    mysql           connection handle
-  @param[IN]    alloc           memory allocator root
-  @param[IN]    field_count     total number of fields
-  @param[IN]    field           number of columns in single field descriptor
-
-  @retval an array of field rows
-
-*/
-MYSQL_FIELD *cli_read_metadata_ex(MYSQL *mysql, MEM_ROOT *alloc,
-                                  ulong field_count, unsigned int field)
-{
-  ulong *len;
-  uint  f;
-  uchar *pos;
-  MYSQL_FIELD *fields, *result;
-  MYSQL_ROWS data;
-  NET *net = &mysql->net;
-
-  DBUG_ENTER("cli_read_metadata");
-
-  len= (ulong*) alloc_root(alloc, sizeof(ulong)*field);
-
-  fields= result= (MYSQL_FIELD*) alloc_root(alloc,
-                          (uint) sizeof(MYSQL_FIELD)*field_count);
-  if (!result)
-  {
-    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-  memset(fields, 0, sizeof(MYSQL_FIELD)*field_count);
-
-  data.data= (MYSQL_ROW) alloc_root(alloc, sizeof(char *)*(field+1));
-  memset(data.data, 0, sizeof(char *)*(field+1));
-
-  /*
-    In this below loop we read each column info as 1 single row
-    and save it in mysql->fields array
-  */
-  for (f=0 ; f < field_count ; ++f)
-  {
-    if(read_one_row(mysql, field, data.data, len) == -1)
-      DBUG_RETURN(NULL);
-    if(unpack_field(mysql, alloc, 0, mysql->server_capabilities, &data,
-                    fields++))
-      DBUG_RETURN(NULL);
-  }
-  /* Read EOF packet in case of old client */
-  if (!(mysql->server_capabilities & CLIENT_DEPRECATE_EOF))
-  {
-    if (packet_error == cli_safe_read(mysql, NULL))
-      DBUG_RETURN(0);
-    pos= net->read_pos;
-    if (*pos == 254)
-    {
-      mysql->warning_count= uint2korr(pos + 1);
-      mysql->server_status= uint2korr(pos + 3);
-    }
-  }
-  DBUG_RETURN(result);
-}
-
-
-/**
-  Read metadata resultset from server
-
-  @param[IN]    mysql           connection handle
-  @param[IN]    field_count     total number of fields
-  @param[IN]    field           number of columns in single field descriptor
-
-  @retval an array of field rows
-
-*/
-MYSQL_FIELD *cli_read_metadata(MYSQL *mysql, ulong field_count,
-                               unsigned int field)
-{
-  return cli_read_metadata_ex(mysql, &mysql->field_alloc, field_count, field);
-}
-
-
-/* Read all rows (data) from server */
-
-MYSQL_DATA *cli_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
-			  unsigned int fields)
-{
-  uint	field;
-  ulong pkt_len;
-  ulong len;
-  uchar *cp;
-  char	*to, *end_to;
-  MYSQL_DATA *result;
-  MYSQL_ROWS **prev_ptr,*cur;
-  NET *net = &mysql->net;
-  my_bool is_data_packet;
-  DBUG_ENTER("cli_read_rows");
-
-  if ((pkt_len= cli_safe_read(mysql, &is_data_packet)) == packet_error)
-    DBUG_RETURN(0);
-  if (!(result=(MYSQL_DATA*) my_malloc(key_memory_MYSQL_DATA,
-                                       sizeof(MYSQL_DATA),
-				       MYF(MY_WME | MY_ZEROFILL))))
-  {
-    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-  init_alloc_root(PSI_NOT_INSTRUMENTED,
-                  &result->alloc, 8192, 0); /* Assume rowlength < 8192 */
-  result->alloc.min_malloc=sizeof(MYSQL_ROWS);
-  prev_ptr= &result->data;
-  result->rows=0;
-  result->fields=fields;
-
-  /*
-    The last EOF packet is either a single 254 character or (in MySQL 4.1)
-    254 followed by 1-7 status bytes or an OK packet starting with 0xFE
-  */
-
-  while (*(cp=net->read_pos) == 0 || is_data_packet)
-  {
-    result->rows++;
-    if (!(cur= (MYSQL_ROWS*) alloc_root(&result->alloc,
-					sizeof(MYSQL_ROWS))) ||
-	!(cur->data= ((MYSQL_ROW)
-		      alloc_root(&result->alloc,
-				 (fields+1)*sizeof(char *)+pkt_len))))
-    {
-      free_rows(result);
-      set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-      DBUG_RETURN(0);
-    }
-    *prev_ptr=cur;
-    prev_ptr= &cur->next;
-    to= (char*) (cur->data+fields+1);
-    end_to=to+pkt_len-1;
-    for (field=0 ; field < fields ; field++)
-    {
-      if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
-      {						/* null field */
-	cur->data[field] = 0;
-      }
-      else
-      {
-	cur->data[field] = to;
-        if (len > (ulong) (end_to - to))
-        {
-          free_rows(result);
-          set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
-          DBUG_RETURN(0);
-        }
-	memcpy(to,(char*) cp,len); to[len]=0;
-	to+=len+1;
-	cp+=len;
-	if (mysql_fields)
-	{
-	  if (mysql_fields[field].max_length < len)
-	    mysql_fields[field].max_length=len;
-	}
-      }
-    }
-    cur->data[field]=to;			/* End of last field */
-    if ((pkt_len= cli_safe_read(mysql, &is_data_packet)) == packet_error)
-    {
-      free_rows(result);
-      DBUG_RETURN(0);
-    }
-  }
-  *prev_ptr=0;					/* last pointer is null */
-  /* read EOF packet or OK packet if it is new client */
-  if (pkt_len > 1)
-  {
-    if (mysql->server_capabilities & CLIENT_DEPRECATE_EOF &&
-        !is_data_packet)
-      read_ok_ex(mysql, pkt_len);
-    else
-    {
-      mysql->warning_count= uint2korr(cp + 1);
-      mysql->server_status= uint2korr(cp + 3);
-    }
-
-    DBUG_PRINT("info",("status: %u  warning_count:  %u",
-                       mysql->server_status, mysql->warning_count));
-  }
-
-#if defined(CLIENT_PROTOCOL_TRACING)
-  if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
-  else
-    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-#endif
-  DBUG_PRINT("exit", ("Got %lu rows", (ulong) result->rows));
-  DBUG_RETURN(result);
-}
-
-/*
-  Read one row. Uses packet buffer as storage for fields.
-  When next packet is read, the previous field values are destroyed
-*/
-
-
-static int
-read_one_row(MYSQL *mysql,uint fields,MYSQL_ROW row, ulong *lengths)
-{
-  uint field;
-  ulong pkt_len,len;
-  my_bool is_data_packet;
-  uchar *pos, *prev_pos, *end_pos;
-  NET *net= &mysql->net;
-
-  if ((pkt_len= cli_safe_read(mysql, &is_data_packet)) == packet_error)
-    return -1;
-  if (net->read_pos[0] != 0x00 && !is_data_packet)
-  {
-    if (pkt_len > 1)				/* MySQL 4.1 protocol */
-    {
-      if (mysql->server_capabilities & CLIENT_DEPRECATE_EOF)
-        read_ok_ex(mysql, pkt_len);
-      else
-      {
-        mysql->warning_count= uint2korr(net->read_pos + 1);
-        mysql->server_status= uint2korr(net->read_pos+3);
-      }
-    }
-#if defined(CLIENT_PROTOCOL_TRACING)
-    if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-      MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
-    else
-      MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-#endif
-    return 1;				/* End of data */
-  }
-  prev_pos= 0;				/* allowed to write at packet[-1] */
-  pos=net->read_pos;
-  end_pos=pos+pkt_len;
-  for (field=0 ; field < fields ; field++)
-  {
-    if ((len=(ulong) net_field_length(&pos)) == NULL_LENGTH)
-    {						/* null field */
-      row[field] = 0;
-      *lengths++=0;
-    }
-    else
-    {
-      if (len > (ulong) (end_pos - pos))
-      {
-        set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
-        return -1;
-      }
-      row[field] = (char*) pos;
-      pos+=len;
-      *lengths++=len;
-    }
-    if (prev_pos)
-      *prev_pos=0;				/* Terminate prev field */
-    prev_pos=pos;
-  }
-  row[field]=(char*) prev_pos+1;		/* End of last field */
-  *prev_pos=0;					/* Terminate last field */
-  return 0;
-}
-
-
-/****************************************************************************
-  Init MySQL structure or allocate one
-****************************************************************************/
-
-
-MYSQL * STDCALL
-mysql_init(MYSQL *mysql)
-{
-  if (mysql_server_init(0, NULL, NULL))
-    return 0;
-  if (!mysql)
-  {
-    if (!(mysql=(MYSQL*) my_malloc(key_memory_MYSQL,
-                                   sizeof(*mysql),MYF(MY_WME | MY_ZEROFILL))))
-    {
-      set_mysql_error(NULL, CR_OUT_OF_MEMORY, unknown_sqlstate);
-      return 0;
-    }
-    mysql->free_me=1;
-  }
-  else
-    memset(mysql, 0, sizeof(*(mysql)));
-  mysql->charset=default_client_charset_info;
-  my_stpcpy(mysql->net.sqlstate, not_error_sqlstate);
-
-  /*
-    Only enable LOAD DATA INFILE by default if configured with option
-    ENABLED_LOCAL_INFILE
-  */
-
-#if defined(ENABLED_LOCAL_INFILE) && !defined(MYSQL_SERVER)
-  mysql->options.client_flag|= CLIENT_LOCAL_FILES;
-#endif
-
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-  mysql->options.shared_memory_base_name= (char*) def_shared_memory_base_name;
-#endif
-
-  mysql->options.methods_to_use= MYSQL_OPT_GUESS_CONNECTION;
-  mysql->options.report_data_truncation= TRUE;  /* default */
-
-  /* Initialize extensions. */
-  if (!(mysql->extension= mysql_extension_init(mysql)))
-  {
-    set_mysql_error(NULL, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    return 0;
-  }
-
-  /*
-    By default we don't reconnect because it could silently corrupt data (after
-    reconnection you potentially lose table locks, user variables, session
-    variables (transactions but they are specifically dealt with in
-    mysql_reconnect()).
-    This is a change: < 5.0.3 mysql->reconnect was set to 1 by default.
-    How this change impacts existing apps:
-    - existing apps which relyed on the default will see a behaviour change;
-    they will have to set reconnect=1 after mysql_real_connect().
-    - existing apps which explicitely asked for reconnection (the only way they
-    could do it was by setting mysql.reconnect to 1 after mysql_real_connect())
-    will not see a behaviour change.
-    - existing apps which explicitely asked for no reconnection
-    (mysql.reconnect=0) will not see a behaviour change.
-  */
-  mysql->reconnect= 0;
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) && !defined(MYSQL_SERVER)
-  ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-  mysql->options.extension->ssl_mode= SSL_MODE_PREFERRED;
-#endif
-
-  return mysql;
-}
-
-
-/*
-  MYSQL::extension handling (see sql_common.h for declaration
-  of st_mysql_extension structure). 
-*/
-
-MYSQL_EXTENSION* mysql_extension_init(MYSQL *mysql MY_ATTRIBUTE((unused)))
-{
-  MYSQL_EXTENSION *ext;
-
-  ext= my_malloc(PSI_NOT_INSTRUMENTED,
-                 sizeof(MYSQL_EXTENSION), MYF(MY_WME | MY_ZEROFILL));
-  return ext;
-}
-
-
-void mysql_extension_free(struct st_mysql_extension* ext)
-{
-  if (!ext)
-    return;
-  if (ext->trace_data)
-    my_free(ext->trace_data);
-
-  // free state change related resources.
-  free_state_change_info(ext);
-
-  my_free(ext);
-}
-
-
-/*
-  Fill in SSL part of MYSQL structure and set 'use_ssl' flag.
-  NB! Errors are not reported until you do mysql_real_connect.
-*/
-
-my_bool STDCALL
-mysql_ssl_set(MYSQL *mysql MY_ATTRIBUTE((unused)) ,
-	      const char *key MY_ATTRIBUTE((unused)),
-	      const char *cert MY_ATTRIBUTE((unused)),
-	      const char *ca MY_ATTRIBUTE((unused)),
-	      const char *capath MY_ATTRIBUTE((unused)),
-	      const char *cipher MY_ATTRIBUTE((unused)))
-{
-  my_bool result= 0;
-  DBUG_ENTER("mysql_ssl_set");
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-  result=
-    mysql_options(mysql, MYSQL_OPT_SSL_KEY,    key)    +
-    mysql_options(mysql, MYSQL_OPT_SSL_CERT,   cert)   +
-    mysql_options(mysql, MYSQL_OPT_SSL_CA,     ca)     +
-    mysql_options(mysql, MYSQL_OPT_SSL_CAPATH, capath) +
-    mysql_options(mysql, MYSQL_OPT_SSL_CIPHER, cipher)
-    ? 1 : 0;
-#endif
-    DBUG_RETURN(result);
-}
-
-
-/*
-  Free strings in the SSL structure and clear 'use_ssl' flag.
-  NB! Errors are not reported until you do mysql_real_connect.
-*/
-
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-
-static void
-mysql_ssl_free(MYSQL *mysql MY_ATTRIBUTE((unused)))
-{
-  struct st_VioSSLFd *ssl_fd= (struct st_VioSSLFd*) mysql->connector_fd;
-  DBUG_ENTER("mysql_ssl_free");
-
-  my_free(mysql->options.ssl_key);
-  my_free(mysql->options.ssl_cert);
-  my_free(mysql->options.ssl_ca);
-  my_free(mysql->options.ssl_capath);
-  my_free(mysql->options.ssl_cipher);
-  if (mysql->options.extension)
-  {
-    my_free(mysql->options.extension->tls_version);
-    my_free(mysql->options.extension->ssl_crl);
-    my_free(mysql->options.extension->ssl_crlpath);
-  }
-  if (ssl_fd)
-    SSL_CTX_free(ssl_fd->ssl_context);
-  my_free(mysql->connector_fd);
-  mysql->options.ssl_key = 0;
-  mysql->options.ssl_cert = 0;
-  mysql->options.ssl_ca = 0;
-  mysql->options.ssl_capath = 0;
-  mysql->options.ssl_cipher= 0;
-  if (mysql->options.extension)
-  {
-    mysql->options.extension->ssl_crl = 0;
-    mysql->options.extension->ssl_crlpath = 0;
-    mysql->options.extension->ssl_ctx_flags= 0;
-    mysql->options.extension->tls_version= 0;
-    mysql->options.extension->ssl_mode= SSL_MODE_DISABLED;
-  }
-  mysql->connector_fd = 0;
-  DBUG_VOID_RETURN;
-}
-
-#endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY */
-
-/*
-  Return the SSL cipher (if any) used for current
-  connection to the server.
-
-  SYNOPSYS
-    mysql_get_ssl_cipher()
-      mysql pointer to the mysql connection
-
-*/
-
-const char * STDCALL
-mysql_get_ssl_cipher(MYSQL *mysql MY_ATTRIBUTE((unused)))
-{
-  DBUG_ENTER("mysql_get_ssl_cipher");
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-  if (mysql->net.vio && mysql->net.vio->ssl_arg)
-    DBUG_RETURN(SSL_get_cipher_name((SSL*)mysql->net.vio->ssl_arg));
-#endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY */
-  DBUG_RETURN(NULL);
-}
-
-
-/*
-  Check the server's (subject) Common Name against the
-  hostname we connected to
-
-  SYNOPSIS
-  ssl_verify_server_cert()
-    vio              pointer to a SSL connected vio
-    server_hostname  name of the server that we connected to
-    errptr           if we fail, we'll return (a pointer to a string
-                     describing) the reason here
-
-  RETURN VALUES
-   0 Success
-   1 Failed to validate server
-
- */
-
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-
-static int ssl_verify_server_cert(Vio *vio, const char* server_hostname, const char **errptr)
-{
-  SSL *ssl;
-  X509 *server_cert= NULL;
-  char *cn= NULL;
-  int cn_loc= -1;
-  ASN1_STRING *cn_asn1= NULL;
-  X509_NAME_ENTRY *cn_entry= NULL;
-  X509_NAME *subject= NULL;
-  int ret_validation= 1;
-
-  DBUG_ENTER("ssl_verify_server_cert");
-  DBUG_PRINT("enter", ("server_hostname: %s", server_hostname));
-
-  if (!(ssl= (SSL*)vio->ssl_arg))
-  {
-    *errptr= "No SSL pointer found";
-    goto error;
-  }
-
-  if (!server_hostname)
-  {
-    *errptr= "No server hostname supplied";
-    goto error;
-  }
-
-  if (!(server_cert= SSL_get_peer_certificate(ssl)))
-  {
-    *errptr= "Could not get server certificate";
-    goto error;
-  }
-
-  if (X509_V_OK != SSL_get_verify_result(ssl))
-  {
-    *errptr= "Failed to verify the server certificate";
-    goto error;
-  }
-  /*
-    We already know that the certificate exchanged was valid; the SSL library
-    handled that. Now we need to verify that the contents of the certificate
-    are what we expect.
-  */
-
-  /*
-   Some notes for future development
-   We should check host name in alternative name first and then if needed check in common name.
-   Currently yssl doesn't support alternative name.
-   openssl 1.0.2 support X509_check_host method for host name validation, we may need to start using
-   X509_check_host in the future.
-  */
-
-  subject= X509_get_subject_name((X509 *) server_cert);
-  // Find the CN location in the subject
-  cn_loc= X509_NAME_get_index_by_NID(subject, NID_commonName, -1);
-  if (cn_loc < 0)
-  {
-    *errptr= "Failed to get CN location in the certificate subject";
-    goto error;
-  }
-
-  // Get the CN entry for given location
-  cn_entry= X509_NAME_get_entry(subject, cn_loc);
-  if (cn_entry == NULL)
-  {
-    *errptr= "Failed to get CN entry using CN location";
-    goto error;
-  }
-
-  // Get CN from common name entry
-  cn_asn1 = X509_NAME_ENTRY_get_data(cn_entry);
-  if (cn_asn1 == NULL)
-  {
-    *errptr= "Failed to get CN from CN entry";
-    goto error;
-  }
-
-  cn= (char *) ASN1_STRING_data(cn_asn1);
-
-  // There should not be any NULL embedded in the CN
-  if ((size_t)ASN1_STRING_length(cn_asn1) != strlen(cn))
-  {
-    *errptr= "NULL embedded in the certificate CN";
-    goto error;
-  }
-
-  DBUG_PRINT("info", ("Server hostname in cert: %s", cn));
-  if (!strcmp(cn, server_hostname))
-  {
-    /* Success */
-    ret_validation= 0;
-  }
-
-  *errptr= "SSL certificate validation failure";
-
-error:
-  if (server_cert != NULL)
-    X509_free (server_cert);
-  DBUG_RETURN(ret_validation);
-}
-
-#endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY */
-
-
-/*
-  Note that the mysql argument must be initialized with mysql_init()
-  before calling mysql_real_connect !
-*/
-
-static my_bool cli_read_query_result(MYSQL *mysql);
-static MYSQL_RES *cli_use_result(MYSQL *mysql);
-
-int cli_read_change_user_result(MYSQL *mysql)
-{
-  return cli_safe_read(mysql, NULL);
-}
-
-static MYSQL_METHODS client_methods=
-{
-  cli_read_query_result,                       /* read_query_result */
-  cli_advanced_command,                        /* advanced_command */
-  cli_read_rows,                               /* read_rows */
-  cli_use_result,                              /* use_result */
-  cli_fetch_lengths,                           /* fetch_lengths */
-  cli_flush_use_result,                        /* flush_use_result */
-  cli_read_change_user_result                  /* read_change_user_result */
-#ifndef MYSQL_SERVER
-  ,cli_list_fields,                            /* list_fields */
-  cli_read_prepare_result,                     /* read_prepare_result */
-  cli_stmt_execute,                            /* stmt_execute */
-  cli_read_binary_rows,                        /* read_binary_rows */
-  cli_unbuffered_fetch,                        /* unbuffered_fetch */
-  NULL,                                        /* free_embedded_thd */
-  cli_read_statistics,                         /* read_statistics */
-  cli_read_query_result,                       /* next_result */
-  cli_read_binary_rows,                        /* read_rows_from_cursor */
-  free_rows
-#endif
-};
-
-
-
-typedef enum my_cs_match_type_enum
-{
-  /* MySQL and OS charsets are fully compatible */
-  my_cs_exact,
-  /* MySQL charset is very close to OS charset  */
-  my_cs_approx,
-  /*
-    MySQL knows this charset, but it is not supported as client character set.
-  */
-  my_cs_unsupp
-} my_cs_match_type;
-
-
-typedef struct str2str_st
-{
-  const char *os_name;
-  const char *my_name;
-  my_cs_match_type param;
-} MY_CSET_OS_NAME;
-
-const MY_CSET_OS_NAME charsets[]=
-{
-#ifdef _WIN32
-  {"cp437",          "cp850",    my_cs_approx},
-  {"cp850",          "cp850",    my_cs_exact},
-  {"cp852",          "cp852",    my_cs_exact},
-  {"cp858",          "cp850",    my_cs_approx},
-  {"cp866",          "cp866",    my_cs_exact},
-  {"cp874",          "tis620",   my_cs_approx},
-  {"cp932",          "cp932",    my_cs_exact},
-  {"cp936",          "gbk",      my_cs_approx},
-  {"cp949",          "euckr",    my_cs_approx},
-  {"cp950",          "big5",     my_cs_exact},
-  {"cp1200",         "utf16le",  my_cs_unsupp},
-  {"cp1201",         "utf16",    my_cs_unsupp},
-  {"cp1250",         "cp1250",   my_cs_exact},
-  {"cp1251",         "cp1251",   my_cs_exact},
-  {"cp1252",         "latin1",   my_cs_exact},
-  {"cp1253",         "greek",    my_cs_exact},
-  {"cp1254",         "latin5",   my_cs_exact},
-  {"cp1255",         "hebrew",   my_cs_approx},
-  {"cp1256",         "cp1256",   my_cs_exact},
-  {"cp1257",         "cp1257",   my_cs_exact},
-  {"cp10000",        "macroman", my_cs_exact},
-  {"cp10001",        "sjis",     my_cs_approx},
-  {"cp10002",        "big5",     my_cs_approx},
-  {"cp10008",        "gb2312",   my_cs_approx},
-  {"cp10021",        "tis620",   my_cs_approx},
-  {"cp10029",        "macce",    my_cs_exact},
-  {"cp12001",        "utf32",    my_cs_unsupp},
-  {"cp20107",        "swe7",     my_cs_exact},
-  {"cp20127",        "latin1",   my_cs_approx},
-  {"cp20866",        "koi8r",    my_cs_exact},
-  {"cp20932",        "ujis",     my_cs_exact},
-  {"cp20936",        "gb2312",   my_cs_approx},
-  {"cp20949",        "euckr",    my_cs_approx},
-  {"cp21866",        "koi8u",    my_cs_exact},
-  {"cp28591",        "latin1",   my_cs_approx},
-  {"cp28592",        "latin2",   my_cs_exact},
-  {"cp28597",        "greek",    my_cs_exact},
-  {"cp28598",        "hebrew",   my_cs_exact},
-  {"cp28599",        "latin5",   my_cs_exact},
-  {"cp28603",        "latin7",   my_cs_exact},
-#ifdef UNCOMMENT_THIS_WHEN_WL_4579_IS_DONE
-  {"cp28605",        "latin9",   my_cs_exact},
-#endif
-  {"cp38598",        "hebrew",   my_cs_exact},
-  {"cp51932",        "ujis",     my_cs_exact},
-  {"cp51936",        "gb2312",   my_cs_exact},
-  {"cp51949",        "euckr",    my_cs_exact},
-  {"cp51950",        "big5",     my_cs_exact},
-  {"cp54936",        "gb18030",  my_cs_exact},
-  {"cp65001",        "utf8",     my_cs_exact},
-
-#else /* not Windows */
-
-  {"646",            "latin1",   my_cs_approx}, /* Default on Solaris */
-  {"ANSI_X3.4-1968", "latin1",   my_cs_approx},
-  {"ansi1251",       "cp1251",   my_cs_exact},
-  {"armscii8",       "armscii8", my_cs_exact},
-  {"armscii-8",      "armscii8", my_cs_exact},
-  {"ASCII",          "latin1",   my_cs_approx},
-  {"Big5",           "big5",     my_cs_exact},
-  {"cp1251",         "cp1251",   my_cs_exact},
-  {"cp1255",         "hebrew",   my_cs_approx},
-  {"CP866",          "cp866",    my_cs_exact},
-  {"eucCN",          "gb2312",   my_cs_exact},
-  {"euc-CN",         "gb2312",   my_cs_exact},
-  {"eucJP",          "ujis",     my_cs_exact},
-  {"euc-JP",         "ujis",     my_cs_exact},
-  {"eucKR",          "euckr",    my_cs_exact},
-  {"euc-KR",         "euckr",    my_cs_exact},
-  {"gb18030",        "gb18030",  my_cs_exact},
-  {"gb2312",         "gb2312",   my_cs_exact},
-  {"gbk",            "gbk",      my_cs_exact},
-  {"georgianps",     "geostd8",  my_cs_exact},
-  {"georgian-ps",    "geostd8",  my_cs_exact},
-  {"IBM-1252",       "cp1252",   my_cs_exact},
-
-  {"iso88591",       "latin1",   my_cs_approx},
-  {"ISO_8859-1",     "latin1",   my_cs_approx},
-  {"ISO8859-1",      "latin1",   my_cs_approx},
-  {"ISO-8859-1",     "latin1",   my_cs_approx},
-
-  {"iso885913",      "latin7",   my_cs_exact},
-  {"ISO_8859-13",    "latin7",   my_cs_exact},
-  {"ISO8859-13",     "latin7",   my_cs_exact},
-  {"ISO-8859-13",    "latin7",   my_cs_exact},
-
-#ifdef UNCOMMENT_THIS_WHEN_WL_4579_IS_DONE
-  {"iso885915",      "latin9",   my_cs_exact},
-  {"ISO_8859-15",    "latin9",   my_cs_exact},
-  {"ISO8859-15",     "latin9",   my_cs_exact},
-  {"ISO-8859-15",    "latin9",   my_cs_exact},
-#endif
-
-  {"iso88592",       "latin2",   my_cs_exact},
-  {"ISO_8859-2",     "latin2",   my_cs_exact},
-  {"ISO8859-2",      "latin2",   my_cs_exact},
-  {"ISO-8859-2",     "latin2",   my_cs_exact},
-
-  {"iso88597",       "greek",    my_cs_exact},
-  {"ISO_8859-7",     "greek",    my_cs_exact},
-  {"ISO8859-7",      "greek",    my_cs_exact},
-  {"ISO-8859-7",     "greek",    my_cs_exact},
-
-  {"iso88598",       "hebrew",   my_cs_exact},
-  {"ISO_8859-8",     "hebrew",   my_cs_exact},
-  {"ISO8859-8",      "hebrew",   my_cs_exact},
-  {"ISO-8859-8",     "hebrew",   my_cs_exact},
-
-  {"iso88599",       "latin5",   my_cs_exact},
-  {"ISO_8859-9",     "latin5",   my_cs_exact},
-  {"ISO8859-9",      "latin5",   my_cs_exact},
-  {"ISO-8859-9",     "latin5",   my_cs_exact},
-
-  {"koi8r",          "koi8r",    my_cs_exact},
-  {"KOI8-R",         "koi8r",    my_cs_exact},
-  {"koi8u",          "koi8u",    my_cs_exact},
-  {"KOI8-U",         "koi8u",    my_cs_exact},
-
-  {"roman8",         "hp8",      my_cs_exact}, /* Default on HP UX */
-
-  {"Shift_JIS",      "sjis",     my_cs_exact},
-  {"SJIS",           "sjis",     my_cs_exact},
-  {"shiftjisx0213",  "sjis",     my_cs_exact},
-  
-  {"tis620",         "tis620",   my_cs_exact},
-  {"tis-620",        "tis620",   my_cs_exact},
-
-  {"ujis",           "ujis",     my_cs_exact},
-
-  {"US-ASCII",       "latin1",   my_cs_approx},
-
-  {"utf8",           "utf8",     my_cs_exact},
-  {"utf-8",          "utf8",     my_cs_exact},
-#endif
-  {NULL,             NULL,       0}
-};
-
-
-static const char *
-my_os_charset_to_mysql_charset(const char *csname)
-{
-  const MY_CSET_OS_NAME *csp;
-  for (csp= charsets; csp->os_name; csp++)
-  {
-    if (!my_strcasecmp(&my_charset_latin1, csp->os_name, csname))
-    {
-      switch (csp->param)
-      {
-      case my_cs_exact:
-        return csp->my_name;
-
-      case my_cs_approx:
-        /*
-          Maybe we should print a warning eventually:
-          character set correspondence is not exact.
-        */
-        return csp->my_name;
-
-      default:
-        my_printf_error(ER_UNKNOWN_ERROR,
-                        "OS character set '%s'"
-                        " is not supported by MySQL client",
-                         MYF(0), csp->my_name);
-        goto def;
-      }
-    }
-  }
-
-  my_printf_error(ER_UNKNOWN_ERROR,
-                  "Unknown OS character set '%s'.",
-                  MYF(0), csname);
-
-def:
-  csname= MYSQL_DEFAULT_CHARSET_NAME;
-  my_printf_error(ER_UNKNOWN_ERROR,
-                  "Switching to the default character set '%s'.",
-                  MYF(0), csname);
-  return csname;
-}
-
-
-#ifndef _WIN32
-#include <stdlib.h> /* for getenv() */
-#ifdef HAVE_LANGINFO_H
-#include <langinfo.h>
-#endif
-#include <locale.h>
-#endif /* _WIN32 */
-
-
-static int
-mysql_autodetect_character_set(MYSQL *mysql)
-{
-  const char *csname= MYSQL_DEFAULT_CHARSET_NAME;
-
-#ifdef _WIN32
-  char cpbuf[64];
-  {
-    my_snprintf(cpbuf, sizeof(cpbuf), "cp%d", (int) GetConsoleCP());
-    csname= my_os_charset_to_mysql_charset(cpbuf);
-  }
-#elif defined(HAVE_NL_LANGINFO)
-  {
-    if (setlocale(LC_CTYPE, "") && (csname= nl_langinfo(CODESET)))
-      csname= my_os_charset_to_mysql_charset(csname);
-  }
-#endif
-
-  if (mysql->options.charset_name)
-    my_free(mysql->options.charset_name);
-  if (!(mysql->options.charset_name= my_strdup(key_memory_mysql_options,
-                                               csname, MYF(MY_WME))))
-    return 1;
-  return 0;
-}
-
-
-static void
-mysql_set_character_set_with_default_collation(MYSQL *mysql)
-{
-  const char *save= charsets_dir;
-  if (mysql->options.charset_dir)
-    charsets_dir=mysql->options.charset_dir;
-
-  if ((mysql->charset= get_charset_by_csname(mysql->options.charset_name,
-                                             MY_CS_PRIMARY, MYF(MY_WME))))
-  {
-    /* Try to set compiled default collation when it's possible. */
-    CHARSET_INFO *collation;
-    if ((collation= 
-         get_charset_by_name(MYSQL_DEFAULT_COLLATION_NAME, MYF(MY_WME))) &&
-                             my_charset_same(mysql->charset, collation))
-    {
-      mysql->charset= collation;
-    }
-    else
-    {
-      /*
-        Default compiled collation not found, or is not applicable
-        to the requested character set.
-        Continue with the default collation of the character set.
-      */
-    }
-  }
-  charsets_dir= save;
-}
-
-
-C_MODE_START
-int mysql_init_character_set(MYSQL *mysql)
-{
-  /* Set character set */
-  if (!mysql->options.charset_name)
-  {
-    if (!(mysql->options.charset_name= 
-       my_strdup(key_memory_mysql_options,
-                 MYSQL_DEFAULT_CHARSET_NAME,MYF(MY_WME))))
-      return 1;
-  }
-  else if (!strcmp(mysql->options.charset_name,
-                   MYSQL_AUTODETECT_CHARSET_NAME) &&
-            mysql_autodetect_character_set(mysql))
-    return 1;
-
-  mysql_set_character_set_with_default_collation(mysql);
-
-  if (!mysql->charset)
-  {
-    if (mysql->options.charset_dir)
-      set_mysql_extended_error(mysql, CR_CANT_READ_CHARSET, unknown_sqlstate,
-                               ER(CR_CANT_READ_CHARSET),
-                               mysql->options.charset_name,
-                               mysql->options.charset_dir);
-    else
-    {
-      char cs_dir_name[FN_REFLEN];
-      get_charsets_dir(cs_dir_name);
-      set_mysql_extended_error(mysql, CR_CANT_READ_CHARSET, unknown_sqlstate,
-                               ER(CR_CANT_READ_CHARSET),
-                               mysql->options.charset_name,
-                               cs_dir_name);
-    }
-    return 1;
-  }
-  return 0;
-}
-C_MODE_END
-
-/*********** client side authentication support **************************/
-
-typedef struct st_mysql_client_plugin_AUTHENTICATION auth_plugin_t;
-static int client_mpvio_write_packet(struct st_plugin_vio*, const uchar*, int);
-static int native_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql);
-static int clear_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql);
-
-static auth_plugin_t native_password_client_plugin=
-{
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN,
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION,
-  native_password_plugin_name,
-  "R.J.Silk, Sergei Golubchik",
-  "Native MySQL authentication",
-  {1, 0, 0},
-  "GPL",
-  NULL,
-  NULL,
-  NULL,
-  NULL,
-  native_password_auth_client
-};
-
-static auth_plugin_t clear_password_client_plugin=
-{
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN,
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION,
-  "mysql_clear_password",
-  "Georgi Kodinov",
-  "Clear password authentication plugin",
-  {0,1,0},
-  "GPL",
-  NULL,
-  NULL,
-  NULL,
-  NULL,
-  clear_password_auth_client
-};
-
-#if defined(HAVE_OPENSSL)
-static auth_plugin_t sha256_password_client_plugin=
-{
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN,
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION,
-  "sha256_password",
-  "Oracle Inc",
-  "SHA256 based authentication with salt",
-  {1, 0, 0},
-  "GPL",
-  NULL,
-  sha256_password_init,
-  sha256_password_deinit,
-  NULL,
-  sha256_password_auth_client
-};
-#endif
-#ifdef AUTHENTICATION_WIN
-extern auth_plugin_t win_auth_client_plugin;
-#endif
-
-/*
-  Test trace plugin can be used only in debug builds. In non-debug ones
-  it is ignored, even if it was enabled by build options (TEST_TRACE_PLUGIN macro).
-*/
-
-#if defined(CLIENT_PROTOCOL_TRACING) \
-    && defined(TEST_TRACE_PLUGIN) \
-    && !defined(DBUG_OFF)
-extern auth_plugin_t test_trace_plugin;
-#endif
-
-struct st_mysql_client_plugin *mysql_client_builtins[]=
-{
-  (struct st_mysql_client_plugin *)&native_password_client_plugin,
-  (struct st_mysql_client_plugin *)&clear_password_client_plugin,
-#if defined(HAVE_OPENSSL)
-  (struct st_mysql_client_plugin *) &sha256_password_client_plugin,
-#endif
-#ifdef AUTHENTICATION_WIN
-  (struct st_mysql_client_plugin *)&win_auth_client_plugin,
-#endif
-#if defined(CLIENT_PROTOCOL_TRACING) \
-    && defined(TEST_TRACE_PLUGIN) \
-    && !defined(DBUG_OFF)
-  (struct st_mysql_client_plugin *)&test_trace_plugin,
-#endif
-  0
-};
-
-
-static uchar *
-write_length_encoded_string3(uchar *buf, char *string, size_t length)
-{
-  buf= net_store_length(buf, length);
-  memcpy(buf, string, length);
-  buf+= length;
-  return buf;
-}
-
-
-uchar *
-send_client_connect_attrs(MYSQL *mysql, uchar *buf)
-{
-  /* check if the server supports connection attributes */
-  if (mysql->server_capabilities & CLIENT_CONNECT_ATTRS)
-  {
-
-    /* Always store the length if the client supports it */
-    buf= net_store_length(buf,
-                          mysql->options.extension ?
-                          mysql->options.extension->connection_attributes_length :
-                          0);
-
-    /* check if we have connection attributes */
-    if (mysql->options.extension &&
-        my_hash_inited(&mysql->options.extension->connection_attributes))
-    {
-      HASH *attrs= &mysql->options.extension->connection_attributes;
-      ulong idx;
-
-      /* loop over and dump the connection attributes */
-      for (idx= 0; idx < attrs->records; idx++)
-      {
-        LEX_STRING *attr= (LEX_STRING *) my_hash_element(attrs, idx);
-        LEX_STRING *key= attr, *value= attr + 1;
-
-        /* we can't have zero length keys */
-        DBUG_ASSERT(key->length);
-
-        buf= write_length_encoded_string3(buf, key->str, key->length);
-        buf= write_length_encoded_string3(buf, value->str, value->length);
-      }
-    }
-  }
-  return buf;
-}
-
-
-static size_t get_length_store_length(size_t length)
-{
-  /* as defined in net_store_length */
-  #define MAX_VARIABLE_STRING_LENGTH 9
-  uchar length_buffer[MAX_VARIABLE_STRING_LENGTH], *ptr;
-
-  ptr= net_store_length(length_buffer, length);
-
-  return ptr - &length_buffer[0];
-}
-
-
-/* this is a "superset" of MYSQL_PLUGIN_VIO, in C++ I use inheritance */
-typedef struct {
-  int (*read_packet)(struct st_plugin_vio *vio, uchar **buf);
-  int (*write_packet)(struct st_plugin_vio *vio, const uchar *pkt, int pkt_len);
-  void (*info)(struct st_plugin_vio *vio, struct st_plugin_vio_info *info);
-  /* -= end of MYSQL_PLUGIN_VIO =- */
-  MYSQL *mysql;
-  auth_plugin_t *plugin;            /**< what plugin we're under */
-  const char *db;
-  struct {
-    uchar *pkt;                     /**< pointer into NET::buff */
-    uint pkt_len;
-  } cached_server_reply;
-  int packets_read, packets_written; /**< counters for send/received packets */
-  int mysql_change_user;            /**< if it's mysql_change_user() */
-  int last_read_packet_len;         /**< the length of the last *read* packet */
-} MCPVIO_EXT;
-
-
-/*
-  Write 1-8 bytes of string length header infromation to dest depending on
-  value of src_len, then copy src_len bytes from src to dest.
- 
- @param dest Destination buffer of size src_len+8
- @param dest_end One byte past the end of the dest buffer
- @param src Source buff of size src_len
- @param src_end One byte past the end of the src buffer
- 
- @return pointer dest+src_len+header size or NULL if 
-*/
-
-char *write_length_encoded_string4(char *dest, char *dest_end, char *src,
-                                  char *src_end)
-{
-  size_t src_len= (size_t)(src_end - src);
-  uchar *to= net_store_length((uchar*) dest, src_len);
-  if ((char*)(to + src_len) >= dest_end)
-    return NULL;
-  memcpy(to, src, src_len);
-  return (char*)(to + src_len);
-}
-
-
-/*
-  Write 1 byte of string length header information to dest and
-  copy src_len bytes from src to dest.
-*/
-char *write_string(char *dest, char *dest_end, char *src, char *src_end)
-{
-  size_t src_len= (size_t)(src_end - src);
-  uchar *to= NULL;
-  if (src_len >= 251)
-    return NULL;
-  *dest=(uchar) src_len;
-  to= (uchar*) dest+1;
-  if ((char*)(to + src_len) >= dest_end)
-    return NULL;
-  memcpy(to, src, src_len);
-  return (char*)(to + src_len);
-}
-/**
-  sends a COM_CHANGE_USER command with a caller provided payload
-
-  Packet format:
-   
-    Bytes       Content
-    -----       ----
-    n           user name - \0-terminated string
-    n           password
-                  3.23 scramble - \0-terminated string (9 bytes)
-                  otherwise - length (1 byte) coded
-    n           database name - \0-terminated string
-    2           character set number (if the server >= 4.1.x)
-    n           client auth plugin name - \0-terminated string,
-                  (if the server supports plugin auth)
-
-  @retval 0 ok
-  @retval 1 error
-*/
-static int send_change_user_packet(MCPVIO_EXT *mpvio,
-                                   const uchar *data, int data_len)
-{
-  MYSQL *mysql= mpvio->mysql;
-  char *buff, *end;
-  int res= 1;
-  size_t connect_attrs_len=
-    (mysql->server_capabilities & CLIENT_CONNECT_ATTRS &&
-     mysql->options.extension) ?
-    mysql->options.extension->connection_attributes_length : 0;
-
-  buff= my_alloca(USERNAME_LENGTH + data_len + 1 + NAME_LEN + 2 + NAME_LEN +
-                  connect_attrs_len + 9 /* for the length of the attrs */);
-
-  end= strmake(buff, mysql->user, USERNAME_LENGTH) + 1;
-
-  if (!data_len)
-    *end++= 0;
-  else
-  {
-    DBUG_ASSERT(data_len <= 255);
-    if (data_len > 255)
-    {
-      set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
-      goto error;
-    }
-    *end++= data_len;
-    memcpy(end, data, data_len);
-    end+= data_len;
-  }
-  end= strmake(end, mpvio->db ? mpvio->db : "", NAME_LEN) + 1;
-
-  if (mysql->server_capabilities & CLIENT_PROTOCOL_41)
-  {
-    int2store((uchar*) end, (ushort) mysql->charset->number);
-    end+= 2;
-  }
-
-  if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
-    end= strmake(end, mpvio->plugin->name, NAME_LEN) + 1;
-
-  end= (char *) send_client_connect_attrs(mysql, (uchar *) end);
-
-  res= simple_command(mysql, COM_CHANGE_USER,
-                      (uchar*)buff, (ulong)(end-buff), 1);
-
-error:
-  return res;
-}
-
-/**
-  Fill in the beginning of the client reply packet.
-
-  Used to fill in the beginning of the client reply packet
-  or the ssl request packet.
-
-  @param       mysql     The mysql handler to operate
-  @param[out]  buff      The buffer to receive the packet
-  @param       buff_size The max size of the buffer. Used in debug only.
-  @return                one past to where the buffer is filled
-
-*/
-static char *
-mysql_fill_packet_header(MYSQL *mysql, char *buff,
-                         size_t buff_size  MY_ATTRIBUTE((unused)))
-{
-  NET *net= &mysql->net;
-  char *end;
-  uchar *buff_p= (uchar*) buff;
-  (void)buff_size; /* avoid warnings */
-
-  if (mysql->client_flag & CLIENT_PROTOCOL_41)
-  {
-    /* 4.1 server and 4.1 client has a 32 byte option flag */
-    DBUG_ASSERT(buff_size >= 32);
-
-    int4store(buff_p, mysql->client_flag);
-    int4store(buff_p + 4, net->max_packet_size);
-    buff[8]= (char) mysql->charset->number;
-    memset(buff + 9, 0, 32 - 9);
-    end= buff + 32;
-  }
-  else
-  {
-    DBUG_ASSERT(buff_size >= 5);
-    DBUG_ASSERT(mysql->client_flag <= UINT_MAX16);
-
-    int2store(buff_p, (uint16) mysql->client_flag);
-    int3store(buff_p + 2, net->max_packet_size);
-    end= buff + 5;
-  }
-  return end;
-}
-
-
-/**
-  Calcualtes client capabilities in effect (mysql->client_flag)
-  
-  Needs to be called immediately after receiving the server handshake packet.
-
-  @param  mysql   the connection context
-  @param  db      The database specified by the client app
-  @param  db      The client flag as specified by the client app
-  */
-
-static void
-cli_calculate_client_flag(MYSQL *mysql, const char *db, ulong client_flag)
-{
-  mysql->client_flag= client_flag;
-  mysql->client_flag|= mysql->options.client_flag;
-  mysql->client_flag|= CLIENT_CAPABILITIES;
-
-  if (mysql->client_flag & CLIENT_MULTI_STATEMENTS)
-    mysql->client_flag|= CLIENT_MULTI_RESULTS;
-
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-  if (mysql->options.extension &&
-      mysql->options.extension->ssl_mode != SSL_MODE_DISABLED)
-    mysql->client_flag |= CLIENT_SSL;
-#endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY*/
-
-  if (db)
-    mysql->client_flag|= CLIENT_CONNECT_WITH_DB;
-  else
-    mysql->client_flag&= ~CLIENT_CONNECT_WITH_DB;
-
-  /* Remove options that server doesn't support */
-  mysql->client_flag= mysql->client_flag &
-    (~(CLIENT_COMPRESS | CLIENT_SSL | CLIENT_PROTOCOL_41)
-    | mysql->server_capabilities);
-
-  if(mysql->options.protocol == MYSQL_PROTOCOL_SOCKET &&
-     mysql->options.extension &&
-     mysql->options.extension->ssl_mode <= SSL_MODE_PREFERRED)
-  {
-    mysql->client_flag&= ~CLIENT_SSL;
-    mysql->options.extension->ssl_mode= SSL_MODE_DISABLED;
-  }
-#ifndef HAVE_COMPRESS
-  mysql->client_flag&= ~CLIENT_COMPRESS;
-#endif
-}
-
-
-/**
-Establishes SSL if requested and supported.
-
-@param  mysql   the connection handle
-@retval 0       success
-@retval 1       failure
-*/
-static int
-cli_establish_ssl(MYSQL *mysql)
-{
-#ifdef HAVE_OPENSSL
-  NET *net= &mysql->net;
-
-  /* Don't fallback on unencrypted connection if SSL required. */
-  if (mysql->options.extension &&
-      mysql->options.extension->ssl_mode >= SSL_MODE_REQUIRED &&
-      !(mysql->server_capabilities & CLIENT_SSL))
-  {
-    set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
-                             ER(CR_SSL_CONNECTION_ERROR),
-                             "SSL is required but the server doesn't "
-                             "support it");
-    goto error;
-  }
-
-  /*
-    If the ssl_mode is VERIFY_CA or VERIFY_IDENTITY, make sure that the
-    connection doesn't succeed without providing the CA certificate.
-  */
-  if (mysql->options.extension &&
-      mysql->options.extension->ssl_mode > SSL_MODE_REQUIRED &&
-      !(mysql->options.ssl_ca || mysql->options.ssl_capath))
-  {
-    set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
-                             ER(CR_SSL_CONNECTION_ERROR),
-                             "CA certificate is required if ssl-mode "
-                             "is VERIFY_CA or VERIFY_IDENTITY");
-    goto error;
-  }
-
-  /*
-    Attempt SSL connection if ssl_mode != SSL_MODE_DISABLED and the
-    server supports SSL. Fallback on unencrypted connection otherwise.
-  */
-  if (mysql->options.extension &&
-      mysql->options.extension->ssl_mode != SSL_MODE_DISABLED &&
-      (mysql->server_capabilities & CLIENT_SSL))
-  {
-    /* Do the SSL layering. */
-    struct st_mysql_options *options= &mysql->options;
-    struct st_VioSSLFd *ssl_fd;
-    enum enum_ssl_init_error ssl_init_error;
-    const char *cert_error;
-    unsigned long ssl_error;
-    char buff[33], *end;
-
-    end= mysql_fill_packet_header(mysql, buff, sizeof(buff));
-
-    /*
-    Send mysql->client_flag, max_packet_size - unencrypted otherwise
-    the server does not know we want to do SSL
-    */
-    MYSQL_TRACE(SEND_SSL_REQUEST, mysql, (end - buff, (const unsigned char*) buff));
-    if (my_net_write(net, (uchar*) buff, (size_t) (end - buff)) || net_flush(net))
-    {
-      set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                               ER(CR_SERVER_LOST_EXTENDED),
-                               "sending connection information to server",
-                               errno);
-      goto error;
-    }
-
-    MYSQL_TRACE_STAGE(mysql, SSL_NEGOTIATION);
-
-    /* Create the VioSSLConnectorFd - init SSL and load certs */
-    if (!(ssl_fd= new_VioSSLConnectorFd(options->ssl_key,
-      options->ssl_cert,
-      options->ssl_ca,
-      options->ssl_capath,
-      options->ssl_cipher,
-      &ssl_init_error,
-      options->extension ?
-      options->extension->ssl_crl : NULL,
-      options->extension ?
-      options->extension->ssl_crlpath : NULL,
-      options->extension ?
-      options->extension->ssl_ctx_flags : 0)))
-    {
-      set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
-                               ER(CR_SSL_CONNECTION_ERROR), sslGetErrString(ssl_init_error));
-      goto error;
-    }
-    mysql->connector_fd= (unsigned char *) ssl_fd;
-
-    /* Connect to the server */
-    DBUG_PRINT("info", ("IO layer change in progress..."));
-    MYSQL_TRACE(SSL_CONNECT, mysql, ());
-    if (sslconnect(ssl_fd, net->vio,
-      (long) (mysql->options.connect_timeout), &ssl_error))
-    {
-      char buf[512];
-      ERR_error_string_n(ssl_error, buf, 512);
-      buf[511]= 0;
-      set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
-                               ER(CR_SSL_CONNECTION_ERROR),
-                               buf);
-      goto error;
-    }
-    DBUG_PRINT("info", ("IO layer change done!"));
-
-    /* Verify server cert */
-    if ((mysql->client_flag & CLIENT_SSL_VERIFY_SERVER_CERT) &&
-        ssl_verify_server_cert(net->vio, mysql->host, &cert_error))
-    {
-      set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
-                               ER(CR_SSL_CONNECTION_ERROR), cert_error);
-      goto error;
-    }
-
-    MYSQL_TRACE(SSL_CONNECTED, mysql, ());
-    MYSQL_TRACE_STAGE(mysql, AUTHENTICATE);
-  }
-
-  return 0;
-
-error:
-  return 1;
-
-#else
-  (void)mysql; /* avoid warning */
-
-#endif /* HAVE_OPENSSL */
-  return 0;
-}
-
-
-#define MAX_CONNECTION_ATTR_STORAGE_LENGTH 65536
-
-/**
-  sends a client authentication packet (second packet in the 3-way handshake)
-
-  Packet format (when the server is 4.0 or earlier):
-
-    Bytes       Content
-    -----       ----
-    2           client capabilities
-    3           max packet size
-    n           user name, \0-terminated
-    9           scramble_323, \0-terminated
-
-  Packet format (when the server is 4.1 or newer):
-
-    Bytes       Content
-    -----       ----
-    4           client capabilities
-    4           max packet size
-    1           charset number
-    23          reserved (always 0)
-    n           user name, \0-terminated
-    n           plugin auth data (e.g. scramble), length encoded
-    n           database name, \0-terminated
-                (if CLIENT_CONNECT_WITH_DB is set in the capabilities)
-    n           client auth plugin name - \0-terminated string,
-                (if CLIENT_PLUGIN_AUTH is set in the capabilities)
-
-  @retval 0 ok
-  @retval 1 error
-*/
-static int send_client_reply_packet(MCPVIO_EXT *mpvio,
-                                    const uchar *data, int data_len)
-{
-  MYSQL *mysql= mpvio->mysql;
-  NET *net= &mysql->net;
-  char *buff, *end;
-  size_t buff_size;
-  size_t connect_attrs_len=
-    (mysql->server_capabilities & CLIENT_CONNECT_ATTRS &&
-     mysql->options.extension) ?
-    mysql->options.extension->connection_attributes_length : 0;
-
-  DBUG_ASSERT(connect_attrs_len < MAX_CONNECTION_ATTR_STORAGE_LENGTH);
-
-
-  /*
-    Fixed size of the packet is 32 bytes. See mysql_fill_packet_header.
-    +9 because data is a length encoded binary where meta data size is max 9.
-  */
-  buff_size= 33 + USERNAME_LENGTH + data_len + 9 + NAME_LEN + NAME_LEN + connect_attrs_len + 9;
-  buff= my_alloca(buff_size);
-
-  /* The client_flags is already calculated. Just fill in the packet header */
-  end= mysql_fill_packet_header(mysql, buff, buff_size);
-
-  DBUG_PRINT("info",("Server version = '%s'  capabilites: %lu  status: %u  client_flag: %lu",
-		     mysql->server_version, mysql->server_capabilities,
-		     mysql->server_status, mysql->client_flag));
-
-  compile_time_assert(MYSQL_USERNAME_LENGTH == USERNAME_LENGTH);
-
-  /* This needs to be changed as it's not useful with big packets */
-  if (mysql->user[0])
-    strmake(end, mysql->user, USERNAME_LENGTH);
-  else
-    read_user_name(end);
-
-  /* We have to handle different version of handshake here */
-  DBUG_PRINT("info",("user: %s",end));
-  end= strend(end) + 1;
-  if (data_len)
-  {
-    /*
-      Since the older versions of server do not have
-      CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA capability,
-      a check is performed on this before sending auth data.
-      If lenenc support is not available, the data is sent
-      in the format of first byte representing the length of
-      the string followed by the actual string.
-      */
-    if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA)
-      end= write_length_encoded_string4(end, (char *) (buff + buff_size),
-                                       (char *) data,
-                                       (char *) (data + data_len));
-    else
-      end= write_string(end, (char *) (buff + buff_size),
-                       (char *) data,
-                       (char *) (data + data_len));
-    if (end == NULL)
-      goto error;
-  }
-  else
-    *end++= 0;
-
-  /* Add database if needed */
-  if (mpvio->db && (mysql->server_capabilities & CLIENT_CONNECT_WITH_DB))
-  {
-    end= strmake(end, mpvio->db, NAME_LEN) + 1;
-    mysql->db= my_strdup(key_memory_MYSQL,
-                         mpvio->db, MYF(MY_WME));
-  }
-
-  if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
-    end= strmake(end, mpvio->plugin->name, NAME_LEN) + 1;
-
-  end= (char *) send_client_connect_attrs(mysql, (uchar *) end);
-
-  /* Write authentication package */
-  MYSQL_TRACE(SEND_AUTH_RESPONSE, mysql, (end-buff, (const unsigned char*)buff));
-  if (my_net_write(net, (uchar*) buff, (size_t) (end-buff)) || net_flush(net))
-  {
-    set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                             ER(CR_SERVER_LOST_EXTENDED),
-                             "sending authentication information",
-                             errno);
-    goto error;
-  }
-  MYSQL_TRACE(PACKET_SENT, mysql, (end-buff));
-  return 0;
-
-error:
-  return 1;
-}
-
-/**
-  vio->read_packet() callback method for client authentication plugins
-
-  This function is called by a client authentication plugin, when it wants
-  to read data from the server.
-*/
-static int client_mpvio_read_packet(struct st_plugin_vio *mpv, uchar **buf)
-{
-  MCPVIO_EXT *mpvio= (MCPVIO_EXT*)mpv;
-  MYSQL *mysql= mpvio->mysql;
-  ulong  pkt_len;
-
-  /* there are cached data left, feed it to a plugin */
-  if (mpvio->cached_server_reply.pkt)
-  {
-    *buf= mpvio->cached_server_reply.pkt;
-    mpvio->cached_server_reply.pkt= 0;
-    mpvio->packets_read++;
-    return mpvio->cached_server_reply.pkt_len;
-  }
-
-  if (mpvio->packets_read == 0)
-  {
-    /*
-      the server handshake packet came from the wrong plugin,
-      or it's mysql_change_user(). Either way, there is no data
-      for a plugin to read. send a dummy packet to the server
-      to initiate a dialog.
-    */
-    if (client_mpvio_write_packet(mpv, 0, 0))
-      return (int)packet_error;
-  }
-
-  /* otherwise read the data */
-  pkt_len= (*mysql->methods->read_change_user_result)(mysql);
-  mpvio->last_read_packet_len= pkt_len;
-  *buf= mysql->net.read_pos;
-
-  /* was it a request to change plugins ? */
-  if (**buf == 254)
-    return (int)packet_error; /* if yes, this plugin shan't continue */
-
-  /*
-    the server sends \1\255 or \1\254 instead of just \255 or \254 -
-    for us to not confuse it with an error or "change plugin" packets.
-    We remove this escaping \1 here.
-
-    See also server_mpvio_write_packet() where the escaping is done.
-  */
-  if (pkt_len && **buf == 1)
-  {
-    (*buf)++;
-    pkt_len--;
-  }
-  mpvio->packets_read++;
-  return pkt_len;
-}
-
-/**
-  vio->write_packet() callback method for client authentication plugins
-
-  This function is called by a client authentication plugin, when it wants
-  to send data to the server.
-
-  It transparently wraps the data into a change user or authentication
-  handshake packet, if neccessary.
-*/
-static int client_mpvio_write_packet(struct st_plugin_vio *mpv,
-                                     const uchar *pkt, int pkt_len)
-{
-  int res;
-  MCPVIO_EXT *mpvio= (MCPVIO_EXT*)mpv;
-
-  if (mpvio->packets_written == 0)
-  {
-    if (mpvio->mysql_change_user)
-      res= send_change_user_packet(mpvio, pkt, pkt_len);
-    else
-      res= send_client_reply_packet(mpvio, pkt, pkt_len);
-  }
-  else
-  {
-    NET *net= &mpvio->mysql->net;
-
-    MYSQL_TRACE(SEND_AUTH_DATA, mpvio->mysql, (pkt_len, pkt));
-
-    if (mpvio->mysql->thd)
-      res= 1; /* no chit-chat in embedded */
-    else
-      res= my_net_write(net, pkt, pkt_len) || net_flush(net);
-
-    if (!res)
-    {
-      MYSQL_TRACE(PACKET_SENT, mpvio->mysql, (pkt_len));
-    }
-    else
-      set_mysql_extended_error(mpvio->mysql, CR_SERVER_LOST, unknown_sqlstate,
-                               ER(CR_SERVER_LOST_EXTENDED),
-                               "sending authentication information",
-                               errno);
-  }
-  mpvio->packets_written++;
-  return res;
-}
-
-/**
-  fills MYSQL_PLUGIN_VIO_INFO structure with the information about the
-  connection
-*/
-void mpvio_info(Vio *vio, MYSQL_PLUGIN_VIO_INFO *info)
-{
-  memset(info, 0, sizeof(*info));
-  switch (vio->type) {
-  case VIO_TYPE_TCPIP:
-    info->protocol= MYSQL_VIO_TCP;
-    info->socket= (int)vio_fd(vio);
-    return;
-  case VIO_TYPE_SOCKET:
-    info->protocol= MYSQL_VIO_SOCKET;
-    info->socket= (int)vio_fd(vio);
-    return;
-  case VIO_TYPE_SSL:
-    {
-      struct sockaddr addr;
-      socklen_t addrlen= sizeof(addr);
-      if (getsockname(vio_fd(vio), &addr, &addrlen))
-        return;
-      info->protocol= addr.sa_family == AF_UNIX ?
-        MYSQL_VIO_SOCKET : MYSQL_VIO_TCP;
-      info->socket= (int)vio_fd(vio);
-      return;
-    }
-#ifdef _WIN32
-  case VIO_TYPE_NAMEDPIPE:
-    info->protocol= MYSQL_VIO_PIPE;
-    info->handle= vio->hPipe;
-    return;
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-  case VIO_TYPE_SHARED_MEMORY:
-    info->protocol= MYSQL_VIO_MEMORY;
-    info->handle= vio->handle_file_map; /* or what ? */
-    return;
-#endif
-#endif
-  default: DBUG_ASSERT(0);
-  }
-}
-
-static void client_mpvio_info(MYSQL_PLUGIN_VIO *vio,
-                              MYSQL_PLUGIN_VIO_INFO *info)
-{
-  MCPVIO_EXT *mpvio= (MCPVIO_EXT*)vio;
-  mpvio_info(mpvio->mysql->net.vio, info);
-}
-
-
-my_bool libmysql_cleartext_plugin_enabled= 0;
-
-static my_bool check_plugin_enabled(MYSQL *mysql, auth_plugin_t *plugin)
-{
-  if (plugin == &clear_password_client_plugin &&
-      (!libmysql_cleartext_plugin_enabled &&
-       (!mysql->options.extension ||
-       !mysql->options.extension->enable_cleartext_plugin)))
-  {
-    set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD,
-                             unknown_sqlstate,
-                             ER(CR_AUTH_PLUGIN_CANNOT_LOAD),
-                             clear_password_client_plugin.name,
-                             "plugin not enabled");
-    return TRUE;
-  }
-  return FALSE;
-}
-
-
-/**
-  Client side of the plugin driver authentication.
-
-  @note this is used by both the mysql_real_connect and mysql_change_user
-
-  @param mysql       mysql
-  @param data        pointer to the plugin auth data (scramble) in the
-                     handshake packet
-  @param data_len    the length of the data
-  @param data_plugin a plugin that data were prepared for
-                     or 0 if it's mysql_change_user()
-  @param db          initial db to use, can be 0
-
-  @retval 0 ok
-  @retval 1 error
-*/
-int run_plugin_auth(MYSQL *mysql, char *data, uint data_len,
-                    const char *data_plugin, const char *db)
-{
-  const char    *auth_plugin_name;
-  auth_plugin_t *auth_plugin;
-  MCPVIO_EXT    mpvio;
-  ulong		pkt_length;
-  int           res;
-
-  DBUG_ENTER ("run_plugin_auth");
-  /* determine the default/initial plugin to use */
-  if (mysql->options.extension && mysql->options.extension->default_auth &&
-      mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
-  {
-    auth_plugin_name= mysql->options.extension->default_auth;
-    if (!(auth_plugin= (auth_plugin_t*) mysql_client_find_plugin(mysql,
-                       auth_plugin_name, MYSQL_CLIENT_AUTHENTICATION_PLUGIN)))
-      DBUG_RETURN (1); /* oops, not found */
-  }
-  else
-  {
-    auth_plugin= &native_password_client_plugin;
-    auth_plugin_name= auth_plugin->name;
-  }
-
-  if (check_plugin_enabled(mysql, auth_plugin))
-    DBUG_RETURN(1);
-
-  DBUG_PRINT ("info", ("using plugin %s", auth_plugin_name));
-
-  mysql->net.last_errno= 0; /* just in case */
-
-  if (data_plugin && strcmp(data_plugin, auth_plugin_name))
-  {
-    /* data was prepared for a different plugin, don't show it to this one */
-    data= 0;
-    data_len= 0;
-  }
-
-  mpvio.mysql_change_user= data_plugin == 0;
-  mpvio.cached_server_reply.pkt= (uchar*)data;
-  mpvio.cached_server_reply.pkt_len= data_len;
-  mpvio.read_packet= client_mpvio_read_packet;
-  mpvio.write_packet= client_mpvio_write_packet;
-  mpvio.info= client_mpvio_info;
-  mpvio.mysql= mysql;
-  mpvio.packets_read= mpvio.packets_written= 0;
-  mpvio.db= db;
-  mpvio.plugin= auth_plugin;
-
-  MYSQL_TRACE(AUTH_PLUGIN, mysql, (auth_plugin->name));
-
-  res= auth_plugin->authenticate_user((struct st_plugin_vio *)&mpvio, mysql);
-  DBUG_PRINT ("info", ("authenticate_user returned %s", 
-                       res == CR_OK ? "CR_OK" : 
-                       res == CR_ERROR ? "CR_ERROR" :
-                       res == CR_OK_HANDSHAKE_COMPLETE ? 
-                         "CR_OK_HANDSHAKE_COMPLETE" : "error"));
-
-  compile_time_assert(CR_OK == -1);
-  compile_time_assert(CR_ERROR == 0);
-
-  /*
-    The connection may be closed. If so: do not try to read from the buffer.
-  */
-  if (res > CR_OK && 
-      (!my_net_is_inited(&mysql->net) || mysql->net.read_pos[0] != 254))
-  {
-    /*
-      the plugin returned an error. write it down in mysql,
-      unless the error code is CR_ERROR and mysql->net.last_errno
-      is already set (the plugin has done it)
-    */
-    DBUG_PRINT ("info", ("res=%d", res));
-    if (res > CR_ERROR)
-      set_mysql_error(mysql, res, unknown_sqlstate);
-    else
-      if (!mysql->net.last_errno)
-        set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
-    DBUG_RETURN (1);
-  }
-
-  /* read the OK packet (or use the cached value in mysql->net.read_pos */
-  if (res == CR_OK)
-    pkt_length= (*mysql->methods->read_change_user_result)(mysql);
-  else /* res == CR_OK_HANDSHAKE_COMPLETE */
-    pkt_length= mpvio.last_read_packet_len;
-
-  DBUG_PRINT ("info", ("OK packet length=%lu", pkt_length));
-  if (pkt_length == packet_error)
-  {
-    if (mysql->net.last_errno == CR_SERVER_LOST)
-      set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                               ER(CR_SERVER_LOST_EXTENDED),
-                               "reading authorization packet",
-                               errno);
-    DBUG_RETURN (1);
-  }
-
-  if (mysql->net.read_pos[0] == 254)
-  {
-    /* The server asked to use a different authentication plugin */
-    if (pkt_length < 2)
-    {
-      set_mysql_error(mysql, CR_MALFORMED_PACKET,
-                      unknown_sqlstate);        /* purecov: inspected */
-      DBUG_RETURN(1);
-    }
-    else
-    { 
-      /* "use different plugin" packet */
-      uint len;
-      auth_plugin_name= (char*)mysql->net.read_pos + 1;
-      len= (uint)strlen(auth_plugin_name); /* safe as my_net_read always appends \0 */
-      mpvio.cached_server_reply.pkt_len= pkt_length - len - 2;
-      mpvio.cached_server_reply.pkt= mysql->net.read_pos + len + 2;
-      DBUG_PRINT ("info", ("change plugin packet from server for plugin %s",
-                           auth_plugin_name));
-    }
-
-    if (!(auth_plugin= (auth_plugin_t *) mysql_client_find_plugin(mysql,
-                         auth_plugin_name, MYSQL_CLIENT_AUTHENTICATION_PLUGIN)))
-      DBUG_RETURN (1);
-
-    if (check_plugin_enabled(mysql, auth_plugin))
-      DBUG_RETURN(1);
-
-    MYSQL_TRACE(AUTH_PLUGIN, mysql, (auth_plugin->name));
-
-    mpvio.plugin= auth_plugin;
-    res= auth_plugin->authenticate_user((struct st_plugin_vio *)&mpvio, mysql);
-
-    DBUG_PRINT ("info", ("second authenticate_user returned %s", 
-                         res == CR_OK ? "CR_OK" : 
-                         res == CR_ERROR ? "CR_ERROR" :
-                         res == CR_OK_HANDSHAKE_COMPLETE ? 
-                         "CR_OK_HANDSHAKE_COMPLETE" : "error"));
-    if (res > CR_OK)
-    {
-      if (res > CR_ERROR)
-        set_mysql_error(mysql, res, unknown_sqlstate);
-      else
-        if (!mysql->net.last_errno)
-          set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
-      DBUG_RETURN (1);
-    }
-
-    if (res != CR_OK_HANDSHAKE_COMPLETE)
-    {
-      /* Read what server thinks about out new auth message report */
-      if (cli_safe_read(mysql, NULL) == packet_error)
-      {
-        if (mysql->net.last_errno == CR_SERVER_LOST)
-          set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                                   ER(CR_SERVER_LOST_EXTENDED),
-                                   "reading final connect information",
-                                   errno);
-        DBUG_RETURN (1);
-      }
-    }
-  }
-  /*
-    net->read_pos[0] should always be 0 here if the server implements
-    the protocol correctly
-  */
-  res= (mysql->net.read_pos[0] != 0);
-
-  MYSQL_TRACE(AUTHENTICATED, mysql, ());
-  DBUG_RETURN(res);
-}
-
-
-/** set some default attributes */
-static int
-set_connect_attributes(MYSQL *mysql, char *buff, size_t buf_len)
-{
-  int rc= 0;
-
-  /*
-    Clean up any values set by the client code. We want these options as
-    consistent as possible
-  */
-  rc+= mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "_client_name");
-  rc+= mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "_os");
-  rc+= mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "_platform");
-  rc+= mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "_pid");
-  rc+= mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "_thread");
-  rc+= mysql_options(mysql, MYSQL_OPT_CONNECT_ATTR_DELETE, "_client_version");
-
-  /*
-   Now let's set up some values
-  */
-  rc+= mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD,
-                     "_client_name", "libmysql");
-  rc+= mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD,
-                      "_client_version", PACKAGE_VERSION);
-  rc+= mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD,
-                      "_os", SYSTEM_TYPE);
-  rc+= mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD,
-                      "_platform", MACHINE_TYPE);
-#ifdef _WIN32
-  my_snprintf(buff, buf_len, "%lu", (ulong) GetCurrentProcessId());
-#else
-  my_snprintf(buff, buf_len, "%lu", (ulong) getpid());
-#endif
-  rc+= mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "_pid", buff);
-
-#ifdef _WIN32
-  my_snprintf(buff, buf_len, "%lu", (ulong) GetCurrentThreadId());
-  rc+= mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "_thread", buff);
-#endif
-
-  return rc > 0 ? 1 : 0;
-}
-
-
-MYSQL * STDCALL 
-CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,const char *host, const char *user,
-		       const char *passwd, const char *db,
-		       uint port, const char *unix_socket,ulong client_flag)
-{
-  char		buff[NAME_LEN+USERNAME_LENGTH+100];
-  int           scramble_data_len, pkt_scramble_len= 0;
-  char          *end,*host_info= 0, *server_version_end, *pkt_end;
-  char          *scramble_data;
-  char          *scramble_buffer= NULL;
-  const char    *scramble_plugin;
-  ulong		pkt_length;
-  NET		*net= &mysql->net;
-  my_bool       scramble_buffer_allocated= FALSE;
-#ifdef _WIN32
-  HANDLE	hPipe=INVALID_HANDLE_VALUE;
-#endif
-#ifdef HAVE_SYS_UN_H
-  struct	sockaddr_un UNIXaddr;
-#endif
-  DBUG_ENTER("mysql_real_connect");
-
-  DBUG_PRINT("enter",("host: %s  db: %s  user: %s (client)",
-		      host ? host : "(Null)",
-		      db ? db : "(Null)",
-		      user ? user : "(Null)"));
-
-  /* Test whether we're already connected */
-  if (net->vio)
-  {
-    set_mysql_error(mysql, CR_ALREADY_CONNECTED, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-
-  if (set_connect_attributes(mysql, buff, sizeof(buff)))
-    DBUG_RETURN(0);
-
-  mysql->methods= &client_methods;
-  net->vio = 0;				/* If something goes wrong */
-  mysql->client_flag=0;			/* For handshake */
-
-  /* use default options */
-  if (mysql->options.my_cnf_file || mysql->options.my_cnf_group)
-  {
-    mysql_read_default_options(&mysql->options,
-			       (mysql->options.my_cnf_file ?
-				mysql->options.my_cnf_file : "my"),
-			       mysql->options.my_cnf_group);
-    my_free(mysql->options.my_cnf_file);
-    my_free(mysql->options.my_cnf_group);
-    mysql->options.my_cnf_file=mysql->options.my_cnf_group=0;
-  }
-
-  /* Some empty-string-tests are done because of ODBC */
-  if (!host || !host[0])
-    host=mysql->options.host;
-  if (!user || !user[0])
-  {
-    user=mysql->options.user;
-    if (!user)
-      user= "";
-  }
-  if (!passwd)
-  {
-    passwd=mysql->options.password;
-#if !defined(MYSQL_SERVER)
-    if (!passwd)
-      passwd=getenv("MYSQL_PWD");		/* get it from environment */
-#endif
-    if (!passwd)
-      passwd= "";
-  }
-  if (!db || !db[0])
-    db=mysql->options.db;
-  if (!port)
-    port=mysql->options.port;
-  if (!unix_socket)
-    unix_socket=mysql->options.unix_socket;
-
-  mysql->server_status=SERVER_STATUS_AUTOCOMMIT;
-  DBUG_PRINT("info", ("Connecting"));
-
-  MYSQL_TRACE_STAGE(mysql, CONNECTING);
-  MYSQL_TRACE(CONNECTING, mysql, ());
-
-  /*
-    Part 0: Grab a socket and connect it to the server
-  */
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-  if ((!mysql->options.protocol ||
-       mysql->options.protocol == MYSQL_PROTOCOL_MEMORY) &&
-      (!host || !strcmp(host,LOCAL_HOST)))
-  {
-    HANDLE handle_map;
-    DBUG_PRINT("info", ("Using shared memory"));
-
-    handle_map= create_shared_memory(mysql, net,
-                                     get_win32_connect_timeout(mysql));
-
-    if (handle_map == INVALID_HANDLE_VALUE)
-    {
-      DBUG_PRINT("error",
-		 ("host: '%s'  socket: '%s'  shared memory: %s  have_tcpip: %d",
-		  host ? host : "<null>",
-		  unix_socket ? unix_socket : "<null>",
-		  (int) mysql->options.shared_memory_base_name,
-		  (int) have_tcpip));
-      if (mysql->options.protocol == MYSQL_PROTOCOL_MEMORY)
-	goto error;
-
-      /*
-        Try also with PIPE or TCP/IP. Clear the error from
-        create_shared_memory().
-      */
-
-      net_clear_error(net);
-    }
-    else
-    {
-      mysql->options.protocol=MYSQL_PROTOCOL_MEMORY;
-      unix_socket = 0;
-      host=mysql->options.shared_memory_base_name;
-      my_snprintf(host_info=buff, sizeof(buff)-1,
-                  ER(CR_SHARED_MEMORY_CONNECTION), host);
-    }
-  }
-#endif /* _WIN32 && !EMBEDDED_LIBRARY */
-#if defined(HAVE_SYS_UN_H)
-  if (!net->vio &&
-      (!mysql->options.protocol ||
-       mysql->options.protocol == MYSQL_PROTOCOL_SOCKET) &&
-      (unix_socket || mysql_unix_port) &&
-      (!host || !strcmp(host,LOCAL_HOST)))
-  {
-    my_socket sock= socket(AF_UNIX, SOCK_STREAM, 0);
-    DBUG_PRINT("info", ("Using socket"));
-    if (sock == SOCKET_ERROR)
-    {
-      set_mysql_extended_error(mysql, CR_SOCKET_CREATE_ERROR,
-                               unknown_sqlstate,
-                               ER(CR_SOCKET_CREATE_ERROR),
-                               socket_errno);
-      goto error;
-    }
-
-    net->vio= vio_new(sock, VIO_TYPE_SOCKET,
-                      VIO_LOCALHOST | VIO_BUFFERED_READ);
-    if (!net->vio)
-    {
-      DBUG_PRINT("error",("Unknow protocol %d ", mysql->options.protocol));
-      set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
-      closesocket(sock);
-      goto error;
-    }
-
-    host= LOCAL_HOST;
-    if (!unix_socket)
-      unix_socket= mysql_unix_port;
-    host_info= (char*) ER(CR_LOCALHOST_CONNECTION);
-    DBUG_PRINT("info", ("Using UNIX sock '%s'", unix_socket));
-
-    memset(&UNIXaddr, 0, sizeof(UNIXaddr));
-    UNIXaddr.sun_family= AF_UNIX;
-    strmake(UNIXaddr.sun_path, unix_socket, sizeof(UNIXaddr.sun_path)-1);
-
-    if (vio_socket_connect(net->vio, (struct sockaddr *) &UNIXaddr,
-                           sizeof(UNIXaddr), get_vio_connect_timeout(mysql)))
-    {
-      DBUG_PRINT("error",("Got error %d on connect to local server",
-			  socket_errno));
-      set_mysql_extended_error(mysql, CR_CONNECTION_ERROR,
-                               unknown_sqlstate,
-                               ER(CR_CONNECTION_ERROR),
-                               unix_socket, socket_errno);
-      vio_delete(net->vio);
-      net->vio= 0;
-      goto error;
-    }
-    mysql->options.protocol=MYSQL_PROTOCOL_SOCKET;
-  }
-#elif defined(_WIN32)
-  if (!net->vio &&
-      (mysql->options.protocol == MYSQL_PROTOCOL_PIPE ||
-       (host && !strcmp(host,LOCAL_HOST_NAMEDPIPE)) ||
-       (! have_tcpip && (unix_socket || !host && is_NT()))))
-  {
-    hPipe= create_named_pipe(mysql, get_win32_connect_timeout(mysql),
-                             &host, &unix_socket);
-
-    if (hPipe == INVALID_HANDLE_VALUE)
-    {
-      DBUG_PRINT("error",
-		 ("host: '%s'  socket: '%s'  have_tcpip: %d",
-		  host ? host : "<null>",
-		  unix_socket ? unix_socket : "<null>",
-		  (int) have_tcpip));
-      if (mysql->options.protocol == MYSQL_PROTOCOL_PIPE ||
-	  (host && !strcmp(host,LOCAL_HOST_NAMEDPIPE)) ||
-	  (unix_socket && !strcmp(unix_socket,MYSQL_NAMEDPIPE)))
-	goto error;
-      /* Try also with TCP/IP */
-    }
-    else
-    {
-      net->vio= vio_new_win32pipe(hPipe);
-      my_snprintf(host_info=buff, sizeof(buff)-1,
-                  ER(CR_NAMEDPIPE_CONNECTION), unix_socket);
-    }
-  }
-#endif
-  DBUG_PRINT("info", ("net->vio: %p  protocol: %d",
-                      net->vio, mysql->options.protocol));
-  if (!net->vio &&
-      (!mysql->options.protocol ||
-       mysql->options.protocol == MYSQL_PROTOCOL_TCP))
-  {
-    struct addrinfo *res_lst, *client_bind_ai_lst= NULL, hints, *t_res;
-    char port_buf[NI_MAXSERV];
-    my_socket sock= SOCKET_ERROR;
-    int gai_errno, saved_error= 0, status= -1, bind_result= 0;
-    uint flags= VIO_BUFFERED_READ;
-
-    unix_socket=0;				/* This is not used */
-
-    if (!port)
-      port= mysql_port;
-
-    if (!host)
-      host= LOCAL_HOST;
-
-    my_snprintf(host_info=buff, sizeof(buff)-1, ER(CR_TCP_CONNECTION), host);
-    DBUG_PRINT("info",("Server name: '%s'.  TCP sock: %d", host, port));
-
-    memset(&hints, 0, sizeof(hints));
-    hints.ai_socktype= SOCK_STREAM;
-    hints.ai_protocol= IPPROTO_TCP;
-    hints.ai_family= AF_UNSPEC;
-
-    DBUG_PRINT("info",("IPV6 getaddrinfo %s", host));
-    my_snprintf(port_buf, NI_MAXSERV, "%d", port);
-    gai_errno= getaddrinfo(host, port_buf, &hints, &res_lst);
-
-    if (gai_errno != 0) 
-    { 
-      /* 
-        For DBUG we are keeping the right message but for client we default to
-        historical error message.
-      */
-      DBUG_PRINT("info",("IPV6 getaddrinfo error %d", gai_errno));
-      set_mysql_extended_error(mysql, CR_UNKNOWN_HOST, unknown_sqlstate,
-                               ER(CR_UNKNOWN_HOST), host, errno);
-
-      goto error;
-    }
-
-    /* Get address info for client bind name if it is provided */
-    if (mysql->options.ci.bind_address)
-    {
-      int bind_gai_errno= 0;
-
-      DBUG_PRINT("info",("Resolving addresses for client bind: '%s'",
-                         mysql->options.ci.bind_address));
-      /* Lookup address info for name */
-      bind_gai_errno= getaddrinfo(mysql->options.ci.bind_address, 0,
-                                  &hints, &client_bind_ai_lst);
-      if (bind_gai_errno)
-      {
-        DBUG_PRINT("info",("client bind getaddrinfo error %d", bind_gai_errno));
-        set_mysql_extended_error(mysql, CR_UNKNOWN_HOST, unknown_sqlstate,
-                                 ER(CR_UNKNOWN_HOST),
-                                 mysql->options.ci.bind_address,
-                                 bind_gai_errno);
-
-        freeaddrinfo(res_lst);
-        goto error;
-      }
-      DBUG_PRINT("info", ("  got address info for client bind name"));
-    }
-
-    /*
-      A hostname might map to multiple IP addresses (IPv4/IPv6). Go over the
-      list of IP addresses until a successful connection can be established.
-      For each IP address, attempt to bind the socket to each client address
-      for the client-side bind hostname until the bind is successful.
-    */
-    DBUG_PRINT("info", ("Try connect on all addresses for host."));
-    for (t_res= res_lst; t_res; t_res= t_res->ai_next)
-    {
-      DBUG_PRINT("info", ("Create socket, family: %d  type: %d  proto: %d",
-                          t_res->ai_family, t_res->ai_socktype,
-                          t_res->ai_protocol));
-
-      sock= socket(t_res->ai_family, t_res->ai_socktype, t_res->ai_protocol);
-      if (sock == SOCKET_ERROR)
-      {
-        DBUG_PRINT("info", ("Socket created was invalid"));
-        /* Try next address if there is one */
-        saved_error= socket_errno;
-        continue;
-      }
-
-      if (client_bind_ai_lst)
-      {
-        struct addrinfo* curr_bind_ai= NULL;
-        DBUG_PRINT("info", ("Attempting to bind socket to bind address(es)"));
-
-        /*
-           We'll attempt to bind to each of the addresses returned, until
-           we find one that works.
-           If none works, we'll try the next destination host address
-           (if any)
-        */
-        curr_bind_ai= client_bind_ai_lst;
-
-        while (curr_bind_ai != NULL)
-        {
-          /* Attempt to bind the socket to the given address */
-          bind_result= bind(sock,
-                            curr_bind_ai->ai_addr,
-                            curr_bind_ai->ai_addrlen);
-          if (!bind_result)
-            break;   /* Success */
-
-          DBUG_PRINT("info", ("bind failed, attempting another bind address"));
-          /* Problem with the bind, move to next address if present */
-          curr_bind_ai= curr_bind_ai->ai_next;
-        }
-
-        if (bind_result)
-        {
-          /*
-            Could not bind to any client-side address with this destination
-             Try the next destination address (if any)
-          */
-          DBUG_PRINT("info", ("All bind attempts with this address failed"));
-          saved_error= socket_errno;
-          closesocket(sock);
-          continue;
-        }
-        DBUG_PRINT("info", ("Successfully bound client side of socket"));
-      }
-
-      /* Create a new Vio object to abstract the socket. */
-      if (!net->vio)
-      {
-        if (!(net->vio= vio_new(sock, VIO_TYPE_TCPIP, flags)))
-        {
-          set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-          closesocket(sock);
-          freeaddrinfo(res_lst);
-          if (client_bind_ai_lst)
-            freeaddrinfo(client_bind_ai_lst);
-          goto error;
-        }
-      }
-      /* Just reinitialize if one is already allocated. */
-      else if (vio_reset(net->vio, VIO_TYPE_TCPIP, sock, NULL, flags))
-      {
-        set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
-        closesocket(sock);
-        freeaddrinfo(res_lst);
-        if (client_bind_ai_lst)
-          freeaddrinfo(client_bind_ai_lst);
-        goto error;
-      }
-
-      DBUG_PRINT("info", ("Connect socket"));
-      status= vio_socket_connect(net->vio, t_res->ai_addr,
-                                 (socklen_t)t_res->ai_addrlen,
-                                 get_vio_connect_timeout(mysql));
-      /*
-        Here we rely on vio_socket_connect() to return success only if
-        the connect attempt was really successful. Otherwise we would
-        stop trying another address, believing we were successful.
-      */
-      if (!status)
-        break;
-
-      /*
-        Save either the socket error status or the error code of
-        the failed vio_connection operation. It is necessary to
-        avoid having it overwritten by later operations.
-      */
-      saved_error= socket_errno;
-
-      DBUG_PRINT("info", ("No success, try next address."));
-    }
-    DBUG_PRINT("info",
-               ("End of connect attempts, sock: %d  status: %d  error: %d",
-                sock, status, saved_error));
-
-    freeaddrinfo(res_lst);
-    if (client_bind_ai_lst)
-      freeaddrinfo(client_bind_ai_lst);
-
-    if (sock == SOCKET_ERROR)
-    {
-      set_mysql_extended_error(mysql, CR_IPSOCK_ERROR, unknown_sqlstate,
-                                ER(CR_IPSOCK_ERROR), saved_error);
-      goto error;
-    }
-
-    if (status)
-    {
-      DBUG_PRINT("error",("Got error %d on connect to '%s'", saved_error, host));
-      set_mysql_extended_error(mysql, CR_CONN_HOST_ERROR, unknown_sqlstate,
-                                ER(CR_CONN_HOST_ERROR), host, saved_error);
-      goto error;
-    }
-  }
-
-  DBUG_PRINT("info", ("net->vio: %p", net->vio));
-  if (!net->vio)
-  {
-    DBUG_PRINT("error",("Unknow protocol %d ",mysql->options.protocol));
-    set_mysql_error(mysql, CR_CONN_UNKNOW_PROTOCOL, unknown_sqlstate);
-    goto error;
-  }
-
-  if (my_net_init(net, net->vio))
-  {
-    vio_delete(net->vio);
-    net->vio = 0;
-    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    goto error;
-  }
-  vio_keepalive(net->vio,TRUE);
-
-  /* If user set read_timeout, let it override the default */
-  if (mysql->options.read_timeout)
-    my_net_set_read_timeout(net, mysql->options.read_timeout);
-
-  /* If user set write_timeout, let it override the default */
-  if (mysql->options.write_timeout)
-    my_net_set_write_timeout(net, mysql->options.write_timeout);
-
-  if (mysql->options.max_allowed_packet)
-    net->max_packet_size= mysql->options.max_allowed_packet;
-
-  MYSQL_TRACE(CONNECTED, mysql, ());
-  MYSQL_TRACE_STAGE(mysql, WAIT_FOR_INIT_PACKET);
-
-  /* Get version info */
-  mysql->protocol_version= PROTOCOL_VERSION;	/* Assume this */
-  if (mysql->options.connect_timeout &&
-      (vio_io_wait(net->vio, VIO_IO_EVENT_READ,
-                   get_vio_connect_timeout(mysql)) < 1))
-  {
-    set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                             ER(CR_SERVER_LOST_EXTENDED),
-                             "waiting for initial communication packet",
-                             socket_errno);
-    goto error;
-  }
-
-  /*
-    Part 1: Connection established, read and parse first packet
-  */
-  DBUG_PRINT("info", ("Read first packet."));
-
-  if ((pkt_length=cli_safe_read(mysql, NULL)) == packet_error)
-  {
-    if (mysql->net.last_errno == CR_SERVER_LOST)
-      set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                               ER(CR_SERVER_LOST_EXTENDED),
-                               "reading initial communication packet",
-                               socket_errno);
-    goto error;
-  }
-  pkt_end= (char*)net->read_pos + pkt_length;
-  /* Check if version of protocol matches current one */
-  mysql->protocol_version= net->read_pos[0];
-  DBUG_DUMP("packet",(uchar*) net->read_pos,10);
-  DBUG_PRINT("info",("mysql protocol version %d, server=%d",
-		     PROTOCOL_VERSION, mysql->protocol_version));
-  if (mysql->protocol_version != PROTOCOL_VERSION)
-  {
-    set_mysql_extended_error(mysql, CR_VERSION_ERROR, unknown_sqlstate,
-                             ER(CR_VERSION_ERROR), mysql->protocol_version,
-                             PROTOCOL_VERSION);
-    goto error;
-  }
-  server_version_end= end= strend((char*) net->read_pos+1);
-  mysql->thread_id=uint4korr((uchar*) end + 1);
-  end+=5;
-  /* 
-    Scramble is split into two parts because old clients do not understand
-    long scrambles; here goes the first part.
-  */
-  scramble_data= end;
-  scramble_data_len= AUTH_PLUGIN_DATA_PART_1_LENGTH + 1;
-  scramble_plugin= NULL;
-  end+= scramble_data_len;
-
-  if (pkt_end >= end + 1)
-    mysql->server_capabilities=uint2korr((uchar*) end);
-  if (pkt_end >= end + 18)
-  {
-    /* New protocol with 16 bytes to describe server characteristics */
-    mysql->server_language=end[2];
-    mysql->server_status=uint2korr((uchar*) end + 3);
-    mysql->server_capabilities|= uint2korr((uchar*) end + 5) << 16;
-    pkt_scramble_len= end[7];
-    if (pkt_scramble_len < 0)
-    {
-      set_mysql_error(mysql, CR_MALFORMED_PACKET,
-                      unknown_sqlstate);        /* purecov: inspected */
-      goto error;
-    }
-  }
-  end+= 18;
-
-  if (mysql_init_character_set(mysql))
-    goto error;
-
-  /* Save connection information */
-  if (!my_multi_malloc(key_memory_MYSQL,
-                       MYF(0),
-		       &mysql->host_info, (uint) strlen(host_info)+1,
-		       &mysql->host,      (uint) strlen(host)+1,
-		       &mysql->unix_socket,unix_socket ?
-		       (uint) strlen(unix_socket)+1 : (uint) 1,
-		       &mysql->server_version,
-		       (uint) (server_version_end - (char*) net->read_pos + 1),
-		       NullS) ||
-      !(mysql->user=my_strdup(key_memory_MYSQL,
-                              user,MYF(0))) ||
-      !(mysql->passwd=my_strdup(key_memory_MYSQL,
-                                passwd,MYF(0))))
-  {
-    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    goto error;
-  }
-  my_stpcpy(mysql->host_info,host_info);
-  my_stpcpy(mysql->host,host);
-  if (unix_socket)
-    my_stpcpy(mysql->unix_socket,unix_socket);
-  else
-    mysql->unix_socket=0;
-  my_stpcpy(mysql->server_version,(char*) net->read_pos+1);
-  mysql->port=port;
-
-  if (pkt_end >= end + SCRAMBLE_LENGTH - AUTH_PLUGIN_DATA_PART_1_LENGTH + 1)
-
-  {
-    /*
-     move the first scramble part - directly in the NET buffer -
-     to get a full continuous scramble. We've read all the header,
-     and can overwrite it now.
-    */
-    memmove(end - AUTH_PLUGIN_DATA_PART_1_LENGTH, scramble_data,
-            AUTH_PLUGIN_DATA_PART_1_LENGTH);
-    scramble_data= end - AUTH_PLUGIN_DATA_PART_1_LENGTH;
-    if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
-    {
-      scramble_data_len= pkt_scramble_len;
-      scramble_plugin= scramble_data + scramble_data_len;
-      if (scramble_data + scramble_data_len > pkt_end)
-        scramble_data_len= (int)(pkt_end - scramble_data);
-    }
-    else
-    {
-      scramble_data_len= (int)(pkt_end - scramble_data);
-      scramble_plugin= native_password_plugin_name;
-    }
-  }
-  else
-  {
-    set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
-    goto error;
-  }
-
-  MYSQL_TRACE(INIT_PACKET_RECEIVED, mysql, (pkt_length, net->read_pos));
-  MYSQL_TRACE_STAGE(mysql, AUTHENTICATE);
-
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-  if ((mysql->options.extension &&
-       mysql->options.extension->ssl_mode <= SSL_MODE_PREFERRED) &&
-      (mysql->options.protocol == MYSQL_PROTOCOL_MEMORY ||
-       mysql->options.protocol == MYSQL_PROTOCOL_PIPE))
-  {
-    mysql->options.extension->ssl_mode= SSL_MODE_DISABLED;
-  }
-#endif
-  /* try and bring up SSL if possible */
-  cli_calculate_client_flag(mysql, db, client_flag);
-
-  /*
-    Allocate separate buffer for scramble data if we are going
-    to attempt TLS connection. This would prevent a possible
-    overwrite through my_net_write.
-  */
-  if (scramble_data_len &&
-      mysql->options.extension &&
-      mysql->options.extension->ssl_mode != SSL_MODE_DISABLED)
-  {
-    if (!(scramble_buffer= (char *) my_malloc(key_memory_MYSQL_HANDSHAKE,
-                                              scramble_data_len, MYF(MY_WME))))
-    {
-      set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-      goto error;
-    }
-    scramble_buffer_allocated= TRUE;
-    memcpy(scramble_buffer, scramble_data, scramble_data_len);
-  }
-  else
-  {
-    scramble_buffer= scramble_data;
-  }
-
-  if (cli_establish_ssl(mysql))
-    goto error;
-
-  /*
-    Part 2: invoke the plugin to send the authentication data to the server
-  */
-
-  if (run_plugin_auth(mysql, scramble_buffer, scramble_data_len,
-                      scramble_plugin, db))
-    goto error;
-
-  if (scramble_buffer_allocated == TRUE)
-  {
-    scramble_buffer_allocated= FALSE;
-    my_free(scramble_buffer);
-  }
-
-  MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-
-  /*
-    Part 3: authenticated, finish the initialization of the connection
-  */
-
-  if (mysql->client_flag & CLIENT_COMPRESS)      /* We will use compression */
-    net->compress=1;
-
-#ifdef CHECK_LICENSE 
-  if (check_license(mysql))
-    goto error;
-#endif
-
-  if (db && !mysql->db && mysql_select_db(mysql, db))
-  {
-    if (mysql->net.last_errno == CR_SERVER_LOST)
-        set_mysql_extended_error(mysql, CR_SERVER_LOST, unknown_sqlstate,
-                                 ER(CR_SERVER_LOST_EXTENDED),
-                                 "Setting intital database",
-                                 errno);
-    goto error;
-  }
-
-  /*
-     Using init_commands is not supported when connecting from within the
-     server.
-  */
-#ifndef MYSQL_SERVER
-  if (mysql->options.init_commands)
-  {
-    DYNAMIC_ARRAY *init_commands= mysql->options.init_commands;
-    char **ptr= (char**)init_commands->buffer;
-    char **end_command= ptr + init_commands->elements;
-
-    my_bool reconnect=mysql->reconnect;
-    mysql->reconnect=0;
-
-    for (; ptr < end_command; ptr++)
-    {
-      int status;
-
-      if (mysql_real_query(mysql,*ptr, (ulong) strlen(*ptr)))
-	goto error;
-
-      do {
-        if (mysql->fields)
-        {
-          MYSQL_RES *res;
-          if (!(res= cli_use_result(mysql)))
-            goto error;
-          mysql_free_result(res);
-        }
-        if ((status= mysql_next_result(mysql)) > 0)
-          goto error;
-      } while (status == 0);
-    }
-    mysql->reconnect=reconnect;
-  }
-#endif
-
-  DBUG_PRINT("exit", ("Mysql handler: 0x%lx", (long) mysql));
-  DBUG_RETURN(mysql);
-
-error:
-  DBUG_PRINT("error",("message: %u/%s (%s)",
-                      net->last_errno,
-                      net->sqlstate,
-                      net->last_error));
-  {
-    /* Free alloced memory */
-    end_server(mysql);
-    mysql_close_free(mysql);
-    if (!(client_flag & CLIENT_REMEMBER_OPTIONS))
-      mysql_close_free_options(mysql);
-    if (scramble_buffer_allocated)
-      my_free(scramble_buffer);
-  }
-  DBUG_RETURN(0);
-}
-
-
-my_bool mysql_reconnect(MYSQL *mysql)
-{
-  MYSQL tmp_mysql;
-  DBUG_ENTER("mysql_reconnect");
-  DBUG_ASSERT(mysql);
-  DBUG_PRINT("enter", ("mysql->reconnect: %d", mysql->reconnect));
-
-  if (!mysql->reconnect ||
-      (mysql->server_status & SERVER_STATUS_IN_TRANS) || !mysql->host_info)
-  {
-    /* Allow reconnect next time */
-    mysql->server_status&= ~SERVER_STATUS_IN_TRANS;
-    set_mysql_error(mysql, CR_SERVER_GONE_ERROR, unknown_sqlstate);
-    DBUG_RETURN(1);
-  }
-  mysql_init(&tmp_mysql);
-  mysql_close_free_options(&tmp_mysql);
-  tmp_mysql.options= mysql->options;
-  tmp_mysql.options.my_cnf_file= tmp_mysql.options.my_cnf_group= 0;
-
-  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))
-  {
-    memset(&tmp_mysql.options, 0, sizeof(tmp_mysql.options));
-    mysql_close(&tmp_mysql);
-    mysql->net.last_errno= tmp_mysql.net.last_errno;
-    my_stpcpy(mysql->net.last_error, tmp_mysql.net.last_error);
-    my_stpcpy(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
-    DBUG_RETURN(1);
-  }
-  if (mysql_set_character_set(&tmp_mysql, mysql->charset->csname))
-  {
-    DBUG_PRINT("error", ("mysql_set_character_set() failed"));
-    memset(&tmp_mysql.options, 0, sizeof(tmp_mysql.options));
-    mysql_close(&tmp_mysql);
-    mysql->net.last_errno= tmp_mysql.net.last_errno;
-    my_stpcpy(mysql->net.last_error, tmp_mysql.net.last_error);
-    my_stpcpy(mysql->net.sqlstate, tmp_mysql.net.sqlstate);
-    DBUG_RETURN(1);
-  }
-
-  DBUG_PRINT("info", ("reconnect succeded"));
-  tmp_mysql.reconnect= 1;
-  tmp_mysql.free_me= mysql->free_me;
-
-  /* Move prepared statements (if any) over to the new mysql object */
-  tmp_mysql.stmts= mysql->stmts;
-  mysql->stmts= 0;
-
-  /* Don't free options as these are now used in tmp_mysql */
-  memset(&mysql->options, 0, sizeof(mysql->options));
-  mysql->free_me=0;
-  mysql_close(mysql);
-  *mysql=tmp_mysql;
-  net_clear(&mysql->net, 1);
-  mysql->affected_rows= ~(my_ulonglong) 0;
-  DBUG_RETURN(0);
-}
-
-
-/**************************************************************************
-  Set current database
-**************************************************************************/
-
-int STDCALL
-mysql_select_db(MYSQL *mysql, const char *db)
-{
-  int error;
-  DBUG_ENTER("mysql_select_db");
-  DBUG_PRINT("enter",("db: '%s'",db));
-
-  if ((error=simple_command(mysql,COM_INIT_DB, (const uchar*) db,
-                            (ulong) strlen(db),0)))
-    DBUG_RETURN(error);
-  my_free(mysql->db);
-  mysql->db=my_strdup(key_memory_MYSQL,
-                      db,MYF(MY_WME));
-  DBUG_RETURN(0);
-}
-
-
-/*************************************************************************
-  Send a QUIT to the server and close the connection
-  If handle is alloced by mysql connect free it.
-*************************************************************************/
-
-void mysql_close_free_options(MYSQL *mysql)
-{
-  DBUG_ENTER("mysql_close_free_options");
-
-  my_free(mysql->options.user);
-  my_free(mysql->options.host);
-  my_free(mysql->options.password);
-  my_free(mysql->options.unix_socket);
-  my_free(mysql->options.db);
-  my_free(mysql->options.my_cnf_file);
-  my_free(mysql->options.my_cnf_group);
-  my_free(mysql->options.charset_dir);
-  my_free(mysql->options.charset_name);
-  my_free(mysql->options.ci.client_ip);
-  /* ci.bind_adress is union with client_ip, already freed above */
-  if (mysql->options.init_commands)
-  {
-    DYNAMIC_ARRAY *init_commands= mysql->options.init_commands;
-    char **ptr= (char**)init_commands->buffer;
-    char **end= ptr + init_commands->elements;
-    for (; ptr<end; ptr++)
-      my_free(*ptr);
-    delete_dynamic(init_commands);
-    my_free(init_commands);
-  }
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-  mysql_ssl_free(mysql);
-#endif /* HAVE_OPENSSL && !EMBEDDED_LIBRARY */
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-  if (mysql->options.shared_memory_base_name != def_shared_memory_base_name)
-    my_free(mysql->options.shared_memory_base_name);
-#endif /* _WIN32 && !EMBEDDED_LIBRARY */
-  if (mysql->options.extension)
-  {
-    my_free(mysql->options.extension->plugin_dir);
-    my_free(mysql->options.extension->default_auth);
-    my_free(mysql->options.extension->server_public_key_path);
-    my_hash_free(&mysql->options.extension->connection_attributes);
-    my_free(mysql->options.extension);
-  }
-  memset(&mysql->options, 0, sizeof(mysql->options));
-  DBUG_VOID_RETURN;
-}
-
-
-/*
-  Free all memory allocated in a MYSQL handle but preserve
-  current options if any.
-*/
-
-void mysql_close_free(MYSQL *mysql)
-{
-  my_free(mysql->host_info);
-  my_free(mysql->user);
-  my_free(mysql->passwd);
-  my_free(mysql->db);
-
-  /* Free extension if any */
-  if (mysql->extension)
-    mysql_extension_free(mysql->extension);
-
-  my_free(mysql->info_buffer);
-  mysql->info_buffer= 0;
-
-  /* Clear pointers for better safety */
-  mysql->host_info= NULL;
-  mysql->user= NULL;
-  mysql->passwd= NULL;
-  mysql->db= NULL;
-  mysql->extension= NULL;
-}
-
-
-/**
-  For use when the connection to the server has been lost (in which case 
-  the server has discarded all information about prepared statements
-  associated with the connection).
-
-  Mark all statements in mysql->stmts by setting stmt->mysql= 0 if the
-  statement has transitioned beyond the MYSQL_STMT_INIT_DONE state, and
-  unlink the statement from the mysql->stmts list.
-
-  The remaining pruned list of statements (if any) is kept in mysql->stmts.
-
-  @param mysql       pointer to the MYSQL object
-
-  @return none
-*/
-static void mysql_prune_stmt_list(MYSQL *mysql)
-{
-  LIST *pruned_list= NULL;
-
-  while(mysql->stmts)
-  {
-    LIST *element= mysql->stmts;
-    MYSQL_STMT *stmt;
-
-    mysql->stmts= list_delete(element, element);
-    stmt= (MYSQL_STMT *) element->data;
-    if (stmt->state != MYSQL_STMT_INIT_DONE)
-    {
-      stmt->mysql= 0;
-      stmt->last_errno= CR_SERVER_LOST;
-      my_stpcpy(stmt->last_error, ER(CR_SERVER_LOST));
-      my_stpcpy(stmt->sqlstate, unknown_sqlstate);
-    }
-    else
-    {
-      pruned_list= list_add(pruned_list, element);
-    }
-  }
-
-  mysql->stmts= pruned_list;
-}
-
-
-/*
-  Clear connection pointer of every statement: this is necessary
-  to give error on attempt to use a prepared statement of closed
-  connection.
-
-  SYNOPSYS
-    mysql_detach_stmt_list()
-      stmt_list  pointer to mysql->stmts
-      func_name  name of calling function
-
-  NOTE
-    There is similar code in mysql_reconnect(), so changes here
-    should also be reflected there.
-*/
-
-void mysql_detach_stmt_list(LIST **stmt_list MY_ATTRIBUTE((unused)),
-                            const char *func_name MY_ATTRIBUTE((unused)))
-{
-#ifdef MYSQL_CLIENT
-  /* Reset connection handle in all prepared statements. */
-  LIST *element= *stmt_list;
-  char buff[MYSQL_ERRMSG_SIZE];
-  DBUG_ENTER("mysql_detach_stmt_list");
-
-  my_snprintf(buff, sizeof(buff)-1, ER(CR_STMT_CLOSED), func_name);
-  for (; element; element= element->next)
-  {
-    MYSQL_STMT *stmt= (MYSQL_STMT *) element->data;
-    set_stmt_error(stmt, CR_STMT_CLOSED, unknown_sqlstate, buff);
-    stmt->mysql= 0;
-    /* No need to call list_delete for statement here */
-  }
-  *stmt_list= 0;
-  DBUG_VOID_RETURN;
-#endif /* MYSQL_CLIENT */
-}
-
-
-void STDCALL mysql_close(MYSQL *mysql)
-{
-  DBUG_ENTER("mysql_close");
-  if (mysql)					/* Some simple safety */
-  {
-    /* If connection is still up, send a QUIT message */
-    if (mysql->net.vio != 0)
-    {
-      free_old_query(mysql);
-      mysql->status=MYSQL_STATUS_READY; /* Force command */
-      simple_command(mysql,COM_QUIT,(uchar*) 0,0,1);
-      mysql->reconnect=0;
-      end_server(mysql);			/* Sets mysql->net.vio= 0 */
-    }
-    mysql_close_free_options(mysql);
-    mysql_close_free(mysql);
-    mysql_detach_stmt_list(&mysql->stmts, "mysql_close");
-#ifndef MYSQL_SERVER
-    if (mysql->thd)
-      (*mysql->methods->free_embedded_thd)(mysql);
-#endif
-    if (mysql->free_me)
-      my_free(mysql);
-  }
-  DBUG_VOID_RETURN;
-}
-
-
-static my_bool cli_read_query_result(MYSQL *mysql)
-{
-  uchar *pos;
-  ulong field_count;
-  ulong length;
-  DBUG_ENTER("cli_read_query_result");
-
-  if ((length = cli_safe_read(mysql, NULL)) == packet_error)
-    DBUG_RETURN(1);
-  free_old_query(mysql);		/* Free old result */
-#ifdef MYSQL_CLIENT			/* Avoid warn of unused labels*/
-get_info:
-#endif
-  pos=(uchar*) mysql->net.read_pos;
-  if ((field_count= net_field_length(&pos)) == 0)
-  {
-    read_ok_ex(mysql, length);
-#if defined(CLIENT_PROTOCOL_TRACING)
-    if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
-      MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
-    else
-      MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
-#endif
-    DBUG_RETURN(0);
-  }
-#ifdef MYSQL_CLIENT
-  if (field_count == NULL_LENGTH)		/* LOAD DATA LOCAL INFILE */
-  {
-    int error;
-
-    MYSQL_TRACE_STAGE(mysql, FILE_REQUEST);
-
-    if (!(mysql->options.client_flag & CLIENT_LOCAL_FILES))
-    {
-      set_mysql_error(mysql, CR_MALFORMED_PACKET, unknown_sqlstate);
-      DBUG_RETURN(1);
-    }   
-
-    error= handle_local_infile(mysql,(char*) pos);
-
-    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
-
-    if ((length= cli_safe_read(mysql, NULL)) == packet_error || error)
-      DBUG_RETURN(1);
-    goto get_info;				/* Get info packet */
-  }
-#endif
-  if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
-    mysql->server_status|= SERVER_STATUS_IN_TRANS;
-
-  MYSQL_TRACE_STAGE(mysql, WAIT_FOR_FIELD_DEF);
-
-  if (!(mysql->fields=cli_read_metadata(mysql, field_count, protocol_41(mysql) ? 7:5)))
-  {
-    free_root(&mysql->field_alloc,MYF(0));
-    DBUG_RETURN(1);
-  }
-  mysql->status= MYSQL_STATUS_GET_RESULT;
-  mysql->field_count= (uint) field_count;
-
-  MYSQL_TRACE_STAGE(mysql, WAIT_FOR_ROW);
-
-  DBUG_PRINT("exit",("ok"));
-  DBUG_RETURN(0);
-}
-
-
-/*
-  Send the query and return so we can do something else.
-  Needs to be followed by mysql_read_query_result() when we want to
-  finish processing it.
-*/
-
-int STDCALL
-mysql_send_query(MYSQL* mysql, const char* query, ulong length)
-{
-  STATE_INFO *info;
-
-  DBUG_ENTER("mysql_send_query");
-
-  if ((info= STATE_DATA(mysql)))
-    free_state_change_info(mysql->extension);
-
-  DBUG_RETURN(simple_command(mysql, COM_QUERY, (uchar*) query, length, 1));
-}
-
-
-int STDCALL
-mysql_real_query(MYSQL *mysql, const char *query, ulong length)
-{
-  int retval;
-  DBUG_ENTER("mysql_real_query");
-  DBUG_PRINT("enter",("handle: %p", mysql));
-  DBUG_PRINT("query",("Query = '%-.*s'", (int) length, query));
-  DBUG_EXECUTE_IF("inject_ER_NET_READ_INTERRUPTED",
-                  {
-                    mysql->net.last_errno= ER_NET_READ_INTERRUPTED;
-                    DBUG_SET("-d,inject_ER_NET_READ_INTERRUPTED");
-                    DBUG_RETURN(1);
-                  });
-
-  if (mysql_send_query(mysql,query,length))
-    DBUG_RETURN(1);
-  retval= (int) (*mysql->methods->read_query_result)(mysql);
-  DBUG_RETURN(retval);
-}
-
-
-/**************************************************************************
-  Alloc result struct for buffered results. All rows are read to buffer.
-  mysql_data_seek may be used.
-**************************************************************************/
-
-MYSQL_RES * STDCALL mysql_store_result(MYSQL *mysql)
-{
-  MYSQL_RES *result;
-  DBUG_ENTER("mysql_store_result");
-
-  if (!mysql->fields)
-    DBUG_RETURN(0);
-  if (mysql->status != MYSQL_STATUS_GET_RESULT)
-  {
-    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-  mysql->status=MYSQL_STATUS_READY;		/* server is ready */
-  if (!(result=(MYSQL_RES*) my_malloc(key_memory_MYSQL_RES,
-                                      (uint) (sizeof(MYSQL_RES)+
-					      sizeof(ulong) *
-					      mysql->field_count),
-				      MYF(MY_WME | MY_ZEROFILL))))
-  {
-    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-  result->methods= mysql->methods;
-  result->eof=1;				/* Marker for buffered */
-  result->lengths=(ulong*) (result+1);
-  if (!(result->data=
-	(*mysql->methods->read_rows)(mysql,mysql->fields,mysql->field_count)))
-  {
-    my_free(result);
-    DBUG_RETURN(0);
-  }
-  mysql->affected_rows= result->row_count= result->data->rows;
-  result->data_cursor=	result->data->data;
-  result->fields=	mysql->fields;
-  result->field_alloc= mysql->field_alloc;
-  result->field_count=	mysql->field_count;
-  /* The rest of result members is zerofilled in my_malloc */
-  mysql->fields=0;				/* fields is now in result */
-  clear_alloc_root(&mysql->field_alloc);
-  /* just in case this was mistakenly called after mysql_stmt_execute() */
-  mysql->unbuffered_fetch_owner= 0;
-  DBUG_RETURN(result);				/* Data fetched */
-}
-
-
-/**************************************************************************
-  Alloc struct for use with unbuffered reads. Data is fetched by domand
-  when calling to mysql_fetch_row.
-  mysql_data_seek is a noop.
-
-  No other queries may be specified with the same MYSQL handle.
-  There shouldn't be much processing per row because mysql server shouldn't
-  have to wait for the client (and will not wait more than 30 sec/packet).
-**************************************************************************/
-
-static MYSQL_RES * cli_use_result(MYSQL *mysql)
-{
-  MYSQL_RES *result;
-  DBUG_ENTER("cli_use_result");
-
-  if (!mysql->fields)
-    DBUG_RETURN(0);
-  if (mysql->status != MYSQL_STATUS_GET_RESULT)
-  {
-    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
-    DBUG_RETURN(0);
-  }
-  if (!(result=(MYSQL_RES*) my_malloc(key_memory_MYSQL_RES,
-                                      sizeof(*result)+
-				      sizeof(ulong)*mysql->field_count,
-				      MYF(MY_WME | MY_ZEROFILL))))
-    DBUG_RETURN(0);
-  result->lengths=(ulong*) (result+1);
-  result->methods= mysql->methods;
-  if (!(result->row=(MYSQL_ROW)
-	my_malloc(key_memory_MYSQL_ROW,
-                  sizeof(result->row[0])*(mysql->field_count+1), MYF(MY_WME))))
-  {					/* Ptrs: to one row */
-    my_free(result);
-    DBUG_RETURN(0);
-  }
-  result->fields=	mysql->fields;
-  result->field_alloc= mysql->field_alloc;
-  result->field_count=	mysql->field_count;
-  result->current_field=0;
-  result->handle=	mysql;
-  result->current_row=	0;
-  mysql->fields=0;			/* fields is now in result */
-  clear_alloc_root(&mysql->field_alloc);
-  mysql->status=MYSQL_STATUS_USE_RESULT;
-  mysql->unbuffered_fetch_owner= &result->unbuffered_fetch_cancelled;
-  DBUG_RETURN(result);			/* Data is read to be fetched */
-}
-
-
-/**************************************************************************
-  Return next row of the query results
-**************************************************************************/
-
-MYSQL_ROW STDCALL
-mysql_fetch_row(MYSQL_RES *res)
-{
-  DBUG_ENTER("mysql_fetch_row");
-  if (!res->data)
-  {						/* Unbufferred fetch */
-    if (!res->eof)
-    {
-      MYSQL *mysql= res->handle;
-      if (mysql->status != MYSQL_STATUS_USE_RESULT)
-      {
-        set_mysql_error(mysql,
-                        res->unbuffered_fetch_cancelled ? 
-                        CR_FETCH_CANCELED : CR_COMMANDS_OUT_OF_SYNC,
-                        unknown_sqlstate);
-      }
-      else if (!(read_one_row(mysql, res->field_count, res->row, res->lengths)))
-      {
-	res->row_count++;
-	DBUG_RETURN(res->current_row=res->row);
-      }
-      DBUG_PRINT("info",("end of data"));
-      res->eof=1;
-      mysql->status=MYSQL_STATUS_READY;
-      /*
-        Reset only if owner points to us: there is a chance that somebody
-        started new query after mysql_stmt_close():
-      */
-      if (mysql->unbuffered_fetch_owner == &res->unbuffered_fetch_cancelled)
-        mysql->unbuffered_fetch_owner= 0;
-      /* Don't clear handle in mysql_free_result */
-      res->handle=0;
-    }
-    DBUG_RETURN((MYSQL_ROW) NULL);
-  }
-  {
-    MYSQL_ROW tmp;
-    if (!res->data_cursor)
-    {
-      DBUG_PRINT("info",("end of data"));
-      DBUG_RETURN(res->current_row=(MYSQL_ROW) NULL);
-    }
-    tmp = res->data_cursor->data;
-    res->data_cursor = res->data_cursor->next;
-    DBUG_RETURN(res->current_row=tmp);
-  }
-}
-
-
-/**************************************************************************
-  Get column lengths of the current row
-  If one uses mysql_use_result, res->lengths contains the length information,
-  else the lengths are calculated from the offset between pointers.
-**************************************************************************/
-
-ulong * STDCALL
-mysql_fetch_lengths(MYSQL_RES *res)
-{
-  MYSQL_ROW column;
-
-  if (!(column=res->current_row))
-    return 0;					/* Something is wrong */
-  if (res->data)
-    (*res->methods->fetch_lengths)(res->lengths, column, res->field_count);
-  return res->lengths;
-}
-
-int STDCALL
-mysql_options(MYSQL *mysql,enum mysql_option option, const void *arg)
-{
-  DBUG_ENTER("mysql_option");
-  DBUG_PRINT("enter",("option: %d",(int) option));
-  switch (option) {
-  case MYSQL_OPT_CONNECT_TIMEOUT:
-    mysql->options.connect_timeout= *(uint*) arg;
-    break;
-  case MYSQL_OPT_READ_TIMEOUT:
-    mysql->options.read_timeout= *(uint*) arg;
-    break;
-  case MYSQL_OPT_WRITE_TIMEOUT:
-    mysql->options.write_timeout= *(uint*) arg;
-    break;
-  case MYSQL_OPT_COMPRESS:
-    mysql->options.compress= 1;			/* Remember for connect */
-    mysql->options.client_flag|= CLIENT_COMPRESS;
-    break;
-  case MYSQL_OPT_NAMED_PIPE:			/* This option is depricated */
-    mysql->options.protocol=MYSQL_PROTOCOL_PIPE; /* Force named pipe */
-    break;
-  case MYSQL_OPT_LOCAL_INFILE:			/* Allow LOAD DATA LOCAL ?*/
-    if (!arg || MY_TEST(*(uint*) arg))
-      mysql->options.client_flag|= CLIENT_LOCAL_FILES;
-    else
-      mysql->options.client_flag&= ~CLIENT_LOCAL_FILES;
-    break;
-  case MYSQL_INIT_COMMAND:
-    add_init_command(&mysql->options,arg);
-    break;
-  case MYSQL_READ_DEFAULT_FILE:
-    my_free(mysql->options.my_cnf_file);
-    mysql->options.my_cnf_file=my_strdup(key_memory_mysql_options,
-                                         arg,MYF(MY_WME));
-    break;
-  case MYSQL_READ_DEFAULT_GROUP:
-    my_free(mysql->options.my_cnf_group);
-    mysql->options.my_cnf_group=my_strdup(key_memory_mysql_options,
-                                          arg,MYF(MY_WME));
-    break;
-  case MYSQL_SET_CHARSET_DIR:
-    my_free(mysql->options.charset_dir);
-    mysql->options.charset_dir=my_strdup(key_memory_mysql_options,
-                                         arg,MYF(MY_WME));
-    break;
-  case MYSQL_SET_CHARSET_NAME:
-    my_free(mysql->options.charset_name);
-    mysql->options.charset_name=my_strdup(key_memory_mysql_options,
-                                          arg,MYF(MY_WME));
-    break;
-  case MYSQL_OPT_PROTOCOL:
-    mysql->options.protocol= *(uint*) arg;
-    break;
-  case MYSQL_SHARED_MEMORY_BASE_NAME:
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-    if (mysql->options.shared_memory_base_name != def_shared_memory_base_name)
-      my_free(mysql->options.shared_memory_base_name);
-    mysql->options.shared_memory_base_name=my_strdup(key_memory_mysql_options,
-                                                     arg,MYF(MY_WME));
-#endif
-    break;
-  case MYSQL_OPT_USE_REMOTE_CONNECTION:
-  case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
-  case MYSQL_OPT_GUESS_CONNECTION:
-    mysql->options.methods_to_use= option;
-    break;
-  case MYSQL_SET_CLIENT_IP:
-    my_free(mysql->options.ci.client_ip);
-    mysql->options.ci.client_ip= my_strdup(key_memory_mysql_options,
-                                           arg, MYF(MY_WME));
-    break;
-  case MYSQL_SECURE_AUTH:
-    if (!*(my_bool *) arg)
-      DBUG_RETURN(1);
-    break;
-  case MYSQL_REPORT_DATA_TRUNCATION:
-    mysql->options.report_data_truncation= MY_TEST(*(my_bool *) arg);
-    break;
-  case MYSQL_OPT_RECONNECT:
-    mysql->reconnect= *(my_bool *) arg;
-    break;
-  case MYSQL_OPT_BIND:
-    my_free(mysql->options.ci.bind_address);
-    mysql->options.ci.bind_address= my_strdup(key_memory_mysql_options,
-                                              arg, MYF(MY_WME));
-    break;
-  case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:
-    if (*(my_bool*) arg)
-      mysql->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
-    else
-      mysql->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
-    break;
-  case MYSQL_PLUGIN_DIR:
-    EXTENSION_SET_STRING(&mysql->options, plugin_dir, arg);
-    break;
-  case MYSQL_DEFAULT_AUTH:
-    EXTENSION_SET_STRING(&mysql->options, default_auth, arg);
-    break;
-  case MYSQL_OPT_SSL_KEY:
-    if (mysql->options.ssl_key)
-      my_free(mysql->options.ssl_key);
-    mysql->options.ssl_key= set_ssl_option_unpack_path(arg);
-    break;
-  case MYSQL_OPT_SSL_CERT:
-    if (mysql->options.ssl_cert)
-      my_free(mysql->options.ssl_cert);
-    mysql->options.ssl_cert= set_ssl_option_unpack_path(arg);
-    break;
-  case MYSQL_OPT_SSL_CA:
-    if (mysql->options.ssl_ca)
-      my_free(mysql->options.ssl_ca);
-    mysql->options.ssl_ca= set_ssl_option_unpack_path(arg);
-    break;
-  case MYSQL_OPT_SSL_CAPATH:
-    if (mysql->options.ssl_capath)
-      my_free(mysql->options.ssl_capath);
-    mysql->options.ssl_capath= set_ssl_option_unpack_path(arg);
-    break;
-  case MYSQL_OPT_SSL_CIPHER:
-    SET_OPTION(ssl_cipher, arg);
-    break;
-  case MYSQL_OPT_SSL_CRL:
-    if (mysql->options.extension)
-      my_free(mysql->options.extension->ssl_crl);
-    else
-      ALLOCATE_EXTENSIONS(&mysql->options);
-    mysql->options.extension->ssl_crl=
-                   set_ssl_option_unpack_path(arg);
-    break;
-  case MYSQL_OPT_SSL_CRLPATH:
-    if (mysql->options.extension)
-      my_free(mysql->options.extension->ssl_crlpath);
-    else
-      ALLOCATE_EXTENSIONS(&mysql->options);
-    mysql->options.extension->ssl_crlpath=
-                   set_ssl_option_unpack_path(arg);
-    break;
-  case MYSQL_OPT_TLS_VERSION:
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-    EXTENSION_SET_STRING(&mysql->options, tls_version, arg);
-    if ((mysql->options.extension->ssl_ctx_flags=
-           process_tls_version(mysql->options.extension->tls_version)) == -1)
-      DBUG_RETURN(1);
-#endif
-    break;
-  case MYSQL_OPT_SSL_ENFORCE:
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-    ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-    mysql->options.extension->ssl_mode= SSL_MODE_REQUIRED;
-#endif
-    break;
-  case MYSQL_OPT_SSL_MODE:
-#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
-    ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-    mysql->options.extension->ssl_mode= *(uint *) arg;
-    if (mysql->options.extension->ssl_mode == SSL_MODE_VERIFY_IDENTITY)
-      mysql->options.client_flag|= CLIENT_SSL_VERIFY_SERVER_CERT;
-    else
-      mysql->options.client_flag&= ~CLIENT_SSL_VERIFY_SERVER_CERT;
-#endif
-    break;
-  case MYSQL_SERVER_PUBLIC_KEY:
-    EXTENSION_SET_STRING(&mysql->options, server_public_key_path, arg);
-    break;
-
-  case MYSQL_OPT_CONNECT_ATTR_RESET:
-    ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-    if (my_hash_inited(&mysql->options.extension->connection_attributes))
-    {
-      my_hash_free(&mysql->options.extension->connection_attributes);
-      mysql->options.extension->connection_attributes_length= 0;
-    }
-    break;
-  case MYSQL_OPT_CONNECT_ATTR_DELETE:
-    ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-    if (my_hash_inited(&mysql->options.extension->connection_attributes))
-    {
-      size_t len;
-      uchar *elt;
-
-      len= arg ? strlen(arg) : 0;
-
-      if (len)
-      {
-        elt= my_hash_search(&mysql->options.extension->connection_attributes,
-                            arg, len);
-        if (elt)
-        {
-          LEX_STRING *attr= (LEX_STRING *) elt;
-          LEX_STRING *key= attr, *value= attr + 1;
-
-          mysql->options.extension->connection_attributes_length-=
-            get_length_store_length(key->length) + key->length +
-            get_length_store_length(value->length) + value->length;
-
-          my_hash_delete(&mysql->options.extension->connection_attributes,
-                         elt);
-
-        }
-      }
-    }
-    break;
-  case MYSQL_ENABLE_CLEARTEXT_PLUGIN:
-    ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-    mysql->options.extension->enable_cleartext_plugin= 
-      (*(my_bool*) arg) ? TRUE : FALSE;
-    break;
-  case MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS:
-    if (*(my_bool*) arg)
-      mysql->options.client_flag|= CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS;
-    else
-      mysql->options.client_flag&= ~CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS;
-    break;
-
-  case MYSQL_OPT_MAX_ALLOWED_PACKET:
-    if (mysql)
-      mysql->options.max_allowed_packet= (*(ulong *) arg);
-    else
-      g_max_allowed_packet= (*(ulong *) arg);
-    break;
-
-  case MYSQL_OPT_NET_BUFFER_LENGTH:
-    g_net_buffer_length= (*(ulong *) arg);
-    break;
-
-  default:
-    DBUG_RETURN(1);
-  }
-  DBUG_RETURN(0);
-}
-
-
-/**
-  Return the current values for the options settable through mysql_options()
-
-  Returns the current values for all of the connection options.
-  Callers should not manipulate the returned data !
-  Data are valid at the time of returning them until the next C API CALL
-  arg should always be a pointer to a variable of the appropriate type.
-  type of variable, based on the parameter:
-
-  uint
-    MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_READ_TIMEOUT, MYSQL_OPT_WRITE_TIMEOUT,
-    MYSQL_OPT_PROTOCOL, MYSQL_OPT_SSL_MODE
-
-  my_bool
-    MYSQL_OPT_COMPRESS, MYSQL_OPT_LOCAL_INFILE, MYSQL_OPT_USE_REMOTE_CONNECTION,
-    MYSQL_OPT_USE_EMBEDDED_CONNECTION, MYSQL_OPT_GUESS_CONNECTION,
-    MYSQL_SECURE_AUTH, MYSQL_REPORT_DATA_TRUNCATION, MYSQL_OPT_RECONNECT,
-    MYSQL_OPT_SSL_VERIFY_SERVER_CERT, MYSQL_OPT_SSL_ENFORCE,
-    MYSQL_ENABLE_CLEARTEXT_PLUGIN, MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS
-
-  const char *
-    MYSQL_READ_DEFAULT_FILE, MYSQL_READ_DEFAULT_GROUP,
-    MYSQL_SET_CHARSET_DIR, MYSQL_SET_CHARSET_NAME, MYSQL_SHARED_MEMORY_BASE_NAME,
-    MYSQL_SET_CLIENT_IP, MYSQL_OPT_BIND, MYSQL_PLUGIN_DIR, MYSQL_DEFAULT_AUTH,
-    MYSQL_OPT_SSL_KEY, MYSQL_OPT_SSL_CERT, MYSQL_OPT_SSL_CA, MYSQL_OPT_SSL_CAPATH,
-    MYSQL_OPT_SSL_CIPHER, MYSQL_OPT_SSL_CRL, MYSQL_OPT_SSL_CRLPATH, MYSQL_OPT_TLS_VERSION,
-    MYSQL_SERVER_PUBLIC_KEY
-
-  <none, error returned>
-    MYSQL_OPT_NAMED_PIPE, MYSQL_OPT_CONNECT_ATTR_RESET,
-    MYSQL_OPT_CONNECT_ATTR_DELETE, MYSQL_INIT_COMMAND
-
-  @param      mysql       The MYSQL connection to operate on
-  @param      option      The option to return the value for
-  @param  out arg         Must be non-null. Receives the current value.
-  @return status
-  @retval 0 SUCCESS
-*/
-
-int STDCALL
-mysql_get_option(MYSQL *mysql, enum mysql_option option, const void *arg)
-{
-  DBUG_ENTER("mysql_option");
-  DBUG_PRINT("enter", ("option: %d", (int)option));
-
-  if (!arg)
-    DBUG_RETURN(1);
-
-  switch (option) {
-  case MYSQL_OPT_CONNECT_TIMEOUT:
-    *((uint *)arg) = mysql->options.connect_timeout;
-    break;
-  case MYSQL_OPT_READ_TIMEOUT:
-    *((uint *)arg)= mysql->options.read_timeout;
-    break;
-  case MYSQL_OPT_WRITE_TIMEOUT:
-    *((uint *)arg)= mysql->options.write_timeout;
-    break;
-  case MYSQL_OPT_COMPRESS:
-    *((my_bool *)arg) = mysql->options.compress ? TRUE : FALSE;
-    break;
-  case MYSQL_OPT_LOCAL_INFILE:			/* Allow LOAD DATA LOCAL ?*/
-    *((uint *)arg)= (mysql->options.client_flag & CLIENT_LOCAL_FILES) ?
-                    TRUE : FALSE;
-    break;
-  case MYSQL_READ_DEFAULT_FILE:
-    *((char **)arg)= mysql->options.my_cnf_file;
-    break;
-  case MYSQL_READ_DEFAULT_GROUP:
-    *((char **)arg)= mysql->options.my_cnf_group;
-    break;
-  case MYSQL_SET_CHARSET_DIR:
-    *((char **)arg)= mysql->options.charset_dir;
-    break;
-  case MYSQL_SET_CHARSET_NAME:
-    *((char **)arg)= mysql->options.charset_name;
-    break;
-  case MYSQL_OPT_PROTOCOL:
-    *((uint *)arg)= mysql->options.protocol;
-    break;
-  case MYSQL_SHARED_MEMORY_BASE_NAME:
-#if defined (_WIN32) && !defined (EMBEDDED_LIBRARY)
-    *((char **)arg)= mysql->options.shared_memory_base_name;
-#else
-    *((const char **)arg)= "";
-#endif
-    break;
-  case MYSQL_OPT_USE_REMOTE_CONNECTION:
-    *((my_bool *)arg)=
-      (mysql->options.methods_to_use == MYSQL_OPT_USE_REMOTE_CONNECTION) ?
-                                        TRUE : FALSE;
-    break;
-  case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
-    *((my_bool *)arg) =
-      (mysql->options.methods_to_use == MYSQL_OPT_USE_EMBEDDED_CONNECTION) ?
-    TRUE : FALSE;
-    break;
-  case MYSQL_OPT_GUESS_CONNECTION:
-    *((my_bool *)arg) =
-      (mysql->options.methods_to_use == MYSQL_OPT_GUESS_CONNECTION) ?
-    TRUE : FALSE;
-    break;
-  case MYSQL_SET_CLIENT_IP:
-    *((char **)arg) = mysql->options.ci.client_ip;
-    break;
-  case MYSQL_SECURE_AUTH:
-    *((my_bool *)arg)= TRUE;
-    break;
-  case MYSQL_REPORT_DATA_TRUNCATION:
-    *((my_bool *)arg)= mysql->options.report_data_truncation;
-    break;
-  case MYSQL_OPT_RECONNECT:
-    *((my_bool *)arg)= mysql->reconnect;
-    break;
-  case MYSQL_OPT_BIND:
-    *((char **)arg)= mysql->options.ci.bind_address;
-    break;
-  case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:               /* Deprecated. */
-    *((my_bool *)arg) = (mysql->options.client_flag &
-                         CLIENT_SSL_VERIFY_SERVER_CERT) ? TRUE : FALSE;
-    break;
-  case MYSQL_OPT_SSL_ENFORCE:                          /* Deprecated. */
-    *((my_bool *) arg)= (mysql->options.extension &&
-                         mysql->options.extension->ssl_mode >= SSL_MODE_REQUIRED) ?
-                        TRUE : FALSE;
-    break;
-  case MYSQL_OPT_SSL_MODE:
-    *((uint *) arg)= mysql->options.extension ?
-                     mysql->options.extension->ssl_mode : 0;
-    break;
-  case MYSQL_PLUGIN_DIR:
-    *((char **)arg)= mysql->options.extension ?
-                     mysql->options.extension->plugin_dir : NULL;
-    break;
-  case MYSQL_DEFAULT_AUTH:
-    *((char **)arg)= mysql->options.extension ?
-                     mysql->options.extension->default_auth : NULL;
-    break;
-  case MYSQL_OPT_SSL_KEY:
-    *((char **)arg)= mysql->options.ssl_key;
-    break;
-  case MYSQL_OPT_SSL_CERT:
-    *((char **)arg)= mysql->options.ssl_cert;
-    break;
-  case MYSQL_OPT_SSL_CA:
-    *((char **)arg)= mysql->options.ssl_ca;
-    break;
-  case MYSQL_OPT_SSL_CAPATH:
-    *((char **)arg)= mysql->options.ssl_capath;
-    break;
-  case MYSQL_OPT_SSL_CIPHER:
-    *((char **)arg)= mysql->options.ssl_cipher;
-    break;
-  case MYSQL_OPT_TLS_VERSION:
-    *((char **)arg)= mysql->options.extension ?
-                     mysql->options.extension->tls_version : NULL;
-    break;
-  case MYSQL_OPT_SSL_CRL:
-    *((char **)arg)= mysql->options.extension ?
-                     mysql->options.extension->ssl_crl : NULL;
-    break;
-  case MYSQL_OPT_SSL_CRLPATH:
-    *((char **)arg)= mysql->options.extension ?
-                     mysql->options.extension->ssl_crlpath : NULL;
-    break;
-  case MYSQL_SERVER_PUBLIC_KEY:
-    *((char **)arg)= mysql->options.extension ?
-                     mysql->options.extension->server_public_key_path : NULL;
-    break;
-  case MYSQL_ENABLE_CLEARTEXT_PLUGIN:
-    *((my_bool *)arg)= (mysql->options.extension &&
-                        mysql->options.extension->enable_cleartext_plugin) ?
-			TRUE : FALSE;
-    break;
-  case MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS:
-    *((my_bool*)arg)= (mysql->options.client_flag &
-                       CLIENT_CAN_HANDLE_EXPIRED_PASSWORDS) ? TRUE : FALSE;
-    break;
-
-  case MYSQL_OPT_MAX_ALLOWED_PACKET:
-    if (mysql)
-      *((ulong*)arg)= mysql->options.max_allowed_packet;
-    else
-      *((ulong*)arg)= g_max_allowed_packet;
-    break;
-
-  case MYSQL_OPT_NET_BUFFER_LENGTH:
-    *((ulong*)arg)= g_net_buffer_length;
-    break;
-
-  case MYSQL_OPT_NAMED_PIPE:			/* This option is depricated */
-  case MYSQL_INIT_COMMAND:                      /* Cumulative */
-  case MYSQL_OPT_CONNECT_ATTR_RESET:            /* Cumulative */
-  case MYSQL_OPT_CONNECT_ATTR_DELETE:           /* Cumulative */
-  default:
-    DBUG_RETURN(1);
-  }
-  DBUG_RETURN(0);
-}
-
-
-/**
-  A function to return the key from a connection attribute
-*/
-uchar *
-get_attr_key(LEX_STRING *part, size_t *length,
-             my_bool not_used MY_ATTRIBUTE((unused)))
-{
-  *length= part[0].length;
-  return (uchar *) part[0].str;
-}
-
-int STDCALL
-mysql_options4(MYSQL *mysql,enum mysql_option option,
-               const void *arg1, const void *arg2)
-{
-  DBUG_ENTER("mysql_option");
-  DBUG_PRINT("enter",("option: %d",(int) option));
-
-  switch (option)
-  {
-  case MYSQL_OPT_CONNECT_ATTR_ADD:
-    {
-      LEX_STRING *elt;
-      char *key, *value;
-      size_t key_len= arg1 ? strlen(arg1) : 0,
-             value_len= arg2 ? strlen(arg2) : 0;
-      size_t attr_storage_length= key_len + value_len;
-
-      /* we can't have a zero length key */
-      if (!key_len)
-      {
-        set_mysql_error(mysql, CR_INVALID_PARAMETER_NO, unknown_sqlstate);
-        DBUG_RETURN(1);
-      }
-
-      /* calculate the total storage length of the attribute */
-      attr_storage_length+= get_length_store_length(key_len);
-      attr_storage_length+= get_length_store_length(value_len);
-
-      ENSURE_EXTENSIONS_PRESENT(&mysql->options);
-
-      /*
-        Throw and error if the maximum combined length of the attribute value
-        will be greater than the maximum that we can safely transmit.
-      */
-      if (attr_storage_length +
-          mysql->options.extension->connection_attributes_length >
-          MAX_CONNECTION_ATTR_STORAGE_LENGTH)
-      {
-        set_mysql_error(mysql, CR_INVALID_PARAMETER_NO, unknown_sqlstate);
-        DBUG_RETURN(1);
-      }
-
-      if (!my_hash_inited(&mysql->options.extension->connection_attributes))
-      {
-        if (my_hash_init(&mysql->options.extension->connection_attributes,
-                     &my_charset_bin, 0, 0, 0, (my_hash_get_key) get_attr_key,
-                     my_free, HASH_UNIQUE,
-                     key_memory_mysql_options))
-        {
-          set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-          DBUG_RETURN(1);
-        }
-      }
-      if (!my_multi_malloc(key_memory_mysql_options,
-                           MY_WME,
-                           &elt, 2 * sizeof(LEX_STRING),
-                           &key, key_len + 1,
-                           &value, value_len + 1,
-                           NULL))
-      {
-        set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
-        DBUG_RETURN(1);
-      }
-      elt[0].str= key; elt[0].length= key_len;
-      elt[1].str= value; elt[1].length= value_len;
-      if (key_len)
-        memcpy(key, arg1, key_len);
-      key[key_len]= 0;
-      if (value_len)
-        memcpy(value, arg2, value_len);
-      value[value_len]= 0;
-      if (my_hash_insert(&mysql->options.extension->connection_attributes,
-                     (uchar *) elt))
-      {
-        /* can't insert the value */
-        my_free(elt);
-        set_mysql_error(mysql, CR_DUPLICATE_CONNECTION_ATTR,
-                        unknown_sqlstate);
-        DBUG_RETURN(1);
-      }
-
-      mysql->options.extension->connection_attributes_length+=
-        attr_storage_length;
-
-      break;
-    }
-
-  default:
-    DBUG_RETURN(1);
-  }
-  DBUG_RETURN(0);
-}
-
-
-/****************************************************************************
-  Functions to get information from the MySQL structure
-  These are functions to make shared libraries more usable.
-****************************************************************************/
-
-/* MYSQL_RES */
-my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res)
-{
-  return res->row_count;
-}
-
-unsigned int STDCALL mysql_num_fields(MYSQL_RES *res)
-{
-  return res->field_count;
-}
-
-uint STDCALL mysql_errno(MYSQL *mysql)
-{
-  return mysql ? mysql->net.last_errno : mysql_server_last_errno;
-}
-
-
-const char * STDCALL mysql_error(MYSQL *mysql)
-{
-  return mysql ? mysql->net.last_error : mysql_server_last_error;
-}
-
-
-/**
-  Read data and its length from a LIST node.
-
-  Assumes LIST which stores data blobs in LEX_STRING structures,
-  where LEX_STRING::str is pointer to the data and LEX_STRING::length
-  is the length of this data.
-
-  If node is NULL then data and length are set to NULL and 0, respectively,
-  and function returns 0, otherwise, if data has been read from the node,
-  function returns 1.
-*/
-
-static int get_data_and_length(LIST *node, const char **data, size_t *length)
-{
-  DBUG_ASSERT(!node || node->data);
-  if (data)
-    *data= node ? ((LEX_STRING*)(node->data))->str : NULL;
-  if (length)
-    *length= node ? ((LEX_STRING*)(node->data))->length : 0;
-
-  return node ? 0 : 1;
-}
-
-
-/**
-  Get the first state change information received from the server.
-
-  @param mysql  [IN]        mysql handle
-  @param type   [IN]        state change type
-  @param data   [OUT]       buffer to store the data
-  @param length [OUT]       length of the data
-
-  @return
-    0 - Valid data stored
-    1 - No data
-*/
-
-int STDCALL mysql_session_track_get_first(MYSQL *mysql,
-                                          enum enum_session_state_type type,
-                                          const char **data,
-                                          size_t *length)
-{
-  STATE_INFO *info= STATE_DATA(mysql);
-
-  if (!info || !IS_SESSION_STATE_TYPE(type)
-            || !(info->info_list[type].head_node))
-    return get_data_and_length(NULL, data, length);
-
-  info->info_list[type].current_node= info->info_list[type].head_node;
-
-  return mysql_session_track_get_next(mysql, type, data, length);
-}
-
-
-/**
-  Get the subsequent state change information received from the server.
-
-  @param mysql  [IN]        mysql handle
-  @param type   [IN]        state change type
-  @param data   [OUT]       buffer to store the data
-  @param length [OUT]       length of the data
-
-  @return
-    0 - Valid data stored
-    1 - No data
-*/
-
-int STDCALL mysql_session_track_get_next(MYSQL *mysql,
-                                         enum enum_session_state_type type,
-                                         const char **data,
-                                         size_t *length)
-{
-  STATE_INFO *info= STATE_DATA(mysql);
-  int ret;
-
-  if (!info || !IS_SESSION_STATE_TYPE(type)
-            || !(info->info_list[type].current_node))
-    return get_data_and_length(NULL, data, length);
-
-  ret= get_data_and_length(info->info_list[type].current_node,
-                           data, length);
-
-  info->info_list[type].current_node= list_rest(info->info_list[type].current_node);
-
-  return ret;
-}
-
-
-/*
-  Get version number for server in a form easy to test on
-
-  SYNOPSIS
-    mysql_get_server_version()
-    mysql		Connection
-
-  EXAMPLE
-    4.1.0-alfa ->  40100
-  
-  NOTES
-    We will ensure that a newer server always has a bigger number.
-
-  RETURN
-   Signed number > 323000
-   Zero if there is no connection
-*/
-
-ulong STDCALL
-mysql_get_server_version(MYSQL *mysql)
-{
-  ulong major= 0, minor= 0, version= 0;
-
-  if (mysql->server_version)
-  {
-    char *pos= mysql->server_version, *end_pos;
-    major=   strtoul(pos, &end_pos, 10);	pos=end_pos+1;
-    minor=   strtoul(pos, &end_pos, 10);	pos=end_pos+1;
-    version= strtoul(pos, &end_pos, 10);
-  }
-  else
-  {
-    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
-  }
-
-  return major*10000 + minor*100 + version;
-}
-
-
-/* 
-   mysql_set_character_set function sends SET NAMES cs_name to
-   the server (which changes character_set_client, character_set_result
-   and character_set_connection) and updates mysql->charset so other
-   functions like mysql_real_escape will work correctly.
-*/
-int STDCALL mysql_set_character_set(MYSQL *mysql, const char *cs_name)
-{
-  struct charset_info_st *cs;
-  const char *save_csdir= charsets_dir;
-
-  if (mysql->options.charset_dir)
-    charsets_dir= mysql->options.charset_dir;
-
-  if (!mysql->net.vio)
-  {
-    /* Initialize with automatic OS character set detection. */
-    mysql_options(mysql, MYSQL_SET_CHARSET_NAME, cs_name);
-    mysql_init_character_set(mysql);
-    /* 
-      In case of automatic OS character set detection
-      mysql_init_character_set changes mysql->options.charset_name
-      from "auto" to the real character set name.
-      Reset cs_name to the detected character set name, accordingly.
-    */
-    cs_name= mysql->options.charset_name;
-  }
-
-  if (strlen(cs_name) < MY_CS_NAME_SIZE &&
-     (cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, MYF(0))))
-  {
-    char buff[MY_CS_NAME_SIZE + 10];
-    charsets_dir= save_csdir;
-    if (!mysql->net.vio)
-    {
-      /* If there is no connection yet we don't send "SET NAMES" query */
-      mysql->charset= cs;
-      return 0;
-    }
-    /* Skip execution of "SET NAMES" for pre-4.1 servers */
-    if (mysql_get_server_version(mysql) < 40100)
-      return 0;
-    sprintf(buff, "SET NAMES %s", cs_name);
-    if (!mysql_real_query(mysql, buff, (ulong) strlen(buff)))
-    {
-      mysql->charset= cs;
-    }
-  }
-  else
-  {
-    char cs_dir_name[FN_REFLEN];
-    get_charsets_dir(cs_dir_name);
-    set_mysql_extended_error(mysql, CR_CANT_READ_CHARSET, unknown_sqlstate,
-                             ER(CR_CANT_READ_CHARSET), cs_name, cs_dir_name);
-  }
-  charsets_dir= save_csdir;
-  return mysql->net.last_errno;
-}
-
-/**
-  client authentication plugin that does native MySQL authentication
-  using a 20-byte (4.1+) scramble
-*/
-static int native_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
-{
-  int pkt_len;
-  uchar *pkt;
-
-  DBUG_ENTER("native_password_auth_client");
-
-
-  if (((MCPVIO_EXT *)vio)->mysql_change_user)
-  {
-    /*
-      in mysql_change_user() the client sends the first packet.
-      we use the old scramble.
-    */
-    pkt= (uchar*)mysql->scramble;
-    pkt_len= SCRAMBLE_LENGTH + 1;
-  }
-  else
-  {
-    /* read the scramble */
-    if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
-      DBUG_RETURN(CR_ERROR);
-
-    if (pkt_len != SCRAMBLE_LENGTH + 1)
-      DBUG_RETURN(CR_SERVER_HANDSHAKE_ERR);
-
-    /* save it in MYSQL */
-    memcpy(mysql->scramble, pkt, SCRAMBLE_LENGTH);
-    mysql->scramble[SCRAMBLE_LENGTH] = 0;
-  }
-
-  if (mysql->passwd[0])
-  {
-    char scrambled[SCRAMBLE_LENGTH + 1];
-    DBUG_PRINT("info", ("sending scramble"));
-    scramble(scrambled, (char*)pkt, mysql->passwd);
-    if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH))
-      DBUG_RETURN(CR_ERROR);
-  }
-  else
-  {
-    DBUG_PRINT("info", ("no password"));
-    if (vio->write_packet(vio, 0, 0)) /* no password */
-      DBUG_RETURN(CR_ERROR);
-  }
-
-  DBUG_RETURN(CR_OK);
-}
-
-/**
-  The main function of the mysql_clear_password authentication plugin.
-*/
-
-static int clear_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
-{
-  int res;
-
-  /* send password in clear text */
-  res= vio->write_packet(vio, (const unsigned char *) mysql->passwd, 
-						 (int)strlen(mysql->passwd) + 1);
-
-  return res ? CR_ERROR : CR_OK;
-}
-
-
diff --git a/mysql/sql-common/client_authentication.cpp b/mysql/sql-common/client_authentication.cpp
deleted file mode 100644
index eaeb2d4..0000000
--- a/mysql/sql-common/client_authentication.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program 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 General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
-
-// First include (the generated) my_config.h, to get correct platform defines.
-#include "my_config.h"
-
-#if defined(HAVE_OPENSSL)
-#include "crypt_genhash_impl.h"
-#include "mysql/client_authentication.h"
-#include "m_ctype.h"
-#include "sql_common.h"
-#include "errmsg.h"
-#include "sql_string.h"
-
-#include <string.h>
-#include <stdarg.h>
-#if !defined(HAVE_YASSL)
-#include <openssl/rsa.h>
-#include <openssl/pem.h>
-#include <openssl/err.h>
-#if defined(_WIN32) && !defined(_OPENSSL_Applink) && defined(HAVE_OPENSSL_APPLINK_C)
-#include <openssl/applink.c>
-#endif
-#endif
-#include "mysql/plugin.h"
-
-#define MAX_CIPHER_LENGTH 1024
-
-#if !defined(HAVE_YASSL)
-mysql_mutex_t g_public_key_mutex;
-#endif
-
-int sha256_password_init(char *a, size_t b, int c, va_list d)
-{
-#if !defined(HAVE_YASSL)
-  mysql_mutex_init(0,&g_public_key_mutex, MY_MUTEX_INIT_SLOW);
-#endif
-  return 0;
-}
-
-int sha256_password_deinit(void)
-{
-#if !defined(HAVE_YASSL)
-  mysql_mutex_destroy(&g_public_key_mutex);
-#endif
-  return 0;
-}
-
-
-#if !defined(HAVE_YASSL)
-/**
-  Reads and parse RSA public key data from a file.
-
-  @param mysql connection handle with file path data
- 
-  @return Pointer to the RSA public key storage buffer
-*/
-
-RSA *rsa_init(MYSQL *mysql)
-{
-  static RSA *g_public_key= NULL;
-  RSA *key= NULL;
-
-  mysql_mutex_lock(&g_public_key_mutex);
-  key= g_public_key;
-  mysql_mutex_unlock(&g_public_key_mutex);
-
-  if (key != NULL)
-    return key;
-
-  FILE *pub_key_file= NULL;
-
-  if (mysql->options.extension != NULL &&
-      mysql->options.extension->server_public_key_path != NULL &&
-      mysql->options.extension->server_public_key_path != '\0')
-  {
-    pub_key_file= fopen(mysql->options.extension->server_public_key_path,
-                        "r");
-  }
-  /* No public key is used; return 0 without errors to indicate this. */
-  else
-    return 0;
-
-  if (pub_key_file == NULL)
-  {
-    /*
-      If a key path was submitted but no key located then we print an error
-      message. Else we just report that there is no public key.
-    */
-    my_message_local(WARNING_LEVEL, "Can't locate server public key '%s'",
-                     mysql->options.extension->server_public_key_path);
-
-    return 0;
-  }
-
-  mysql_mutex_lock(&g_public_key_mutex);
-  key= g_public_key= PEM_read_RSA_PUBKEY(pub_key_file, 0, 0, 0);
-  mysql_mutex_unlock(&g_public_key_mutex);
-  fclose(pub_key_file);
-  if (g_public_key == NULL)
-  {
-    ERR_clear_error();
-    my_message_local(WARNING_LEVEL, "Public key is not in PEM format: '%s'",
-                     mysql->options.extension->server_public_key_path);
-    return 0;
-  }
-
-  return key;
-}
-#endif // !defined(HAVE_YASSL)
-
-/**
-  Authenticate the client using the RSA or TLS and a SHA256 salted password.
- 
-  @param vio Provides plugin access to communication channel
-  @param mysql Client connection handler
-
-  @return Error status
-    @retval CR_ERROR An error occurred.
-    @retval CR_OK Authentication succeeded.
-*/
-
-extern "C"
-int sha256_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
-{
-  bool uses_password= mysql->passwd[0] != 0;
-#if !defined(HAVE_YASSL)
-  unsigned char encrypted_password[MAX_CIPHER_LENGTH];
-  static char request_public_key= '\1';
-  RSA *public_key= NULL;
-  bool got_public_key_from_server= false;
-#endif
-  bool connection_is_secure= false;
-  unsigned char scramble_pkt[20];
-  unsigned char *pkt;
-
-
-  DBUG_ENTER("sha256_password_auth_client");
-
-  /*
-    Get the scramble from the server because we need it when sending encrypted
-    password.
-  */
-  if (vio->read_packet(vio, &pkt) != SCRAMBLE_LENGTH + 1)
-  {
-    DBUG_PRINT("info",("Scramble is not of correct length."));
-    DBUG_RETURN(CR_ERROR);
-  }
-  if (pkt[SCRAMBLE_LENGTH] != '\0')
-  {
-    DBUG_PRINT("info",("Missing protocol token in scramble data."));
-    DBUG_RETURN(CR_ERROR);
-  }
-  /*
-    Copy the scramble to the stack or it will be lost on the next use of the 
-    net buffer.
-  */
-  memcpy(scramble_pkt, pkt, SCRAMBLE_LENGTH);
-
-  if (mysql_get_ssl_cipher(mysql) != NULL)
-    connection_is_secure= true;
-
-  /* If connection isn't secure attempt to get the RSA public key file */
-  if (!connection_is_secure)
-  {
- #if !defined(HAVE_YASSL)
-    public_key= rsa_init(mysql);
-#endif
-  }
-
-  if (!uses_password)
-  {
-    /* We're not using a password */
-    static const unsigned char zero_byte= '\0'; 
-    if (vio->write_packet(vio, &zero_byte, 1))
-      DBUG_RETURN(CR_ERROR);
-  }
-  else
-  {
-    /* Password is a 0-terminated byte array ('\0' character included) */
-    unsigned int passwd_len= static_cast<unsigned int>(strlen(mysql->passwd) + 1);
-    if (!connection_is_secure)
-    {
-#if !defined(HAVE_YASSL)
-      /*
-        If no public key; request one from the server.
-      */
-      if (public_key == NULL)
-      {
-        if (vio->write_packet(vio, (const unsigned char *) &request_public_key,
-                              1))
-          DBUG_RETURN(CR_ERROR);
-      
-        int pkt_len= 0;
-        unsigned char *pkt;
-        if ((pkt_len= vio->read_packet(vio, &pkt)) == -1)
-          DBUG_RETURN(CR_ERROR);
-        BIO* bio= BIO_new_mem_buf(pkt, pkt_len);
-        public_key= PEM_read_bio_RSA_PUBKEY(bio, NULL, NULL, NULL);
-        BIO_free(bio);
-        if (public_key == 0)
-        {
-          ERR_clear_error();
-          DBUG_RETURN(CR_ERROR);
-        }
-        got_public_key_from_server= true;
-      }
-
-      /*
-        An arbitrary limitation based on the assumption that passwords
-        larger than e.g. 15 symbols don't contribute to security.
-        Note also that it's furter restricted to RSA_size() - 41 down
-        below, so this leaves 471 bytes of possible RSA key sizes which
-        should be reasonably future-proof.
-        We avoid heap allocation for speed reasons.
-      */
-      char passwd_scramble[512];
-
-      if (passwd_len > sizeof(passwd_scramble))
-      {
-        /* password too long for the buffer */
-        if (got_public_key_from_server)
-          RSA_free(public_key);
-        DBUG_RETURN(CR_ERROR);
-      }
-      memmove(passwd_scramble, mysql->passwd, passwd_len);
-      
-      /* Obfuscate the plain text password with the session scramble */
-      xor_string(passwd_scramble, passwd_len - 1, (char *) scramble_pkt,
-                 SCRAMBLE_LENGTH);
-      /* Encrypt the password and send it to the server */
-      int cipher_length= RSA_size(public_key);
-      /*
-        When using RSA_PKCS1_OAEP_PADDING the password length must be less
-        than RSA_size(rsa) - 41.
-      */
-      if (passwd_len + 41 >= (unsigned) cipher_length)
-      {
-        /* password message is to long */
-        if (got_public_key_from_server)
-          RSA_free(public_key);
-        DBUG_RETURN(CR_ERROR);
-      }
-      RSA_public_encrypt(passwd_len, (unsigned char *) passwd_scramble,
-                         encrypted_password,
-                         public_key, RSA_PKCS1_OAEP_PADDING);
-      if (got_public_key_from_server)
-        RSA_free(public_key);
-
-      if (vio->write_packet(vio, (uchar*) encrypted_password, cipher_length))
-        DBUG_RETURN(CR_ERROR);
-#else
-      set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_ERR, unknown_sqlstate,
-                                ER(CR_AUTH_PLUGIN_ERR), "sha256_password",
-                                "Authentication requires SSL encryption");
-      DBUG_RETURN(CR_ERROR); // If no openssl support
-#endif
-    }
-    else
-    {
-      /* The vio is encrypted already; just send the plain text passwd */
-      if (vio->write_packet(vio, (uchar*) mysql->passwd, passwd_len))
-        DBUG_RETURN(CR_ERROR);
-    }
-  }
-    
-  DBUG_RETURN(CR_OK);
-}
-
-#endif
diff --git a/mysql/sql-common/client_plugin.c b/mysql/sql-common/client_plugin.c
deleted file mode 100644
index c7dfda9..0000000
--- a/mysql/sql-common/client_plugin.c
+++ /dev/null
@@ -1,592 +0,0 @@
-/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program 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 General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
-
-/**
-  @file
-  
-  Support code for the client side (libmysql) plugins
-
-  Client plugins are somewhat different from server plugins, they are simpler.
-
-  They do not need to be installed or in any way explicitly loaded on the
-  client, they are loaded automatically on demand.
-  One client plugin per shared object, soname *must* match the plugin name.
-
-  There is no reference counting and no unloading either.
-*/
-
-#include <my_global.h>
-#include "mysql.h"
-#include <my_sys.h>
-#include <m_string.h>
-#include <my_thread.h>
-
-#include <sql_common.h>
-#include "errmsg.h"
-#include <mysql/client_plugin.h>
-
-#ifdef HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-
-#if defined(CLIENT_PROTOCOL_TRACING)
-#include <mysql/plugin_trace.h>
-#endif
-
-PSI_memory_key key_memory_root;
-PSI_memory_key key_memory_load_env_plugins;
-
-#ifdef HAVE_PSI_INTERFACE
-PSI_mutex_key key_mutex_LOCK_load_client_plugin;
-
-static PSI_mutex_info all_client_plugin_mutexes[]=
-{
-  {&key_mutex_LOCK_load_client_plugin, "LOCK_load_client_plugin", PSI_FLAG_GLOBAL}
-};
-
-static PSI_memory_info all_client_plugin_memory[]=
-{
-  {&key_memory_root, "root", PSI_FLAG_GLOBAL},
-  {&key_memory_load_env_plugins, "load_env_plugins", PSI_FLAG_GLOBAL}
-};
-
-static void init_client_plugin_psi_keys()
-{
-  const char* category= "sql";
-  int count;
-
-  count= array_elements(all_client_plugin_mutexes);
-  mysql_mutex_register(category, all_client_plugin_mutexes, count);
-
-  count= array_elements(all_client_plugin_memory);
-  mysql_memory_register(category, all_client_plugin_memory, count);
-}
-#endif /* HAVE_PSI_INTERFACE */
-
-struct st_client_plugin_int {
-  struct st_client_plugin_int *next;
-  void   *dlhandle;
-  struct st_mysql_client_plugin *plugin;
-};
-
-static my_bool initialized= 0;
-static MEM_ROOT mem_root;
-
-static const char *plugin_declarations_sym= "_mysql_client_plugin_declaration_";
-static uint plugin_version[MYSQL_CLIENT_MAX_PLUGINS]=
-{
-  0, /* these two are taken by Connector/C */
-  0, /* these two are taken by Connector/C */
-  MYSQL_CLIENT_AUTHENTICATION_PLUGIN_INTERFACE_VERSION,
-  MYSQL_CLIENT_TRACE_PLUGIN_INTERFACE_VERSION,
-};
-
-/*
-  Loaded plugins are stored in a linked list.
-  The list is append-only, the elements are added to the head (like in a stack).
-  The elements are added under a mutex, but the list can be read and traversed
-  without any mutex because once an element is added to the list, it stays
-  there. The main purpose of a mutex is to prevent two threads from
-  loading the same plugin twice in parallel.
-*/
-struct st_client_plugin_int *plugin_list[MYSQL_CLIENT_MAX_PLUGINS];
-static mysql_mutex_t LOCK_load_client_plugin;
-
-static int is_not_initialized(MYSQL *mysql, const char *name)
-{
-  if (initialized)
-    return 0;
-
-  set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD,
-                           unknown_sqlstate, ER(CR_AUTH_PLUGIN_CANNOT_LOAD),
-                           name, "not initialized");
-  return 1;
-}
-
-/**
-  finds a plugin in the list
-
-  @param name   plugin name to search for
-  @param type   plugin type
-
-  @note this does NOT necessarily need a mutex, take care!
-  
-  @retval a pointer to a found plugin or 0
-*/
-static struct st_mysql_client_plugin *
-find_plugin(const char *name, int type)
-{
-  struct st_client_plugin_int *p;
-
-  DBUG_ASSERT(initialized);
-  DBUG_ASSERT(type >= 0 && type < MYSQL_CLIENT_MAX_PLUGINS);
-  if (type < 0 || type >= MYSQL_CLIENT_MAX_PLUGINS)
-    return 0;
-
-  for (p= plugin_list[type]; p; p= p->next)
-  {
-    if (strcmp(p->plugin->name, name) == 0)
-      return p->plugin;
-  }
-  return NULL;
-}
-
-/**
-  verifies the plugin and adds it to the list
-
-  @param mysql          MYSQL structure (for error reporting)
-  @param plugin         plugin to install
-  @param dlhandle       a handle to the shared object (returned by dlopen)
-                        or 0 if the plugin was not dynamically loaded
-  @param argc           number of arguments in the 'va_list args'
-  @param args           arguments passed to the plugin initialization function
-
-  @retval a pointer to an installed plugin or 0
-*/
-static struct st_mysql_client_plugin *
-do_add_plugin(MYSQL *mysql, struct st_mysql_client_plugin *plugin,
-              void *dlhandle,
-              int argc, va_list args)
-{
-  const char *errmsg;
-  struct st_client_plugin_int plugin_int, *p;
-  char errbuf[1024];
-
-  DBUG_ASSERT(initialized);
-
-  plugin_int.plugin= plugin;
-  plugin_int.dlhandle= dlhandle;
-
-  if (plugin->type >= MYSQL_CLIENT_MAX_PLUGINS)
-  {
-    errmsg= "Unknown client plugin type";
-    goto err1;
-  }
-
-  if (plugin->interface_version < plugin_version[plugin->type] ||
-      (plugin->interface_version >> 8) >
-       (plugin_version[plugin->type] >> 8))
-  {
-    errmsg= "Incompatible client plugin interface";
-    goto err1;
-  }
-
-#if defined(CLIENT_PROTOCOL_TRACING) && !defined(MYSQL_SERVER)
-  /*
-    If we try to load a protocol trace plugin but one is already
-    loaded (global trace_plugin pointer is not NULL) then we ignore
-    the new trace plugin and give error. This is done before the
-    new plugin gets initialized.
-  */
-  if (plugin->type == MYSQL_CLIENT_TRACE_PLUGIN && NULL != trace_plugin)
-  {
-    errmsg= "Can not load another trace plugin while one is already loaded";
-    goto err1;
-  }
-#endif
-
-  /* Call the plugin initialization function, if any */
-  if (plugin->init && plugin->init(errbuf, sizeof(errbuf), argc, args))
-  {
-    errmsg= errbuf;
-    goto err1;
-  }
-
-  p= (struct st_client_plugin_int *)
-    memdup_root(&mem_root, &plugin_int, sizeof(plugin_int));
-
-  if (!p)
-  {
-    errmsg= "Out of memory";
-    goto err2;
-  }
-
-  mysql_mutex_assert_owner(&LOCK_load_client_plugin);
-
-  p->next= plugin_list[plugin->type];
-  plugin_list[plugin->type]= p;
-  net_clear_error(&mysql->net);
-
-#if defined(CLIENT_PROTOCOL_TRACING) && !defined(MYSQL_SERVER)
-  /*
-    If loaded plugin is a protocol trace one, then set the global
-    trace_plugin pointer to point at it. When trace_plugin is not NULL,
-    each new connection will be traced using the plugin pointed by it
-    (see MYSQL_TRACE_STAGE() macro in libmysql/mysql_trace.h).
-  */
-  if (plugin->type == MYSQL_CLIENT_TRACE_PLUGIN)
-  {
-    trace_plugin = (struct st_mysql_client_plugin_TRACE*)plugin;
-  }
-#endif
-
-  return plugin;
-
-err2:
-  if (plugin->deinit)
-    plugin->deinit();
-err1:
-  set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, unknown_sqlstate,
-                           ER(CR_AUTH_PLUGIN_CANNOT_LOAD), plugin->name,
-                           errmsg);
-  if (dlhandle)
-    dlclose(dlhandle);
-  return NULL;
-}
-
-
-static struct st_mysql_client_plugin *
-add_plugin_noargs(MYSQL *mysql, struct st_mysql_client_plugin *plugin,
-                  void *dlhandle,
-                  int argc, ...)
-{
-  struct st_mysql_client_plugin *retval= NULL;
-  va_list ap;
-  va_start(ap, argc);
-  retval= do_add_plugin(mysql, plugin, dlhandle, argc, ap);
-  va_end(ap);
-  return retval;
-}
-
-
-static struct st_mysql_client_plugin *
-add_plugin_withargs(MYSQL *mysql, struct st_mysql_client_plugin *plugin,
-                    void *dlhandle,
-                    int argc, va_list args)
-{
-  return do_add_plugin(mysql, plugin, dlhandle, argc, args);
-}
-
-
-
-/**
-  Loads plugins which are specified in the environment variable
-  LIBMYSQL_PLUGINS.
-  
-  Multiple plugins must be separated by semicolon. This function doesn't
-  return or log an error.
-
-  The function is be called by mysql_client_plugin_init
-
-  @todo
-  Support extended syntax, passing parameters to plugins, for example
-  LIBMYSQL_PLUGINS="plugin1(param1,param2);plugin2;..."
-  or
-  LIBMYSQL_PLUGINS="plugin1=int:param1,str:param2;plugin2;..."
-*/
-static void load_env_plugins(MYSQL *mysql)
-{
-  char *plugs, *free_env, *s= getenv("LIBMYSQL_PLUGINS");
-  char *enable_cleartext_plugin= getenv("LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN");
-
-  if (enable_cleartext_plugin && strchr("1Yy", enable_cleartext_plugin[0]))
-    libmysql_cleartext_plugin_enabled= 1;
-
-  /* no plugins to load */
-  if(!s)
-    return;
-
-  free_env= plugs= my_strdup(key_memory_load_env_plugins,
-                             s, MYF(MY_WME));
-
-  do {
-    if ((s= strchr(plugs, ';')))
-      *s= '\0';
-    mysql_load_plugin(mysql, plugs, -1, 0);
-    plugs= s + 1;
-  } while (s);
-
-  my_free(free_env);
-
-}
-
-
-/********** extern functions to be used by libmysql *********************/
-
-/**
-  Initializes the client plugin layer.
-
-  This function must be called before any other client plugin function.
-
-  @retval 0    successful
-  @retval != 0 error occured
-*/
-int mysql_client_plugin_init()
-{
-  MYSQL mysql;
-  struct st_mysql_client_plugin **builtin;
-
-  if (initialized)
-    return 0;
-
-#ifdef HAVE_PSI_INTERFACE
-  init_client_plugin_psi_keys();
-#endif /* HAVE_PSI_INTERFACE */
-
-  memset(&mysql, 0, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */
-
-  mysql_mutex_init(key_mutex_LOCK_load_client_plugin,
-                   &LOCK_load_client_plugin, MY_MUTEX_INIT_SLOW);
-  init_alloc_root(key_memory_root, &mem_root, 128, 128);
-
-  memset(&plugin_list, 0, sizeof(plugin_list));
-
-  initialized= 1;
-
-  mysql_mutex_lock(&LOCK_load_client_plugin);
-
-  for (builtin= mysql_client_builtins; *builtin; builtin++)
-    add_plugin_noargs(&mysql, *builtin, 0, 0);
-
-  mysql_mutex_unlock(&LOCK_load_client_plugin);
-
-  load_env_plugins(&mysql);
-
-  mysql_close_free(&mysql);
-
-  return 0;
-}
-
-/**
-  Deinitializes the client plugin layer.
-
-  Unloades all client plugins and frees any associated resources.
-*/
-void mysql_client_plugin_deinit()
-{
-  int i;
-  struct st_client_plugin_int *p;
-
-  if (!initialized)
-    return;
-
-  for (i=0; i < MYSQL_CLIENT_MAX_PLUGINS; i++)
-    for (p= plugin_list[i]; p; p= p->next)
-    {
-      if (p->plugin->deinit)
-        p->plugin->deinit();
-      if (p->dlhandle)
-        dlclose(p->dlhandle);
-    }
-
-  memset(&plugin_list, 0, sizeof(plugin_list));
-  initialized= 0;
-  free_root(&mem_root, MYF(0));
-  mysql_mutex_destroy(&LOCK_load_client_plugin);
-}
-
-
-/************* public facing functions, for client consumption *********/
-
-/* see <mysql/client_plugin.h> for a full description */
-struct st_mysql_client_plugin *
-mysql_client_register_plugin(MYSQL *mysql,
-                             struct st_mysql_client_plugin *plugin)
-{
-  if (is_not_initialized(mysql, plugin->name))
-    return NULL;
-
-  mysql_mutex_lock(&LOCK_load_client_plugin);
-
-  /* make sure the plugin wasn't loaded meanwhile */
-  if (find_plugin(plugin->name, plugin->type))
-  {
-    set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD,
-                             unknown_sqlstate, ER(CR_AUTH_PLUGIN_CANNOT_LOAD),
-                             plugin->name, "it is already loaded");
-    plugin= NULL;
-  }
-  else
-    plugin= add_plugin_noargs(mysql, plugin, 0, 0);
-
-  mysql_mutex_unlock(&LOCK_load_client_plugin);
-  return plugin;
-}
-
-/* see <mysql/client_plugin.h> for a full description */
-struct st_mysql_client_plugin *
-mysql_load_plugin_v(MYSQL *mysql, const char *name, int type,
-                    int argc, va_list args)
-{
-  const char *errmsg;
-  char dlpath[FN_REFLEN+1];
-  void *sym, *dlhandle;
-  struct st_mysql_client_plugin *plugin;
-  const char *plugindir;
-#ifdef _WIN32
-  char win_errormsg[2048];
-#endif
-
-  DBUG_ENTER ("mysql_load_plugin_v");
-  DBUG_PRINT ("entry", ("name=%s type=%d int argc=%d", name, type, argc));
-  if (is_not_initialized(mysql, name))
-  {
-    DBUG_PRINT ("leave", ("mysql not initialized"));
-    DBUG_RETURN (NULL);
-  }
-
-  mysql_mutex_lock(&LOCK_load_client_plugin);
-
-  /* make sure the plugin wasn't loaded meanwhile */
-  if (type >= 0 && find_plugin(name, type))
-  {
-    errmsg= "it is already loaded";
-    goto err;
-  }
-
-  if (mysql->options.extension && mysql->options.extension->plugin_dir)
-  {
-    plugindir= mysql->options.extension->plugin_dir;
-  }
-  else
-  {
-    plugindir= getenv("LIBMYSQL_PLUGIN_DIR");
-    if (!plugindir)
-    {
-      plugindir= PLUGINDIR;
-    }
-  }
-
-  /* Compile dll path */
-  strxnmov(dlpath, sizeof(dlpath) - 1,
-           plugindir, "/",
-           name, SO_EXT, NullS);
-   
-  DBUG_PRINT ("info", ("dlopeninig %s", dlpath));
-  /* Open new dll handle */
-  if (!(dlhandle= dlopen(dlpath, RTLD_NOW)))
-  {
-#if defined(__APPLE__)
-    /* Apple supports plugins with .so also, so try this as well */
-    strxnmov(dlpath, sizeof(dlpath) - 1,
-             plugindir, "/",
-             name, ".so", NullS);
-    if ((dlhandle= dlopen(dlpath, RTLD_NOW)))
-      goto have_plugin;
-#endif
-
-#ifdef _WIN32
-    /* There should be no win32 calls between failed dlopen() and GetLastError() */
-    if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
-                  0, GetLastError(), 0, win_errormsg, 2048, NULL))
-      errmsg= win_errormsg;
-    else
-      errmsg= "";
-#else
-    errmsg= dlerror();
-#endif
-    DBUG_PRINT ("info", ("failed to dlopen"));
-    goto err;
-  }
-
-#if defined(__APPLE__)
-have_plugin:  
-#endif
-  if (!(sym= dlsym(dlhandle, plugin_declarations_sym)))
-  {
-    errmsg= "not a plugin";
-    dlclose(dlhandle);
-    goto err;
-  }
-
-  plugin= (struct st_mysql_client_plugin*)sym;
-
-  if (type >=0 && type != plugin->type)
-  {
-    errmsg= "type mismatch";
-    goto err;
-  }
-
-  if (strcmp(name, plugin->name))
-  {
-    errmsg= "name mismatch";
-    goto err;
-  }
-
-  if (type < 0 && find_plugin(name, plugin->type))
-  {
-    errmsg= "it is already loaded";
-    goto err;
-  }
-
-  plugin= add_plugin_withargs(mysql, plugin, dlhandle, argc, args);
-
-  mysql_mutex_unlock(&LOCK_load_client_plugin);
-
-  DBUG_PRINT ("leave", ("plugin loaded ok"));
-  DBUG_RETURN (plugin);
-
-err:
-  mysql_mutex_unlock(&LOCK_load_client_plugin);
-  DBUG_PRINT ("leave", ("plugin load error : %s", errmsg));
-  set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, unknown_sqlstate,
-                           ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, errmsg);
-  DBUG_RETURN (NULL);
-}
-
-/* see <mysql/client_plugin.h> for a full description */
-struct st_mysql_client_plugin *
-mysql_load_plugin(MYSQL *mysql, const char *name, int type, int argc, ...)
-{
-  struct st_mysql_client_plugin *p;
-  va_list args;
-  va_start(args, argc);
-  p= mysql_load_plugin_v(mysql, name, type, argc, args);
-  va_end(args);
-  return p;
-}
-
-/* see <mysql/client_plugin.h> for a full description */
-struct st_mysql_client_plugin *
-mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
-{
-  struct st_mysql_client_plugin *p;
-
-  DBUG_ENTER ("mysql_client_find_plugin");
-  DBUG_PRINT ("entry", ("name=%s, type=%d", name, type));
-  if (is_not_initialized(mysql, name))
-    DBUG_RETURN (NULL);
-
-  if (type < 0 || type >= MYSQL_CLIENT_MAX_PLUGINS)
-  {
-    set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, unknown_sqlstate,
-                             ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name,
-                             "invalid type");
-  }
-
-  if ((p= find_plugin(name, type)))
-  {
-    DBUG_PRINT ("leave", ("found %p", p));
-    DBUG_RETURN (p);
-  }
-
-  /* not found, load it */
-  p= mysql_load_plugin(mysql, name, type, 0);
-  DBUG_PRINT ("leave", ("loaded %p", p));
-  DBUG_RETURN (p);
-}
-
-
-/* see <mysql/client_plugin.h> for a full description */
-int mysql_plugin_options(struct st_mysql_client_plugin *plugin,
-                                 const char *option,
-                                 const void *value)
-{
-  DBUG_ENTER("mysql_plugin_options");
-  /* does the plugin support options call? */
-  if (!plugin || !plugin->options)
-    DBUG_RETURN(1);
-  DBUG_RETURN(plugin->options(option, value));
-}
diff --git a/mysql/sql-common/my_time.c b/mysql/sql-common/my_time.c
deleted file mode 100644
index 35ca499..0000000
--- a/mysql/sql-common/my_time.c
+++ /dev/null
@@ -1,2022 +0,0 @@
-/* Copyright (c) 2004, 2016, Oracle and/or its affiliates. All rights reserved.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; version 2 of the License.
-
- This program 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 General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
-
-#include <my_time.h>
-#include <m_string.h>
-#include <m_ctype.h>
-#include <myisampack.h>
-/* Windows version of localtime_r() is declared in my_global.h */
-#include <my_global.h>
-#include "binary_log_types.h"
-
-ulonglong log_10_int[20]=
-{
-  1, 10, 100, 1000, 10000UL, 100000UL, 1000000UL, 10000000UL,
-  100000000ULL, 1000000000ULL, 10000000000ULL, 100000000000ULL,
-  1000000000000ULL, 10000000000000ULL, 100000000000000ULL,
-  1000000000000000ULL, 10000000000000000ULL, 100000000000000000ULL,
-  1000000000000000000ULL, 10000000000000000000ULL
-};
-
-
-const char my_zero_datetime6[]= "0000-00-00 00:00:00.000000";
-
-
-/* Position for YYYY-DD-MM HH-MM-DD.FFFFFF AM in default format */
-
-static uchar internal_format_positions[]=
-{0, 1, 2, 3, 4, 5, 6, (uchar) 255};
-
-static char time_separator=':';
-
-static ulong const days_at_timestart=719528;	/* daynr at 1970.01.01 */
-uchar days_in_month[]= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
-
-/*
-  Offset of system time zone from UTC in seconds used to speed up 
-  work of my_system_gmt_sec() function.
-*/
-static long my_time_zone=0;
-
-
-/* Calc days in one year. works with 0 <= year <= 99 */
-
-uint calc_days_in_year(uint year)
-{
-  return ((year & 3) == 0 && (year%100 || (year%400 == 0 && year)) ?
-          366 : 365);
-}
-
-
-/**
-   Set MYSQL_TIME structure to 0000-00-00 00:00:00.000000
-   @param tm[OUT]    The value to set.
-   @param time_type  Timestasmp type
-*/
-void set_zero_time(MYSQL_TIME *tm,
-                   enum enum_mysql_timestamp_type time_type)
-{
-  memset(tm, 0, sizeof(*tm));
-  tm->time_type= time_type;
-}
-
-
-/**
-  Set hour, minute and second of a MYSQL_TIME variable to maximum time value.
-  Unlike set_max_time(), does not touch the other structure members.
-*/
-void set_max_hhmmss(MYSQL_TIME *tm)
-{
-  tm->hour= TIME_MAX_HOUR;
-  tm->minute= TIME_MAX_MINUTE;
-  tm->second= TIME_MAX_SECOND;
-}
-
-
-/**
-  Set MYSQL_TIME variable to maximum time value
-  @param tm    OUT  The variable to set.
-  @param neg        Sign: 1 if negative, 0 if positive.
-*/
-void set_max_time(MYSQL_TIME *tm, my_bool neg)
-{
-  set_zero_time(tm, MYSQL_TIMESTAMP_TIME);
-  set_max_hhmmss(tm);
-  tm->neg= neg;
-}
-
-
-/**
-  @brief Check datetime value for validity according to flags.
-
-  @param[in]  ltime          Date to check.
-  @param[in]  not_zero_date  ltime is not the zero date
-  @param[in]  flags          flags to check
-                             (see str_to_datetime() flags in my_time.h)
-  @param[out] was_cut        set to 2 if value was invalid according to flags.
-                             (Feb 29 in non-leap etc.)  This remains unchanged
-                             if value is not invalid.
-  @details Here we assume that year and month is ok!
-    If month is 0 we allow any date. (This only happens if we allow zero
-    date parts in str_to_datetime())
-    Disallow dates with zero year and non-zero month and/or day.
-
-  @return
-    0  OK
-    1  error
-*/
-
-my_bool check_date(const MYSQL_TIME *ltime, my_bool not_zero_date,
-                   my_time_flags_t flags, int *was_cut)
-{
-  if (not_zero_date)
-  {
-    if (((flags & TIME_NO_ZERO_IN_DATE) || !(flags & TIME_FUZZY_DATE)) &&
-        (ltime->month == 0 || ltime->day == 0))
-    {
-      *was_cut= MYSQL_TIME_WARN_ZERO_IN_DATE;
-      return TRUE;
-    }
-    else if ((!(flags & TIME_INVALID_DATES) &&
-              ltime->month && ltime->day > days_in_month[ltime->month-1] &&
-              (ltime->month != 2 || calc_days_in_year(ltime->year) != 366 ||
-               ltime->day != 29)))
-    {
-      *was_cut= MYSQL_TIME_WARN_OUT_OF_RANGE;
-      return TRUE;
-    }
-  }
-  else if (flags & TIME_NO_ZERO_DATE)
-  {
-    *was_cut= MYSQL_TIME_WARN_ZERO_DATE;
-    return TRUE;
-  }
-  return FALSE;
-}
-
-
-/**
-  Check if TIME fields are fatally bad and cannot be further adjusted.
-  @param ltime  Time value.
-  @retval  TRUE   if the value is fatally bad.
-  @retval  FALSE  if the value is Ok.
-*/
-my_bool check_time_mmssff_range(const MYSQL_TIME *ltime)
-{
-  return ltime->minute >= 60 || ltime->second >= 60 ||
-         ltime->second_part > 999999;
-}
-
-
-/**
-  Check TIME range. The value can include day part,
-  for example:  '1 10:20:30.123456'.
-
-  minute, second and second_part values are not checked
-  unless hour is equal TIME_MAX_HOUR.
-
-  @param ltime   Rime value.
-  @returns       Test result.
-  @retval        FALSE if value is Ok.
-  @retval        TRUE if value is out of range. 
-*/
-my_bool check_time_range_quick(const MYSQL_TIME *ltime)
-{
-  longlong hour= (longlong) ltime->hour + 24LL * ltime->day;
-  /* The input value should not be fatally bad */
-  DBUG_ASSERT(!check_time_mmssff_range(ltime));
-  if (hour <= TIME_MAX_HOUR &&
-      (hour != TIME_MAX_HOUR || ltime->minute != TIME_MAX_MINUTE ||
-       ltime->second != TIME_MAX_SECOND || !ltime->second_part))
-    return FALSE;
-  return TRUE;
-}
-
-
-/**
-  Check datetime, date, or normalized time (i.e. time without days) range.
-  @param ltime   Datetime value.
-  @returns
-  @retval   FALSE on success
-  @retval   TRUE  on error
-*/
-my_bool check_datetime_range(const MYSQL_TIME *ltime)
-{
-  /*
-    In case of MYSQL_TIMESTAMP_TIME hour value can be up to TIME_MAX_HOUR.
-    In case of MYSQL_TIMESTAMP_DATETIME it cannot be bigger than 23.
-  */
-  return
-    ltime->year > 9999U || ltime->month > 12U  || ltime->day > 31U || 
-    ltime->minute > 59U || ltime->second > 59U || ltime->second_part > 999999U ||
-    (ltime->hour >
-     (ltime->time_type == MYSQL_TIMESTAMP_TIME ? TIME_MAX_HOUR : 23U));
-}
-
-
-/*
-  Convert a timestamp string to a MYSQL_TIME value.
-
-  SYNOPSIS
-    str_to_datetime()
-    str                 String to parse
-    length              Length of string
-    l_time              Date is stored here
-    flags               Bitmap of following items
-                        TIME_FUZZY_DATE    Set if we should allow partial dates
-                        TIME_DATETIME_ONLY Set if we only allow full datetimes.
-                        TIME_NO_ZERO_IN_DATE	Don't allow partial dates
-                        TIME_NO_ZERO_DATE	Don't allow 0000-00-00 date
-                        TIME_INVALID_DATES	Allow 2000-02-31
-    status              Conversion status
-
-
-  DESCRIPTION
-    At least the following formats are recogniced (based on number of digits)
-    YYMMDD, YYYYMMDD, YYMMDDHHMMSS, YYYYMMDDHHMMSS
-    YY-MM-DD, YYYY-MM-DD, YY-MM-DD HH.MM.SS
-    YYYYMMDDTHHMMSS  where T is a the character T (ISO8601)
-    Also dates where all parts are zero are allowed
-
-    The second part may have an optional .###### fraction part.
-
-  NOTES
-   This function should work with a format position vector as long as the
-   following things holds:
-   - All date are kept together and all time parts are kept together
-   - Date and time parts must be separated by blank
-   - Second fractions must come after second part and be separated
-     by a '.'.  (The second fractions are optional)
-   - AM/PM must come after second fractions (or after seconds if no fractions)
-   - Year must always been specified.
-   - If time is before date, then we will use datetime format only if
-     the argument consist of two parts, separated by space.
-     Otherwise we will assume the argument is a date.
-   - The hour part must be specified in hour-minute-second order.
-
-    status->warnings is set to:
-    0                            Value OK
-    MYSQL_TIME_WARN_TRUNCATED    If value was cut during conversion
-    MYSQL_TIME_WARN_OUT_OF_RANGE check_date(date,flags) considers date invalid
-
-    l_time->time_type is set as follows:
-    MYSQL_TIMESTAMP_NONE        String wasn't a timestamp, like
-                                [DD [HH:[MM:[SS]]]].fraction.
-                                l_time is not changed.
-    MYSQL_TIMESTAMP_DATE        DATE string (YY MM and DD parts ok)
-    MYSQL_TIMESTAMP_DATETIME    Full timestamp
-    MYSQL_TIMESTAMP_ERROR       Timestamp with wrong values.
-                                All elements in l_time is set to 0
-  RETURN VALUES
-    0 - Ok
-    1 - Error
-*/
-
-#define MAX_DATE_PARTS 8
-
-my_bool
-str_to_datetime(const char *str, size_t length, MYSQL_TIME *l_time,
-                my_time_flags_t flags, MYSQL_TIME_STATUS *status)
-{
-  uint field_length= 0, year_length= 0, digits, i, number_of_fields;
-  uint date[MAX_DATE_PARTS], date_len[MAX_DATE_PARTS];
-  uint add_hours= 0, start_loop;
-  ulong not_zero_date, allow_space;
-  my_bool is_internal_format;
-  const char *pos, *last_field_pos= NULL;
-  const char *end=str+length;
-  const uchar *format_position;
-  my_bool found_delimitier= 0, found_space= 0;
-  uint frac_pos, frac_len;
-  DBUG_ENTER("str_to_datetime");
-  DBUG_PRINT("ENTER", ("str: %.*s", (int)length, str));
-
-  my_time_status_init(status);
-
-  /* Skip space at start */
-  for (; str != end && my_isspace(&my_charset_latin1, *str) ; str++)
-    ;
-  if (str == end || ! my_isdigit(&my_charset_latin1, *str))
-  {
-    status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-    l_time->time_type= MYSQL_TIMESTAMP_NONE;
-    DBUG_RETURN(1);
-  }
-
-  is_internal_format= 0;
-  /* This has to be changed if want to activate different timestamp formats */
-  format_position= internal_format_positions;
-
-  /*
-    Calculate number of digits in first part.
-    If length= 8 or >= 14 then year is of format YYYY.
-    (YYYY-MM-DD,  YYYYMMDD, YYYYYMMDDHHMMSS)
-  */
-  for (pos=str;
-       pos != end && (my_isdigit(&my_charset_latin1,*pos) || *pos == 'T');
-       pos++)
-    ;
-
-  digits= (uint) (pos-str);
-  start_loop= 0;                                /* Start of scan loop */
-  date_len[format_position[0]]= 0;              /* Length of year field */
-  if (pos == end || *pos == '.')
-  {
-    /* Found date in internal format (only numbers like YYYYMMDD) */
-    year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
-    field_length= year_length;
-    is_internal_format= 1;
-    format_position= internal_format_positions;
-  }
-  else
-  {
-    if (format_position[0] >= 3)                /* If year is after HHMMDD */
-    {
-      /*
-        If year is not in first part then we have to determinate if we got
-        a date field or a datetime field.
-        We do this by checking if there is two numbers separated by
-        space in the input.
-      */
-      while (pos < end && !my_isspace(&my_charset_latin1, *pos))
-        pos++;
-      while (pos < end && !my_isdigit(&my_charset_latin1, *pos))
-        pos++;
-      if (pos == end)
-      {
-        if (flags & TIME_DATETIME_ONLY)
-        {
-          status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-          l_time->time_type= MYSQL_TIMESTAMP_NONE;
-          DBUG_RETURN(1); /* Can't be a full datetime */
-        }
-        /* Date field.  Set hour, minutes and seconds to 0 */
-        date[0]= date[1]= date[2]= date[3]= date[4]= 0;
-        start_loop= 5;                         /* Start with first date part */
-      }
-    }
-
-    field_length= format_position[0] == 0 ? 4 : 2;
-  }
-
-  /*
-    Only allow space in the first "part" of the datetime field and:
-    - after days, part seconds
-    - before and after AM/PM (handled by code later)
-
-    2003-03-03 20:00:20 AM
-    20:00:20.000000 AM 03-03-2000
-  */
-  i= MY_MAX((uint) format_position[0], (uint) format_position[1]);
-  set_if_bigger(i, (uint) format_position[2]);
-  allow_space= ((1 << i) | (1 << format_position[6]));
-  allow_space&= (1 | 2 | 4 | 8 | 64);
-
-  not_zero_date= 0;
-  for (i = start_loop;
-       i < MAX_DATE_PARTS-1 && str != end &&
-         my_isdigit(&my_charset_latin1,*str);
-       i++)
-  {
-    const char *start= str;
-    ulong tmp_value= (uint) (uchar) (*str++ - '0');
-
-    /*
-      Internal format means no delimiters; every field has a fixed
-      width. Otherwise, we scan until we find a delimiter and discard
-      leading zeroes -- except for the microsecond part, where leading
-      zeroes are significant, and where we never process more than six
-      digits.
-    */
-    my_bool     scan_until_delim= !is_internal_format &&
-                                  ((i != format_position[6]));
-
-    while (str != end && my_isdigit(&my_charset_latin1,str[0]) &&
-           (scan_until_delim || --field_length))
-    {
-      tmp_value=tmp_value*10 + (ulong) (uchar) (*str - '0');
-      str++;
-    }
-    date_len[i]= (uint) (str - start);
-    if (tmp_value > 999999)                     /* Impossible date part */
-    {
-      status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-      l_time->time_type= MYSQL_TIMESTAMP_NONE;
-      DBUG_RETURN(1);
-    }
-    date[i]=tmp_value;
-    not_zero_date|= tmp_value;
-
-    /* Length of next field */
-    field_length= format_position[i+1] == 0 ? 4 : 2;
-
-    if ((last_field_pos= str) == end)
-    {
-      i++;                                      /* Register last found part */
-      break;
-    }
-    /* Allow a 'T' after day to allow CCYYMMDDT type of fields */
-    if (i == format_position[2] && *str == 'T')
-    {
-      str++;                                    /* ISO8601:  CCYYMMDDThhmmss */
-      continue;
-    }
-    if (i == format_position[5])                /* Seconds */
-    {
-      if (*str == '.')                          /* Followed by part seconds */
-      {
-        str++;
-        /*
-          Shift last_field_pos, so '2001-01-01 00:00:00.'
-          is treated as a valid value
-        */
-        last_field_pos= str;
-        field_length= 6;                        /* 6 digits */
-      }
-      else if (my_isdigit(&my_charset_latin1,str[0]))
-      {
-        /*
-          We do not see a decimal point which would have indicated a
-          fractional second part in further read. So we skip the further
-          processing of digits.
-        */
-        i++;
-        break;
-      }
-      continue;
-    }
-    while (str != end &&
-           (my_ispunct(&my_charset_latin1,*str) ||
-            my_isspace(&my_charset_latin1,*str)))
-    {
-      if (my_isspace(&my_charset_latin1,*str))
-      {
-        if (!(allow_space & (1 << i)))
-        {
-          status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-          l_time->time_type= MYSQL_TIMESTAMP_NONE;
-          DBUG_RETURN(1);
-        }
-        found_space= 1;
-      }
-      str++;
-      found_delimitier= 1;                      /* Should be a 'normal' date */
-    }
-    /* Check if next position is AM/PM */
-    if (i == format_position[6])                /* Seconds, time for AM/PM */
-    {
-      i++;                                      /* Skip AM/PM part */
-      if (format_position[7] != 255)            /* If using AM/PM */
-      {
-        if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
-        {
-          if (str[0] == 'p' || str[0] == 'P')
-            add_hours= 12;
-          else if (str[0] != 'a' || str[0] != 'A')
-            continue;                           /* Not AM/PM */
-          str+= 2;                              /* Skip AM/PM */
-          /* Skip space after AM/PM */
-          while (str != end && my_isspace(&my_charset_latin1,*str))
-            str++;
-        }
-      }
-    }
-    last_field_pos= str;
-  }
-  if (found_delimitier && !found_space && (flags & TIME_DATETIME_ONLY))
-  {
-    status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-    l_time->time_type= MYSQL_TIMESTAMP_NONE;
-    DBUG_RETURN(1);  /* Can't be a datetime */
-  }
-
-  str= last_field_pos;
-
-  number_of_fields= i - start_loop;
-  while (i < MAX_DATE_PARTS)
-  {
-    date_len[i]= 0;
-    date[i++]= 0;
-  }
-
-  if (!is_internal_format)
-  {
-    year_length= date_len[(uint) format_position[0]];
-    if (!year_length)                           /* Year must be specified */
-    {
-      status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-      l_time->time_type= MYSQL_TIMESTAMP_NONE;
-      DBUG_RETURN(1);
-    }
-
-    l_time->year=               date[(uint) format_position[0]];
-    l_time->month=              date[(uint) format_position[1]];
-    l_time->day=                date[(uint) format_position[2]];
-    l_time->hour=               date[(uint) format_position[3]];
-    l_time->minute=             date[(uint) format_position[4]];
-    l_time->second=             date[(uint) format_position[5]];
-
-    frac_pos= (uint) format_position[6];
-    frac_len= date_len[frac_pos];
-    status->fractional_digits= frac_len;
-    if (frac_len < 6)
-      date[frac_pos]*= (uint) log_10_int[DATETIME_MAX_DECIMALS - frac_len];
-    l_time->second_part= date[frac_pos];
-
-    if (format_position[7] != (uchar) 255)
-    {
-      if (l_time->hour > 12)
-      {
-        status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-        goto err;
-      }
-      l_time->hour= l_time->hour%12 + add_hours;
-    }
-  }
-  else
-  {
-    l_time->year=       date[0];
-    l_time->month=      date[1];
-    l_time->day=        date[2];
-    l_time->hour=       date[3];
-    l_time->minute=     date[4];
-    l_time->second=     date[5];
-    if (date_len[6] < 6)
-      date[6]*= (uint) log_10_int[DATETIME_MAX_DECIMALS - date_len[6]];
-    l_time->second_part=date[6];
-    status->fractional_digits= date_len[6];
-  }
-  l_time->neg= 0;
-
-  if (year_length == 2 && not_zero_date)
-    l_time->year+= (l_time->year < YY_PART_YEAR ? 2000 : 1900);
-
-  /*
-    Set time_type before check_datetime_range(),
-    as the latter relies on initialized time_type value.
-  */
-  l_time->time_type= (number_of_fields <= 3 ?
-                      MYSQL_TIMESTAMP_DATE : MYSQL_TIMESTAMP_DATETIME);
-
-  if (number_of_fields < 3 || check_datetime_range(l_time))
-  {
-    /* Only give warning for a zero date if there is some garbage after */
-    if (!not_zero_date)                         /* If zero date */
-    {
-      for (; str != end ; str++)
-      {
-        if (!my_isspace(&my_charset_latin1, *str))
-        {
-          not_zero_date= 1;                     /* Give warning */
-          break;
-        }
-      }
-    }
-    status->warnings|= not_zero_date ? MYSQL_TIME_WARN_TRUNCATED :
-                                       MYSQL_TIME_WARN_ZERO_DATE;
-    goto err;
-  }
-
-  if (check_date(l_time, not_zero_date != 0, flags, &status->warnings))
-    goto err;
-
-  /* Scan all digits left after microseconds */
-  if (status->fractional_digits == 6 && str != end)
-  {
-    if (my_isdigit(&my_charset_latin1, *str))
-    {
-      /*
-        We don't need the exact nanoseconds value.
-        Knowing the first digit is enough for rounding.
-      */
-      status->nanoseconds= 100 * (int) (*str++ - '0');
-      for (; str != end && my_isdigit(&my_charset_latin1, *str); str++)
-      { }
-    }
-  }
-
-  for (; str != end ; str++)
-  {
-    if (!my_isspace(&my_charset_latin1,*str))
-    {
-      status->warnings= MYSQL_TIME_WARN_TRUNCATED;
-      break;
-    }
-  }
-
-  DBUG_RETURN(0);
-
-err:
-  set_zero_time(l_time, MYSQL_TIMESTAMP_ERROR);
-  DBUG_RETURN(1);
-}
-
-
-/*
- Convert a time string to a MYSQL_TIME struct.
-
-  SYNOPSIS
-   str_to_time()
-   str                  A string in full TIMESTAMP format or
-                        [-] DAYS [H]H:MM:SS, [H]H:MM:SS, [M]M:SS, [H]HMMSS,
-                        [M]MSS or [S]S
-                        There may be an optional [.second_part] after seconds
-   length               Length of str
-   l_time               Store result here
-   status               Conversion status
-
-   status.warning is set to:
-     MYSQL_TIME_WARN_TRUNCATED flag if the input string
-                        was cut during conversion, and/or
-     MYSQL_TIME_WARN_OUT_OF_RANGE flag, if the value is out of range.
-
-   NOTES
-     Because of the extra days argument, this function can only
-     work with times where the time arguments are in the above order.
-
-   RETURN
-     0  ok
-     1  error
-*/
-
-my_bool str_to_time(const char *str, size_t length, MYSQL_TIME *l_time,
-                    MYSQL_TIME_STATUS *status)
-{
-  ulong date[5];
-  ulonglong value;
-  const char *end=str+length, *end_of_days;
-  my_bool found_days,found_hours;
-  uint state;
-
-  my_time_status_init(status);
-  l_time->neg=0;
-  for (; str != end && my_isspace(&my_charset_latin1,*str) ; str++)
-    length--;
-  if (str != end && *str == '-')
-  {
-    l_time->neg=1;
-    str++;
-    length--;
-  }
-  if (str == end)
-    return 1;
-
-  /* Check first if this is a full TIMESTAMP */
-  if (length >= 12)
-  {                                             /* Probably full timestamp */
-    (void) str_to_datetime(str, length, l_time,
-                           (TIME_FUZZY_DATE | TIME_DATETIME_ONLY), status);
-    if (l_time->time_type >= MYSQL_TIMESTAMP_ERROR)
-      return l_time->time_type == MYSQL_TIMESTAMP_ERROR;
-    my_time_status_init(status);
-  }
-
-  /* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */
-  for (value=0; str != end && my_isdigit(&my_charset_latin1,*str) ; str++)
-    value=value*10L + (long) (*str - '0');
-
-  if (value > UINT_MAX)
-    return 1;
-
-  /* Skip all space after 'days' */
-  end_of_days= str;
-  for (; str != end && my_isspace(&my_charset_latin1, str[0]) ; str++)
-    ;
-
-  state= 0;
-  found_days=found_hours=0;
-  if ((uint) (end-str) > 1 && str != end_of_days &&
-      my_isdigit(&my_charset_latin1, *str))
-  {                                             /* Found days part */
-    date[0]= (ulong) value;
-    state= 1;                                   /* Assume next is hours */
-    found_days= 1;
-  }
-  else if ((end-str) > 1 &&  *str == time_separator &&
-           my_isdigit(&my_charset_latin1, str[1]))
-  {
-    date[0]= 0;                                 /* Assume we found hours */
-    date[1]= (ulong) value;
-    state=2;
-    found_hours=1;
-    str++;                                      /* skip ':' */
-  }
-  else
-  {
-    /* String given as one number; assume HHMMSS format */
-    date[0]= 0;
-    date[1]= (ulong) (value/10000);
-    date[2]= (ulong) (value/100 % 100);
-    date[3]= (ulong) (value % 100);
-    state=4;
-    goto fractional;
-  }
-
-  /* Read hours, minutes and seconds */
-  for (;;)
-  {
-    for (value=0; str != end && my_isdigit(&my_charset_latin1,*str) ; str++)
-      value=value*10L + (long) (*str - '0');
-    date[state++]= (ulong) value;
-    if (state == 4 || (end-str) < 2 || *str != time_separator ||
-        !my_isdigit(&my_charset_latin1,str[1]))
-      break;
-    str++;                                      /* Skip time_separator (':') */
-  }
-
-  if (state != 4)
-  {                                             /* Not HH:MM:SS */
-    /* Fix the date to assume that seconds was given */
-    if (!found_hours && !found_days)
-    {
-      size_t len= sizeof(long) * (state - 1);
-      memmove((uchar*) (date+4) - len, (uchar*) (date+state) - len, len);
-      memset(date, 0, sizeof(long)*(4-state));
-    }
-    else
-      memset((date+state), 0, sizeof(long)*(4-state));
-  }
-
-fractional:
-  /* Get fractional second part */
-  if ((end-str) >= 2 && *str == '.' && my_isdigit(&my_charset_latin1,str[1]))
-  {
-    int field_length= 5;
-    str++; value=(uint) (uchar) (*str - '0');
-    while (++str != end && my_isdigit(&my_charset_latin1, *str))
-    {
-      if (field_length-- > 0)
-        value= value*10 + (uint) (uchar) (*str - '0');
-    }
-    if (field_length >= 0)
-    {
-      status->fractional_digits= DATETIME_MAX_DECIMALS - field_length;
-      if (field_length > 0)
-        value*= (long) log_10_int[field_length];
-    }
-    else
-    {
-      /* Scan digits left after microseconds */
-      status->fractional_digits= 6;
-      status->nanoseconds= 100 * (int) (str[-1] - '0');
-      for ( ; str != end && my_isdigit(&my_charset_latin1, *str); str++)
-      { }
-    }
-    date[4]= (ulong) value;
-  }
-  else if ((end - str) == 1 && *str == '.')
-  {
-    str++;
-    date[4]= 0;
-  }
-  else
-    date[4]=0;
-    
-  /* Check for exponent part: E<gigit> | E<sign><digit> */
-  /* (may occur as result of %g formatting of time value) */
-  if ((end - str) > 1 &&
-      (*str == 'e' || *str == 'E') &&
-      (my_isdigit(&my_charset_latin1, str[1]) ||
-       ((str[1] == '-' || str[1] == '+') &&
-        (end - str) > 2 &&
-        my_isdigit(&my_charset_latin1, str[2]))))
-    return 1;
-
-  if (internal_format_positions[7] != 255)
-  {
-    /* Read a possible AM/PM */
-    while (str != end && my_isspace(&my_charset_latin1, *str))
-      str++;
-    if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
-    {
-      if (str[0] == 'p' || str[0] == 'P')
-      {
-        str+= 2;
-        date[1]= date[1]%12 + 12;
-      }
-      else if (str[0] == 'a' || str[0] == 'A')
-        str+=2;
-    }
-  }
-
-  /* Integer overflow checks */
-  if (date[0] > UINT_MAX || date[1] > UINT_MAX ||
-      date[2] > UINT_MAX || date[3] > UINT_MAX ||
-      date[4] > UINT_MAX)
-    return 1;
-  
-  l_time->year=         0;                      /* For protocol::store_time */
-  l_time->month=        0;
-  
-  l_time->day=  0;
-  l_time->hour= date[1] + date[0] * 24; /* Mix days and hours */
-
-  l_time->minute=       date[2];
-  l_time->second=       date[3];
-  l_time->second_part=  date[4];
-  l_time->time_type= MYSQL_TIMESTAMP_TIME;
-
-  if (check_time_mmssff_range(l_time))
-  {
-    status->warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE;
-    return TRUE;
-  }
-
-  /* Adjust the value into supported MYSQL_TIME range */
-  adjust_time_range(l_time, &status->warnings);
-
-  /* Check if there is garbage at end of the MYSQL_TIME specification */
-  if (str != end)
-  {
-    do
-    {
-      if (!my_isspace(&my_charset_latin1,*str))
-      {
-        status->warnings|= MYSQL_TIME_WARN_TRUNCATED;
-        break;
-      }
-    } while (++str != end);
-  }
-  return 0;
-}
-
-
-/**
-  Convert number to TIME
-  @param nr            Number to convert.
-  @param OUT ltime     Variable to convert to.
-  @param OUT warnings  Warning vector.
-
-  @retval false OK
-  @retval true No. is out of range
-*/
-my_bool
-number_to_time(longlong nr, MYSQL_TIME *ltime, int *warnings)
-{
-  if (nr > TIME_MAX_VALUE)
-  {
-    /* For huge numbers try full DATETIME, like str_to_time does. */
-    if (nr >= 10000000000LL) /* '0001-00-00 00-00-00' */
-    {
-      int warnings_backup= *warnings;
-      if (number_to_datetime(nr, ltime, 0, warnings) != -1LL)
-        return FALSE;
-      *warnings= warnings_backup;
-    }
-    set_max_time(ltime, 0);
-    *warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE;
-    return TRUE;
-  }
-  else if (nr < -TIME_MAX_VALUE)
-  {
-    set_max_time(ltime, 1);
-    *warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE;
-    return TRUE;
-  }
-  if ((ltime->neg= (nr < 0)))
-    nr= -nr;
-  if (nr % 100 >= 60 || nr / 100 % 100 >= 60) /* Check hours and minutes */
-  {
-    set_zero_time(ltime, MYSQL_TIMESTAMP_TIME);
-    *warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE;
-    return TRUE;
-  }
-  ltime->time_type= MYSQL_TIMESTAMP_TIME;
-  ltime->year= ltime->month= ltime->day= 0;
-  TIME_set_hhmmss(ltime, (uint)nr);
-  ltime->second_part= 0;
-  return FALSE;
-}
-
-
-/**
-  Adjust 'time' value to lie in the MYSQL_TIME range.
-  If the time value lies outside of the range [-838:59:59, 838:59:59],
-  set it to the closest endpoint of the range and set
-  MYSQL_TIME_WARN_OUT_OF_RANGE flag in the 'warning' variable.
-
-  @param  time     pointer to MYSQL_TIME value
-  @param  warning  set MYSQL_TIME_WARN_OUT_OF_RANGE flag if the value is out of range
-*/
-void adjust_time_range(struct st_mysql_time *my_time, int *warning) 
-{
-  DBUG_ASSERT(!check_time_mmssff_range(my_time));
-  if (check_time_range_quick(my_time))
-  {
-    my_time->day= my_time->second_part= 0;
-    set_max_hhmmss(my_time);
-    *warning|= MYSQL_TIME_WARN_OUT_OF_RANGE;
-  }
-}
-
-
-/*
-  Prepare offset of system time zone from UTC for my_system_gmt_sec() func.
-
-  SYNOPSIS
-    my_init_time()
-*/
-void my_init_time(void)
-{
-  time_t seconds;
-  struct tm *l_time,tm_tmp;
-  MYSQL_TIME my_time;
-  my_bool not_used;
-
-  seconds= (time_t) time((time_t*) 0);
-  localtime_r(&seconds,&tm_tmp);
-  l_time= &tm_tmp;
-  my_time_zone=		3600;		/* Comp. for -3600 in my_gmt_sec */
-  my_time.year=		(uint) l_time->tm_year+1900;
-  my_time.month=	(uint) l_time->tm_mon+1;
-  my_time.day=		(uint) l_time->tm_mday;
-  my_time.hour=		(uint) l_time->tm_hour;
-  my_time.minute=	(uint) l_time->tm_min;
-  my_time.second=	(uint) l_time->tm_sec;
-  my_time.time_type= MYSQL_TIMESTAMP_DATETIME;
-  my_time.neg= 0;
-  my_time.second_part= 0;
-  my_system_gmt_sec(&my_time, &my_time_zone, &not_used); /* Init my_time_zone */
-}
-
-
-/*
-  Handle 2 digit year conversions
-
-  SYNOPSIS
-  year_2000_handling()
-  year     2 digit year
-
-  RETURN
-    Year between 1970-2069
-*/
-
-uint year_2000_handling(uint year)
-{
-  if ((year=year+1900) < 1900+YY_PART_YEAR)
-    year+=100;
-  return year;
-}
-
-
-/*
-  Calculate nr of day since year 0 in new date-system (from 1615)
-
-  SYNOPSIS
-    calc_daynr()
-    year		 Year (exact 4 digit year, no year conversions)
-    month		 Month
-    day			 Day
-
-  NOTES: 0000-00-00 is a valid date, and will return 0
-
-  RETURN
-    Days since 0000-00-00
-*/
-
-long calc_daynr(uint year,uint month,uint day)
-{
-  long delsum;
-  int temp;
-  int y= year;                                  /* may be < 0 temporarily */
-  DBUG_ENTER("calc_daynr");
-
-  if (y == 0 && month == 0)
-    DBUG_RETURN(0);				/* Skip errors */
-  /* Cast to int to be able to handle month == 0 */
-  delsum= (long) (365 * y + 31 *((int) month - 1) + (int) day);
-  if (month <= 2)
-      y--;
-  else
-    delsum-= (long) ((int) month * 4 + 23) / 10;
-  temp=(int) ((y/100+1)*3)/4;
-  DBUG_PRINT("exit",("year: %d  month: %d  day: %d -> daynr: %ld",
-		     y+(month <= 2),month,day,delsum+y/4-temp));
-  DBUG_ASSERT(delsum+(int) y/4-temp >= 0);
-  DBUG_RETURN(delsum+(int) y/4-temp);
-} /* calc_daynr */
-
-
-/*
-  Convert time in MYSQL_TIME representation in system time zone to its
-  my_time_t form (number of seconds in UTC since begginning of Unix Epoch).
-
-  SYNOPSIS
-    my_system_gmt_sec()
-      t               - time value to be converted
-      my_timezone     - pointer to long where offset of system time zone
-                        from UTC will be stored for caching
-      in_dst_time_gap - set to true if time falls into spring time-gap
-
-  NOTES
-    The idea is to cache the time zone offset from UTC (including daylight 
-    saving time) for the next call to make things faster. But currently we 
-    just calculate this offset during startup (by calling my_init_time() 
-    function) and use it all the time.
-    Time value provided should be legal time value (e.g. '2003-01-01 25:00:00'
-    is not allowed).
-
-  RETURN VALUE
-    Time in UTC seconds since Unix Epoch representation.
-*/
-my_time_t
-my_system_gmt_sec(const MYSQL_TIME *t_src, long *my_timezone,
-                  my_bool *in_dst_time_gap)
-{
-  uint loop;
-  time_t tmp= 0;
-  int shift= 0;
-  MYSQL_TIME tmp_time;
-  MYSQL_TIME *t= &tmp_time;
-  struct tm *l_time,tm_tmp;
-  long diff, current_timezone;
-
-  /*
-    Use temp variable to avoid trashing input data, which could happen in
-    case of shift required for boundary dates processing.
-  */
-  memcpy(&tmp_time, t_src, sizeof(MYSQL_TIME));
-
-  if (!validate_timestamp_range(t))
-    return 0;
-
-  /*
-    Calculate the gmt time based on current time and timezone
-    The -1 on the end is to ensure that if have a date that exists twice
-    (like 2002-10-27 02:00:0 MET), we will find the initial date.
-
-    By doing -3600 we will have to call localtime_r() several times, but
-    I couldn't come up with a better way to get a repeatable result :(
-
-    We can't use mktime() as it's buggy on many platforms and not thread safe.
-
-    Note: this code assumes that our time_t estimation is not too far away
-    from real value (we assume that localtime_r(tmp) will return something
-    within 24 hrs from t) which is probably true for all current time zones.
-
-    Note2: For the dates, which have time_t representation close to
-    MAX_INT32 (efficient time_t limit for supported platforms), we should
-    do a small trick to avoid overflow. That is, convert the date, which is
-    two days earlier, and then add these days to the final value.
-
-    The same trick is done for the values close to 0 in time_t
-    representation for platfroms with unsigned time_t (QNX).
-
-    To be more verbose, here is a sample (extracted from the code below):
-    (calc_daynr(2038, 1, 19) - (long) days_at_timestart)*86400L + 4*3600L
-    would return -2147480896 because of the long type overflow. In result
-    we would get 1901 year in localtime_r(), which is an obvious error.
-
-    Alike problem raises with the dates close to Epoch. E.g.
-    (calc_daynr(1969, 12, 31) - (long) days_at_timestart)*86400L + 23*3600L
-    will give -3600.
-
-    On some platforms, (E.g. on QNX) time_t is unsigned and localtime(-3600)
-    wil give us a date around 2106 year. Which is no good.
-
-    Theoreticaly, there could be problems with the latter conversion:
-    there are at least two timezones, which had time switches near 1 Jan
-    of 1970 (because of political reasons). These are America/Hermosillo and
-    America/Mazatlan time zones. They changed their offset on
-    1970-01-01 08:00:00 UTC from UTC-8 to UTC-7. For these zones
-    the code below will give incorrect results for dates close to
-    1970-01-01, in the case OS takes into account these historical switches.
-    Luckily, it seems that we support only one platform with unsigned
-    time_t. It's QNX. And QNX does not support historical timezone data at all.
-    E.g. there are no /usr/share/zoneinfo/ files or any other mean to supply
-    historical information for localtime_r() etc. That is, the problem is not
-    relevant to QNX.
-
-    We are safe with shifts close to MAX_INT32, as there are no known
-    time switches on Jan 2038 yet :)
-  */
-  if ((t->year == TIMESTAMP_MAX_YEAR) && (t->month == 1) && (t->day > 4))
-  {
-    /*
-      Below we will pass (uint) (t->day - shift) to calc_daynr.
-      As we don't want to get an overflow here, we will shift
-      only safe dates. That's why we have (t->day > 4) above.
-    */
-    t->day-= 2;
-    shift= 2;
-  }
-
-  tmp= (time_t) (((calc_daynr((uint) t->year, (uint) t->month, (uint) t->day) -
-                   (long) days_at_timestart) * SECONDS_IN_24H +
-                   (long) t->hour*3600L +
-                  (long) (t->minute*60 + t->second)) + (time_t) my_time_zone -
-                 3600);
-
-  current_timezone= my_time_zone;
-  localtime_r(&tmp,&tm_tmp);
-  l_time=&tm_tmp;
-  for (loop=0;
-       loop < 2 &&
-	 (t->hour != (uint) l_time->tm_hour ||
-	  t->minute != (uint) l_time->tm_min ||
-          t->second != (uint) l_time->tm_sec);
-       loop++)
-  {					/* One check should be enough ? */
-    /* Get difference in days */
-    int days= t->day - l_time->tm_mday;
-    if (days < -1)
-      days= 1;					/* Month has wrapped */
-    else if (days > 1)
-      days= -1;
-    diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour)) +
-          (long) (60*((int) t->minute - (int) l_time->tm_min)) +
-          (long) ((int) t->second - (int) l_time->tm_sec));
-    current_timezone+= diff+3600;		/* Compensate for -3600 above */
-    tmp+= (time_t) diff;
-    localtime_r(&tmp,&tm_tmp);
-    l_time=&tm_tmp;
-  }
-  /*
-    Fix that if we are in the non existing daylight saving time hour
-    we move the start of the next real hour.
-
-    This code doesn't handle such exotical thing as time-gaps whose length
-    is more than one hour or non-integer (latter can theoretically happen
-    if one of seconds will be removed due leap correction, or because of
-    general time correction like it happened for Africa/Monrovia time zone
-    in year 1972).
-  */
-  if (loop == 2 && t->hour != (uint) l_time->tm_hour)
-  {
-    int days= t->day - l_time->tm_mday;
-    if (days < -1)
-      days=1;					/* Month has wrapped */
-    else if (days > 1)
-      days= -1;
-    diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour))+
-	  (long) (60*((int) t->minute - (int) l_time->tm_min)) +
-          (long) ((int) t->second - (int) l_time->tm_sec));
-    if (diff == 3600)
-      tmp+=3600 - t->minute*60 - t->second;	/* Move to next hour */
-    else if (diff == -3600)
-      tmp-=t->minute*60 + t->second;		/* Move to previous hour */
-
-    *in_dst_time_gap= 1;
-  }
-  *my_timezone= current_timezone;
-
-
-  /* shift back, if we were dealing with boundary dates */
-  tmp+= shift * SECONDS_IN_24H;
-
-  /*
-    This is possible for dates, which slightly exceed boundaries.
-    Conversion will pass ok for them, but we don't allow them.
-    First check will pass for platforms with signed time_t.
-    instruction above (tmp+= shift*86400L) could exceed
-    MAX_INT32 (== TIMESTAMP_MAX_VALUE) and overflow will happen.
-    So, tmp < TIMESTAMP_MIN_VALUE will be triggered. On platfroms
-    with unsigned time_t tmp+= shift*86400L might result in a number,
-    larger then TIMESTAMP_MAX_VALUE, so another check will work.
-  */
-  if (!IS_TIME_T_VALID_FOR_TIMESTAMP(tmp))
-    tmp= 0;
-
-  return (my_time_t) tmp;
-} /* my_system_gmt_sec */
-
-
-/**
-  Print the microsecond part: ".NNN"
-  @param to        OUT The string pointer to print at
-  @param useconds      The microseconds value.
-  @param dec           Precision, between 1 and 6.
-  @return              The length of the result string.
-*/
-static inline int
-my_useconds_to_str(char *to, ulong useconds, uint dec)
-{
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-  return sprintf(to, ".%0*lu", (int) dec,
-                 useconds / (ulong) log_10_int[DATETIME_MAX_DECIMALS - dec]);
-}
-
-
-/*
-  Functions to convert time/date/datetime value to a string,
-  using default format.
-  This functions don't check that given MYSQL_TIME structure members are
-  in valid range. If they are not, return value won't reflect any
-  valid date either. Additionally, make_time doesn't take into
-  account time->day member: it's assumed that days have been converted
-  to hours already.
-
-  RETURN
-    number of characters written to 'to'
-*/
-
-int my_time_to_str(const MYSQL_TIME *l_time, char *to, uint dec)
-{
-  uint extra_hours= 0;
-  int len= sprintf(to, "%s%02u:%02u:%02u", (l_time->neg ? "-" : ""),
-                   extra_hours + l_time->hour, l_time->minute, l_time->second);
-  if (dec)
-    len+= my_useconds_to_str(to + len, l_time->second_part, dec);
-  return len;
-}
-
-int my_date_to_str(const MYSQL_TIME *l_time, char *to)
-{
-  return sprintf(to, "%04u-%02u-%02u",
-                 l_time->year, l_time->month, l_time->day);
-}
-
-
-/*
-  Convert datetime to a string 'YYYY-MM-DD hh:mm:ss'.
-  Open coded for better performance.
-  This code previously resided in field.cc, in Field_timestamp::val_str().
-
-  @param  to     OUT  The string pointer to print at.
-  @param  ltime       The MYSQL_TIME value.
-  @return             The length of the result string.
-*/
-static inline int
-TIME_to_datetime_str(char *to, const MYSQL_TIME *ltime)
-{
-  uint32 temp, temp2;
-  /* Year */
-  temp= ltime->year / 100;
-  *to++= (char) ('0' + temp / 10);
-  *to++= (char) ('0' + temp % 10);
-  temp= ltime->year % 100;
-  *to++= (char) ('0' + temp / 10);
-  *to++= (char) ('0' + temp % 10);
-  *to++= '-';
-  /* Month */
-  temp= ltime->month;
-  temp2= temp / 10;
-  temp= temp-temp2 * 10;
-  *to++= (char) ('0' + (char) (temp2));
-  *to++= (char) ('0' + (char) (temp));
-  *to++= '-';
-  /* Day */ 
-  temp= ltime->day;
-  temp2= temp / 10;
-  temp= temp - temp2 * 10;
-  *to++= (char) ('0' + (char) (temp2));
-  *to++= (char) ('0' + (char) (temp));
-  *to++= ' ';
-  /* Hour */
-  temp= ltime->hour;
-  temp2= temp / 10;
-  temp= temp - temp2 * 10;
-  *to++= (char) ('0' + (char) (temp2));
-  *to++= (char) ('0' + (char) (temp));
-  *to++= ':';
-  /* Minute */
-  temp= ltime->minute;
-  temp2= temp / 10;
-  temp= temp - temp2 * 10;
-  *to++= (char) ('0' + (char) (temp2));
-  *to++= (char) ('0' + (char) (temp));
-  *to++= ':';
-  /* Second */
-  temp= ltime->second;
-  temp2=temp / 10;
-  temp= temp - temp2 * 10;
-  *to++= (char) ('0' + (char) (temp2));
-  *to++= (char) ('0' + (char) (temp));
-  return 19;
-}
-
-
-/**
-  Print a datetime value with an optional fractional part.
-
-  @l_time       The MYSQL_TIME value to print.
-  @to      OUT  The string pointer to print at.
-  @return       The length of the result string.  
-*/
-int my_datetime_to_str(const MYSQL_TIME *l_time, char *to, uint dec)
-{
-  int len= TIME_to_datetime_str(to, l_time);
-  if (dec)
-    len+= my_useconds_to_str(to + len, l_time->second_part, dec);
-  else
-    to[len]= '\0';
-  return len;
-}
-
-
-/*
-  Convert struct DATE/TIME/DATETIME value to string using built-in
-  MySQL time conversion formats.
-
-  SYNOPSIS
-    my_TIME_to_string()
-
-  NOTE
-    The string must have at least MAX_DATE_STRING_REP_LENGTH bytes reserved.
-*/
-
-int my_TIME_to_str(const MYSQL_TIME *l_time, char *to, uint dec)
-{
-  switch (l_time->time_type) {
-  case MYSQL_TIMESTAMP_DATETIME:
-    return my_datetime_to_str(l_time, to, dec);
-  case MYSQL_TIMESTAMP_DATE:
-    return my_date_to_str(l_time, to);
-  case MYSQL_TIMESTAMP_TIME:
-    return my_time_to_str(l_time, to, dec);
-  case MYSQL_TIMESTAMP_NONE:
-  case MYSQL_TIMESTAMP_ERROR:
-    to[0]='\0';
-    return 0;
-  default:
-    DBUG_ASSERT(0);
-    return 0;
-  }
-}
-
-
-/**
-  Print a timestamp with an oprional fractional part: XXXXX[.YYYYY]
-
-  @param      tm  The timestamp value to print.
-  @param  OUT to  The string pointer to print at. 
-  @param      dec Precision, in the range 0..6.
-  @return         The length of the result string.
-*/
-int my_timeval_to_str(const struct timeval *tm, char *to, uint dec)
-{
-  int len= sprintf(to, "%d", (int) tm->tv_sec);
-  if (dec)
-    len+= my_useconds_to_str(to + len, tm->tv_usec, dec);
-  return len;
-}
-
-
-/*
-  Convert datetime value specified as number to broken-down TIME
-  representation and form value of DATETIME type as side-effect.
-
-  SYNOPSIS
-    number_to_datetime()
-      nr         - datetime value as number
-      time_res   - pointer for structure for broken-down representation
-      flags      - flags to use in validating date, as in str_to_datetime()
-      was_cut    0      Value ok
-                 1      If value was cut during conversion
-                 2      check_date(date,flags) considers date invalid
-
-  DESCRIPTION
-    Convert a datetime value of formats YYMMDD, YYYYMMDD, YYMMDDHHMSS,
-    YYYYMMDDHHMMSS to broken-down MYSQL_TIME representation. Return value in
-    YYYYMMDDHHMMSS format as side-effect.
-
-    This function also checks if datetime value fits in DATETIME range.
-
-  RETURN VALUE
-    -1              Timestamp with wrong values
-    anything else   DATETIME as integer in YYYYMMDDHHMMSS format
-    Datetime value in YYYYMMDDHHMMSS format.
-
-    was_cut         if return value -1: one of
-                      - MYSQL_TIME_WARN_OUT_OF_RANGE
-                      - MYSQL_TIME_WARN_ZERO_DATE
-                      - MYSQL_TIME_WARN_TRUNCATED
-                    otherwise 0.
-*/
-
-longlong number_to_datetime(longlong nr, MYSQL_TIME *time_res,
-                            my_time_flags_t flags, int *was_cut)
-{
-  long part1,part2;
-
-  *was_cut= 0;
-  memset(time_res, 0, sizeof(*time_res));
-  time_res->time_type=MYSQL_TIMESTAMP_DATE;
-
-  if (nr == 0LL || nr >= 10000101000000LL)
-  {
-    time_res->time_type=MYSQL_TIMESTAMP_DATETIME;
-    if (nr > 99999999999999LL) /* 9999-99-99 99:99:99 */
-    {
-      *was_cut= MYSQL_TIME_WARN_OUT_OF_RANGE;
-      return -1LL;
-    }
-    goto ok;
-  }
-  if (nr < 101)
-    goto err;
-  if (nr <= (YY_PART_YEAR-1)*10000L+1231L)
-  {
-    nr= (nr+20000000L)*1000000L;                 /* YYMMDD, year: 2000-2069 */
-    goto ok;
-  }
-  if (nr < (YY_PART_YEAR)*10000L+101L)
-    goto err;
-  if (nr <= 991231L)
-  {
-    nr= (nr+19000000L)*1000000L;                 /* YYMMDD, year: 1970-1999 */
-    goto ok;
-  }
-  /*
-    Though officially we support DATE values from 1000-01-01 only, one can
-    easily insert a value like 1-1-1. So, for consistency reasons such dates
-    are allowed when TIME_FUZZY_DATE is set.
-  */
-  if (nr < 10000101L && !(flags & TIME_FUZZY_DATE))
-    goto err;
-  if (nr <= 99991231L)
-  {
-    nr= nr*1000000L;
-    goto ok;
-  }
-  if (nr < 101000000L)
-    goto err;
-
-  time_res->time_type=MYSQL_TIMESTAMP_DATETIME;
-
-  if (nr <= (YY_PART_YEAR-1)*10000000000LL+1231235959LL)
-  {
-    nr= nr+20000000000000LL;                   /* YYMMDDHHMMSS, 2000-2069 */
-    goto ok;
-  }
-  if (nr <  YY_PART_YEAR*10000000000LL+ 101000000LL)
-    goto err;
-  if (nr <= 991231235959LL)
-    nr= nr+19000000000000LL;		/* YYMMDDHHMMSS, 1970-1999 */
-
- ok:
-  part1=(long) (nr/1000000LL);
-  part2=(long) (nr - (longlong) part1*1000000LL);
-  time_res->year=  (int) (part1/10000L);  part1%=10000L;
-  time_res->month= (int) part1 / 100;
-  time_res->day=   (int) part1 % 100;
-  time_res->hour=  (int) (part2/10000L);  part2%=10000L;
-  time_res->minute=(int) part2 / 100;
-  time_res->second=(int) part2 % 100;
-
-  if (!check_datetime_range(time_res) &&
-      !check_date(time_res, (nr != 0), flags, was_cut))
-    return nr;
-
-  /* Don't want to have was_cut get set if TIME_NO_ZERO_DATE was violated. */
-  if (!nr && (flags & TIME_NO_ZERO_DATE))
-    return -1LL;
-
- err:
-  *was_cut= MYSQL_TIME_WARN_TRUNCATED;
-  return -1LL;
-}
-
-
-/**
-  Convert time value to integer in YYYYMMDDHHMMSS.
-  @param  my_time  The MYSQL_TIME value to convert.
-  @return          A number in format YYYYMMDDHHMMSS.
-*/
-ulonglong TIME_to_ulonglong_datetime(const MYSQL_TIME *my_time)
-{
-  return ((ulonglong) (my_time->year * 10000UL +
-                       my_time->month * 100UL +
-                       my_time->day) * 1000000ULL +
-          (ulonglong) (my_time->hour * 10000UL +
-                       my_time->minute * 100UL +
-                       my_time->second));
-}
-
-
-
-/**
-  Convert MYSQL_TIME value to integer in YYYYMMDD format
-  @param my_time  The MYSQL_TIME value to convert.
-  @return         A number in format YYYYMMDD.
-*/
-ulonglong TIME_to_ulonglong_date(const MYSQL_TIME *my_time)
-{
-  return (ulonglong) (my_time->year * 10000UL + my_time->month * 100UL +
-                      my_time->day);
-}
-
-
-/**
-  Convert MYSQL_TIME value to integer in HHMMSS format.
-  This function doesn't take into account time->day member:
-  it's assumed that days have been converted to hours already.
-  @param my_time  The TIME value to convert.
-  @return         The number in HHMMSS format.
-*/
-ulonglong TIME_to_ulonglong_time(const MYSQL_TIME *my_time)
-{
-  return (ulonglong) (my_time->hour * 10000UL +
-                      my_time->minute * 100UL +
-                      my_time->second);
-}
-
-
-/**
-  Set day, month and year from a number
-  @param ltime    MYSQL_TIME variable
-  @param yymmdd   Number in YYYYMMDD format
-*/
-void TIME_set_yymmdd(MYSQL_TIME *ltime, uint yymmdd)
-{
-  ltime->day=   (int) (yymmdd % 100);
-  ltime->month= (int) (yymmdd / 100) % 100;
-  ltime->year=  (int) (yymmdd / 10000);
-}
-
-
-/**
-  Set hour, minute and secondr from a number
-  @param ltime    MYSQL_TIME variable
-  @param hhmmss   Number in HHMMSS format
-*/
-void TIME_set_hhmmss(MYSQL_TIME *ltime, uint hhmmss)
-{
-  ltime->second=  (int) (hhmmss % 100);
-  ltime->minute=  (int) (hhmmss / 100) % 100;
-  ltime->hour=    (int) (hhmmss / 10000);
-}
-
-
-/*
-  Convert struct MYSQL_TIME (date and time split into year/month/day/hour/...
-  to a number in format YYYYMMDDHHMMSS (DATETIME),
-  YYYYMMDD (DATE)  or HHMMSS (TIME).
-
-  SYNOPSIS
-    TIME_to_ulonglong()
-
-  DESCRIPTION
-    The function is used when we need to convert value of time item
-    to a number if it's used in numeric context, i. e.:
-    SELECT NOW()+1, CURDATE()+0, CURTIMIE()+0;
-    SELECT ?+1;
-
-  NOTE
-    This function doesn't check that given MYSQL_TIME structure members are
-    in valid range. If they are not, return value won't reflect any
-    valid date either.
-*/
-
-ulonglong TIME_to_ulonglong(const MYSQL_TIME *my_time)
-{
-  switch (my_time->time_type) {
-  case MYSQL_TIMESTAMP_DATETIME:
-    return TIME_to_ulonglong_datetime(my_time);
-  case MYSQL_TIMESTAMP_DATE:
-    return TIME_to_ulonglong_date(my_time);
-  case MYSQL_TIMESTAMP_TIME:
-    return TIME_to_ulonglong_time(my_time);
-  case MYSQL_TIMESTAMP_NONE:
-  case MYSQL_TIMESTAMP_ERROR:
-    return 0ULL;
-  default:
-    DBUG_ASSERT(0);
-  }
-  return 0;
-}
-
-
-/*** TIME low-level memory and disk representation routines ***/
-
-/*
-  In-memory format:
-
-   1  bit sign          (Used for sign, when on disk)
-   1  bit unused        (Reserved for wider hour range, e.g. for intervals)
-   10 bit hour          (0-836)
-   6  bit minute        (0-59)
-   6  bit second        (0-59)
-  24  bits microseconds (0-999999)
-
- Total: 48 bits = 6 bytes
-   Suhhhhhh.hhhhmmmm.mmssssss.ffffffff.ffffffff.ffffffff
-*/
-
-
-/**
-  Convert time value to numeric packed representation.
-  
-  @param    ltime   The value to convert.
-  @return           Numeric packed representation.
-*/
-longlong TIME_to_longlong_time_packed(const MYSQL_TIME *ltime)
-{
-  /* If month is 0, we mix day with hours: "1 00:10:10" -> "24:00:10" */
-  long hms= (((ltime->month ? 0 : ltime->day * 24) + ltime->hour) << 12) |
-            (ltime->minute << 6) | ltime->second;
-  longlong tmp= MY_PACKED_TIME_MAKE(hms, ltime->second_part);
-  return ltime->neg ? -tmp : tmp;
-}
-
-
-/**
-  Convert time packed numeric representation to time.
-
-  @param  OUT ltime  The MYSQL_TIME variable to set.
-  @param      tmp    The packed numeric representation.
-*/
-void TIME_from_longlong_time_packed(MYSQL_TIME *ltime, longlong tmp)
-{
-  longlong hms;
-  if ((ltime->neg= (tmp < 0)))
-    tmp= -tmp;
-  hms= MY_PACKED_TIME_GET_INT_PART(tmp);
-  ltime->year=   (uint) 0;
-  ltime->month=  (uint) 0;
-  ltime->day=    (uint) 0;
-  ltime->hour=   (uint) (hms >> 12) % (1 << 10); /* 10 bits starting at 12th */
-  ltime->minute= (uint) (hms >> 6)  % (1 << 6);  /* 6 bits starting at 6th   */
-  ltime->second= (uint)  hms        % (1 << 6);  /* 6 bits starting at 0th   */
-  ltime->second_part= MY_PACKED_TIME_GET_FRAC_PART(tmp);
-  ltime->time_type= MYSQL_TIMESTAMP_TIME;
-}
-
-/*
-  On disk we convert from signed representation to unsigned
-  representation using TIMEF_OFS, so all values become binary comparable.
-*/
-#define TIMEF_OFS 0x800000000000LL
-#define TIMEF_INT_OFS 0x800000LL
-
-
-/**
-  Convert in-memory numeric time representation to on-disk representation
-  
-  @param       nr   Value in packed numeric time format.
-  @param   OUT ptr  The buffer to put value at.
-  @param       dec  Precision.
-*/
-void my_time_packed_to_binary(longlong nr, uchar *ptr, uint dec)
-{
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-  /* Make sure the stored value was previously properly rounded or truncated */
-  DBUG_ASSERT((MY_PACKED_TIME_GET_FRAC_PART(nr) % 
-              (int) log_10_int[DATETIME_MAX_DECIMALS - dec]) == 0);
-
-  switch (dec)
-  {
-  case 0:
-  default:
-    mi_int3store(ptr, TIMEF_INT_OFS + MY_PACKED_TIME_GET_INT_PART(nr));
-    break;
-
-  case 1:
-  case 2:
-    mi_int3store(ptr, TIMEF_INT_OFS + MY_PACKED_TIME_GET_INT_PART(nr));
-    ptr[3]= (unsigned char) (char) (MY_PACKED_TIME_GET_FRAC_PART(nr) / 10000);
-    break;
-
-  case 4:
-  case 3:
-    mi_int3store(ptr, TIMEF_INT_OFS + MY_PACKED_TIME_GET_INT_PART(nr));
-    mi_int2store(ptr + 3, MY_PACKED_TIME_GET_FRAC_PART(nr) / 100);
-    break;
-
-  case 5:
-  case 6:
-    mi_int6store(ptr, nr + TIMEF_OFS);
-    break;
-  }
-}
-
-
-/**
-  Convert on-disk time representation to in-memory packed numeric 
-  representation.
-  
-  @param   ptr  The pointer to read the value at.
-  @param   dec  Precision.
-  @return       Packed numeric time representation.
-*/
-longlong my_time_packed_from_binary(const uchar *ptr, uint dec)
-{
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-
-  switch (dec)
-  {
-  case 0:
-  default:
-    {
-      longlong intpart= mi_uint3korr(ptr) - TIMEF_INT_OFS;
-      return MY_PACKED_TIME_MAKE_INT(intpart);
-    }
-  case 1:
-  case 2:
-    {
-      longlong intpart= mi_uint3korr(ptr) - TIMEF_INT_OFS;
-      int frac= (uint) ptr[3];
-      if (intpart < 0 && frac)
-      {
-        /*
-          Negative values are stored with reverse fractional part order,
-          for binary sort compatibility.
-
-            Disk value  intpart frac   Time value   Memory value
-            800000.00    0      0      00:00:00.00  0000000000.000000
-            7FFFFF.FF   -1      255   -00:00:00.01  FFFFFFFFFF.FFD8F0
-            7FFFFF.9D   -1      99    -00:00:00.99  FFFFFFFFFF.F0E4D0
-            7FFFFF.00   -1      0     -00:00:01.00  FFFFFFFFFF.000000
-            7FFFFE.FF   -1      255   -00:00:01.01  FFFFFFFFFE.FFD8F0
-            7FFFFE.F6   -2      246   -00:00:01.10  FFFFFFFFFE.FE7960
-
-            Formula to convert fractional part from disk format
-            (now stored in "frac" variable) to absolute value: "0x100 - frac".
-            To reconstruct in-memory value, we shift
-            to the next integer value and then substruct fractional part.
-        */
-        intpart++;    /* Shift to the next integer value */
-        frac-= 0x100; /* -(0x100 - frac) */
-      }
-      return MY_PACKED_TIME_MAKE(intpart, frac * 10000);
-    }
-
-  case 3:
-  case 4:
-    {
-      longlong intpart= mi_uint3korr(ptr) - TIMEF_INT_OFS;
-      int frac= mi_uint2korr(ptr + 3);
-      if (intpart < 0 && frac)
-      {
-        /*
-          Fix reverse fractional part order: "0x10000 - frac".
-          See comments for FSP=1 and FSP=2 above.
-        */
-        intpart++;      /* Shift to the next integer value */
-        frac-= 0x10000; /* -(0x10000-frac) */
-      }
-      return MY_PACKED_TIME_MAKE(intpart, frac * 100);
-    }
-
-  case 5:
-  case 6:
-    return ((longlong) mi_uint6korr(ptr)) - TIMEF_OFS;
-  }
-}
-
-
-/*** DATETIME and DATE low-level memory and disk representation routines ***/
-
-/*
-    1 bit  sign            (used when on disk)
-   17 bits year*13+month   (year 0-9999, month 0-12)
-    5 bits day             (0-31)
-    5 bits hour            (0-23)
-    6 bits minute          (0-59)
-    6 bits second          (0-59)
-   24 bits microseconds    (0-999999)
-
-   Total: 64 bits = 8 bytes
-
-   SYYYYYYY.YYYYYYYY.YYdddddh.hhhhmmmm.mmssssss.ffffffff.ffffffff.ffffffff
-*/
-
-/**
-  Convert datetime to packed numeric datetime representation.
-  @param ltime  The value to convert.
-  @return       Packed numeric representation of ltime.
-*/
-longlong TIME_to_longlong_datetime_packed(const MYSQL_TIME *ltime)
-{
-  longlong ymd= ((ltime->year * 13 + ltime->month) << 5) | ltime->day;
-  longlong hms= (ltime->hour << 12) | (ltime->minute << 6) | ltime->second;
-  longlong tmp= MY_PACKED_TIME_MAKE(((ymd << 17) | hms), ltime->second_part);
-  DBUG_ASSERT(!check_datetime_range(ltime)); /* Make sure no overflow */
-  return ltime->neg ? -tmp : tmp;
-}
-
-
-/**
-  Convert date to packed numeric date representation.
-  Numeric packed date format is similar to numeric packed datetime
-  representation, with zero hhmmss part.
-  
-  @param ltime The value to convert.
-  @return      Packed numeric representation of ltime.
-*/
-longlong TIME_to_longlong_date_packed(const MYSQL_TIME *ltime)
-{
-  longlong ymd= ((ltime->year * 13 + ltime->month) << 5) | ltime->day;
-  return MY_PACKED_TIME_MAKE_INT(ymd << 17);
-}
-
-
-/**
-  Convert year to packed numeric date representation.
-  Packed value for YYYY is the same to packed value for date YYYY-00-00.
-*/
-longlong year_to_longlong_datetime_packed(long year)
-{
-  longlong ymd= ((year * 13) << 5);
-  return MY_PACKED_TIME_MAKE_INT(ymd << 17);
-}
-
-
-/**
-  Convert packed numeric datetime representation to MYSQL_TIME.
-  @param OUT  ltime The datetime variable to convert to.
-  @param      tmp   The packed numeric datetime value.
-*/
-void TIME_from_longlong_datetime_packed(MYSQL_TIME *ltime, longlong tmp)
-{
-  longlong ymd, hms;
-  longlong ymdhms, ym;
-  if ((ltime->neg= (tmp < 0)))
-    tmp= -tmp;
-
-  ltime->second_part= MY_PACKED_TIME_GET_FRAC_PART(tmp);
-  ymdhms= MY_PACKED_TIME_GET_INT_PART(tmp);
-
-  ymd= ymdhms >> 17;
-  ym= ymd >> 5;
-  hms= ymdhms % (1 << 17);
-
-  ltime->day= ymd % (1 << 5);
-  ltime->month= ym % 13;
-  ltime->year= (uint)(ym / 13);
-
-  ltime->second= hms % (1 << 6);
-  ltime->minute= (hms >> 6) % (1 << 6);
-  ltime->hour= (uint)(hms >> 12);
-  
-  ltime->time_type= MYSQL_TIMESTAMP_DATETIME;
-}
-
-
-/**
-  Convert packed numeric date representation to MYSQL_TIME.
-  @param OUT  ltime The date variable to convert to.
-  @param      tmp   The packed numeric date value.
-*/
-void TIME_from_longlong_date_packed(MYSQL_TIME *ltime, longlong tmp)
-{
-  TIME_from_longlong_datetime_packed(ltime, tmp);
-  ltime->time_type= MYSQL_TIMESTAMP_DATE;
-}
-
-
-/*
-  On disk we store as unsigned number with DATETIMEF_INT_OFS offset,
-  for HA_KETYPE_BINARY compatibilty purposes.
-*/
-#define DATETIMEF_INT_OFS 0x8000000000LL
-
-
-/**
-  Convert on-disk datetime representation
-  to in-memory packed numeric representation.
-
-  @param ptr   The pointer to read value at.
-  @param dec   Precision.
-  @return      In-memory packed numeric datetime representation.
-*/
-longlong my_datetime_packed_from_binary(const uchar *ptr, uint dec)
-{
-  longlong intpart= mi_uint5korr(ptr) - DATETIMEF_INT_OFS;
-  int frac;
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-  switch (dec)
-  {
-  case 0:
-  default:
-    return MY_PACKED_TIME_MAKE_INT(intpart);
-  case 1:
-  case 2:
-    frac= ((int) (signed char) ptr[5]) * 10000;
-    break;
-  case 3:
-  case 4:
-    frac= mi_sint2korr(ptr + 5) * 100;
-    break;
-  case 5:
-  case 6:
-    frac= mi_sint3korr(ptr + 5);
-    break;
-  }
-  return MY_PACKED_TIME_MAKE(intpart, frac);
-}
-
-
-/**
-  Store in-memory numeric packed datetime representation to disk.
-
-  @param      nr  In-memory numeric packed datetime representation.
-  @param OUT  ptr The pointer to store at.
-  @param      dec Precision, 1-6.
-*/
-void my_datetime_packed_to_binary(longlong nr, uchar *ptr, uint dec)
-{
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-  /* The value being stored must have been properly rounded or truncated */
-  DBUG_ASSERT((MY_PACKED_TIME_GET_FRAC_PART(nr) %
-              (int) log_10_int[DATETIME_MAX_DECIMALS - dec]) == 0);
-
-  mi_int5store(ptr, MY_PACKED_TIME_GET_INT_PART(nr) + DATETIMEF_INT_OFS);
-  switch (dec)
-  {
-  case 0:
-  default:
-    break;
-  case 1:
-  case 2:
-    ptr[5]= (unsigned char) (char) (MY_PACKED_TIME_GET_FRAC_PART(nr) / 10000);
-    break;
-  case 3:
-  case 4:
-    mi_int2store(ptr + 5, MY_PACKED_TIME_GET_FRAC_PART(nr) / 100);
-    break;
-  case 5:
-  case 6:
-    mi_int3store(ptr + 5, MY_PACKED_TIME_GET_FRAC_PART(nr));
-  }
-}
-
-
-/*** TIMESTAMP low-level memory and disk representation routines ***/
-
-/**
-  Convert binary timestamp representation to in-memory representation.
-
-  @param  OUT tm  The variable to convert to.
-  @param      ptr The pointer to read the value from.
-  @param      dec Precision.
-*/
-void my_timestamp_from_binary(struct timeval *tm, const uchar *ptr, uint dec)
-{
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-  tm->tv_sec= mi_uint4korr(ptr);
-  switch (dec)
-  {
-    case 0:
-    default:
-      tm->tv_usec= 0;
-      break;
-    case 1:
-    case 2:
-      tm->tv_usec= ((int) ptr[4]) * 10000;
-      break;
-    case 3:
-    case 4:
-      tm->tv_usec= mi_sint2korr(ptr + 4) * 100;
-      break;
-    case 5:
-    case 6:
-      tm->tv_usec= mi_sint3korr(ptr + 4);
-  }
-}
-
-
-/**
-  Convert in-memory timestamp representation to on-disk representation.
-
-  @param        tm   The value to convert.
-  @param  OUT   ptr  The pointer to store the value to.
-  @param        dec  Precision.
-*/
-void my_timestamp_to_binary(const struct timeval *tm, uchar *ptr, uint dec)
-{
-  DBUG_ASSERT(dec <= DATETIME_MAX_DECIMALS);
-  /* Stored value must have been previously properly rounded or truncated */
-  DBUG_ASSERT((tm->tv_usec %
-               (int) log_10_int[DATETIME_MAX_DECIMALS - dec]) == 0);
-  mi_int4store(ptr, tm->tv_sec);
-  switch (dec)
-  {
-    case 0:
-    default:
-      break;
-    case 1:
-    case 2:
-      ptr[4]= (unsigned char) (char) (tm->tv_usec / 10000);
-      break;
-    case 3:
-    case 4:
-      mi_int2store(ptr + 4, tm->tv_usec / 100);
-      break;
-      /* Impossible second precision. Fall through */
-    case 5:
-    case 6:
-      mi_int3store(ptr + 4, tm->tv_usec);
-  }
-}
-
-/****************************************/
-
-
-/**
-  Convert a temporal value to packed numeric temporal representation,
-  depending on its time_type.
-
-  @ltime   The value to convert.
-  @return  Packed numeric time/date/datetime representation.
-*/
-longlong TIME_to_longlong_packed(const MYSQL_TIME *ltime)
-{
-  switch (ltime->time_type) {
-  case MYSQL_TIMESTAMP_DATE:
-    return TIME_to_longlong_date_packed(ltime);
-  case MYSQL_TIMESTAMP_DATETIME:
-    return TIME_to_longlong_datetime_packed(ltime);
-  case MYSQL_TIMESTAMP_TIME:
-    return TIME_to_longlong_time_packed(ltime);   
-  case MYSQL_TIMESTAMP_NONE:
-  case MYSQL_TIMESTAMP_ERROR:
-    return 0;
-  }
-  DBUG_ASSERT(0);
-  return 0;
-}
-
-/*** End of low level format routines ***/
diff --git a/mysql/sql-common/pack.c b/mysql/sql-common/pack.c
deleted file mode 100644
index 971fa66..0000000
--- a/mysql/sql-common/pack.c
+++ /dev/null
@@ -1,140 +0,0 @@
-/* Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program 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 General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
-
-#include <my_global.h>
-#include <mysql_com.h>
-#include <mysql.h>
-
-/* Get the length of next field. Change parameter to point at fieldstart */
-ulong STDCALL net_field_length(uchar **packet)
-{
-  uchar *pos= (uchar *)*packet;
-  if (*pos < 251)
-  {
-    (*packet)++;
-    return (ulong) *pos;
-  }
-  if (*pos == 251)
-  {
-    (*packet)++;
-    return NULL_LENGTH;
-  }
-  if (*pos == 252)
-  {
-    (*packet)+=3;
-    return (ulong) uint2korr(pos+1);
-  }
-  if (*pos == 253)
-  {
-    (*packet)+=4;
-    return (ulong) uint3korr(pos+1);
-  }
-  (*packet)+=9;					/* Must be 254 when here */
-  return (ulong) uint4korr(pos+1);
-}
-
-/* The same as above but returns longlong */
-my_ulonglong net_field_length_ll(uchar **packet)
-{
-  uchar *pos= *packet;
-  if (*pos < 251)
-  {
-    (*packet)++;
-    return (my_ulonglong) *pos;
-  }
-  if (*pos == 251)
-  {
-    (*packet)++;
-    return (my_ulonglong) NULL_LENGTH;
-  }
-  if (*pos == 252)
-  {
-    (*packet)+=3;
-    return (my_ulonglong) uint2korr(pos+1);
-  }
-  if (*pos == 253)
-  {
-    (*packet)+=4;
-    return (my_ulonglong) uint3korr(pos+1);
-  }
-  (*packet)+=9;					/* Must be 254 when here */
-  return (my_ulonglong) uint8korr(pos+1);
-}
-
-/*
-  Store an integer with simple packing into a output package
-
-  SYNOPSIS
-    net_store_length()
-    pkg			Store the packed integer here
-    length		integers to store
-
-  NOTES
-    This is mostly used to store lengths of strings.
-    We have to cast the result of the LL because of a bug in Forte CC
-    compiler.
-
-  RETURN
-   Position in 'pkg' after the packed length
-*/
-
-uchar *net_store_length(uchar *packet, ulonglong length)
-{
-  if (length < (ulonglong) 251LL)
-  {
-    *packet=(uchar) length;
-    return packet+1;
-  }
-  /* 251 is reserved for NULL */
-  if (length < (ulonglong) 65536LL)
-  {
-    *packet++=252;
-    int2store(packet,(uint) length);
-    return packet+2;
-  }
-  if (length < (ulonglong) 16777216LL)
-  {
-    *packet++=253;
-    int3store(packet,(ulong) length);
-    return packet+3;
-  }
-  *packet++=254;
-  int8store(packet,length);
-  return packet+8;
-}
-
-
-/**
-  The length of space required to store the resulting length-encoded integer
-  for the given number. This function can be used at places where one needs to
-  dynamically allocate the buffer for a given number to be stored as length-
-  encoded integer.
-
-  @param num [IN]   the input number
-
-  @return length of buffer needed to store this number [1, 3, 4, 9].
-*/
-
-uint net_length_size(ulonglong num)
-{
-  if (num < (ulonglong) 252LL)
-    return 1;
-  if (num < (ulonglong) 65536LL)
-    return 3;
-  if (num < (ulonglong) 16777216LL)
-    return 4;
-  return 9;
-}
-