Merge branch 'mysql-5.6' into mysql-5.7

Author: Sujatha Sivakumar

client/mysqlbinlog.cc

@@ -15,7 +15,7 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */
 
-/* 
+/*
 
    TODO: print the catalog (some USE catalog.db ????).
 

include/base64.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2003, 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
@@ -23,22 +23,22 @@ extern "C" {
 /*
   Calculate how much memory needed for dst of base64_encode()
 */
-int base64_needed_encoded_length(int length_of_data);
+uint64 base64_needed_encoded_length(uint64 length_of_data);
 
 /*
   Maximum length base64_encode_needed_length() can accept with no overflow.
 */
-int base64_encode_max_arg_length(void);
+uint64 base64_encode_max_arg_length(void);
 
 /*
   Calculate how much memory needed for dst of base64_decode()
 */
-int base64_needed_decoded_length(int length_of_encoded_data);
+uint64 base64_needed_decoded_length(uint64 length_of_encoded_data);
 
 /*
   Maximum length base64_decode_needed_length() can accept with no overflow.
 */
-int base64_decode_max_arg_length();
+uint64 base64_decode_max_arg_length();
 
 /*
   Encode data as a base64 string
@@ -48,7 +48,7 @@ int base64_encode(const void *src, size_t src_len, char *dst);
 /*
   Decode a base64 string into data
 */
-int base64_decode(const char *src, size_t src_len,
+int64 base64_decode(const char *src, size_t src_len,
                   void *dst, const char **end_ptr, int flags);
 
 /* Allow multuple chunks 'AAA= AA== AA==', binlog uses this */

mysys/CMakeLists.txt

@@ -85,6 +85,10 @@ TARGET_LINK_LIBRARIES(queues mysys)
 SET_TARGET_PROPERTIES(queues PROPERTIES COMPILE_FLAGS "-DMAIN")
 ADD_TEST(queues_test queues)
 
+ADD_EXECUTABLE(base64_test base64.c)
+SET_TARGET_PROPERTIES(base64_test PROPERTIES COMPILE_FLAGS "-DMAIN")
+TARGET_LINK_LIBRARIES(base64_test mysys)
+
 IF(MSVC)
    INSTALL_DEBUG_TARGET(mysys DESTINATION ${INSTALL_LIBDIR}/debug)
 ENDIF()

mysys/base64.c

@@ -1,4 +1,4 @@
-/* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2003, 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
@@ -28,15 +28,15 @@ static char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  * Maximum length base64_needed_encoded_length()
  * can handle without overflow.
  */
-int
+uint64
 base64_encode_max_arg_length()
 {
-#if (SIZEOF_INT == 8)
+#if (SIZEOF_VOIDP == 8)
   /*
     6827690988321067803 ->   9223372036854775805
     6827690988321067804 ->  -9223372036854775807
   */
-  return 0x5EC0D4C77B03531BLL
+  return 0x5EC0D4C77B03531BLL;
 #else
   /*
     1589695686 ->  2147483646
@@ -47,10 +47,11 @@ base64_encode_max_arg_length()
 }
 
 
-int
-base64_needed_encoded_length(int length_of_data)
+uint64
+base64_needed_encoded_length(uint64 length_of_data)
 {
-  int nb_base64_chars;
+  uint64 nb_base64_chars;
+  if (length_of_data == 0) return 1;
   nb_base64_chars= (length_of_data + 2) / 3 * 4;
 
   return
@@ -64,21 +65,21 @@ base64_needed_encoded_length(int length_of_data)
  * Maximum length base64_needed_decoded_length()
  * can handle without overflow.
  */
-int
+uint64
 base64_decode_max_arg_length()
 {
-#if (SIZEOF_INT == 8)
+#if (SIZEOF_VOIDP == 8)
   return 0x2AAAAAAAAAAAAAAALL;
 #else
   return 0x2AAAAAAA;
 #endif
 }
 
 
-int
-base64_needed_decoded_length(int length_of_encoded_data)
+uint64
+base64_needed_decoded_length(uint64 length_of_encoded_data)
 {
-  return (int) ceil(length_of_encoded_data * 3 / 4);
+  return (uint64) ceil(length_of_encoded_data * 3 / 4);
 }
 
 
@@ -313,7 +314,7 @@ my_base64_decoder_getch(MY_BASE64_DECODER *decoder)
  * @flags         flags e.g. allow multiple chunks
  * @return Number of bytes written at 'dst', or -1 in case of failure
  */
-int
+int64
 base64_decode(const char *src_base, size_t len,
               void *dst, const char **end_ptr, int flags)
 {
@@ -379,16 +380,31 @@ main(void)
   size_t k, l;
   size_t dst_len;
   size_t needed_length;
-
-  for (i= 0; i < 500; i++)
+  char * src;
+  char * s;
+  char * str;
+  char * dst;
+  const char *end_ptr;
+  size_t src_len;
+
+  for (i= 0; i <= 500; i++)
   {
     /* Create source data */
-    const size_t src_len= rand() % 1000 + 1;
+    if (i == 500)
+    {
+#if (SIZEOF_VOIDP == 8)
+      printf("Test case for base64 max event length: 2119594243\n");
+      src_len= 2119594243;
+#else
+      printf("Test case for base64 max event length: 536870912\n");
+      src_len= 536870912;
+#endif
+    }
+    else
+     src_len= rand() % 1000 + 1;
 
-    char * src= (char *) malloc(src_len);
-    char * s= src;
-    char * str;
-    char * dst;
+    src= (char *) malloc(src_len);
+    s= src;
 
     require(src);
     for (j= 0; j<src_len; j++)
@@ -409,7 +425,7 @@ main(void)
     /* Decode */
     dst= (char *) malloc(base64_needed_decoded_length(strlen(str)));
     require(dst);
-    dst_len= base64_decode(str, strlen(str), dst, NULL);
+    dst_len= base64_decode(str, strlen(str), dst, &end_ptr, 0);
     require(dst_len == src_len);
 
     if (memcmp(src, dst, src_len) != 0)
@@ -437,6 +453,9 @@ main(void)
              (uint) src_len, (uint) dst_len);
       require(0);
     }
+    free(src);
+    free(str);
+    free(dst);
   }
   printf("Test succeeded.\n");
   return 0;

sql/item_strfunc.cc

@@ -1313,7 +1313,7 @@ void Item_func_to_base64::fix_length_and_dec()
   }
   else
   {
-    int length= base64_needed_encoded_length((int) args[0]->max_length);
+    uint64 length= base64_needed_encoded_length((uint64) args[0]->max_length);
     DBUG_ASSERT(length > 0);
     fix_char_length_ulonglong((ulonglong) length - 1);
   }
@@ -1324,11 +1324,11 @@ String *Item_func_to_base64::val_str_ascii(String *str)
 {
   String *res= args[0]->val_str(str);
   bool too_long= false;
-  int length;
+  uint64 length;
   if (!res ||
       res->length() > (uint) base64_encode_max_arg_length() ||
       (too_long=
-       ((uint) (length= base64_needed_encoded_length((int) res->length())) >
+       ((uint64) (length= base64_needed_encoded_length((uint64) res->length())) >
         current_thd->variables.max_allowed_packet)) ||
       tmp_value.alloc((uint) length))
   {
@@ -1358,7 +1358,7 @@ void Item_func_from_base64::fix_length_and_dec()
   }
   else
   {
-    int length= base64_needed_decoded_length((int) args[0]->max_length);
+    uint64 length= base64_needed_decoded_length((uint64) args[0]->max_length);
     fix_char_length_ulonglong((ulonglong) length);
   }
   maybe_null= 1; // Can be NULL, e.g. in case of badly formed input string
@@ -1369,16 +1369,16 @@ String *Item_func_from_base64::val_str(String *str)
 {
   String *res= args[0]->val_str_ascii(str);
   bool too_long= false;
-  int length;
+  int64 length;
   const char *end_ptr;
 
   if (!res ||
       res->length() > (uint) base64_decode_max_arg_length() ||
       (too_long=
-       ((uint) (length= base64_needed_decoded_length((int) res->length())) >
+       ((uint64) (length= base64_needed_decoded_length((uint64) res->length())) >
         current_thd->variables.max_allowed_packet)) ||
       tmp_value.alloc((uint) length) ||
-      (length= base64_decode(res->ptr(), (int) res->length(),
+      (length= base64_decode(res->ptr(), (uint64) res->length(),
                              (char *) tmp_value.ptr(), &end_ptr, 0)) < 0 ||
       end_ptr < res->ptr() + res->length())
   {

sql/log_event.cc

@@ -2691,7 +2691,7 @@ void Log_event::print_base64(IO_CACHE* file,
   uint32 size= uint4korr(ptr + EVENT_LEN_OFFSET);
   DBUG_ENTER("Log_event::print_base64");
 
-  size_t const tmp_str_sz= base64_needed_encoded_length((int) size);
+  uint64 const tmp_str_sz= base64_needed_encoded_length((uint64) size);
   char *const tmp_str= (char *) my_malloc(key_memory_log_event,
                                           tmp_str_sz, MYF(MY_WME));
   if (!tmp_str) {

sql/sql_binlog.cc

@@ -185,11 +185,11 @@ void mysql_client_binlog_statement(THD* thd)
        strptr < thd->lex->comment.str + thd->lex->comment.length ; )
   {
     char const *endptr= 0;
-    int bytes_decoded= base64_decode(strptr, coded_len, buf, &endptr,
+    int64 bytes_decoded= base64_decode(strptr, coded_len, buf, &endptr,
                                      MY_BASE64_DECODE_ALLOW_MULTIPLE_CHUNKS);
 
     DBUG_PRINT("info",
-               ("bytes_decoded: %d  strptr: 0x%lx  endptr: 0x%lx ('%c':%d)",
+               ("bytes_decoded: %lld  strptr: 0x%lx  endptr: 0x%lx ('%c':%d)",
                 bytes_decoded, (long) strptr, (long) endptr, *endptr,
                 *endptr));
 
@@ -217,7 +217,7 @@ void mysql_client_binlog_statement(THD* thd)
       order to be able to read exactly what is necessary.
     */
 
-    DBUG_PRINT("info",("binlog base64 decoded_len: %lu  bytes_decoded: %d",
+    DBUG_PRINT("info",("binlog base64 decoded_len: %lu  bytes_decoded: %lld",
                        (ulong) decoded_len, bytes_decoded));
 
     /*
@@ -237,7 +237,7 @@ void mysql_client_binlog_statement(THD* thd)
         my_error(ER_SYNTAX_ERROR, MYF(0));
         goto end;
       }
-      DBUG_PRINT("info", ("event_len=%lu, bytes_decoded=%d",
+      DBUG_PRINT("info", ("event_len=%lu, bytes_decoded=%lld",
                           event_len, bytes_decoded));
 
       if (check_event_type(bufptr[EVENT_TYPE_OFFSET], rli))

storage/ndb/src/mgmapi/mgmapi.cpp

@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+   Copyright (c) 2003, 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
@@ -3404,7 +3404,11 @@ ndb_mgm_set_configuration(NdbMgmHandle h, ndb_mgm_configuration *c)
   }
 
   BaseString encoded;
-  encoded.assfmt("%*s", base64_needed_encoded_length(buf.length()), "Z");
+  /*
+    The base64 encoded data of BaseString can be of max length (1024*1024)/3*4
+    hence using int to store the length.
+  */
+  encoded.assfmt("%*s", (int)base64_needed_encoded_length(buf.length()), "Z");
   (void) base64_encode(buf.get_data(), buf.length(), (char*)encoded.c_str());
 
   Properties args;

storage/ndb/src/mgmsrv/Config.cpp

@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+   Copyright (c) 2003, 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
@@ -240,9 +240,13 @@ Config::pack64(BaseString& encoded) const
   if (m_configValues->m_config.pack(buf) == 0)
     return false;
 
-  // Expand the string to correct length by filling with Z
+  /*
+    Expand the string to correct length by filling with Z.
+    The base64 encoded data of UtilBuffer can be of max length (1024*1024)/3*4
+    hence using int to store the length.
+  */
   encoded.assfmt("%*s",
-                 base64_needed_encoded_length(buf.length()),
+                 (int)base64_needed_encoded_length(buf.length()),
                  "Z");
 
   if (base64_encode(buf.get_data(),