/**
The method returns the checksum algorithm used to checksum the binary log.
For MySQL server versions < 5.6, the algorithm is undefined. For the higher
versions, the type is decoded from the FORMAT_DESCRIPTION_EVENT.
@param buf buffer holding serialized FD event
@param len netto (possible checksum is stripped off) length of the event buf
@return the version-safe checksum alg descriptor where zero
designates no checksum, 255 - the orginator is
checksum-unaware (effectively no checksum) and the actuall
[1-254] range alg descriptor.
*/
enum_binlog_checksum_alg
Log_event_footer::get_checksum_alg(const char* buf, unsigned long len)
{
enum_binlog_checksum_alg ret;
char version[ST_SERVER_VER_LEN];
unsigned char version_split[3];
BAPI_ASSERT(buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT);
memcpy(version, buf +
buf[LOG_EVENT_MINIMAL_HEADER_LEN + ST_COMMON_HEADER_LEN_OFFSET]
+ ST_SERVER_VER_OFFSET, ST_SERVER_VER_LEN);
version[ST_SERVER_VER_LEN - 1]= 0;
do_server_version_split(version, version_split);
if (version_product(version_split) < checksum_version_product)
ret= BINLOG_CHECKSUM_ALG_UNDEF;
else
ret= static_cast<enum_binlog_checksum_alg>(*(buf + len -
BINLOG_CHECKSUM_LEN -
BINLOG_CHECKSUM_ALG_DESC_LEN));
BAPI_ASSERT(ret == BINLOG_CHECKSUM_ALG_OFF ||
ret == BINLOG_CHECKSUM_ALG_UNDEF ||
ret == BINLOG_CHECKSUM_ALG_CRC32);
return ret;
}
/**
The constructor for User_var_event.
*/
User_var_event::
User_var_event(const char* buf, unsigned int event_len,
const Format_description_event* description_event)
:Binary_log_event(&buf, description_event->binlog_version,
description_event->server_version)
{
//buf is advanced in Binary_log_event constructor to point to
//beginning of post-header
bool error= false;
const char* buf_start= buf - description_event->common_header_len;
/* The Post-Header is empty. The Variable Data part begins immediately. */
const char *start= buf_start;
buf+= description_event->post_header_len[USER_VAR_EVENT-1];
memcpy(&name_len, buf, 4);
name_len= le32toh(name_len);
name= (char *) buf + UV_NAME_LEN_SIZE;
/*
We don't know yet is_null value, so we must assume that name_len
may have the bigger value possible, is_null= True and there is no
payload for val, or even that name_len is 0.
*/
if (!valid_buffer_range<unsigned int>(name_len, buf_start, name,
event_len - UV_VAL_IS_NULL))
{
error= true;
goto err;
}
buf+= UV_NAME_LEN_SIZE + name_len;
is_null= (bool) *buf;
flags= User_var_event::UNDEF_F; // defaults to UNDEF_F
if (is_null)
{
type= STRING_TYPE;
/*
*my_charset_bin.number= 63, and my_charset_bin is defined in server
*so replacing it with its value.
*/
charset_number= 63;
val_len= 0;
val= 0;
}
else
{
if (!valid_buffer_range<unsigned int>(UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE
+ UV_CHARSET_NUMBER_SIZE +
UV_VAL_LEN_SIZE, buf_start, buf,
event_len))
{
error= true;
goto err;
}
type= (Value_type) buf[UV_VAL_IS_NULL];
memcpy(&charset_number, buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE,
sizeof(charset_number));
charset_number= le32toh(charset_number);
memcpy(&val_len, (buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
UV_CHARSET_NUMBER_SIZE), sizeof(val_len));
val_len= le32toh(val_len);
val= (char *) (buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE);
if (!valid_buffer_range<unsigned int>(val_len, buf_start, val, event_len))
{
error= true;
goto err;
}
/**
We need to check if this is from an old server
that did not pack information for flags.
We do this by checking if there are extra bytes
after the packed value. If there are we take the
extra byte and it's value is assumed to contain
the flags value.
Old events will not have this extra byte, thence,
we keep the flags set to UNDEF_F.
*/
size_t bytes_read= ((val + val_len) - start);
#ifndef DBUG_OFF
bool old_pre_checksum_fd= description_event->is_version_before_checksum();
bool checksum_verify= (old_pre_checksum_fd ||
(description_event->footer()->checksum_alg ==
BINLOG_CHECKSUM_ALG_OFF));
size_t data_written= (header()->data_written- checksum_verify);
BAPI_ASSERT(((bytes_read == data_written) ? 0 : BINLOG_CHECKSUM_LEN)||
((bytes_read == data_written - 1) ? 0 : BINLOG_CHECKSUM_LEN));
#endif
if ((header()->data_written - bytes_read) > 0)
{
flags= (unsigned int) *(buf + UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE +
UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE +
val_len);
}
}
err:
if (error)
name= 0;
}
/**
The event occurs when an updating statement is done.
*/
Query_event::Query_event(const char* buf, unsigned int event_len,
const Format_description_event *description_event,
Log_event_type event_type)
: Binary_log_event(&buf, description_event->binlog_version,
description_event->server_version),
query(0), db(0), catalog(0), time_zone_str(0),
user(0), user_len(0), host(0), host_len(0),
db_len(0), status_vars_len(0), q_len(0),
flags2_inited(0), sql_mode_inited(0), charset_inited(0),
auto_increment_increment(1), auto_increment_offset(1),
time_zone_len(0), catalog_len(0), lc_time_names_number(0),
charset_database_number(0), table_map_for_update(0), master_data_written(0),
mts_accessed_dbs(OVER_MAX_DBS_IN_EVENT_MTS), last_committed(SEQ_UNINIT),
sequence_number(SEQ_UNINIT)
{
//buf is advanced in Binary_log_event constructor to point to
//beginning of post-header
uint32_t tmp;
uint8_t common_header_len, post_header_len;
Log_event_header::Byte *start;
const Log_event_header::Byte *end;
query_data_written= 0;
common_header_len= description_event->common_header_len;
post_header_len= description_event->post_header_len[event_type - 1];
/*
We test if the event's length is sensible, and if so we compute data_len.
We cannot rely on QUERY_HEADER_LEN here as it would not be format-tolerant.
We use QUERY_HEADER_MINIMAL_LEN which is the same for 3.23, 4.0 & 5.0.
*/
if (event_len < (unsigned int)(common_header_len + post_header_len))
return;
data_len= event_len - (common_header_len + post_header_len);
memcpy(&thread_id, buf + Q_THREAD_ID_OFFSET, sizeof(thread_id));
thread_id= le32toh(thread_id);
memcpy(&query_exec_time, buf + Q_EXEC_TIME_OFFSET, sizeof(query_exec_time));
query_exec_time= le32toh(query_exec_time);
db_len= (unsigned int)buf[Q_DB_LEN_OFFSET];
// TODO: add a check of all *_len vars
memcpy(&error_code, buf + Q_ERR_CODE_OFFSET, sizeof(error_code));
error_code= le16toh(error_code);
/*
5.0 format starts here.
Depending on the format, we may or not have affected/warnings etc
The remnent post-header to be parsed has length:
*/
tmp= post_header_len - QUERY_HEADER_MINIMAL_LEN;
if (tmp)
{
memcpy(&status_vars_len, buf + Q_STATUS_VARS_LEN_OFFSET,
sizeof(status_vars_len));
status_vars_len= le16toh(status_vars_len);
/*
Check if status variable length is corrupt and will lead to very
wrong data. We could be even more strict and require data_len to
be even bigger, but this will suffice to catch most corruption
errors that can lead to a crash.
*/
if (status_vars_len >
std::min<unsigned long>(data_len, MAX_SIZE_LOG_EVENT_STATUS))
{
query= 0;
return;
}
data_len-= status_vars_len;
tmp-= 2;
}
else
{
/*
server version < 5.0 / binlog_version < 4 master's event is
relay-logged with storing the original size of the event in
Q_MASTER_DATA_WRITTEN_CODE status variable.
The size is to be restored at reading Q_MASTER_DATA_WRITTEN_CODE-marked
event from the relay log.
*/
BAPI_ASSERT(description_event->binlog_version < 4);
master_data_written= header()->data_written;
}
/*
We have parsed everything we know in the post header for QUERY_EVENT,
the rest of post header is either comes from older version MySQL or
dedicated to derived events (e.g. Execute_load_query...)
*/
/* variable-part: the status vars; only in MySQL 5.0 */
start= (Log_event_header::Byte*) (buf + post_header_len);
end= (const Log_event_header::Byte*) (start + status_vars_len);
for (const Log_event_header::Byte* pos= start; pos < end;)
{
switch (*pos++) {
case Q_FLAGS2_CODE:
CHECK_SPACE(pos, end, 4);
flags2_inited= 1;
memcpy(&flags2, pos, sizeof(flags2));
flags2= le32toh(flags2);
pos+= 4;
break;
case Q_SQL_MODE_CODE:
{
CHECK_SPACE(pos, end, 8);
sql_mode_inited= 1;
memcpy(&sql_mode, pos, sizeof(sql_mode));
sql_mode= le64toh(sql_mode);
pos+= 8;
break;
}
case Q_CATALOG_NZ_CODE:
if ((catalog_len= *pos))
catalog= (const char*) (pos + 1);
CHECK_SPACE(pos, end, catalog_len + 1);
pos+= catalog_len + 1;
break;
case Q_AUTO_INCREMENT:
CHECK_SPACE(pos, end, 4);
memcpy(&auto_increment_increment, pos, sizeof(auto_increment_increment));
auto_increment_increment= le16toh(auto_increment_increment);
memcpy(&auto_increment_offset, pos + 2, sizeof(auto_increment_offset));
auto_increment_offset= le16toh(auto_increment_offset);
pos+= 4;
break;
case Q_CHARSET_CODE:
{
CHECK_SPACE(pos, end, 6);
charset_inited= 1;
memcpy(charset, pos, 6);
pos+= 6;
break;
}
case Q_TIME_ZONE_CODE:
{
if ((time_zone_len= *pos))
time_zone_str= (const char*)(pos + 1);
pos+= time_zone_len + 1;
break;
}
case Q_CATALOG_CODE: /* for 5.0.x where 0<=x<=3 masters */
CHECK_SPACE(pos, end, 1);
if ((catalog_len= *pos))
catalog= (const char*) (pos+1);
CHECK_SPACE(pos, end, catalog_len + 2);
pos+= catalog_len + 2; // leap over end 0
break;
case Q_LC_TIME_NAMES_CODE:
CHECK_SPACE(pos, end, 2);
memcpy(&lc_time_names_number, pos, sizeof(lc_time_names_number));
lc_time_names_number= le16toh(lc_time_names_number);
pos+= 2;
break;
case Q_CHARSET_DATABASE_CODE:
CHECK_SPACE(pos, end, 2);
memcpy(&charset_database_number, pos, sizeof(lc_time_names_number));
charset_database_number= le16toh(charset_database_number);
pos+= 2;
break;
case Q_TABLE_MAP_FOR_UPDATE_CODE:
CHECK_SPACE(pos, end, 8);
memcpy(&table_map_for_update, pos, sizeof(table_map_for_update));
table_map_for_update= le64toh(table_map_for_update);
pos+= 8;
break;
case Q_MASTER_DATA_WRITTEN_CODE:
CHECK_SPACE(pos, end, 4);
memcpy(&master_data_written, pos, sizeof(master_data_written));
master_data_written= le32toh(static_cast<uint32_t>(master_data_written));
header()->data_written= master_data_written;
pos+= 4;
break;
case Q_MICROSECONDS:
{
CHECK_SPACE(pos, end, 3);
uint32_t temp_usec= 0;
memcpy(&temp_usec, pos, 3);
header()->when.tv_usec= le32toh(temp_usec);
pos+= 3;
break;
}
case Q_INVOKER:
{
CHECK_SPACE(pos, end, 1);
user_len= *pos++;
CHECK_SPACE(pos, end, user_len);
user= (const char*)pos;
pos+= user_len;
CHECK_SPACE(pos, end, 1);
host_len= *pos++;
CHECK_SPACE(pos, end, host_len);
host= (const char*)pos;
pos+= host_len;
break;
}
case Q_UPDATED_DB_NAMES:
{
unsigned char i= 0;
#ifndef DBUG_OFF
bool is_corruption_injected= false;
#endif
CHECK_SPACE(pos, end, 1);
mts_accessed_dbs= *pos++;
/*
Notice, the following check is positive also in case of
the master's MAX_DBS_IN_EVENT_MTS > the slave's one and the event
contains e.g the master's MAX_DBS_IN_EVENT_MTS db:s.
*/
if (mts_accessed_dbs > MAX_DBS_IN_EVENT_MTS)
{
mts_accessed_dbs= OVER_MAX_DBS_IN_EVENT_MTS;
break;
}
BAPI_ASSERT(mts_accessed_dbs != 0);
for (i= 0; i < mts_accessed_dbs && pos < start + status_vars_len; i++)
{
#ifndef DBUG_OFF
/*
This is specific to mysql test run on the server
for the keyword "query_log_event_mts_corrupt_db_names"
*/
if (binary_log_debug::debug_query_mts_corrupt_db_names)
{
if (mts_accessed_dbs == 2)
{
BAPI_ASSERT(pos[sizeof("d?") - 1] == 0);
((char*) pos)[sizeof("d?") - 1]= 'a';
is_corruption_injected= true;
}
}
#endif
strncpy(mts_accessed_db_names[i], (char*) pos,
std::min<unsigned long>(NAME_LEN, start + status_vars_len - pos));
mts_accessed_db_names[i][NAME_LEN - 1]= 0;
pos+= 1 + strlen((const char*) pos);
}
if (i != mts_accessed_dbs
#ifndef DBUG_OFF
|| is_corruption_injected
#endif
)
return;
break;
}
case Q_COMMIT_TS2:
CHECK_SPACE(pos, end, COMMIT_SEQ_LEN);
last_committed= 0;
memcpy(&last_committed, pos, 8);
last_committed= le64toh(last_committed);
sequence_number= 0;
memcpy(&sequence_number, pos + 8, 8);
sequence_number= le64toh(sequence_number);
pos+= COMMIT_SEQ_LEN;
break;
default:
/* That's why you must write status vars in growing order of code */
pos= (const unsigned char*) end; // Break loop
}
}
if (catalog_len) // If catalog is given
query_data_written+= catalog_len + 1;
if (time_zone_len)
query_data_written+= time_zone_len + 1;
if (user_len > 0)
query_data_written+= user_len + 1;
if (host_len > 0)
query_data_written+= host_len + 1;
/*
if time_zone_len or catalog_len are 0, then time_zone and catalog
are uninitialized at this point. shouldn't they point to the
zero-length null-terminated strings we allocated space for in the
my_alloc call above? /sven
*/
/* A 2nd variable part; this is common to all versions */
query_data_written+= data_len + 1;
db= (const char* )end;
q_len= data_len - db_len -1;
start[status_vars_len + data_len]= '\0';
query= (const char *)(end + db_len + 1);
return;
}
/**
Log_event_header constructor
@param buf the buffer containing the complete information
including the event and the header data
@param description_event first constructor of Format_description_event,
used to extract the binlog_version
*/
Log_event_header::
Log_event_header(const char* buf, uint16_t binlog_version)
: data_written(0), log_pos(0)
{
uint32_t tmp_sec;
memcpy(&tmp_sec, buf, sizeof(tmp_sec));
when.tv_sec= le32toh(tmp_sec);
when.tv_usec= 0;
type_code= static_cast<Log_event_type>(buf[EVENT_TYPE_OFFSET]);
memcpy(&unmasked_server_id,
buf + SERVER_ID_OFFSET, sizeof(unmasked_server_id));
unmasked_server_id= le32toh(unmasked_server_id);
/**
@verbatim
The first 13 bytes in the header is as follows:
+============================================+
| member_variable offset : len |
+============================================+
| when.tv_sec 0 : 4 |
+--------------------------------------------+
| type_code EVENT_TYPE_OFFSET(4) : 1 |
+--------------------------------------------+
| server_id SERVER_ID_OFFSET(5) : 4 |
+--------------------------------------------+
| data_written EVENT_LEN_OFFSET(9) : 4 |
+============================================+
@endverbatim
*/
memcpy(&data_written, buf + EVENT_LEN_OFFSET, 4);
data_written= le64toh(data_written);
memcpy(&log_pos, buf + LOG_POS_OFFSET, 4);
log_pos= le64toh(log_pos);
switch (binlog_version)
{
case 1:
log_pos= 0;
flags= 0;
break;
case 3:
/*
If the log is 4.0 (so here it can only be a 4.0 relay log read by
the SQL thread or a 4.0 master binlog read by the I/O thread),
log_pos is the beginning of the event: we transform it into the end
of the event, which is more useful.
But how do you know that the log is 4.0: you know it if
description_event is version 3 *and* you are not reading a
Format_desc (remember that mysqlbinlog starts by assuming that 5.0
logs are in 4.0 format, until it finds a Format_desc).
*/
if (buf[EVENT_TYPE_OFFSET] < FORMAT_DESCRIPTION_EVENT && log_pos)
{
/*
If log_pos=0, don't change it. log_pos==0 is a marker to mean
"don't change rli->group_master_log_pos" (see
inc_group_relay_log_pos()). As it is unreal log_pos, adding the
event len's is not correct. For example, a fake Rotate event should
not have its log_pos (which is 0) changed or it will modify
Exec_master_log_pos in SHOW SLAVE STATUS, displaying a wrong
value of (a non-zero offset which does not exist in the master's
binlog, so which will cause problems if the user uses this value
in CHANGE MASTER).
*/
log_pos+= data_written; /* purecov: inspected */
}
/* 4.0 or newer */
/**
@verbatim
Additional header fields include:
+=============================================+
| member_variable offset : len |
+=============================================+
| log_pos LOG_POS_OFFSET(13) : 4 |
+---------------------------------------------+
| flags FLAGS_OFFSET(17) : 1 |
+---------------------------------------------+
| extra_headers 19 : x-19 |
+=============================================+
extra_headers are not used in the current version.
@endverbatim
*/
default:
memcpy(&flags, buf + FLAGS_OFFSET, sizeof(flags));
flags= le16toh(flags);
if ((buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT) ||
(buf[EVENT_TYPE_OFFSET] == ROTATE_EVENT))
{
/*
These events always have a header which stops here (i.e. their
header is FROZEN).
*/
/*
Initialization to zero of all other Log_event members as they're
not specified. Currently there are no such members; in the future
there will be an event UID (but Format_description and Rotate
don't need this UID, as they are not propagated through
--log-slave-updates (remember the UID is used to not play a query
twice when you have two masters which are slaves of a 3rd master).
Then we are done with decoding the header.
*/
break;
}
/* otherwise, go on with reading the header from buf (nothing now) */
} //end switch (binlog_version)
BAPI_ASSERT(type_code < ENUM_END_EVENT || flags & LOG_EVENT_IGNORABLE_F);
}
/**
Tests the checksum algorithm used for the binary log, and asserts in case
if the checksum algorithm is invalid.
@param event_buf point to the buffer containing serialized event
@param event_len length of the event accounting possible
checksum alg
@param alg checksum algorithm used for the binary log
@retval true if test fails
@retval false as success
*/
bool Log_event_footer::event_checksum_test(unsigned char *event_buf,
unsigned long event_len,
enum_binlog_checksum_alg alg)
{
bool res= false;
unsigned short flags= 0; // to store in FD's buffer flags orig value
if (alg != BINLOG_CHECKSUM_ALG_OFF && alg != BINLOG_CHECKSUM_ALG_UNDEF)
{
uint32_t incoming;
uint32_t computed;
if (event_buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT)
{
#ifndef DBUG_OFF
unsigned char fd_alg= event_buf[event_len - BINLOG_CHECKSUM_LEN -
BINLOG_CHECKSUM_ALG_DESC_LEN];
#endif
/*
FD event is checksummed and therefore verified w/o
the binlog-in-use flag.
*/
memcpy(&flags, event_buf + FLAGS_OFFSET, sizeof(flags));
flags= le16toh(flags);
if (flags & LOG_EVENT_BINLOG_IN_USE_F)
event_buf[FLAGS_OFFSET] &= ~LOG_EVENT_BINLOG_IN_USE_F;
/*
The only algorithm currently is CRC32. Zero indicates
the binlog file is checksum-free *except* the FD-event.
*/
#ifndef DBUG_OFF
BAPI_ASSERT(fd_alg == BINLOG_CHECKSUM_ALG_CRC32 || fd_alg == 0);
#endif
BAPI_ASSERT(alg == BINLOG_CHECKSUM_ALG_CRC32);
/*
Complile time guard to watch over the max number of alg
*/
do_compile_time_assert(BINLOG_CHECKSUM_ALG_ENUM_END <= 0x80);
}
memcpy(&incoming,
event_buf + event_len - BINLOG_CHECKSUM_LEN, sizeof(incoming));
incoming= le32toh(incoming);
computed= checksum_crc32(0L, NULL, 0);
/* checksum the event content but not the checksum part itself */
computed= binary_log::checksum_crc32(computed,
(const unsigned char*) event_buf,
event_len - BINLOG_CHECKSUM_LEN);
if (flags != 0)
{
/* restoring the orig value of flags of FD */
BAPI_ASSERT(event_buf[EVENT_TYPE_OFFSET] == FORMAT_DESCRIPTION_EVENT);
event_buf[FLAGS_OFFSET]= static_cast<unsigned char>(flags);
}
res= !(computed == incoming);
}
#ifndef DBUG_OFF
if (binary_log_debug::debug_checksum_test)
return true;
#endif
return res;
}