Merge branch 'mysql-5.6' into mysql-5.7

Author: Arun Kuruvila

libmysqld/lib_sql.cc

@@ -328,15 +328,26 @@ static my_bool emb_read_query_result(MYSQL *mysql)
   return 0;
 }
 
+#define HEADER_SIZE 9
 static int emb_stmt_execute(MYSQL_STMT *stmt)
 {
   DBUG_ENTER("emb_stmt_execute");
-  uchar header[5];
+  /*
+    Header size is made similar to non-embedded library.
+    It should be consistent across embedded and non-embedded
+    libraries.
+  */
+  uchar header[HEADER_SIZE];
   THD *thd;
   my_bool res;
 
   int4store(header, stmt->stmt_id);
   header[4]= (uchar) stmt->flags;
+  /*
+    Dummy value is stored in the last 4 bytes of the header
+    to make it consistent with non-embedded library.
+  */
+  int4store(header + 5, 1);
   thd= (THD*)stmt->mysql->thd;
   thd->client_param_count= stmt->param_count;
   thd->client_params= stmt->params;
@@ -1270,6 +1281,16 @@ bool net_send_error_packet(THD *thd, uint sql_errno, const char *err,
 }
 
 
+void Protocol_binary::start_row()
+{
+  MYSQL_DATA *data= m_thd->cur_data;
+  next_mysql_field= data->embedded_info->fields_list;
+  packet->length(bit_fields + 1);
+  memset(const_cast<char*>(packet->ptr()), 0, 1 + bit_fields);
+  field_pos= 0;
+}
+
+
 void Protocol_text::start_row()
 {
   MYSQL_ROWS *cur;
@@ -1310,6 +1331,78 @@ bool Protocol_text::store_null()
 }
 
 
+bool Protocol_binary::net_store_data(const uchar *from, size_t length)
+{
+  if (!m_thd->mysql)            // bootstrap file handling
+    return 0;
+
+  size_t 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->mem_realloc(packet_length + 9 + length))
+    return 1;
+  uchar *to= net_store_length((uchar*)packet->ptr() + packet_length, length);
+  memcpy(to, from, length);
+  packet->length((uint)(to + length - (uchar*)packet->ptr()));
+  if (next_mysql_field->max_length < length)
+    next_mysql_field->max_length= length;
+  ++next_mysql_field;
+  return 0;
+}
+
+bool Protocol_binary::net_store_data(const uchar *from, size_t length,
+                                     const CHARSET_INFO *from_cs,
+                                     const CHARSET_INFO *to_cs)
+{
+  uint dummy_errors;
+  /* Calculate maxumum possible result length */
+  size_t conv_length= to_cs->mbmaxlen * length / from_cs->mbminlen;
+
+  if (!m_thd->mysql)            // bootstrap file handling
+    return 0;
+
+  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->mem_realloc(new_length))
+    return 1;
+
+  char *length_pos= (char*) packet->ptr() + packet_length;
+  char *to= length_pos + 1;
+
+  to+= length= 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()));
+  if (next_mysql_field->max_length < length)
+    next_mysql_field->max_length= length;
+  ++next_mysql_field;
+  return 0;
+}
+
+
 bool Protocol_classic::net_store_data(const uchar *from, size_t length)
 {
   char *field_buf;

sql/protocol_classic.cc

@@ -41,9 +41,6 @@ static bool write_eof_packet(THD *, NET *, uint, uint);
 
 #ifndef EMBEDDED_LIBRARY
 bool Protocol_classic::net_store_data(const uchar *from, size_t length)
-#else
-bool Protocol_binary::net_store_data(const uchar *from, size_t length)
-#endif
 {
   size_t packet_length=packet->length();
   /*
@@ -58,6 +55,7 @@ bool Protocol_binary::net_store_data(const uchar *from, size_t length)
   packet->length((uint) (to+length-(uchar *) packet->ptr()));
   return 0;
 }
+#endif
 
 
 /**
@@ -1552,6 +1550,7 @@ bool Protocol_binary::start_result_metadata(uint num_cols, uint flags,
 }
 
 
+#ifndef EMBEDDED_LIBRARY
 void Protocol_binary::start_row()
 {
   if (send_metadata)
@@ -1560,6 +1559,7 @@ void Protocol_binary::start_row()
   memset(const_cast<char*>(packet->ptr()), 0, 1+bit_fields);
   field_pos=0;
 }
+#endif
 
 
 bool Protocol_binary::store(const char *from, size_t length,

sql/protocol_classic.h

@@ -53,8 +53,9 @@ class Protocol_classic : public Protocol
   MEM_ROOT     *field_alloc;
   virtual bool net_store_data(const uchar *from, size_t length);
 #endif
-  bool net_store_data(const uchar *from, size_t length,
-                      const CHARSET_INFO *fromcs, const CHARSET_INFO *tocs);
+  virtual bool net_store_data(const uchar *from, size_t length,
+                              const CHARSET_INFO *fromcs,
+                              const CHARSET_INFO *tocs);
   bool store_string_aux(const char *from, size_t length,
                         const CHARSET_INFO *fromcs, const CHARSET_INFO *tocs);
 
@@ -252,6 +253,9 @@ class Protocol_binary : public Protocol_text
 #ifdef EMBEDDED_LIBRARY
   virtual bool end_row();
   bool net_store_data(const uchar *from, size_t length);
+  bool net_store_data(const uchar *from, size_t length,
+                      const CHARSET_INFO *fromcs,
+                      const CHARSET_INFO *tocs);
 #endif
   virtual bool store_null();
   virtual bool store_tiny(longlong from);

testclients/mysql_client_test.c

@@ -20681,6 +20681,52 @@ static void test_wl8754()
   mysql_close(conn);
  }
 
+/*
+  BUG#17883203: MYSQL EMBEDDED MYSQL_STMT_EXECUTE RETURN
+                "MALFORMED COMMUNICATION PACKET" ERROR
+*/
+#define BUG17883203_STRING_SIZE 50
+
+static void test_bug17883203()
+{
+  MYSQL_STMT *stmt;
+  MYSQL_BIND bind;
+  char str_data[BUG17883203_STRING_SIZE];
+  my_bool is_null;
+  my_bool error;
+  unsigned long length;
+  const char stmt_text[] ="SELECT VERSION()";
+  int rc;
+
+  myheader("test_bug17883203");
+
+  stmt = mysql_stmt_init(mysql);
+  check_stmt(stmt);
+  rc= mysql_stmt_prepare(stmt, stmt_text, strlen(stmt_text));
+  check_execute(stmt, rc);
+  rc= mysql_stmt_execute(stmt);
+  check_execute(stmt, rc);
+  memset(&bind, 0, sizeof(bind));
+
+  bind.buffer_type= MYSQL_TYPE_STRING;
+  bind.buffer= (char *)str_data;
+  bind.buffer_length= BUG17883203_STRING_SIZE;
+  bind.is_null= &is_null;
+  bind.length= &length;
+  bind.error= &error;
+
+  rc= mysql_stmt_bind_result(stmt, &bind);
+  check_execute(stmt, rc);
+  rc= mysql_stmt_fetch(stmt);
+  check_execute(stmt, rc);
+
+  if (!opt_silent)
+  {
+    fprintf(stdout, "\n Version: %s", str_data);
+  }
+  mysql_stmt_close(stmt);
+}
+
 static struct my_tests_st my_tests[]= {
   { "disable_query_logs", disable_query_logs },
   { "test_view_sp_list_fields", test_view_sp_list_fields },
@@ -20968,6 +21014,7 @@ static struct my_tests_st my_tests[]= {
   { "test_bug21199582", test_bug21199582 },
   { "test_bug20821550", test_bug20821550 },
   { "test_wl8754", test_wl8754 },
+  { "test_bug17883203", test_bug17883203 },
   { 0, 0 }
 };