1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

name clash with gnutls on on base64_encode

Browse Source
This commit is contained in:
Sergei Golubchik 2016-09-07 19:16:43 +02:00
parent 5ea5a7f7e7
commit 0aa6817e86
7 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/base64.h
View File

@ -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 */

32
mysys/base64.c
View File

@ -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)

4
plugin/feedback/utils.cc
View File

@ -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;
}

24
sql/item_strfunc.cc
View File

@ -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())
{

4
sql/log_event.cc
View File

@ -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);
}

4
sql/sql_binlog.cc
View File

@ -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

12
unittest/mysys/base64-t.c
View File

@ -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);