diff --git a/include/base64.h b/include/base64.h index 9a843b5088e..cb5ac5e0b5e 100644 --- a/include/base64.h +++ b/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 */ diff --git a/mysys/base64.c b/mysys/base64.c index 265b2f22aad..67a9a13120b 100644 --- a/mysys/base64.c +++ b/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) diff --git a/plugin/feedback/utils.cc b/plugin/feedback/utils.cc index b83b69be0ce..327db69feda 100644 --- a/plugin/feedback/utils.cc +++ b/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; } diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc index bd38d644101..26b50ee96cf 100644 --- a/sql/item_strfunc.cc +++ b/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()) { diff --git a/sql/log_event.cc b/sql/log_event.cc index 49c8e2e6162..347baae84ef 100644 --- a/sql/log_event.cc +++ b/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); } diff --git a/sql/sql_binlog.cc b/sql/sql_binlog.cc index f0465cdf5bf..1967b74e737 100644 --- a/sql/sql_binlog.cc +++ b/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 diff --git a/unittest/mysys/base64-t.c b/unittest/mysys/base64-t.c index 1cf54f9b673..97558083bef 100644 --- a/unittest/mysys/base64-t.c +++ b/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);