name clash with gnutls on on base64_encode

include/base64.h

@@ -22,34 +22,34 @@ extern "C" {
 #endif
 
 /*
-  Calculate how much memory needed for dst of base64_encode()
+  Calculate how much memory needed for dst of my_base64_encode()
 */
-int base64_needed_encoded_length(int length_of_data);
+int my_base64_needed_encoded_length(int length_of_data);
 
 /*
-  Maximum length base64_encode_needed_length() can accept with no overflow.
+  Maximum length my_base64_encode_needed_length() can accept with no overflow.
 */
-int base64_encode_max_arg_length(void);
+int my_base64_encode_max_arg_length(void);
 
 /*
-  Calculate how much memory needed for dst of base64_decode()
+  Calculate how much memory needed for dst of my_base64_decode()
 */
-int base64_needed_decoded_length(int length_of_encoded_data);
+int my_base64_needed_decoded_length(int length_of_encoded_data);
 
 /*
-  Maximum length base64_decode_needed_length() can accept with no overflow.
+  Maximum length my_base64_decode_needed_length() can accept with no overflow.
 */
-int base64_decode_max_arg_length();
+int my_base64_decode_max_arg_length();
 
 /*
   Encode data as a base64 string
 */
-int base64_encode(const void *src, size_t src_len, char *dst);
+int my_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,
+int my_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/base64.c

@@ -26,22 +26,22 @@ static char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                              "0123456789+/";
 
 /**
- * Maximum length base64_needed_encoded_length()
+ * Maximum length my_base64_needed_encoded_length()
  * can handle without signed integer overflow.
  */
 int
-base64_encode_max_arg_length()
+my_base64_encode_max_arg_length()
 {
   /*
-    base64_needed_encoded_length(1589695686) ->  2147483646 (7FFFFFFE)
-    base64_needed_encoded_length(1589695687) -> -2147483645
+    my_base64_needed_encoded_length(1589695686) ->  2147483646 (7FFFFFFE)
+    my_base64_needed_encoded_length(1589695687) -> -2147483645
   */
   return 0x5EC0D4C6; /* 1589695686 */
 }
 
 
 int
-base64_needed_encoded_length(int length_of_data)
+my_base64_needed_encoded_length(int length_of_data)
 {
   int nb_base64_chars;
   nb_base64_chars= (length_of_data + 2) / 3 * 4;
@@ -54,17 +54,17 @@ base64_needed_encoded_length(int length_of_data)
 
 
 /**
- * Maximum length supported by base64_decode().
+ * Maximum length supported by my_base64_decode().
  */
 int
-base64_decode_max_arg_length()
+my_base64_decode_max_arg_length()
 {
   return 0x7FFFFFFF;
 }
 
 
 int
-base64_needed_decoded_length(int length_of_encoded_data)
+my_base64_needed_decoded_length(int length_of_encoded_data)
 {
   return (int) ((longlong) length_of_encoded_data + 3) / 4 * 3;
 }
@@ -74,7 +74,7 @@ base64_needed_decoded_length(int length_of_encoded_data)
   Encode a data as base64.
 
   Note: We require that dst is pre-allocated to correct size.
-        See base64_needed_encoded_length().
+        See my_base64_needed_encoded_length().
 
   Note: We add line separators every 76 characters.
   
@@ -83,7 +83,7 @@ base64_needed_decoded_length(int length_of_encoded_data)
 */
 
 int
-base64_encode(const void *src, size_t src_len, char *dst)
+my_base64_encode(const void *src, size_t src_len, char *dst)
 {
   const unsigned char *s= (const unsigned char*)src;
   size_t i= 0;
@@ -299,7 +299,7 @@ my_base64_decoder_getch(MY_BASE64_DECODER *decoder)
  * the last read character, even in the presence of error.
  *
  * Note: 'dst' must have sufficient space to store the decoded data.
- * Use base64_needed_decoded_length() to calculate the correct space size.
+ * Use my_base64_needed_decoded_length() to calculate the correct space size.
  *
  * Note: we allow spaces and line separators at any position.
  *
@@ -313,7 +313,7 @@ my_base64_decoder_getch(MY_BASE64_DECODER *decoder)
  * @return Number of bytes written at 'dst', or -1 in case of failure
  */
 int
-base64_decode(const char *src_base, size_t len,
+my_base64_decode(const char *src_base, size_t len,
               void *dst, const char **end_ptr, int flags)
 {
   char *d= (char*) dst;
@@ -397,18 +397,18 @@ main(void)
     }
 
     /* Encode */
-    needed_length= base64_needed_encoded_length(src_len);
+    needed_length= my_base64_needed_encoded_length(src_len);
     str= (char *) malloc(needed_length);
     require(str);
     for (k= 0; k < needed_length; k++)
       str[k]= 0xff; /* Fill memory to check correct NUL termination */
-    require(base64_encode(src, src_len, str) == 0);
+    require(my_base64_encode(src, src_len, str) == 0);
     require(needed_length == strlen(str) + 1);
 
     /* Decode */
-    dst= (char *) malloc(base64_needed_decoded_length(strlen(str)));
+    dst= (char *) malloc(my_base64_needed_decoded_length(strlen(str)));
     require(dst);
-    dst_len= base64_decode(str, strlen(str), dst, NULL);
+    dst_len= my_base64_decode(str, strlen(str), dst, NULL);
     require(dst_len == src_len);
 
     if (memcmp(src, dst, src_len) != 0)

plugin/feedback/utils.cc

@@ -422,8 +422,8 @@ int calculate_server_uid(char *dest)
 
   compute_sha1_hash((uint8*) shabuf, (char*) rawbuf, sizeof(rawbuf));
 
-  assert(base64_needed_encoded_length(sizeof(shabuf)) <= SERVER_UID_SIZE);
-  base64_encode(shabuf, sizeof(shabuf), dest);
+  assert(my_base64_needed_encoded_length(sizeof(shabuf)) <= SERVER_UID_SIZE);
+  my_base64_encode(shabuf, sizeof(shabuf), dest);
 
   return 0;
 }

sql/item_strfunc.cc

@@ -427,14 +427,14 @@ void Item_func_to_base64::fix_length_and_dec()
 {
   maybe_null= args[0]->maybe_null;
   collation.set(default_charset(), DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
-  if (args[0]->max_length > (uint) base64_encode_max_arg_length())
+  if (args[0]->max_length > (uint) my_base64_encode_max_arg_length())
   {
     maybe_null= 1;
-    fix_char_length_ulonglong((ulonglong) base64_encode_max_arg_length());
+    fix_char_length_ulonglong((ulonglong) my_base64_encode_max_arg_length());
   }
   else
   {
-    int length= base64_needed_encoded_length((int) args[0]->max_length);
+    int length= my_base64_needed_encoded_length((int) args[0]->max_length);
     DBUG_ASSERT(length > 0);
     fix_char_length_ulonglong((ulonglong) length - 1);
   }
@@ -447,9 +447,9 @@ String *Item_func_to_base64::val_str_ascii(String *str)
   bool too_long= false;
   int length;
   if (!res ||
-      res->length() > (uint) base64_encode_max_arg_length() ||
+      res->length() > (uint) my_base64_encode_max_arg_length() ||
       (too_long=
-       ((uint) (length= base64_needed_encoded_length((int) res->length())) >
+       ((uint) (length= my_base64_needed_encoded_length((int) res->length())) >
         current_thd->variables.max_allowed_packet)) ||
       tmp_value.alloc((uint) length))
   {
@@ -465,7 +465,7 @@ String *Item_func_to_base64::val_str_ascii(String *str)
     }
     return 0;
   }
-  base64_encode(res->ptr(), (int) res->length(), (char*) tmp_value.ptr());
+  my_base64_encode(res->ptr(), (int) res->length(), (char*) tmp_value.ptr());
   DBUG_ASSERT(length > 0);
   tmp_value.length((uint) length - 1); // Without trailing '\0'
   null_value= 0;
@@ -475,13 +475,13 @@ String *Item_func_to_base64::val_str_ascii(String *str)
 
 void Item_func_from_base64::fix_length_and_dec()
 {
-  if (args[0]->max_length > (uint) base64_decode_max_arg_length())
+  if (args[0]->max_length > (uint) my_base64_decode_max_arg_length())
   {
-    fix_char_length_ulonglong((ulonglong) base64_decode_max_arg_length());
+    fix_char_length_ulonglong((ulonglong) my_base64_decode_max_arg_length());
   }
   else
   {
-    int length= base64_needed_decoded_length((int) args[0]->max_length);
+    int length= my_base64_needed_decoded_length((int) 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
@@ -497,8 +497,8 @@ String *Item_func_from_base64::val_str(String *str)
   if (!res)
     goto err;
 
-  if (res->length() > (uint) base64_decode_max_arg_length() ||
-      ((uint) (length= base64_needed_decoded_length((int) res->length())) >
+  if (res->length() > (uint) my_base64_decode_max_arg_length() ||
+      ((uint) (length= my_base64_needed_decoded_length((int) res->length())) >
        current_thd->variables.max_allowed_packet))
   {
     THD *thd= current_thd;
@@ -513,7 +513,7 @@ String *Item_func_from_base64::val_str(String *str)
   if (tmp_value.alloc((uint) length))
     goto err;
 
-  if ((length= base64_decode(res->ptr(), (int) res->length(),
+  if ((length= my_base64_decode(res->ptr(), (int) res->length(),
                              (char *) tmp_value.ptr(), &end_ptr, 0)) < 0 ||
       end_ptr < res->ptr() + res->length())
   {

sql/log_event.cc

@@ -2771,7 +2771,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);
+  size_t const tmp_str_sz= my_base64_needed_encoded_length((int) size);
   char *const tmp_str= (char *) my_malloc(tmp_str_sz, MYF(MY_WME));
   if (!tmp_str) {
     fprintf(stderr, "\nError: Out of memory. "
@@ -2779,7 +2779,7 @@ void Log_event::print_base64(IO_CACHE* file,
     DBUG_VOID_RETURN;
   }
 
-  if (base64_encode(ptr, (size_t) size, tmp_str))
+  if (my_base64_encode(ptr, (size_t) size, tmp_str))
   {
     DBUG_ASSERT(0);
   }

sql/sql_binlog.cc

@@ -60,7 +60,7 @@ void mysql_client_binlog_statement(THD* thd)
     my_error(ER_SYNTAX_ERROR, MYF(0));
     DBUG_VOID_RETURN;
   }
-  size_t decoded_len= base64_needed_decoded_length(coded_len);
+  size_t decoded_len= my_base64_needed_decoded_length(coded_len);
 
   /*
     option_bits will be changed when applying the event. But we don't expect
@@ -124,7 +124,7 @@ 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,
+    int bytes_decoded= my_base64_decode(strptr, coded_len, buf, &endptr,
                                      MY_BASE64_DECODE_ALLOW_MULTIPLE_CHUNKS);
 
 #ifndef HAVE_valgrind

unittest/mysys/base64-t.c

@@ -49,18 +49,18 @@ main(int argc __attribute__((unused)),char *argv[])
     }
 
     /* Encode */
-    needed_length= base64_needed_encoded_length(src_len);
+    needed_length= my_base64_needed_encoded_length(src_len);
     str= (char *) malloc(needed_length);
     for (k= 0; k < needed_length; k++)
       str[k]= 0xff; /* Fill memory to check correct NUL termination */
-    ok(base64_encode(src, src_len, str) == 0,
-       "base64_encode: size %d", i);
+    ok(my_base64_encode(src, src_len, str) == 0,
+       "my_base64_encode: size %d", i);
     ok(needed_length == strlen(str) + 1,
-       "base64_needed_encoded_length: size %d", i);
+       "my_base64_needed_encoded_length: size %d", i);
 
     /* Decode */
-    dst= (char *) malloc(base64_needed_decoded_length(strlen(str)));
-    dst_len= base64_decode(str, strlen(str), dst, NULL, 0);
+    dst= (char *) malloc(my_base64_needed_decoded_length(strlen(str)));
+    dst_len= my_base64_decode(str, strlen(str), dst, NULL, 0);
     ok(dst_len == src_len, "Comparing lengths");
 
     cmp= memcmp(src, dst, src_len);