summaryrefslogtreecommitdiffstats
path: root/sql/protocol.cc
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--sql/protocol.cc1715
1 files changed, 1715 insertions, 0 deletions
diff --git a/sql/protocol.cc b/sql/protocol.cc
new file mode 100644
index 00000000..eb50b02c
--- /dev/null
+++ b/sql/protocol.cc
@@ -0,0 +1,1715 @@
+/* Copyright (c) 2000, 2012, Oracle and/or its affiliates.
+ Copyright (c) 2008, 2020, MariaDB Corporation.
+
+ 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-1335 USA */
+
+/**
+ @file
+
+ Low level functions for storing data to be send to the MySQL client.
+ The actual communction is handled by the net_xxx functions in net_serv.cc
+*/
+
+#ifdef USE_PRAGMA_IMPLEMENTATION
+#pragma implementation // gcc: Class implementation
+#endif
+
+#include "mariadb.h"
+#include "sql_priv.h"
+#include "protocol.h"
+#include "sql_class.h" // THD
+#include <stdarg.h>
+
+static const unsigned int PACKET_BUFFER_EXTRA_ALLOC= 1024;
+#ifndef EMBEDDED_LIBRARY
+static bool write_eof_packet(THD *, NET *, uint, uint);
+#endif
+
+CHARSET_INFO *Protocol::character_set_results() const
+{
+ return thd->variables.character_set_results;
+}
+
+
+#ifndef EMBEDDED_LIBRARY
+bool Protocol::net_store_data(const uchar *from, size_t length)
+#else
+bool Protocol_binary::net_store_data(const uchar *from, size_t length)
+#endif
+{
+ ulong packet_length=packet->length();
+ /*
+ The +9 comes from that strings of length longer than 16M require
+ 9 bytes to be stored (see net_store_length).
+ */
+ if (packet_length+9+length > packet->alloced_length() &&
+ packet->realloc(packet_length+9+length))
+ return 1;
+ uchar *to= net_store_length((uchar*) packet->ptr()+packet_length, length);
+ if (length)
+ memcpy(to,from,length);
+ packet->length((uint) (to+length-(uchar*) packet->ptr()));
+ return 0;
+}
+
+
+/*
+ net_store_data_cs() - extended version with character set conversion.
+
+ It is optimized for short strings whose length after
+ conversion is garanteed to be less than 251, which accupies
+ exactly one byte to store length. It allows not to use
+ the "convert" member as a temporary buffer, conversion
+ is done directly to the "packet" member.
+ The limit 251 is good enough to optimize send_result_set_metadata()
+ because column, table, database names fit into this limit.
+*/
+
+#ifndef EMBEDDED_LIBRARY
+bool Protocol::net_store_data_cs(const uchar *from, size_t length,
+ CHARSET_INFO *from_cs, CHARSET_INFO *to_cs)
+#else
+bool Protocol_binary::net_store_data_cs(const uchar *from, size_t length,
+ CHARSET_INFO *from_cs, CHARSET_INFO *to_cs)
+#endif
+{
+ uint dummy_errors;
+ /* Calculate maxumum possible result length */
+ size_t conv_length= to_cs->mbmaxlen * length / from_cs->mbminlen;
+
+ if (conv_length > 250)
+ {
+ /*
+ For strings with conv_length greater than 250 bytes
+ we don't know how many bytes we will need to store length: one or two,
+ because we don't know result length until conversion is done.
+ For example, when converting from utf8 (mbmaxlen=3) to latin1,
+ conv_length=300 means that the result length can vary between 100 to 300.
+ length=100 needs one byte, length=300 needs to bytes.
+
+ Thus conversion directly to "packet" is not worthy.
+ Let's use "convert" as a temporary buffer.
+ */
+ return (convert->copy((const char*) from, length, from_cs,
+ to_cs, &dummy_errors) ||
+ net_store_data((const uchar*) convert->ptr(), convert->length()));
+ }
+
+ size_t packet_length= packet->length();
+ size_t new_length= packet_length + conv_length + 1;
+
+ if (new_length > packet->alloced_length() && packet->realloc(new_length))
+ return 1;
+
+ char *length_pos= (char*) packet->ptr() + packet_length;
+ char *to= length_pos + 1;
+
+ to+= copy_and_convert(to, conv_length, to_cs,
+ (const char*) from, length, from_cs, &dummy_errors);
+
+ net_store_length((uchar*) length_pos, to - length_pos - 1);
+ packet->length((uint) (to - packet->ptr()));
+ return 0;
+}
+
+
+/**
+ Send a error string to client.
+
+ Design note:
+
+ net_printf_error and net_send_error are low-level functions
+ that shall be used only when a new connection is being
+ established or at server startup.
+
+ For SIGNAL/RESIGNAL and GET DIAGNOSTICS functionality it's
+ critical that every error that can be intercepted is issued in one
+ place only, my_message_sql.
+
+ @param thd Thread handler
+ @param sql_errno The error code to send
+ @param err A pointer to the error message
+
+ @return
+ @retval FALSE The message was sent to the client
+ @retval TRUE An error occurred and the message wasn't sent properly
+*/
+
+bool Protocol::net_send_error(THD *thd, uint sql_errno, const char *err,
+ const char* sqlstate)
+{
+ bool error;
+ DBUG_ENTER("Protocol::net_send_error");
+
+ DBUG_ASSERT(!thd->spcont);
+ DBUG_ASSERT(sql_errno);
+ DBUG_ASSERT(err);
+
+ DBUG_PRINT("enter",("sql_errno: %d err: %s", sql_errno, err));
+
+ if (sqlstate == NULL)
+ sqlstate= mysql_errno_to_sqlstate(sql_errno);
+
+ /*
+ It's one case when we can push an error even though there
+ is an OK or EOF already.
+ */
+ thd->get_stmt_da()->set_overwrite_status(true);
+
+ /* Abort multi-result sets */
+ thd->server_status&= ~SERVER_MORE_RESULTS_EXISTS;
+
+ error= net_send_error_packet(thd, sql_errno, err, sqlstate);
+
+ thd->get_stmt_da()->set_overwrite_status(false);
+
+ DBUG_RETURN(error);
+}
+
+/**
+ Return ok to the client.
+
+ The ok packet has the following structure:
+
+ - 0 : Marker (1 byte)
+ - affected_rows : Stored in 1-9 bytes
+ - id : Stored in 1-9 bytes
+ - server_status : Copy of thd->server_status; Can be used by client
+ to check if we are inside an transaction.
+ New in 4.0 protocol
+ - warning_count : Stored in 2 bytes; New in 4.1 protocol
+ - message : Stored as packed length (1-9 bytes) + message.
+ Is not stored if no message.
+
+ @param thd Thread handler
+ @param server_status The server status
+ @param statement_warn_count Total number of warnings
+ @param affected_rows Number of rows changed by statement
+ @param id Auto_increment id for first row (if used)
+ @param message Message to send to the client (Used by mysql_status)
+ @param is_eof this called instead of old EOF packet
+
+ @return
+ @retval FALSE The message was successfully sent
+ @retval TRUE An error occurred and the messages wasn't sent properly
+
+*/
+
+#ifndef EMBEDDED_LIBRARY
+bool
+Protocol::net_send_ok(THD *thd,
+ uint server_status, uint statement_warn_count,
+ ulonglong affected_rows, ulonglong id,
+ const char *message, bool is_eof,
+ bool skip_flush)
+{
+ NET *net= &thd->net;
+ StringBuffer<MYSQL_ERRMSG_SIZE + 10> store;
+
+ bool state_changed= false;
+
+ bool error= FALSE;
+ DBUG_ENTER("Protocol::net_send_ok");
+
+ if (! net->vio) // hack for re-parsing queries
+ {
+ DBUG_PRINT("info", ("vio present: NO"));
+ DBUG_RETURN(FALSE);
+ }
+
+ /*
+ OK send instead of EOF still require 0xFE header, but OK packet content.
+ */
+ if (is_eof)
+ {
+ DBUG_ASSERT(thd->client_capabilities & CLIENT_DEPRECATE_EOF);
+ store.q_append((char)254);
+ }
+ else
+ store.q_append('\0');
+
+ /* affected rows */
+ store.q_net_store_length(affected_rows);
+
+ /* last insert id */
+ store.q_net_store_length(id);
+
+ if (thd->client_capabilities & CLIENT_PROTOCOL_41)
+ {
+ DBUG_PRINT("info",
+ ("affected_rows: %lu id: %lu status: %u warning_count: %u",
+ (ulong) affected_rows,
+ (ulong) id,
+ (uint) (server_status & 0xffff),
+ (uint) statement_warn_count));
+ store.q_append2b(server_status);
+
+ /* We can only return up to 65535 warnings in two bytes */
+ uint tmp= MY_MIN(statement_warn_count, 65535);
+ store.q_append2b(tmp);
+ }
+ else if (net->return_status) // For 4.0 protocol
+ {
+ store.q_append2b(server_status);
+ }
+ thd->get_stmt_da()->set_overwrite_status(true);
+
+ state_changed=
+ (thd->client_capabilities & CLIENT_SESSION_TRACK) &&
+ (server_status & SERVER_SESSION_STATE_CHANGED);
+
+ if (state_changed || (message && message[0]))
+ {
+ DBUG_ASSERT(safe_strlen(message) <= MYSQL_ERRMSG_SIZE);
+ store.q_net_store_data((uchar*) safe_str(message), safe_strlen(message));
+ }
+
+ if (unlikely(state_changed))
+ {
+ store.set_charset(thd->variables.collation_database);
+
+ thd->session_tracker.store(thd, &store);
+ }
+
+ DBUG_ASSERT(store.length() <= MAX_PACKET_LENGTH);
+
+ error= my_net_write(net, (const unsigned char*)store.ptr(), store.length());
+ if (likely(!error) && (!skip_flush || is_eof))
+ error= net_flush(net);
+
+ thd->server_status&= ~SERVER_SESSION_STATE_CHANGED;
+
+ thd->get_stmt_da()->set_overwrite_status(false);
+ DBUG_PRINT("info", ("OK sent, so no more error sending allowed"));
+
+ DBUG_RETURN(error);
+}
+
+
+static uchar eof_buff[1]= { (uchar) 254 }; /* Marker for end of fields */
+
+/**
+ Send eof (= end of result set) to the client.
+
+ The eof packet has the following structure:
+
+ - 254 : Marker (1 byte)
+ - warning_count : Stored in 2 bytes; New in 4.1 protocol
+ - status_flag : Stored in 2 bytes;
+ For flags like SERVER_MORE_RESULTS_EXISTS.
+
+ Note that the warning count will not be sent if 'no_flush' is set as
+ we don't want to report the warning count until all data is sent to the
+ client.
+
+ @param thd Thread handler
+ @param server_status The server status
+ @param statement_warn_count Total number of warnings
+
+ @return
+ @retval FALSE The message was successfully sent
+ @retval TRUE An error occurred and the message wasn't sent properly
+*/
+
+bool
+Protocol::net_send_eof(THD *thd, uint server_status, uint statement_warn_count)
+{
+ NET *net= &thd->net;
+ bool error= FALSE;
+ DBUG_ENTER("Protocol::net_send_eof");
+
+ /*
+ Check if client understand new format packets (OK instead of EOF)
+
+ Normally end of statement reply is signaled by OK packet, but in case
+ of binlog dump request an EOF packet is sent instead. Also, old clients
+ expect EOF packet instead of OK
+ */
+ if ((thd->client_capabilities & CLIENT_DEPRECATE_EOF) &&
+ (thd->get_command() != COM_BINLOG_DUMP ))
+ {
+ error= net_send_ok(thd, server_status, statement_warn_count, 0, 0, NULL,
+ true, false);
+ DBUG_RETURN(error);
+ }
+
+ /* Set to TRUE if no active vio, to work well in case of --init-file */
+ if (net->vio != 0)
+ {
+ thd->get_stmt_da()->set_overwrite_status(true);
+ error= write_eof_packet(thd, net, server_status, statement_warn_count);
+ if (likely(!error))
+ error= net_flush(net);
+ thd->get_stmt_da()->set_overwrite_status(false);
+ DBUG_PRINT("info", ("EOF sent, so no more error sending allowed"));
+ }
+ DBUG_RETURN(error);
+}
+
+
+/**
+ Format EOF packet according to the current protocol and
+ write it to the network output buffer.
+
+ @param thd The thread handler
+ @param net The network handler
+ @param server_status The server status
+ @param statement_warn_count The number of warnings
+
+
+ @return
+ @retval FALSE The message was sent successfully
+ @retval TRUE An error occurred and the messages wasn't sent properly
+*/
+
+static bool write_eof_packet(THD *thd, NET *net,
+ uint server_status,
+ uint statement_warn_count)
+{
+ bool error;
+ if (thd->client_capabilities & CLIENT_PROTOCOL_41)
+ {
+ uchar buff[5];
+ /*
+ Don't send warn count during SP execution, as the warn_list
+ is cleared between substatements, and mysqltest gets confused
+ */
+ uint tmp= MY_MIN(statement_warn_count, 65535);
+ buff[0]= 254;
+ int2store(buff+1, tmp);
+ /*
+ The following test should never be true, but it's better to do it
+ because if 'is_fatal_error' is set the server is not going to execute
+ other queries (see the if test in dispatch_command / COM_QUERY)
+ */
+ if (unlikely(thd->is_fatal_error))
+ server_status&= ~SERVER_MORE_RESULTS_EXISTS;
+ int2store(buff + 3, server_status);
+ error= my_net_write(net, buff, 5);
+ }
+ else
+ error= my_net_write(net, eof_buff, 1);
+
+ return error;
+}
+
+/**
+ @param thd Thread handler
+ @param sql_errno The error code to send
+ @param err A pointer to the error message
+
+ @return
+ @retval FALSE The message was successfully sent
+ @retval TRUE An error occurred and the messages wasn't sent properly
+*/
+
+bool Protocol::net_send_error_packet(THD *thd, uint sql_errno, const char *err,
+ const char* sqlstate)
+
+{
+ NET *net= &thd->net;
+ uint length;
+ /*
+ buff[]: sql_errno:2 + ('#':1 + SQLSTATE_LENGTH:5) + MYSQL_ERRMSG_SIZE:512
+ */
+ uint error;
+ char converted_err[MYSQL_ERRMSG_SIZE];
+ char buff[2+1+SQLSTATE_LENGTH+MYSQL_ERRMSG_SIZE], *pos;
+ my_bool ret;
+ uint8 save_compress;
+ DBUG_ENTER("Protocol::send_error_packet");
+
+ if (net->vio == 0)
+ {
+ if (thd->bootstrap)
+ {
+ /* In bootstrap it's ok to print on stderr */
+ fprintf(stderr,"ERROR: %d %s\n",sql_errno,err);
+ }
+ DBUG_RETURN(FALSE);
+ }
+
+ int2store(buff,sql_errno);
+ pos= buff+2;
+ if (thd->client_capabilities & CLIENT_PROTOCOL_41)
+ {
+ /* The first # is to make the protocol backward compatible */
+ buff[2]= '#';
+ pos= strmov(buff+3, sqlstate);
+ }
+
+ convert_error_message(converted_err, sizeof(converted_err),
+ thd->variables.character_set_results,
+ err, strlen(err), system_charset_info, &error);
+ /* Converted error message is always null-terminated. */
+ length= (uint) (strmake(pos, converted_err, MYSQL_ERRMSG_SIZE - 1) - buff);
+
+ /*
+ Ensure that errors are not compressed. This is to ensure we can
+ detect out of bands error messages in the client
+ */
+ if ((save_compress= net->compress))
+ net->compress= 2;
+
+ /*
+ Sometimes, we send errors "out-of-band", e.g ER_CONNECTION_KILLED
+ on an idle connection. The current protocol "sequence number" is 0,
+ however some client drivers would however always expect packets
+ coming from server to have seq_no > 0, due to missing awareness
+ of "out-of-band" operations. Make these clients happy.
+ */
+ if (!net->pkt_nr)
+ net->pkt_nr= 1;
+
+ ret= net_write_command(net,(uchar) 255, (uchar*) "", 0, (uchar*) buff,
+ length);
+ net->compress= save_compress;
+ DBUG_RETURN(ret);
+}
+
+#endif /* EMBEDDED_LIBRARY */
+
+/**
+ Faster net_store_length when we know that length is less than 65536.
+ We keep a separate version for that range because it's widely used in
+ libmysql.
+
+ uint is used as agrument type because of MySQL type conventions:
+ - uint for 0..65536
+ - ulong for 0..4294967296
+ - ulonglong for bigger numbers.
+*/
+
+static uchar *net_store_length_fast(uchar *packet, size_t length)
+{
+ DBUG_ASSERT(length < UINT_MAX16);
+ if (length < 251)
+ {
+ *packet=(uchar) length;
+ return packet+1;
+ }
+ *packet++=252;
+ int2store(packet,(uint) length);
+ return packet+2;
+}
+
+/**
+ Send the status of the current statement execution over network.
+
+ @param thd in fact, carries two parameters, NET for the transport and
+ Diagnostics_area as the source of status information.
+
+ In MySQL, there are two types of SQL statements: those that return
+ a result set and those that return status information only.
+
+ If a statement returns a result set, it consists of 3 parts:
+ - result set meta-data
+ - variable number of result set rows (can be 0)
+ - followed and terminated by EOF or ERROR packet
+
+ Once the client has seen the meta-data information, it always
+ expects an EOF or ERROR to terminate the result set. If ERROR is
+ received, the result set rows are normally discarded (this is up
+ to the client implementation, libmysql at least does discard them).
+ EOF, on the contrary, means "successfully evaluated the entire
+ result set". Since we don't know how many rows belong to a result
+ set until it's evaluated, EOF/ERROR is the indicator of the end
+ of the row stream. Note, that we can not buffer result set rows
+ on the server -- there may be an arbitrary number of rows. But
+ we do buffer the last packet (EOF/ERROR) in the Diagnostics_area and
+ delay sending it till the very end of execution (here), to be able to
+ change EOF to an ERROR if commit failed or some other error occurred
+ during the last cleanup steps taken after execution.
+
+ A statement that does not return a result set doesn't send result
+ set meta-data either. Instead it returns one of:
+ - OK packet
+ - ERROR packet.
+ Similarly to the EOF/ERROR of the previous statement type, OK/ERROR
+ packet is "buffered" in the diagnostics area and sent to the client
+ in the end of statement.
+
+ @note This method defines a template, but delegates actual
+ sending of data to virtual Protocol::send_{ok,eof,error}. This
+ allows for implementation of protocols that "intercept" ok/eof/error
+ messages, and store them in memory, etc, instead of sending to
+ the client.
+
+ @pre The diagnostics area is assigned or disabled. It can not be empty
+ -- we assume that every SQL statement or COM_* command
+ generates OK, ERROR, or EOF status.
+
+ @post The status information is encoded to protocol format and sent to the
+ client.
+
+ @return We conventionally return void, since the only type of error
+ that can happen here is a NET (transport) error, and that one
+ will become visible when we attempt to read from the NET the
+ next command.
+ Diagnostics_area::is_sent is set for debugging purposes only.
+*/
+
+void Protocol::end_statement()
+{
+#ifdef WITH_WSREP
+ /*
+ Commented out: This sanity check does not hold in general.
+ Thd->LOCK_thd_data() must be unlocked before sending response
+ to client, so BF abort may sneak in here.
+ DBUG_ASSERT(!WSREP(thd) || thd->wsrep_conflict_state() == NO_CONFLICT);
+ */
+
+ /*
+ sanity check, don't send end statement while replaying
+ */
+ DBUG_ASSERT(thd->wsrep_trx().state() != wsrep::transaction::s_replaying);
+ if (WSREP(thd) && thd->wsrep_trx().state() ==
+ wsrep::transaction::s_replaying)
+ {
+ WSREP_ERROR("attempting net_end_statement while replaying");
+ return;
+ }
+#endif /* WITH_WSREP */
+
+ DBUG_ENTER("Protocol::end_statement");
+ DBUG_ASSERT(! thd->get_stmt_da()->is_sent());
+ bool error= FALSE;
+
+ /* Can not be true, but do not take chances in production. */
+ if (thd->get_stmt_da()->is_sent())
+ DBUG_VOID_RETURN;
+
+ switch (thd->get_stmt_da()->status()) {
+ case Diagnostics_area::DA_ERROR:
+ /* The query failed, send error to log and abort bootstrap. */
+ error= send_error(thd->get_stmt_da()->sql_errno(),
+ thd->get_stmt_da()->message(),
+ thd->get_stmt_da()->get_sqlstate());
+ break;
+ case Diagnostics_area::DA_EOF:
+ case Diagnostics_area::DA_EOF_BULK:
+ error= send_eof(thd->server_status,
+ thd->get_stmt_da()->statement_warn_count());
+ break;
+ case Diagnostics_area::DA_OK:
+ case Diagnostics_area::DA_OK_BULK:
+ error= send_ok(thd->server_status,
+ thd->get_stmt_da()->statement_warn_count(),
+ thd->get_stmt_da()->affected_rows(),
+ thd->get_stmt_da()->last_insert_id(),
+ thd->get_stmt_da()->message(),
+ thd->get_stmt_da()->skip_flush());
+ break;
+ case Diagnostics_area::DA_DISABLED:
+ break;
+ case Diagnostics_area::DA_EMPTY:
+ default:
+ DBUG_ASSERT(0);
+ error= send_ok(thd->server_status, 0, 0, 0, NULL,
+ thd->get_stmt_da()->skip_flush());
+ break;
+ }
+ if (likely(!error))
+ thd->get_stmt_da()->set_is_sent(true);
+ DBUG_VOID_RETURN;
+}
+
+/**
+ A default implementation of "OK" packet response to the client.
+
+ Currently this implementation is re-used by both network-oriented
+ protocols -- the binary and text one. They do not differ
+ in their OK packet format, which allows for a significant simplification
+ on client side.
+*/
+
+bool Protocol::send_ok(uint server_status, uint statement_warn_count,
+ ulonglong affected_rows, ulonglong last_insert_id,
+ const char *message, bool skip_flush)
+{
+ DBUG_ENTER("Protocol::send_ok");
+ const bool retval=
+ net_send_ok(thd, server_status, statement_warn_count,
+ affected_rows, last_insert_id, message, false, skip_flush);
+ DBUG_RETURN(retval);
+}
+
+
+/**
+ A default implementation of "EOF" packet response to the client.
+
+ Binary and text protocol do not differ in their EOF packet format.
+*/
+
+bool Protocol::send_eof(uint server_status, uint statement_warn_count)
+{
+ DBUG_ENTER("Protocol::send_eof");
+ bool retval= net_send_eof(thd, server_status, statement_warn_count);
+ DBUG_RETURN(retval);
+}
+
+
+/**
+ A default implementation of "ERROR" packet response to the client.
+
+ Binary and text protocol do not differ in ERROR packet format.
+*/
+
+bool Protocol::send_error(uint sql_errno, const char *err_msg,
+ const char *sql_state)
+{
+ DBUG_ENTER("Protocol::send_error");
+ const bool retval= net_send_error_packet(thd, sql_errno, err_msg, sql_state);
+ DBUG_RETURN(retval);
+}
+
+
+/**
+ Send a progress report to the client
+
+ What we send is:
+ header (255,255,255,1)
+ stage, max_stage as on byte integers
+ percentage withing the stage as percentage*1000
+ (that is, ratio*100000) as a 3 byte integer
+ proc_info as a string
+*/
+
+const uchar progress_header[2]= {(uchar) 255, (uchar) 255 };
+
+void net_send_progress_packet(THD *thd)
+{
+ uchar buff[200], *pos;
+ const char *proc_info= thd->proc_info ? thd->proc_info : "";
+ size_t length= strlen(proc_info);
+ ulonglong progress;
+ DBUG_ENTER("net_send_progress_packet");
+
+ if (unlikely(!thd->net.vio))
+ DBUG_VOID_RETURN; // Socket is closed
+
+ pos= buff;
+ /*
+ Store number of strings first. This allows us to later expand the
+ progress indicator if needed.
+ */
+ *pos++= (uchar) 1; // Number of strings
+ *pos++= (uchar) thd->progress.stage + 1;
+ /*
+ We have the MY_MAX() here to avoid problems if max_stage is not set,
+ which may happen during automatic repair of table
+ */
+ *pos++= (uchar) MY_MAX(thd->progress.max_stage, thd->progress.stage + 1);
+ progress= 0;
+ if (thd->progress.max_counter)
+ progress= 100000ULL * thd->progress.counter / thd->progress.max_counter;
+ int3store(pos, progress); // Between 0 & 100000
+ pos+= 3;
+ pos= net_store_data(pos, (const uchar*) proc_info,
+ MY_MIN(length, sizeof(buff)-7));
+ net_write_command(&thd->net, (uchar) 255, progress_header,
+ sizeof(progress_header), (uchar*) buff,
+ (uint) (pos - buff));
+ DBUG_VOID_RETURN;
+}
+
+
+/****************************************************************************
+ Functions used by the protocol functions (like net_send_ok) to store
+ strings and numbers in the header result packet.
+****************************************************************************/
+
+/* The following will only be used for short strings < 65K */
+
+uchar *net_store_data(uchar *to, const uchar *from, size_t length)
+{
+ to=net_store_length_fast(to,length);
+ if (length)
+ memcpy(to,from,length);
+ return to+length;
+}
+
+uchar *net_store_data(uchar *to,int32 from)
+{
+ char buff[22];
+ uint length=(uint) (int10_to_str(from,buff,10)-buff);
+ to=net_store_length_fast(to,length);
+ memcpy(to,buff,length);
+ return to+length;
+}
+
+uchar *net_store_data(uchar *to,longlong from)
+{
+ char buff[22];
+ uint length=(uint) (longlong10_to_str(from,buff,10)-buff);
+ to=net_store_length_fast(to,length);
+ memcpy(to,buff,length);
+ return to+length;
+}
+
+
+/*****************************************************************************
+ Default Protocol functions
+*****************************************************************************/
+
+void Protocol::init(THD *thd_arg)
+{
+ thd=thd_arg;
+ packet= &thd->packet;
+ convert= &thd->convert_buffer;
+#ifndef DBUG_OFF
+ field_handlers= 0;
+ field_pos= 0;
+#endif
+}
+
+/**
+ Finish the result set with EOF packet, as is expected by the client,
+ if there is an error evaluating the next row and a continue handler
+ for the error.
+*/
+
+void Protocol::end_partial_result_set(THD *thd_arg)
+{
+ net_send_eof(thd_arg, thd_arg->server_status,
+ 0 /* no warnings, we're inside SP */);
+}
+
+
+bool Protocol::flush()
+{
+#ifndef EMBEDDED_LIBRARY
+ bool error;
+ thd->get_stmt_da()->set_overwrite_status(true);
+ error= net_flush(&thd->net);
+ thd->get_stmt_da()->set_overwrite_status(false);
+ return error;
+#else
+ return 0;
+#endif
+}
+
+#ifndef EMBEDDED_LIBRARY
+
+
+class Send_field_packed_extended_metadata: public Binary_string
+{
+public:
+ bool append_chunk(mariadb_field_attr_t type, const LEX_CSTRING &value)
+ {
+ /*
+ If we eventually support many metadata chunk types and long metadata
+ values, we'll need to encode type and length using net_store_length()
+ and do corresponding changes to the unpacking code in libmariadb.
+ For now let's just assert that type and length fit into one byte.
+ */
+ DBUG_ASSERT(net_length_size(type) == 1);
+ DBUG_ASSERT(net_length_size(value.length) == 1);
+ size_t nbytes= 1/*type*/ + 1/*length*/ + value.length;
+ if (reserve(nbytes))
+ return true;
+ qs_append((char) (uchar) type);
+ qs_append((char) (uchar) value.length);
+ qs_append(&value);
+ return false;
+ }
+ bool pack(const Send_field_extended_metadata &src)
+ {
+ for (uint i= 0 ; i <= MARIADB_FIELD_ATTR_LAST; i++)
+ {
+ const LEX_CSTRING attr= src.attr(i);
+ if (attr.str && append_chunk((mariadb_field_attr_t) i, attr))
+ return true;
+ }
+ return false;
+ }
+};
+
+
+bool Protocol_text::store_field_metadata(const THD * thd,
+ const Send_field &field,
+ CHARSET_INFO *charset_for_protocol,
+ uint fieldnr)
+{
+ CHARSET_INFO *thd_charset= thd->variables.character_set_results;
+ char *pos;
+ DBUG_ASSERT(field.is_sane());
+
+ if (thd->client_capabilities & CLIENT_PROTOCOL_41)
+ {
+ const LEX_CSTRING def= {STRING_WITH_LEN("def")};
+ if (store_ident(def) ||
+ store_ident(field.db_name) ||
+ store_ident(field.table_name) ||
+ store_ident(field.org_table_name) ||
+ store_ident(field.col_name) ||
+ store_ident(field.org_col_name))
+ return true;
+ if (thd->client_capabilities & MARIADB_CLIENT_EXTENDED_METADATA)
+ {
+ Send_field_packed_extended_metadata metadata;
+ metadata.pack(field);
+
+ /*
+ Don't apply character set conversion:
+ extended metadata is a binary encoded data.
+ */
+ if (store_binary_string(metadata.ptr(), metadata.length()))
+ return true;
+ }
+ if (packet->realloc(packet->length() + 12))
+ return true;
+ /* Store fixed length fields */
+ pos= (char*) packet->end();
+ *pos++= 12; // Length of packed fields
+ /* inject a NULL to test the client */
+ DBUG_EXECUTE_IF("poison_rs_fields", pos[-1]= (char) 0xfb;);
+ if (charset_for_protocol == &my_charset_bin || thd_charset == NULL)
+ {
+ /* No conversion */
+ int2store(pos, charset_for_protocol->number);
+ int4store(pos + 2, field.length);
+ }
+ else
+ {
+ /* With conversion */
+ int2store(pos, thd_charset->number);
+ uint32 field_length= field.max_octet_length(charset_for_protocol,
+ thd_charset);
+ int4store(pos + 2, field_length);
+ }
+ pos[6]= field.type_handler()->type_code_for_protocol();
+ int2store(pos + 7, field.flags);
+ pos[9]= (char) field.decimals;
+ pos[10]= 0; // For the future
+ pos[11]= 0; // For the future
+ pos+= 12;
+ }
+ else
+ {
+ if (store_ident(field.table_name) ||
+ store_ident(field.col_name) ||
+ packet->realloc(packet->length() + 10))
+ return true;
+ pos= (char*) packet->end();
+ pos[0]= 3;
+ int3store(pos + 1, field.length);
+ pos[4]= 1;
+ pos[5]= field.type_handler()->type_code_for_protocol();
+ pos[6]= 3;
+ int2store(pos + 7, field.flags);
+ pos[9]= (char) field.decimals;
+ pos+= 10;
+ }
+ packet->length((uint) (pos - packet->ptr()));
+ return false;
+}
+
+
+/**
+ Send name and type of result to client.
+
+ Sum fields has table name empty and field_name.
+
+ @param THD Thread data object
+ @param list List of items to send to client
+ @param flag Bit mask with the following functions:
+ - 1 send number of rows
+ - 2 send default values
+ - 4 don't write eof packet
+
+ @retval
+ 0 ok
+ @retval
+ 1 Error (Note that in this case the error is not sent to the
+ client)
+*/
+bool Protocol::send_result_set_metadata(List<Item> *list, uint flags)
+{
+ List_iterator_fast<Item> it(*list);
+ Item *item;
+ Protocol_text prot(thd, thd->variables.net_buffer_length);
+ DBUG_ENTER("Protocol::send_result_set_metadata");
+
+ if (flags & SEND_NUM_ROWS)
+ { // Packet with number of elements
+ uchar buff[MAX_INT_WIDTH];
+ uchar *pos= net_store_length(buff, list->elements);
+ DBUG_ASSERT(pos <= buff + sizeof(buff));
+ if (my_net_write(&thd->net, buff, (size_t) (pos-buff)))
+ DBUG_RETURN(1);
+ }
+
+#ifndef DBUG_OFF
+ field_handlers= (const Type_handler**) thd->alloc(sizeof(field_handlers[0]) *
+ list->elements);
+#endif
+
+ for (uint pos= 0; (item=it++); pos++)
+ {
+ prot.prepare_for_resend();
+ if (prot.store_item_metadata(thd, item, pos))
+ goto err;
+ if (prot.write())
+ DBUG_RETURN(1);
+#ifndef DBUG_OFF
+ field_handlers[pos]= item->type_handler();
+#endif
+ }
+
+ if (flags & SEND_EOF)
+ {
+
+ /* if it is new client do not send EOF packet */
+ if (!(thd->client_capabilities & CLIENT_DEPRECATE_EOF))
+ {
+ /*
+ Mark the end of meta-data result set, and store thd->server_status,
+ to show that there is no cursor.
+ Send no warning information, as it will be sent at statement end.
+ */
+ if (write_eof_packet(thd, &thd->net, thd->server_status,
+ thd->get_stmt_da()->current_statement_warn_count()))
+ DBUG_RETURN(1);
+ }
+ }
+ DBUG_RETURN(prepare_for_send(list->elements));
+
+err:
+ my_message(ER_OUT_OF_RESOURCES, ER_THD(thd, ER_OUT_OF_RESOURCES),
+ MYF(0)); /* purecov: inspected */
+ DBUG_RETURN(1); /* purecov: inspected */
+}
+
+
+bool Protocol::send_list_fields(List<Field> *list, const TABLE_LIST *table_list)
+{
+ DBUG_ENTER("Protocol::send_list_fields");
+ List_iterator_fast<Field> it(*list);
+ Field *fld;
+ Protocol_text prot(thd, thd->variables.net_buffer_length);
+
+#ifndef DBUG_OFF
+ field_handlers= (const Type_handler **) thd->alloc(sizeof(field_handlers[0]) *
+ list->elements);
+#endif
+
+ for (uint pos= 0; (fld= it++); pos++)
+ {
+ prot.prepare_for_resend();
+ if (prot.store_field_metadata_for_list_fields(thd, fld, table_list, pos))
+ goto err;
+ prot.store(fld); // Send default value
+ if (prot.write())
+ DBUG_RETURN(1);
+#ifndef DBUG_OFF
+ /*
+ Historically all BLOB variant Fields are displayed as
+ MYSQL_TYPE_BLOB in metadata.
+ See Field_blob::make_send_field() for more comments.
+ */
+ field_handlers[pos]= Send_field(fld).type_handler();
+#endif
+ }
+ DBUG_RETURN(prepare_for_send(list->elements));
+
+err:
+ my_message(ER_OUT_OF_RESOURCES, ER_THD(thd, ER_OUT_OF_RESOURCES), MYF(0));
+ DBUG_RETURN(1);
+}
+
+
+bool Protocol::write()
+{
+ DBUG_ENTER("Protocol::write");
+ DBUG_RETURN(my_net_write(&thd->net, (uchar*) packet->ptr(),
+ packet->length()));
+}
+#endif /* EMBEDDED_LIBRARY */
+
+
+bool Protocol_text::store_item_metadata(THD *thd, Item *item, uint pos)
+{
+ Send_field field(thd, item);
+ return store_field_metadata(thd, field, item->charset_for_protocol(), pos);
+}
+
+
+bool Protocol_text::store_field_metadata_for_list_fields(const THD *thd,
+ Field *fld,
+ const TABLE_LIST *tl,
+ uint pos)
+{
+ Send_field field= tl->view ?
+ Send_field(fld, tl->view_db, tl->view_name) :
+ Send_field(fld);
+ return store_field_metadata(thd, field, fld->charset_for_protocol(), pos);
+}
+
+
+/**
+ Send one result set row.
+
+ @param row_items a collection of column values for that row
+
+ @return Error status.
+ @retval TRUE Error.
+ @retval FALSE Success.
+*/
+
+bool Protocol::send_result_set_row(List<Item> *row_items)
+{
+ List_iterator_fast<Item> it(*row_items);
+
+ DBUG_ENTER("Protocol::send_result_set_row");
+
+ for (Item *item= it++; item; item= it++)
+ {
+ /*
+ ValueBuffer::m_string can be altered during Item::send().
+ It's important to declare value_buffer inside the loop,
+ to have ValueBuffer::m_string point to ValueBuffer::buffer
+ on every iteration.
+ */
+ ValueBuffer<MAX_FIELD_WIDTH> value_buffer;
+ if (item->send(this, &value_buffer))
+ {
+ // If we're out of memory, reclaim some, to help us recover.
+ this->free();
+ DBUG_RETURN(TRUE);
+ }
+ /* Item::send() may generate an error. If so, abort the loop. */
+ if (unlikely(thd->is_error()))
+ DBUG_RETURN(TRUE);
+ }
+
+ DBUG_RETURN(FALSE);
+}
+
+
+/**
+ Send \\0 end terminated string.
+
+ @param from NullS or \\0 terminated string
+
+ @note
+ In most cases one should use store(from, length) instead of this function
+
+ @retval
+ 0 ok
+ @retval
+ 1 error
+*/
+
+bool Protocol::store(const char *from, CHARSET_INFO *cs)
+{
+ if (!from)
+ return store_null();
+ size_t length= strlen(from);
+ return store(from, length, cs);
+}
+
+
+/**
+ Send a set of strings as one long string with ',' in between.
+*/
+
+bool Protocol::store(I_List<i_string>* str_list)
+{
+ char buf[256];
+ String tmp(buf, sizeof(buf), &my_charset_bin);
+ uint32 len;
+ I_List_iterator<i_string> it(*str_list);
+ i_string* s;
+
+ tmp.length(0);
+ while ((s=it++))
+ {
+ tmp.append(s->ptr);
+ tmp.append(',');
+ }
+ if ((len= tmp.length()))
+ len--; // Remove last ','
+ return store((char*) tmp.ptr(), len, tmp.charset());
+}
+
+/****************************************************************************
+ Functions to handle the simple (default) protocol where everything is
+ This protocol is the one that is used by default between the MySQL server
+ and client when you are not using prepared statements.
+
+ All data are sent as 'packed-string-length' followed by 'string-data'
+****************************************************************************/
+
+#ifndef EMBEDDED_LIBRARY
+void Protocol_text::prepare_for_resend()
+{
+ packet->length(0);
+#ifndef DBUG_OFF
+ field_pos= 0;
+#endif
+}
+
+bool Protocol_text::store_null()
+{
+#ifndef DBUG_OFF
+ field_pos++;
+#endif
+ char buff[1];
+ buff[0]= (char)251;
+ return packet->append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
+}
+#endif
+
+
+/**
+ Auxilary function to convert string to the given character set
+ and store in network buffer.
+*/
+
+bool Protocol::store_string_aux(const char *from, size_t length,
+ CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
+{
+ /* 'tocs' is set 0 when client issues SET character_set_results=NULL */
+ if (needs_conversion(fromcs, tocs))
+ {
+ /* Store with conversion */
+ return net_store_data_cs((uchar*) from, length, fromcs, tocs);
+ }
+ /* Store without conversion */
+ return net_store_data((uchar*) from, length);
+}
+
+
+bool Protocol_text::store_numeric_string_aux(const char *from, size_t length)
+{
+ CHARSET_INFO *tocs= thd->variables.character_set_results;
+ // 'tocs' is NULL when the client issues SET character_set_results=NULL
+ if (tocs && (tocs->state & MY_CS_NONASCII)) // Conversion needed
+ return net_store_data_cs((uchar*) from, length, &my_charset_latin1, tocs);
+ return net_store_data((uchar*) from, length); // No conversion
+}
+
+
+bool Protocol::store_warning(const char *from, size_t length)
+{
+ BinaryStringBuffer<MYSQL_ERRMSG_SIZE> tmp;
+ CHARSET_INFO *cs= thd->variables.character_set_results;
+ if (!cs || cs == &my_charset_bin)
+ cs= system_charset_info;
+ if (tmp.copy_printable_hhhh(cs, system_charset_info, from, length))
+ return net_store_data((const uchar*)"", 0);
+ return net_store_data((const uchar *) tmp.ptr(), tmp.length());
+}
+
+
+bool Protocol_text::store_str(const char *from, size_t length,
+ CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
+{
+#ifndef DBUG_OFF
+ DBUG_PRINT("info", ("Protocol_text::store field %u : %.*b", field_pos,
+ (int) length, (length == 0 ? "" : from)));
+ DBUG_ASSERT(field_handlers == 0 || field_pos < field_count);
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_STRING));
+ field_pos++;
+#endif
+ return store_string_aux(from, length, fromcs, tocs);
+}
+
+
+bool Protocol_text::store_numeric_zerofill_str(const char *from,
+ size_t length,
+ protocol_send_type_t send_type)
+{
+#ifndef DBUG_OFF
+ DBUG_PRINT("info",
+ ("Protocol_text::store_numeric_zerofill_str field %u : %.*b",
+ field_pos, (int) length, (length == 0 ? "" : from)));
+ DBUG_ASSERT(field_handlers == 0 || field_pos < field_count);
+ DBUG_ASSERT(valid_handler(field_pos, send_type));
+ field_pos++;
+#endif
+ return store_numeric_string_aux(from, length);
+}
+
+
+bool Protocol_text::store_tiny(longlong from)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_TINY));
+ field_pos++;
+#endif
+ char buff[22];
+ size_t length= (size_t) (int10_to_str((int) from, buff, -10) - buff);
+ return store_numeric_string_aux(buff, length);
+}
+
+
+bool Protocol_text::store_short(longlong from)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_SHORT));
+ field_pos++;
+#endif
+ char buff[22];
+ size_t length= (size_t) (int10_to_str((int) from, buff, -10) - buff);
+ return store_numeric_string_aux(buff, length);
+}
+
+
+bool Protocol_text::store_long(longlong from)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_LONG));
+ field_pos++;
+#endif
+ char buff[22];
+ size_t length= (size_t) (int10_to_str((long int)from, buff,
+ (from < 0) ? - 10 : 10) - buff);
+ return store_numeric_string_aux(buff, length);
+}
+
+
+bool Protocol_text::store_longlong(longlong from, bool unsigned_flag)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_LONGLONG));
+ field_pos++;
+#endif
+ char buff[22];
+ size_t length= (size_t) (longlong10_to_str(from, buff,
+ unsigned_flag ? 10 : -10) -
+ buff);
+ return store_numeric_string_aux(buff, length);
+}
+
+
+bool Protocol_text::store_decimal(const my_decimal *d)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(0); // This method is not used yet
+ field_pos++;
+#endif
+ StringBuffer<DECIMAL_MAX_STR_LENGTH> str;
+ (void) d->to_string(&str);
+ return store_numeric_string_aux(str.ptr(), str.length());
+}
+
+
+bool Protocol_text::store_float(float from, uint32 decimals)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_FLOAT));
+ field_pos++;
+#endif
+ Float(from).to_string(&buffer, decimals);
+ return store_numeric_string_aux(buffer.ptr(), buffer.length());
+}
+
+
+bool Protocol_text::store_double(double from, uint32 decimals)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_DOUBLE));
+ field_pos++;
+#endif
+ buffer.set_real(from, decimals, thd->charset());
+ return store_numeric_string_aux(buffer.ptr(), buffer.length());
+}
+
+
+bool Protocol_text::store(Field *field)
+{
+ if (field->is_null())
+ return store_null();
+#ifdef DBUG_ASSERT_EXISTS
+ TABLE *table= field->table;
+ MY_BITMAP *old_map= 0;
+ if (table->file)
+ old_map= dbug_tmp_use_all_columns(table, &table->read_set);
+#endif
+
+ bool rc= field->send(this);
+
+#ifdef DBUG_ASSERT_EXISTS
+ if (old_map)
+ dbug_tmp_restore_column_map(&table->read_set, old_map);
+#endif
+
+ return rc;
+}
+
+
+bool Protocol_text::store(MYSQL_TIME *tm, int decimals)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_DATETIME));
+ field_pos++;
+#endif
+ char buff[MAX_DATE_STRING_REP_LENGTH];
+ uint length= my_datetime_to_str(tm, buff, decimals);
+ return store_numeric_string_aux(buff, length);
+}
+
+
+bool Protocol_text::store_date(MYSQL_TIME *tm)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_DATE));
+ field_pos++;
+#endif
+ char buff[MAX_DATE_STRING_REP_LENGTH];
+ size_t length= my_date_to_str(tm, buff);
+ return store_numeric_string_aux(buff, length);
+}
+
+
+bool Protocol_text::store_time(MYSQL_TIME *tm, int decimals)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(valid_handler(field_pos, PROTOCOL_SEND_TIME));
+ field_pos++;
+#endif
+ char buff[MAX_DATE_STRING_REP_LENGTH];
+ uint length= my_time_to_str(tm, buff, decimals);
+ return store_numeric_string_aux(buff, length);
+}
+
+/**
+ Assign OUT-parameters to user variables.
+
+ @param sp_params List of PS/SP parameters (both input and output).
+
+ @return Error status.
+ @retval FALSE Success.
+ @retval TRUE Error.
+*/
+
+bool Protocol_text::send_out_parameters(List<Item_param> *sp_params)
+{
+ DBUG_ASSERT(sp_params->elements == thd->lex->prepared_stmt.param_count());
+
+ List_iterator_fast<Item_param> item_param_it(*sp_params);
+ List_iterator_fast<Item> param_it(thd->lex->prepared_stmt.params());
+
+ while (true)
+ {
+ Item_param *item_param= item_param_it++;
+ Item *param= param_it++;
+ Settable_routine_parameter *sparam;
+
+ if (!item_param || !param)
+ break;
+
+ if (!item_param->get_out_param_info())
+ continue; // It's an IN-parameter.
+
+ if (!(sparam= param->get_settable_routine_parameter()))
+ {
+ DBUG_ASSERT(0);
+ continue;
+ }
+
+ DBUG_ASSERT(sparam->get_item_param() == NULL);
+ sparam->set_value(thd, thd->spcont, reinterpret_cast<Item **>(&item_param));
+ }
+
+ return FALSE;
+}
+
+/****************************************************************************
+ Functions to handle the binary protocol used with prepared statements
+
+ Data format:
+
+ [ok:1] reserved ok packet
+ [null_field:(field_count+7+2)/8] reserved to send null data. The size is
+ calculated using:
+ bit_fields= (field_count+7+2)/8;
+ 2 bits are reserved for identifying type
+ of package.
+ [[length]data] data field (the length applies only for
+ string/binary/time/timestamp fields and
+ rest of them are not sent as they have
+ the default length that client understands
+ based on the field type
+ [..]..[[length]data] data
+****************************************************************************/
+
+bool Protocol_binary::prepare_for_send(uint num_columns)
+{
+ Protocol::prepare_for_send(num_columns);
+ bit_fields= (field_count+9)/8;
+ return packet->alloc(bit_fields+1);
+
+ /* prepare_for_resend will be called after this one */
+}
+
+
+void Protocol_binary::prepare_for_resend()
+{
+ packet->length(bit_fields+1);
+ bzero((uchar*) packet->ptr(), 1+bit_fields);
+ field_pos=0;
+}
+
+
+bool Protocol_binary::store_str(const char *from, size_t length,
+ CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
+{
+ field_pos++;
+ return store_string_aux(from, length, fromcs, tocs);
+}
+
+bool Protocol_binary::store_null()
+{
+ uint offset= (field_pos+2)/8+1, bit= (1 << ((field_pos+2) & 7));
+ /* Room for this as it's allocated in prepare_for_send */
+ char *to= (char*) packet->ptr()+offset;
+ *to= (char) ((uchar) *to | (uchar) bit);
+ field_pos++;
+ return 0;
+}
+
+
+bool Protocol_binary::store_tiny(longlong from)
+{
+ char buff[1];
+ field_pos++;
+ buff[0]= (uchar) from;
+ return packet->append(buff, sizeof(buff), PACKET_BUFFER_EXTRA_ALLOC);
+}
+
+
+bool Protocol_binary::store_short(longlong from)
+{
+ field_pos++;
+ char *to= packet->prep_append(2, PACKET_BUFFER_EXTRA_ALLOC);
+ if (!to)
+ return 1;
+ int2store(to, (int) from);
+ return 0;
+}
+
+
+bool Protocol_binary::store_long(longlong from)
+{
+ field_pos++;
+ char *to= packet->prep_append(4, PACKET_BUFFER_EXTRA_ALLOC);
+ if (!to)
+ return 1;
+ int4store(to, from);
+ return 0;
+}
+
+
+bool Protocol_binary::store_longlong(longlong from, bool unsigned_flag)
+{
+ field_pos++;
+ char *to= packet->prep_append(8, PACKET_BUFFER_EXTRA_ALLOC);
+ if (!to)
+ return 1;
+ int8store(to, from);
+ return 0;
+}
+
+bool Protocol_binary::store_decimal(const my_decimal *d)
+{
+#ifndef DBUG_OFF
+ DBUG_ASSERT(0); // This method is not used yet
+#endif
+ StringBuffer<DECIMAL_MAX_STR_LENGTH> str;
+ (void) d->to_string(&str);
+ return store_str(str.ptr(), str.length(), str.charset(),
+ thd->variables.character_set_results);
+}
+
+bool Protocol_binary::store_float(float from, uint32 decimals)
+{
+ field_pos++;
+ char *to= packet->prep_append(4, PACKET_BUFFER_EXTRA_ALLOC);
+ if (!to)
+ return 1;
+ float4store(to, from);
+ return 0;
+}
+
+
+bool Protocol_binary::store_double(double from, uint32 decimals)
+{
+ field_pos++;
+ char *to= packet->prep_append(8, PACKET_BUFFER_EXTRA_ALLOC);
+ if (!to)
+ return 1;
+ float8store(to, from);
+ return 0;
+}
+
+
+bool Protocol_binary::store(Field *field)
+{
+ /*
+ We should not increment field_pos here as send() will call another
+ protocol function to do this for us
+ */
+ if (field->is_null())
+ return store_null();
+ return field->send(this);
+}
+
+
+bool Protocol_binary::store(MYSQL_TIME *tm, int decimals)
+{
+ char buff[12],*pos;
+ uint length;
+ field_pos++;
+ pos= buff+1;
+
+ int2store(pos, tm->year);
+ pos[2]= (uchar) tm->month;
+ pos[3]= (uchar) tm->day;
+ pos[4]= (uchar) tm->hour;
+ pos[5]= (uchar) tm->minute;
+ pos[6]= (uchar) tm->second;
+ DBUG_ASSERT(decimals == AUTO_SEC_PART_DIGITS ||
+ (decimals >= 0 && decimals <= TIME_SECOND_PART_DIGITS));
+ if (decimals != AUTO_SEC_PART_DIGITS)
+ my_datetime_trunc(tm, decimals);
+ int4store(pos+7, tm->second_part);
+ if (tm->second_part)
+ length=11;
+ else if (tm->hour || tm->minute || tm->second)
+ length=7;
+ else if (tm->year || tm->month || tm->day)
+ length=4;
+ else
+ length=0;
+ buff[0]=(char) length; // Length is stored first
+ return packet->append(buff, length+1, PACKET_BUFFER_EXTRA_ALLOC);
+}
+
+bool Protocol_binary::store_date(MYSQL_TIME *tm)
+{
+ tm->hour= tm->minute= tm->second=0;
+ tm->second_part= 0;
+ return Protocol_binary::store(tm, 0);
+}
+
+
+bool Protocol_binary::store_time(MYSQL_TIME *tm, int decimals)
+{
+ char buff[13], *pos;
+ uint length;
+ field_pos++;
+ pos= buff+1;
+ pos[0]= tm->neg ? 1 : 0;
+ if (tm->hour >= 24)
+ {
+ uint days= tm->hour/24;
+ tm->hour-= days*24;
+ tm->day+= days;
+ }
+ int4store(pos+1, tm->day);
+ pos[5]= (uchar) tm->hour;
+ pos[6]= (uchar) tm->minute;
+ pos[7]= (uchar) tm->second;
+ DBUG_ASSERT(decimals == AUTO_SEC_PART_DIGITS ||
+ (decimals >= 0 && decimals <= TIME_SECOND_PART_DIGITS));
+ if (decimals != AUTO_SEC_PART_DIGITS)
+ my_time_trunc(tm, decimals);
+ int4store(pos+8, tm->second_part);
+ if (tm->second_part)
+ length=12;
+ else if (tm->hour || tm->minute || tm->second || tm->day)
+ length=8;
+ else
+ length=0;
+ buff[0]=(char) length; // Length is stored first
+ return packet->append(buff, length+1, PACKET_BUFFER_EXTRA_ALLOC);
+}
+
+/**
+ Send a result set with OUT-parameter values by means of PS-protocol.
+
+ @param sp_params List of PS/SP parameters (both input and output).
+
+ @return Error status.
+ @retval FALSE Success.
+ @retval TRUE Error.
+*/
+
+bool Protocol_binary::send_out_parameters(List<Item_param> *sp_params)
+{
+ bool ret;
+ if (!(thd->client_capabilities & CLIENT_PS_MULTI_RESULTS))
+ {
+ /* The client does not support OUT-parameters. */
+ return FALSE;
+ }
+
+ List<Item> out_param_lst;
+
+ {
+ List_iterator_fast<Item_param> item_param_it(*sp_params);
+
+ while (true)
+ {
+ Item_param *item_param= item_param_it++;
+
+ if (!item_param)
+ break;
+
+ if (!item_param->get_out_param_info())
+ continue; // It's an IN-parameter.
+
+ if (out_param_lst.push_back(item_param, thd->mem_root))
+ return TRUE;
+ }
+ }
+
+ if (!out_param_lst.elements)
+ return FALSE;
+
+ /*
+ We have to set SERVER_PS_OUT_PARAMS in THD::server_status, because it
+ is used in send_result_set_metadata().
+ */
+
+ thd->server_status|= SERVER_PS_OUT_PARAMS | SERVER_MORE_RESULTS_EXISTS;
+
+ /* Send meta-data. */
+ if (send_result_set_metadata(&out_param_lst, SEND_NUM_ROWS | SEND_EOF))
+ return TRUE;
+
+ /* Send data. */
+
+ prepare_for_resend();
+
+ if (send_result_set_row(&out_param_lst))
+ return TRUE;
+
+ if (write())
+ return TRUE;
+
+ ret= net_send_eof(thd, thd->server_status, 0);
+
+ /*
+ Reset server_status:
+ - SERVER_MORE_RESULTS_EXISTS bit, because this is the last packet for sure.
+ - Restore SERVER_PS_OUT_PARAMS status.
+ */
+ thd->server_status&= ~(SERVER_PS_OUT_PARAMS | SERVER_MORE_RESULTS_EXISTS);
+
+ return ret ? FALSE : TRUE;
+}