database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-30 16:24:05 +03:00
Code Activity

Removed files that had been accidentally committed

Browse Source 
Removed compiler warnings
This commit is contained in:
Monty
2014-10-07 11:39:42 +03:00
parent cc8aed3eb7
commit 4af97bc0e3
14 changed files with 57 additions and 604 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
mysys/md5.c.THIS
View File

@ -1,329 +0,0 @@
/* Copyright (c) 2000, 2013, 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
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*
* To compute the message digest of a chunk of bytes, declare an
* MD5Context structure, pass it to MD5Init, call MD5Update as
* needed on buffers full of bytes, and then call MD5Final, which
* will fill a supplied 16-byte array with the digest.
*/
/* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
not require an integer type which is exactly 32 bits. This work
draws on the changes for the same purpose by Tatu Ylonen
<ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
that code, there is no copyright issue. I hereby disclaim
copyright in any changes I have made; this code remains in the
public domain. */
/*
Skip entirely if built with OpenSSL/YaSSL support.
*/
#if !defined(HAVE_OPENSSL) && !defined(HAVE_YASSL)
#include <my_global.h>
#include <m_string.h>
#include "my_md5.h"
static void
my_MD5Transform (cvs_uint32 buf[4], const unsigned char in[64]);
/* Little-endian byte-swapping routines. Note that these do not
depend on the size of datatypes such as uint32, nor do they require
us to detect the endianness of the machine we are running on. It
is possible they should be macros for speed, but I would be
surprised if they were a performance bottleneck for MD5. */
static uint32 getu32 (const unsigned char *addr)
{
return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
| addr[1]) << 8 | addr[0];
}
static void
putu32 (uint32 data, unsigned char *addr)
{
addr[0] = (unsigned char)data;
addr[1] = (unsigned char)(data >> 8);
addr[2] = (unsigned char)(data >> 16);
addr[3] = (unsigned char)(data >> 24);
}
/*
Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
initialization constants.
*/
void
my_MD5Init (my_MD5Context *ctx)
{
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
ctx->bits[0] = 0;
ctx->bits[1] = 0;
}
/*
Update context to reflect the concatenation of another buffer full
of bytes.
*/
void
my_MD5Update (my_MD5Context *ctx, unsigned char const *buf, unsigned len)
{
uint32 t;
/* Update bitcount */
t = ctx->bits[0];
if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
/* Handle any leading odd-sized chunks */
if ( t ) {
unsigned char *p = ctx->in + t;
t = 64-t;
if (len < t) {
memcpy(p, buf, len);
return;
}
memcpy(p, buf, t);
my_MD5Transform (ctx->buf, ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while (len >= 64) {
memcpy(ctx->in, buf, 64);
my_MD5Transform (ctx->buf, ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
memcpy(ctx->in, buf, len);
}
/*
Final wrapup - pad to 64-byte boundary with the bit pattern
1 0* (64-bit count of bits processed, MSB-first)
*/
void
my_MD5Final (unsigned char digest[16], my_MD5Context *ctx)
{
unsigned count;
unsigned char *p;
/* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
/* Set the first char of padding to 0x80. This is safe since there is
always at least one byte free */
p = ctx->in + count;
*p++ = 0x80;
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Pad out to 56 mod 64 */
if (count < 8) {
/* Two lots of padding: Pad the first block to 64 bytes */
memset(p, 0, count);
my_MD5Transform (ctx->buf, ctx->in);
/* Now fill the next block with 56 bytes */
memset(ctx->in, 0, 56);
} else {
/* Pad block to 56 bytes */
memset(p, 0, count-8);
}
/* Append length in bits and transform */
putu32(ctx->bits[0], ctx->in + 56);
putu32(ctx->bits[1], ctx->in + 60);
my_MD5Transform (ctx->buf, ctx->in);
putu32(ctx->buf[0], digest);
putu32(ctx->buf[1], digest + 4);
putu32(ctx->buf[2], digest + 8);
putu32(ctx->buf[3], digest + 12);
memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
}
#ifndef ASM_MD5
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f, w, x, y, z, data, s) \
( w += f(x, y, z) + data, w &= 0xffffffff, w = w<<s | w>>(32-s), w += x )
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data. MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
static void
my_MD5Transform (uint32 buf[4], const unsigned char inraw[64])
{
register uint32 a, b, c, d;
uint32 in[16];
int i;
for (i = 0; i < 16; ++i)
in[i] = getu32 (inraw + 4 * i);
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);
MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);
MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);
MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);
MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);
MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
#endif
#ifdef TEST
/*
Simple test program. Can use it to manually run the tests from
RFC1321 for example.
*/
#include <stdio.h>
int
main (int argc, char **argv)
{
my_MD5Context context;
unsigned char checksum[16];
int i;
int j;
if (argc < 2)
{
fprintf (stderr, "usage: %s string-to-hash\n", argv[0]);
exit (1);
}
for (j = 1; j < argc; ++j)
{
printf ("MD5 (\"%s\") = ", argv[j]);
my_MD5Init (&context);
my_MD5Update (&context, argv[j], strlen (argv[j]));
my_MD5Final (checksum, &context);
for (i = 0; i < 16; i++)
{
printf ("%02x", (unsigned int) checksum[i]);
}
printf ("\n");
}
return 0;
}
#endif /* TEST */
#endif /* !defined(HAVE_OPENSSL) && !defined(HAVE_YASSL) */

228
mysys/my_aes.c.THIS
View File

@ -1,228 +0,0 @@
/* Copyright (c) 2002, 2006 MySQL AB
Use is subject to license terms
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
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
/*
Implementation of AES Encryption for MySQL
Initial version by Peter Zaitsev June 2002
*/
#include <my_global.h>
#include <m_string.h>
#include "my_aes.h"
enum encrypt_dir { AES_ENCRYPT, AES_DECRYPT };
#define AES_BLOCK_SIZE 16 /* Block size in bytes */
#define AES_BAD_DATA -1 /* If bad data discovered during decoding */
/* The structure for key information */
typedef struct {
int nr; /* Number of rounds */
uint32 rk[4*(AES_MAXNR + 1)]; /* key schedule */
} KEYINSTANCE;
/*
This is internal function just keeps joint code of Key generation
SYNOPSIS
my_aes_create_key()
aes_key Address of Key Instance to be created
direction Direction (are we encoding or decoding)
key Key to use for real key creation
key_length Length of the key
DESCRIPTION
RESULT
0 ok
-1 Error Note: The current impementation never returns this
*/
static int my_aes_create_key(KEYINSTANCE *aes_key,
enum encrypt_dir direction, const char *key,
int key_length)
{
uint8 rkey[AES_KEY_LENGTH/8]; /* The real key to be used for encryption */
uint8 *rkey_end=rkey+AES_KEY_LENGTH/8; /* Real key boundary */
uint8 *ptr; /* Start of the real key*/
const char *sptr; /* Start of the working key */
const char *key_end=key+key_length; /* Working key boundary*/
bzero((char*) rkey,AES_KEY_LENGTH/8); /* Set initial key */
for (ptr= rkey, sptr= key; sptr < key_end; ptr++,sptr++)
{
if (ptr == rkey_end)
ptr= rkey; /* Just loop over tmp_key until we used all key */
*ptr^= (uint8) *sptr;
}
#ifdef AES_USE_KEY_BITS
/*
This block is intended to allow more weak encryption if application
build with libmysqld needs to correspond to export regulations
It should be never used in normal distribution as does not give
any speed improvement.
To get worse security define AES_USE_KEY_BITS to number of bits
you want key to be. It should be divisible by 8
WARNING: Changing this value results in changing of enryption for
all key lengths so altering this value will result in impossibility
to decrypt data encrypted with previous value
*/
#define AES_USE_KEY_BYTES (AES_USE_KEY_BITS/8)
/*
To get weaker key we use first AES_USE_KEY_BYTES bytes of created key
and cyclically copy them until we created all required key length
*/
for (ptr= rkey+AES_USE_KEY_BYTES, sptr=rkey ; ptr < rkey_end;
ptr++,sptr++)
{
if (sptr == rkey+AES_USE_KEY_BYTES)
sptr=rkey;
*ptr=*sptr;
}
#endif
if (direction == AES_DECRYPT)
aes_key->nr = rijndaelKeySetupDec(aes_key->rk, rkey, AES_KEY_LENGTH);
else
aes_key->nr = rijndaelKeySetupEnc(aes_key->rk, rkey, AES_KEY_LENGTH);
return 0;
}
/*
Crypt buffer with AES encryption algorithm.
SYNOPSIS
my_aes_encrypt()
source Pointer to data for encryption
source_length Size of encryption data
dest Buffer to place encrypted data (must be large enough)
key Key to be used for encryption
key_length Length of the key. Will handle keys of any length
RETURN
>= 0 Size of encrypted data
< 0 Error
*/
int my_aes_encrypt(const char* source, int source_length, char* dest,
const char* key, int key_length)
{
KEYINSTANCE aes_key;
uint8 block[AES_BLOCK_SIZE]; /* 128 bit block used for padding */
int rc; /* result codes */
int num_blocks; /* number of complete blocks */
char pad_len; /* pad size for the last block */
int i;
if ((rc= my_aes_create_key(&aes_key,AES_ENCRYPT,key,key_length)))
return rc;
num_blocks = source_length/AES_BLOCK_SIZE;
for (i = num_blocks; i > 0; i--) /* Encode complete blocks */
{
rijndaelEncrypt(aes_key.rk, aes_key.nr, (const uint8*) source,
(uint8*) dest);
source+= AES_BLOCK_SIZE;
dest+= AES_BLOCK_SIZE;
}
/* Encode the rest. We always have incomplete block */
pad_len = AES_BLOCK_SIZE - (source_length - AES_BLOCK_SIZE*num_blocks);
memcpy(block, source, 16 - pad_len);
bfill(block + AES_BLOCK_SIZE - pad_len, pad_len, pad_len);
rijndaelEncrypt(aes_key.rk, aes_key.nr, block, (uint8*) dest);
return AES_BLOCK_SIZE*(num_blocks + 1);
}
/*
DeCrypt buffer with AES encryption algorithm.
SYNOPSIS
my_aes_decrypt()
source Pointer to data for decryption
source_length Size of encrypted data
dest Buffer to place decrypted data (must be large enough)
key Key to be used for decryption
key_length Length of the key. Will handle keys of any length
RETURN
>= 0 Size of encrypted data
< 0 Error
*/
int my_aes_decrypt(const char *source, int source_length, char *dest,
const char *key, int key_length)
{
KEYINSTANCE aes_key;
uint8 block[AES_BLOCK_SIZE]; /* 128 bit block used for padding */
int rc; /* Result codes */
int num_blocks; /* Number of complete blocks */
uint pad_len; /* Pad size for the last block */
int i;
if ((rc=my_aes_create_key(&aes_key,AES_DECRYPT,key,key_length)))
return rc;
num_blocks = source_length/AES_BLOCK_SIZE;
if ((source_length != num_blocks*AES_BLOCK_SIZE) || num_blocks ==0 )
return AES_BAD_DATA; /* Input size has to be even and at least one block */
for (i = num_blocks-1; i > 0; i--) /* Decode all but last blocks */
{
rijndaelDecrypt(aes_key.rk, aes_key.nr, (const uint8*) source,
(uint8*) dest);
source+= AES_BLOCK_SIZE;
dest+= AES_BLOCK_SIZE;
}
rijndaelDecrypt(aes_key.rk, aes_key.nr, (const uint8*) source, block);
/* Use last char in the block as size */
pad_len = (uint) (uchar) block[AES_BLOCK_SIZE-1];
if (pad_len > AES_BLOCK_SIZE)
return AES_BAD_DATA;
/* We could also check whole padding but we do not really need this */
memcpy(dest, block, AES_BLOCK_SIZE - pad_len);
return AES_BLOCK_SIZE*num_blocks - pad_len;
}
/*
Get size of buffer which will be large enough for encrypted data
SYNOPSIS
my_aes_get_size()
source_length Length of data to be encrypted
RETURN
Size of buffer required to store encrypted data
*/
int my_aes_get_size(int source_length)
{
return AES_BLOCK_SIZE*(source_length/AES_BLOCK_SIZE)+AES_BLOCK_SIZE;
}

7
sql/events.cc
View File

@ -1131,8 +1131,11 @@ Events::load_events_from_db(THD *thd)
goto end; goto end;
} }
#ifdef WITH_WSREP #ifdef WITH_WSREP
// when SST from master node who initials event, the event status is ENABLED /*
// this is problematic because there are two nodes with same events and both enabled. When SST from master node who initials event, the event status is ENABLED
this is problematic because there are two nodes with same events and
both enabled.
*/
if (WSREP(thd) && et->originator != thd->variables.server_id) if (WSREP(thd) && et->originator != thd->variables.server_id)
{ {
store_record(table, record[1]); store_record(table, record[1]);

10
sql/log.cc
View File

@ -1910,12 +1910,12 @@ static bool trans_cannot_safely_rollback(THD *thd, bool all)
return ((thd->variables.option_bits & OPTION_KEEP_LOG) || return ((thd->variables.option_bits & OPTION_KEEP_LOG) ||
(trans_has_updated_non_trans_table(thd) && (trans_has_updated_non_trans_table(thd) &&
WSREP_FORMAT(thd->variables.binlog_format) == BINLOG_FORMAT_STMT) || WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) == BINLOG_FORMAT_STMT) ||
(cache_mngr->trx_cache.changes_to_non_trans_temp_table() && (cache_mngr->trx_cache.changes_to_non_trans_temp_table() &&
WSREP_FORMAT(thd->variables.binlog_format) == BINLOG_FORMAT_MIXED) || WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) == BINLOG_FORMAT_MIXED) ||
(trans_has_updated_non_trans_table(thd) && (trans_has_updated_non_trans_table(thd) &&
ending_single_stmt_trans(thd,all) && ending_single_stmt_trans(thd,all) &&
WSREP_FORMAT(thd->variables.binlog_format) == BINLOG_FORMAT_MIXED)); WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) == BINLOG_FORMAT_MIXED));
} }
@ -2064,9 +2064,9 @@ static int binlog_rollback(handlerton *hton, THD *thd, bool all)
else if (ending_trans(thd, all) || else if (ending_trans(thd, all) ||
(!(thd->variables.option_bits & OPTION_KEEP_LOG) && (!(thd->variables.option_bits & OPTION_KEEP_LOG) &&
(!stmt_has_updated_non_trans_table(thd) || (!stmt_has_updated_non_trans_table(thd) ||
WSREP_FORMAT(thd->variables.binlog_format) != BINLOG_FORMAT_STMT) && WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) != BINLOG_FORMAT_STMT) &&
(!cache_mngr->trx_cache.changes_to_non_trans_temp_table() || (!cache_mngr->trx_cache.changes_to_non_trans_temp_table() ||
WSREP_FORMAT(thd->variables.binlog_format) != BINLOG_FORMAT_MIXED))) WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) != BINLOG_FORMAT_MIXED)))
error= binlog_truncate_trx_cache(thd, cache_mngr, all); error= binlog_truncate_trx_cache(thd, cache_mngr, all);
} }

4
sql/sql_base.cc
View File

@ -3558,7 +3558,7 @@ thr_lock_type read_lock_type_for_table(THD *thd,
*/ */
bool log_on= mysql_bin_log.is_open() && thd->variables.sql_log_bin; bool log_on= mysql_bin_log.is_open() && thd->variables.sql_log_bin;
ulong binlog_format= thd->variables.binlog_format; ulong binlog_format= thd->variables.binlog_format;
if ((log_on == FALSE) || (WSREP_FORMAT(binlog_format) == BINLOG_FORMAT_ROW) || if ((log_on == FALSE) || (WSREP_FORMAT((enum enum_binlog_format) binlog_format) == BINLOG_FORMAT_ROW) ||
(table_list->table->s->table_category == TABLE_CATEGORY_LOG) || (table_list->table->s->table_category == TABLE_CATEGORY_LOG) ||
(table_list->table->s->table_category == TABLE_CATEGORY_PERFORMANCE) || (table_list->table->s->table_category == TABLE_CATEGORY_PERFORMANCE) ||
!(is_update_query(prelocking_ctx->sql_command) || !(is_update_query(prelocking_ctx->sql_command) ||
@ -5327,7 +5327,7 @@ bool lock_tables(THD *thd, TABLE_LIST *tables, uint count,
We can solve these problems in mixed mode by switching to binlogging We can solve these problems in mixed mode by switching to binlogging
if at least one updated table is used by sub-statement if at least one updated table is used by sub-statement
*/ */
if (WSREP_FORMAT(thd->variables.binlog_format) != BINLOG_FORMAT_ROW && tables && if (WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) != BINLOG_FORMAT_ROW && tables &&
has_write_table_with_auto_increment(thd->lex->first_not_own_table())) has_write_table_with_auto_increment(thd->lex->first_not_own_table()))
thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS); thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS);
} }

27
sql/sql_class.cc
View File

@ -916,13 +916,14 @@ THD::THD(bool is_wsrep_applier)
main_da(0, false, false), main_da(0, false, false),
m_stmt_da(&main_da) m_stmt_da(&main_da)
#ifdef WITH_WSREP #ifdef WITH_WSREP
,wsrep_applier(is_wsrep_applier) ,
,wsrep_applier_closing(false) wsrep_applier(is_wsrep_applier),
,wsrep_client_thread(false) wsrep_applier_closing(false),
,wsrep_apply_toi(false) wsrep_client_thread(false),
,wsrep_po_handle(WSREP_PO_INITIALIZER) wsrep_apply_toi(false),
,wsrep_po_cnt(0) wsrep_po_handle(WSREP_PO_INITIALIZER),
,wsrep_apply_format(0) wsrep_po_cnt(0),
wsrep_apply_format(0)
#endif #endif
{ {
ulong tmp; ulong tmp;
@ -4349,7 +4350,7 @@ extern "C" int thd_binlog_format(const MYSQL_THD thd)
{ {
if (((WSREP(thd) && wsrep_emulate_bin_log) || mysql_bin_log.is_open()) && if (((WSREP(thd) && wsrep_emulate_bin_log) || mysql_bin_log.is_open()) &&
thd->variables.option_bits & OPTION_BIN_LOG) thd->variables.option_bits & OPTION_BIN_LOG)
return (int) WSREP_FORMAT(thd->variables.binlog_format); return (int) WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format);
else else
return BINLOG_FORMAT_UNSPEC; return BINLOG_FORMAT_UNSPEC;
} }
@ -5079,7 +5080,7 @@ int THD::decide_logging_format(TABLE_LIST *tables)
binlog by filtering rules. binlog by filtering rules.
*/ */
if (mysql_bin_log.is_open() && (variables.option_bits & OPTION_BIN_LOG) && if (mysql_bin_log.is_open() && (variables.option_bits & OPTION_BIN_LOG) &&
!(WSREP_FORMAT(variables.binlog_format) == BINLOG_FORMAT_STMT && !(WSREP_FORMAT((enum enum_binlog_format) variables.binlog_format) == BINLOG_FORMAT_STMT &&
!binlog_filter->db_ok(db))) !binlog_filter->db_ok(db)))
{ {
/* /*
@ -5289,7 +5290,7 @@ int THD::decide_logging_format(TABLE_LIST *tables)
*/ */
my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0)); my_error((error= ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE), MYF(0));
} }
else if (WSREP_FORMAT(variables.binlog_format) == BINLOG_FORMAT_ROW && else if (WSREP_FORMAT((enum enum_binlog_format) variables.binlog_format) == BINLOG_FORMAT_ROW &&
sqlcom_can_generate_row_events(this)) sqlcom_can_generate_row_events(this))
{ {
/* /*
@ -5318,7 +5319,7 @@ int THD::decide_logging_format(TABLE_LIST *tables)
else else
{ {
/* binlog_format = STATEMENT */ /* binlog_format = STATEMENT */
if (WSREP_FORMAT(variables.binlog_format) == BINLOG_FORMAT_STMT) if (WSREP_FORMAT((enum enum_binlog_format) variables.binlog_format) == BINLOG_FORMAT_STMT)
{ {
if (lex->is_stmt_row_injection()) if (lex->is_stmt_row_injection())
{ {
@ -5446,11 +5447,11 @@ int THD::decide_logging_format(TABLE_LIST *tables)
DBUG_PRINT("info", ("decision: no logging since " DBUG_PRINT("info", ("decision: no logging since "
"mysql_bin_log.is_open() = %d " "mysql_bin_log.is_open() = %d "
"and (options & OPTION_BIN_LOG) = 0x%llx " "and (options & OPTION_BIN_LOG) = 0x%llx "
"and binlog_format = %lu " "and binlog_format = %u "
"and binlog_filter->db_ok(db) = %d", "and binlog_filter->db_ok(db) = %d",
mysql_bin_log.is_open(), mysql_bin_log.is_open(),
(variables.option_bits & OPTION_BIN_LOG), (variables.option_bits & OPTION_BIN_LOG),
WSREP_FORMAT(variables.binlog_format), (uint) WSREP_FORMAT((enum enum_binlog_format) variables.binlog_format),
binlog_filter->db_ok(db))); binlog_filter->db_ok(db)));
#endif #endif

17
sql/sql_class.h
View File

@ -3286,8 +3286,8 @@ public:
tests fail and so force them to propagate the tests fail and so force them to propagate the
lex->binlog_row_based_if_mixed upwards to the caller. lex->binlog_row_based_if_mixed upwards to the caller.
*/ */
if ((WSREP_FORMAT(variables.binlog_format) == BINLOG_FORMAT_MIXED) && if ((WSREP_FORMAT((enum enum_binlog_format) variables.binlog_format) ==
(in_sub_stmt == 0)) BINLOG_FORMAT_MIXED) && (in_sub_stmt == 0))
set_current_stmt_binlog_format_row(); set_current_stmt_binlog_format_row();
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -3338,7 +3338,8 @@ public:
show_system_thread(system_thread))); show_system_thread(system_thread)));
if (in_sub_stmt == 0) if (in_sub_stmt == 0)
{ {
if (WSREP_FORMAT(variables.binlog_format) == BINLOG_FORMAT_ROW) if (WSREP_FORMAT((enum enum_binlog_format) variables.binlog_format) ==
BINLOG_FORMAT_ROW)
set_current_stmt_binlog_format_row(); set_current_stmt_binlog_format_row();
else if (temporary_tables == NULL) else if (temporary_tables == NULL)
set_current_stmt_binlog_format_stmt(); set_current_stmt_binlog_format_stmt();
@ -3762,17 +3763,17 @@ public:
mysql_cond_t COND_wsrep_thd; mysql_cond_t COND_wsrep_thd;
wsrep_trx_meta_t wsrep_trx_meta; wsrep_trx_meta_t wsrep_trx_meta;
uint32 wsrep_rand; uint32 wsrep_rand;
Relay_log_info* wsrep_rli; Relay_log_info *wsrep_rli;
rpl_group_info* wsrep_rgi; rpl_group_info *wsrep_rgi;
wsrep_ws_handle_t wsrep_ws_handle; wsrep_ws_handle_t wsrep_ws_handle;
ulong wsrep_retry_counter; // of autocommit ulong wsrep_retry_counter; // of autocommit
char* wsrep_retry_query; char *wsrep_retry_query;
size_t wsrep_retry_query_len; size_t wsrep_retry_query_len;
enum enum_server_command wsrep_retry_command; enum enum_server_command wsrep_retry_command;
enum wsrep_consistency_check_mode enum wsrep_consistency_check_mode
wsrep_consistency_check; wsrep_consistency_check;
int wsrep_mysql_replicated; int wsrep_mysql_replicated;
const char* wsrep_TOI_pre_query; /* a query to apply before const char *wsrep_TOI_pre_query; /* a query to apply before
the actual TOI query */ the actual TOI query */
size_t wsrep_TOI_pre_query_len; size_t wsrep_TOI_pre_query_len;
wsrep_po_handle_t wsrep_po_handle; wsrep_po_handle_t wsrep_po_handle;
@ -3780,7 +3781,7 @@ public:
#ifdef GTID_SUPPORT #ifdef GTID_SUPPORT
rpl_sid wsrep_po_sid; rpl_sid wsrep_po_sid;
#endif /* GTID_SUPPORT */ #endif /* GTID_SUPPORT */
void* wsrep_apply_format; void *wsrep_apply_format;
char wsrep_info[128]; /* string for dynamic proc info */ char wsrep_info[128]; /* string for dynamic proc info */
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */

7
sql/sql_parse.cc
View File

@ -2781,10 +2781,9 @@ mysql_execute_command(THD *thd)
else else
res= check_access(thd, privileges_requested, any_db, NULL, NULL, 0, 0); res= check_access(thd, privileges_requested, any_db, NULL, NULL, 0, 0);
if (res) if (!res)
break;
res= execute_sqlcom_select(thd, all_tables); res= execute_sqlcom_select(thd, all_tables);
break; break;
} }
case SQLCOM_PREPARE: case SQLCOM_PREPARE:
@ -3135,7 +3134,7 @@ mysql_execute_command(THD *thd)
*/ */
if (thd->query_name_consts && if (thd->query_name_consts &&
mysql_bin_log.is_open() && mysql_bin_log.is_open() &&
WSREP_FORMAT(thd->variables.binlog_format) == BINLOG_FORMAT_STMT && WSREP_FORMAT((enum enum_binlog_format) thd->variables.binlog_format) == BINLOG_FORMAT_STMT &&
!mysql_bin_log.is_query_in_union(thd, thd->query_id)) !mysql_bin_log.is_query_in_union(thd, thd->query_id))
{ {
List_iterator_fast<Item> it(select_lex->item_list); List_iterator_fast<Item> it(select_lex->item_list);

2
sql/wsrep_thd.cc
View File

@ -90,7 +90,7 @@ void wsrep_client_rollback(THD *thd)
#define NUMBER_OF_FIELDS_TO_IDENTIFY_WORKER 2 #define NUMBER_OF_FIELDS_TO_IDENTIFY_WORKER 2
//#include "rpl_info_factory.h" //#include "rpl_info_factory.h"
#if 0 #ifdef NOT_USED
static Relay_log_info* wsrep_relay_log_init(const char* log_fname) static Relay_log_info* wsrep_relay_log_init(const char* log_fname)
{ {

6
storage/innobase/fil/fil0pagecompress.cc
View File

@ -99,7 +99,6 @@ fil_decompress_page_2(
return; return;
} }
ulint olen = 0;
byte* ptr = buf + FIL_PAGE_DATA; byte* ptr = buf + FIL_PAGE_DATA;
ulint version = mach_read_from_1(buf + FIL_PAGE_VERSION); ulint version = mach_read_from_1(buf + FIL_PAGE_VERSION);
int err = 0; int err = 0;
@ -206,6 +205,7 @@ fil_decompress_page_2(
#ifdef HAVE_LZO #ifdef HAVE_LZO
case PAGE_LZO_ALGORITHM: { case PAGE_LZO_ALGORITHM: {
ulint olen = 0;
fprintf(stderr, "InnoDB: [Note]: lzo \n"); fprintf(stderr, "InnoDB: [Note]: lzo \n");
err = lzo1x_decompress((const unsigned char *)ptr, err = lzo1x_decompress((const unsigned char *)ptr,
original_len,(unsigned char *)(page_buf), &olen, NULL); original_len,(unsigned char *)(page_buf), &olen, NULL);
@ -493,7 +493,6 @@ fil_decompress_page(
ulint actual_size = 0; ulint actual_size = 0;
ulint compression_alg = 0; ulint compression_alg = 0;
byte *in_buf; byte *in_buf;
ulint olen=0;
ulint ptype; ulint ptype;
ut_ad(buf); ut_ad(buf);
@ -607,6 +606,8 @@ fil_decompress_page(
#endif /* HAVE_LZ4 */ #endif /* HAVE_LZ4 */
#ifdef HAVE_LZO #ifdef HAVE_LZO
case PAGE_LZO_ALGORITHM: case PAGE_LZO_ALGORITHM:
{
ulint olen=0;
err = lzo1x_decompress((const unsigned char *)buf+FIL_PAGE_DATA+FIL_PAGE_COMPRESSED_SIZE, err = lzo1x_decompress((const unsigned char *)buf+FIL_PAGE_DATA+FIL_PAGE_COMPRESSED_SIZE,
actual_size,(unsigned char *)in_buf, &olen, NULL); actual_size,(unsigned char *)in_buf, &olen, NULL);
@ -621,6 +622,7 @@ fil_decompress_page(
ut_error; ut_error;
} }
break; break;
}
#endif /* HAVE_LZO */ #endif /* HAVE_LZO */
#ifdef HAVE_LZMA #ifdef HAVE_LZMA
case PAGE_LZMA_ALGORITHM: { case PAGE_LZMA_ALGORITHM: {

1
storage/oqgraph/mysql-test/oqgraph/regression_mdev5996.result
View File

@ -1,3 +1,4 @@
call mtr.add_suppression("99999999 is open on delete");
Performing OQGraph regression test mdev5996 - using db=``, table=`999999999` Performing OQGraph regression test mdev5996 - using db=``, table=`999999999`
use test; use test;
drop table if exists `999999999` ; drop table if exists `999999999` ;

2
storage/oqgraph/mysql-test/oqgraph/regression_mdev5996.test
View File

@ -2,6 +2,8 @@
# MidSchipDB_unstable # MidSchipDB_unstable
--let $oqgraph_table_name= 999999999 --let $oqgraph_table_name= 999999999
call mtr.add_suppression("99999999 is open on delete");
--let $oqgraph_database_name= --let $oqgraph_database_name=
--source regression_mdev5996.inc --source regression_mdev5996.inc

7
storage/xtradb/fil/fil0pagecompress.cc
View File

@ -99,7 +99,6 @@ fil_decompress_page_2(
return; return;
} }
ulint olen = 0;
byte* ptr = buf + FIL_PAGE_DATA; byte* ptr = buf + FIL_PAGE_DATA;
ulint version = mach_read_from_1(buf + FIL_PAGE_VERSION); ulint version = mach_read_from_1(buf + FIL_PAGE_VERSION);
int err = 0; int err = 0;
@ -206,6 +205,7 @@ fil_decompress_page_2(
#ifdef HAVE_LZO #ifdef HAVE_LZO
case PAGE_LZO_ALGORITHM: { case PAGE_LZO_ALGORITHM: {
ulint olen = 0;
fprintf(stderr, "InnoDB: [Note]: lzo \n"); fprintf(stderr, "InnoDB: [Note]: lzo \n");
err = lzo1x_decompress((const unsigned char *)ptr, err = lzo1x_decompress((const unsigned char *)ptr,
original_len,(unsigned char *)(page_buf), &olen, NULL); original_len,(unsigned char *)(page_buf), &olen, NULL);
@ -490,7 +490,6 @@ fil_decompress_page(
ulint actual_size = 0; ulint actual_size = 0;
ulint compression_alg = 0; ulint compression_alg = 0;
byte *in_buf; byte *in_buf;
ulint olen=0;
ulint ptype; ulint ptype;
ut_ad(buf); ut_ad(buf);
@ -603,7 +602,8 @@ fil_decompress_page(
break; break;
#endif /* HAVE_LZ4 */ #endif /* HAVE_LZ4 */
#ifdef HAVE_LZO #ifdef HAVE_LZO
case PAGE_LZO_ALGORITHM: case PAGE_LZO_ALGORITHM: {
ulint olen=0;
err = lzo1x_decompress((const unsigned char *)buf+FIL_PAGE_DATA+FIL_PAGE_COMPRESSED_SIZE, err = lzo1x_decompress((const unsigned char *)buf+FIL_PAGE_DATA+FIL_PAGE_COMPRESSED_SIZE,
actual_size,(unsigned char *)in_buf, &olen, NULL); actual_size,(unsigned char *)in_buf, &olen, NULL);
@ -618,6 +618,7 @@ fil_decompress_page(
ut_error; ut_error;
} }
break; break;
}
#endif /* HAVE_LZO */ #endif /* HAVE_LZO */
#ifdef HAVE_LZMA #ifdef HAVE_LZMA
case PAGE_LZMA_ALGORITHM: { case PAGE_LZMA_ALGORITHM: {

2
storage/xtradb/os/os0file.cc
View File

@ -6404,7 +6404,7 @@ os_file_trim(
#define SECT_SIZE 512 #define SECT_SIZE 512
size_t trim_len = UNIV_PAGE_SIZE - len; size_t trim_len = UNIV_PAGE_SIZE - len;
os_offset_t off = slot->offset + len; os_offset_t off __attribute__((unused)) = slot->offset + len;
// len here should be alligned to sector size // len here should be alligned to sector size
ut_a((trim_len % SECT_SIZE) == 0); ut_a((trim_len % SECT_SIZE) == 0);
ut_a((len % SECT_SIZE) == 0); ut_a((len % SECT_SIZE) == 0);