~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2003 MySQL AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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

  - Protection against sigpipe

  - Prepared statements

  - Things that only works for the server

  - Alarm handling on connect

  In all other cases, the code should be idential for the client and

  server.

*/ 

#include <my_global.h>

#include "mysql.h"

/* Windows lacks a netdb.h */

#ifdef __WIN__

#include <Ws2tcpip.h>

#else

#include <netdb.h>

#endif

/* Remove client convenience wrappers */

#undef max_allowed_packet

#undef net_buffer_length

#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 <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(THREAD) && !defined(__WIN__)

#include <my_pthread.h>				/* because of signal()	*/

#endif /* defined(THREAD) && !defined(__WIN__) */

#include <sys/stat.h>

#include <signal.h>

#include <time.h>

#ifdef	 HAVE_PWD_H

#include <pwd.h>

#endif

#if !defined(MSDOS) && !defined(__WIN__)

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#ifdef HAVE_SELECT_H

#  include <select.h>

#endif

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#endif /*!defined(MSDOS) && !defined(__WIN__) */

#ifdef HAVE_SYS_UN_H

#  include <sys/un.h>

#endif

#if defined(MSDOS) || defined(__WIN__)

#define perror(A)

#else

#include <errno.h>

#define SOCKET_ERROR -1

#endif

#ifdef __WIN__

#define CONNECT_TIMEOUT 20

#else

#define CONNECT_TIMEOUT 0

#endif

#include "client_settings.h"

#include <sql_common.h>

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";

#ifdef HAVE_SMEM

char		 *shared_memory_base_name= 0;

const char 	*def_shared_memory_base_name= default_shared_memory_base_name;

#endif

static void mysql_close_free_options(MYSQL *mysql);

static void mysql_close_free(MYSQL *mysql);

#if !(defined(__WIN__) || defined(__NETWARE__))

static int wait_for_data(my_socket fd, uint timeout);

#endif

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];

/****************************************************************************

  A modified version of connect().  my_connect() allows you to specify

  a timeout value, in seconds, that we should wait until we

  derermine we can't connect to a particular host.  If timeout is 0,

  my_connect() will behave exactly like connect().

  Base version coded by Steve Bernacki, Jr. <steve@navinet.net>

*****************************************************************************/

int my_connect(my_socket fd, const struct sockaddr *name, uint namelen,

	       uint timeout)

{

#if defined(__WIN__) || defined(__NETWARE__)

  return connect(fd, (struct sockaddr*) name, namelen);

#else

  int flags, res, s_err;

  /*

    If they passed us a timeout of zero, we should behave

    exactly like the normal connect() call does.

  */

  if (timeout == 0)

    return connect(fd, (struct sockaddr*) name, namelen);

  flags = fcntl(fd, F_GETFL, 0);	  /* Set socket to not block */

#ifdef O_NONBLOCK

  fcntl(fd, F_SETFL, flags | O_NONBLOCK);  /* and save the flags..  */

#endif

  res= connect(fd, (struct sockaddr*) name, namelen);

  s_err= errno;			/* Save the error... */

  fcntl(fd, F_SETFL, flags);

  if ((res != 0) && (s_err != EINPROGRESS))

  {

    errno= s_err;			/* Restore it */

    return(-1);

  }

  if (res == 0)				/* Connected quickly! */

    return(0);

  return wait_for_data(fd, timeout);

#endif

}

/*

  Wait up to timeout seconds for a connection to be established.

  We prefer to do this with poll() as there is no limitations with this.

  If not, we will use select()

*/

#if !(defined(__WIN__) || defined(__NETWARE__))

static int wait_for_data(my_socket fd, uint timeout)

{

#ifdef HAVE_POLL

  struct pollfd ufds;

  int res;

  ufds.fd= fd;

  ufds.events= POLLIN | POLLPRI;

  if (!(res= poll(&ufds, 1, (int) timeout*1000)))

  {

    errno= EINTR;

    return -1;

  }

  if (res < 0 || !(ufds.revents & (POLLIN | POLLPRI)))

    return -1;

  return 0;

#else

  SOCKOPT_OPTLEN_TYPE s_err_size = sizeof(uint);

  fd_set sfds;

  struct timeval tv;

  time_t start_time, now_time;

  int res, s_err;

  if (fd >= FD_SETSIZE)				/* Check if wrong error */

    return 0;					/* Can't use timeout */

  /*

    Our connection is "in progress."  We can use the select() call to wait

    up to a specified period of time for the connection to suceed.

    If select() returns 0 (after waiting howevermany seconds), our socket

    never became writable (host is probably unreachable.)  Otherwise, if

    select() returns 1, then one of two conditions exist:

    1. An error occured.  We use getsockopt() to check for this.

    2. The connection was set up sucessfully: getsockopt() will

    return 0 as an error.

    Thanks goes to Andrew Gierth <andrew@erlenstar.demon.co.uk>

    who posted this method of timing out a connect() in

    comp.unix.programmer on August 15th, 1997.

  */

  FD_ZERO(&sfds);

  FD_SET(fd, &sfds);

  /*

    select could be interrupted by a signal, and if it is, 

    the timeout should be adjusted and the select restarted

    to work around OSes that don't restart select and 

    implementations of select that don't adjust tv upon

    failure to reflect the time remaining

   */

  start_time= my_time(0);

  for (;;)

  {

    tv.tv_sec = (long) timeout;

    tv.tv_usec = 0;

#if defined(HPUX10) && defined(THREAD)

    if ((res = select(fd+1, NULL, (int*) &sfds, NULL, &tv)) > 0)

      break;

#else

    if ((res = select(fd+1, NULL, &sfds, NULL, &tv)) > 0)

      break;

#endif

    if (res == 0)					/* timeout */

      return -1;

    now_time= my_time(0);

    timeout-= (uint) (now_time - start_time);

    if (errno != EINTR || (int) timeout <= 0)

      return -1;

  }

  /*

    select() returned something more interesting than zero, let's

    see if we have any errors.  If the next two statements pass,

    we've got an open socket!

  */

  s_err=0;

  if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*) &s_err, &s_err_size) != 0)

    return(-1);

  if (s_err)

  {						/* getsockopt could succeed */

    errno = s_err;

    return(-1);					/* but return an error... */

  }

  return (0);					/* ok */

#endif /* HAVE_POLL */

}

#endif /* defined(__WIN__) || defined(__NETWARE__) */

/**

  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;

    strmov(net->last_error, ER(errcode));

    strmov(net->sqlstate, sqlstate);

  }

  else

  {

    mysql_server_last_errno= errcode;

    strmov(mysql_server_last_error, ER(errcode));

  }

  DBUG_VOID_RETURN;

}

/**

  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';

  strmov(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

*/

static 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);

  strmov(net->sqlstate, sqlstate);

  DBUG_VOID_RETURN;

}

/*

  Create a named pipe connection

*/

#ifdef __WIN__

HANDLE create_named_pipe(MYSQL *mysql, uint connect_timeout, char **arg_host,

			 char **arg_unix_socket)

{

  HANDLE hPipe=INVALID_HANDLE_VALUE;

  char pipe_name[1024];

  DWORD dwMode;

  int i;

  my_bool testing_named_pipes=0;

  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,

			    0,

			    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*1000) )

    {

      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

  SYNOPSIS

    create_shared_memory()

    mysql		Pointer of mysql structure

    net			Pointer of net structure

    connect_timeout	Timeout of connection

*/

#ifdef HAVE_SMEM

HANDLE create_shared_memory(MYSQL *mysql,NET *net, uint 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;

  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;

  /*

     get enough space base-name + '_' + longest suffix we might ever send

   */

  if (!(tmp= (char *)my_malloc(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)

  */

  suffix_pos = strxmov(tmp, "Global\\", shared_memory_base_name, "_", NullS);

  strmov(suffix_pos, "CONNECT_REQUEST");

  if (!(event_connect_request= OpenEvent(event_access_rights, FALSE, tmp)))

  {

    error_allow = CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR;

    goto err;

  }

  strmov(suffix_pos, "CONNECT_ANSWER");

  if (!(event_connect_answer= OpenEvent(event_access_rights,FALSE,tmp)))

  {

    error_allow = CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR;

    goto err;

  }

  strmov(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;

  }

  /* 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*1000) !=

      WAIT_OBJECT_0)

  {

    error_allow = CR_SHARED_MEMORY_CONNECT_ABANDONED_ERROR;

    goto err;

  }

  /* 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, "Global\\", shared_memory_base_name, "_", connect_number_char,

		       "_", NullS);

  strmov(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;

  }

  strmov(suffix_pos, "SERVER_WROTE");

  if ((event_server_wrote = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)

  {

    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;

    goto err2;

  }

  strmov(suffix_pos, "SERVER_READ");

  if ((event_server_read = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)

  {

    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;

    goto err2;

  }

  strmov(suffix_pos, "CLIENT_WROTE");

  if ((event_client_wrote = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)

  {

    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;

    goto err2;

  }

  strmov(suffix_pos, "CLIENT_READ");

  if ((event_client_read = OpenEvent(event_access_rights,FALSE,tmp)) == NULL)

  {

    error_allow = CR_SHARED_MEMORY_EVENT_ERROR;

    goto err2;

  }

  strmov(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(net,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:

  if (tmp)

    my_free(tmp, MYF(0));

  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 (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

/*****************************************************************************

  Read a packet from server. Give error message if socket was down

  or packet is an error message

*****************************************************************************/

ulong

cli_safe_read(MYSQL *mysql)

{

  NET *net= &mysql->net;

  ulong len=0;

  init_sigpipe_variables

  /* Don't give sigpipe errors if the client doesn't want them */

  set_sigpipe(mysql);

  if (net->vio != 0)

    len=my_net_read(net);

  reset_sigpipe(mysql);

  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 && vio_was_interrupted(net->vio))

      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);

  }

  if (net->read_pos[0] == 255)

  {

    if (len > 3)

    {

      char *pos=(char*) net->read_pos+1;

      net->last_errno=uint2korr(pos);

      pos+=2;

      len-=2;

      if (protocol_41(mysql) && pos[0] == '#')

      {

	strmake(net->sqlstate, 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).

        */

        strmov(net->sqlstate, unknown_sqlstate);

      }

      (void) strmake(net->last_error,(char*) pos,

		     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);

  }

  return len;

}

void free_rows(MYSQL_DATA *cur)

{

  if (cur)

  {

    free_root(&cur->alloc,MYF(0));

    my_free((uchar*) cur,MYF(0));

  }

}

my_bool

cli_advanced_command(MYSQL *mysql, enum enum_server_command command,

		     const uchar *header, ulong header_length,

		     const uchar *arg, ulong arg_length, my_bool skip_check,

                     MYSQL_STMT *stmt)

{

  NET *net= &mysql->net;

  my_bool result= 1;

  init_sigpipe_variables

  my_bool stmt_skip= stmt ? stmt->state != MYSQL_STMT_INIT_DONE : FALSE;

  DBUG_ENTER("cli_advanced_command");

  /* Don't give sigpipe errors if the client doesn't want them */

  set_sigpipe(mysql);

  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;

  /*

    We don't want to clear the protocol buffer on COM_QUIT, because if

    the previous command was a shutdown command, we may have the

    response for the COM_QUIT already in the communication buffer

  */

  net_clear(&mysql->net, (command != COM_QUIT));

  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;

    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;

    }

  }

  result=0;

  if (!skip_check)

    result= ((mysql->packet_length=cli_safe_read(mysql)) == packet_error ?

	     1 : 0);

end:

  reset_sigpipe(mysql);

  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(&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;

}

/*

  Flush result set sent from server

*/

static void cli_flush_use_result(MYSQL *mysql)

{

  /* Clear the current execution status */

  DBUG_ENTER("cli_flush_use_result");

  DBUG_PRINT("warning",("Not all packets read, clearing them"));