From b760d985544f6066fd6c587863591b8b91109140 Mon Sep 17 00:00:00 2001 From: yuanyazhi Date: Fri, 9 Aug 2024 09:24:55 +0800 Subject: [PATCH] fix release --- mysql-test/enableCases.list | 2 +- storage/tianchi/ha_tse.cc | 93 +++++++----- storage/tianchi/ha_tse.h | 6 +- storage/tianchi/ha_tse_ddl.cc | 166 ++++++++++++++------- storage/tianchi/ha_tsepart.cc | 9 +- storage/tianchi/tse_ddl_rewriter_plugin.cc | 20 +-- storage/tianchi/tse_srv_mq_stub.cc | 153 ++++++++++--------- storage/tianchi/tse_util.cc | 2 +- 8 files changed, 257 insertions(+), 194 deletions(-) diff --git a/mysql-test/enableCases.list b/mysql-test/enableCases.list index ed84c07..e0caeb3 100644 --- a/mysql-test/enableCases.list +++ b/mysql-test/enableCases.list @@ -73,7 +73,6 @@ tianchi.ctc_ddl_auto_inc tianchi.ctc_ddl_multi_db tianchi.ctc_ddl_temporary_table # tianchi.ctc_ddl_engine -tianchi.ctc_ddl_unsupport_command tianchi.ctc_ddl_func_index tianchi.ctc_ddl_create_table_check tianchi.ctc_ddl_generated_columns @@ -104,3 +103,4 @@ tianchi.ctc_varchar # ------ TEST CASES for handler operation ------ ctc_handler_operation.test +tianchi.ctc_ddl_unsupport_command diff --git a/storage/tianchi/ha_tse.cc b/storage/tianchi/ha_tse.cc index 663bbdd..60a9cc7 100644 --- a/storage/tianchi/ha_tse.cc +++ b/storage/tianchi/ha_tse.cc @@ -403,7 +403,7 @@ bool engine_ddl_passthru(MYSQL_THD thd) { } bool ha_tse::is_replay_ddl(MYSQL_THD thd) { - char db_name[SMALL_RECORD_SIZE]; + char db_name[SMALL_RECORD_SIZE] = { 0 }; tse_split_normalized_name(table->s->normalized_path.str, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_copy_name(db_name, db_name, SMALL_RECORD_SIZE); if (mysql_system_db.find(db_name) != mysql_system_db.end()) { @@ -1318,7 +1318,7 @@ int get_tch_in_handler_data(handlerton *hton, THD *thd, tianchi_handler_t &tch, static void ctc_copy_cursors_to_free(thd_sess_ctx_s *sess_ctx, uint64_t *cursors, uint32_t left) { uint32_t idx = 0; - if (sess_ctx->invalid_cursors) { + if (sess_ctx->invalid_cursors && sess_ctx->invalid_cursors->size() > 0) { uint32_t invalid_csize = sess_ctx->invalid_cursors->size(); memcpy(cursors, &(*sess_ctx->invalid_cursors)[0], invalid_csize * sizeof(uint64_t)); sess_ctx->invalid_cursors->clear(); @@ -1492,6 +1492,9 @@ static int tse_start_trx_and_assign_scn( // get_tch_in_handler_data若成功返回，则sess_ctx肯定不为空 assert(sess_ctx != nullptr); assert(sess_ctx->is_tse_trx_begin == 0); + if (sess_ctx == nullptr) { + return HA_ERR_OUT_OF_MEM; + } uint32_t autocommit = !thd->in_multi_stmt_transaction_mode(); int isolation_level = isolation_level_to_cantian(mysql_isolation); @@ -1808,7 +1811,9 @@ static int tse_close_connect(handlerton *hton, THD *thd) { static void tse_kill_connection(handlerton *hton, THD *thd) { tianchi_handler_t tch; int ret = get_tch_in_handler_data(hton, thd, tch); - assert(ret == 0); + if (ret != CT_SUCCESS) { + return; + } if (tch.sess_addr == INVALID_VALUE64) { tse_log_system("[TSE_KILL_SESSION]:trying to kill a thd without session assigned, conn_id=%u, instid=%u", tch.thd_id, tch.inst_id); @@ -1833,7 +1838,7 @@ static int tse_pre_create_db4cantian(THD *thd, tianchi_handler_t *tch) { if (engine_skip_ddl(thd)) { return CT_SUCCESS; } - char user_name[SMALL_RECORD_SIZE]; + char user_name[SMALL_RECORD_SIZE] = { 0 }; tse_copy_name(user_name, thd->lex->name.str, SMALL_RECORD_SIZE); int error_code = 0; char error_message[ERROR_MESSAGE_LEN] = {0}; @@ -1903,6 +1908,9 @@ static void tse_lock_table_handle_error(int err_code, tse_lock_table_info *lock_ static int tse_notify_pre_event(THD *thd, handlerton *tse_hton, tianchi_handler_t &tch, tse_lock_table_info *lock_info) { thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); assert(sess_ctx != nullptr); + if (sess_ctx == nullptr) { + return HA_ERR_OUT_OF_MEM; + } int ret = 0; int err_code = 0; @@ -1945,6 +1953,9 @@ static int tse_notify_pre_event(THD *thd, handlerton *tse_hton, tianchi_handler_ static int tse_notify_post_event(THD *thd, handlerton *tse_hton, tianchi_handler_t &tch, tse_lock_table_info *lock_info) { thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); assert(sess_ctx != nullptr); + if (sess_ctx == nullptr) { + return HA_ERR_OUT_OF_MEM; + } DBUG_EXECUTE_IF("core_before_tse_unlock_table", { assert(0); }); // 解锁前core @@ -1998,7 +2009,10 @@ static bool tse_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, we can not check sql length while using prepare statement, so we need to check the sql length before ddl sql again */ - if (!IS_METADATA_NORMALIZATION() && thd->query().str && tse_check_ddl_sql_length(thd->query().str)) { + int query_len = thd->query().length; + if (!IS_METADATA_NORMALIZATION() && query_len > MAX_DDL_SQL_LEN_CONTEXT) { + string err_msg = "`" + string(thd->query().str).substr(0, 100) + "...` Is Large Than " + to_string(MAX_DDL_SQL_LEN_CONTEXT); + my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), err_msg.c_str()); return true; } @@ -2032,8 +2046,8 @@ static bool tse_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, thd->lex->sql_command, (int32_t)mdl_key->mdl_namespace()}; FILL_USER_INFO_WITH_THD(lock_info, thd); - strncpy(lock_info.db_name, mdl_key->db_name(), SMALL_RECORD_SIZE); - strncpy(lock_info.table_name, mdl_key->name(), SMALL_RECORD_SIZE); + strncpy(lock_info.db_name, mdl_key->db_name(), SMALL_RECORD_SIZE - 1); + strncpy(lock_info.table_name, mdl_key->name(), SMALL_RECORD_SIZE - 1); if (notification_type == HA_NOTIFY_PRE_EVENT) { ret = tse_notify_pre_event(thd, tse_hton, tch, &lock_info); @@ -3330,7 +3344,7 @@ int ha_tse::info(uint flag) { } if (flag & HA_STATUS_ERRKEY) { - char index_name[TSE_MAX_KEY_NAME_LENGTH + 1]; + char index_name[TSE_MAX_KEY_NAME_LENGTH + 1] = { 0 }; ret = (ct_errno_t)tse_get_index_name(&m_tch, index_name); if (ret == CT_SUCCESS) { @@ -3362,7 +3376,7 @@ int ha_tse::analyze(THD *thd, HA_CHECK_OPT *) { return HA_ADMIN_OK; } - char user_name_str[SMALL_RECORD_SIZE]; + char user_name_str[SMALL_RECORD_SIZE] = { 0 }; tse_copy_name(user_name_str, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); ct_errno_t ret = (ct_errno_t)tse_analyze_table( @@ -4261,9 +4275,12 @@ EXTER_ATTACK bool tse_drop_database_with_err(handlerton *hton, char *path) { tianchi_handler_t tch; int res = get_tch_in_handler_data(hton, thd, tch); - assert(res == 0); + if (res != CT_SUCCESS) { + assert(0); + return true; + } - char db_name[SMALL_RECORD_SIZE]; + char db_name[SMALL_RECORD_SIZE] = { 0 }; tse_split_normalized_name(path, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); int error_code = 0; char error_message[ERROR_MESSAGE_LEN] = {0}; @@ -4481,23 +4498,28 @@ static int tse_init_tablespace(List *tablespaces) tablespaces->push_back(&dd_space); return 0; } - + static bool tse_ddse_dict_init( dict_init_mode_t dict_init_mode, uint version, List *tables, List *tablespaces) { DBUG_TRACE; - tse_log_system("[CTC_INIT]:begin init!"); - + tse_log_system("[CTC_INIT]: begin tse_ddse_dict_init."); + assert(tables && tables->is_empty()); assert(tablespaces && tablespaces->is_empty()); assert(dict_init_mode == DICT_INIT_CREATE_FILES || dict_init_mode == DICT_INIT_CHECK_FILES); assert(version < 1000000000); - + if (!(tables && tables->is_empty()) || !(tablespaces && tablespaces->is_empty()) || + !(dict_init_mode == DICT_INIT_CREATE_FILES || dict_init_mode == DICT_INIT_CHECK_FILES) || + version >= 1000000000) { + return true; + } + if (tse_init_tablespace(tablespaces)) { - return true; + return true; } - + /* Instantiate table defs only if we are successful so far. */ dd::Object_table *innodb_dynamic_metadata = dd::Object_table::create_object_table(); @@ -4510,24 +4532,24 @@ static bool tse_ddse_dict_init( def->add_field(2, "metadata", "metadata BLOB NOT NULL"); def->add_index(0, "index_pk", "PRIMARY KEY (table_id)"); /* Options and tablespace are set at the SQL layer. */ - + /* Changing these values would change the specification of innodb statistics tables. */ static constexpr size_t DB_NAME_FIELD_SIZE = 64; static constexpr size_t TABLE_NAME_FIELD_SIZE = 199; - + /* Set length for database name field. */ std::ostringstream db_name_field; db_name_field << "database_name VARCHAR(" << DB_NAME_FIELD_SIZE << ") NOT NULL"; std::string db_field = db_name_field.str(); - + /* Set length for table name field. */ std::ostringstream table_name_field; table_name_field << "table_name VARCHAR(" << TABLE_NAME_FIELD_SIZE << ") NOT NULL"; std::string table_field = table_name_field.str(); - + dd::Object_table *innodb_table_stats = dd::Object_table::create_object_table(); innodb_table_stats->set_hidden(false); @@ -4546,7 +4568,7 @@ static bool tse_ddse_dict_init( "sum_of_other_index_sizes BIGINT UNSIGNED NOT NULL"); def->add_index(0, "index_pk", "PRIMARY KEY (database_name, table_name)"); /* Options and tablespace are set at the SQL layer. */ - + dd::Object_table *innodb_index_stats = dd::Object_table::create_object_table(); innodb_index_stats->set_hidden(false); @@ -4573,7 +4595,7 @@ static bool tse_ddse_dict_init( "PRIMARY KEY (database_name, table_name, " "index_name, stat_name)"); /* Options and tablespace are set at the SQL layer. */ - + dd::Object_table *innodb_ddl_log = dd::Object_table::create_object_table(); innodb_ddl_log->set_hidden(true); def = innodb_ddl_log->target_table_definition(); @@ -4592,17 +4614,17 @@ static bool tse_ddse_dict_init( def->add_index(0, "index_pk", "PRIMARY KEY(id)"); def->add_index(1, "index_k_thread_id", "KEY(thread_id)"); /* Options and tablespace are set at the SQL layer. */ - + tables->push_back(innodb_dynamic_metadata); tables->push_back(innodb_table_stats); tables->push_back(innodb_index_stats); tables->push_back(innodb_ddl_log); - + tse_log_system("[CTC_INIT]:end init dict!"); - + return false; } - + /** Set of ids of DD tables */ static set s_dd_table_ids; @@ -4610,24 +4632,15 @@ static bool is_dd_table_id(uint16_t id) { DBUG_TRACE; return (s_dd_table_ids.find(id) != s_dd_table_ids.end()); } - + static void tse_dict_register_dd_table_id(dd::Object_id dd_table_id) { DBUG_TRACE; s_dd_table_ids.insert(dd_table_id); return; } -static bool tse_dict_recover(dict_recovery_mode_t dict_recovery_mode, uint version){ +static bool tse_dict_recover(dict_recovery_mode_t, uint){ DBUG_TRACE; - switch (dict_recovery_mode) { - case DICT_RECOVERY_INITIALIZE_SERVER: - return false; - case DICT_RECOVERY_INITIALIZE_TABLESPACES: - return false; - case DICT_RECOVERY_RESTART_SERVER: - return false; - } - assert(version < 0xFFFFFFFF); return false; } @@ -4813,7 +4826,7 @@ void ha_tse::update_create_info(HA_CREATE_INFO *create_info) { int ret = 0; if (m_tch.ctx_addr == INVALID_VALUE64) { - char user_name[SMALL_RECORD_SIZE]; + char user_name[SMALL_RECORD_SIZE] = { 0 }; tse_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_copy_name(user_name, user_name, SMALL_RECORD_SIZE); update_member_tch(m_tch, tse_hton, thd); @@ -5320,7 +5333,7 @@ int ha_tse::get_cbo_stats_4share() time_t now = time(nullptr); if (m_share && (m_share->need_fetch_cbo || now - m_share->get_cbo_time > ctc_update_analyze_time)) { if (m_tch.ctx_addr == INVALID_VALUE64) { - char user_name[SMALL_RECORD_SIZE]; + char user_name[SMALL_RECORD_SIZE] = { 0 }; tse_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_copy_name(user_name, user_name, SMALL_RECORD_SIZE); update_member_tch(m_tch, tse_hton, thd); diff --git a/storage/tianchi/ha_tse.h b/storage/tianchi/ha_tse.h index 2eb1b19..e7a1ef7 100644 --- a/storage/tianchi/ha_tse.h +++ b/storage/tianchi/ha_tse.h @@ -181,10 +181,8 @@ typedef int (*tse_prefetch_fn)(tianchi_handler_t *tch, uint8_t *records, uint16_ do { \ const char *user_name = _thd->m_main_security_ctx.priv_user().str; \ const char *user_ip = _thd->m_main_security_ctx.priv_host().str; \ - assert(strlen(user_name) + 1 <= sizeof(ctrl.user_name)); \ - memcpy(ctrl.user_name, user_name, strlen(user_name) + 1); \ - assert(strlen(user_ip) + 1 <= sizeof(ctrl.user_ip)); \ - memcpy(ctrl.user_ip, user_ip, strlen(user_ip) + 1); \ + strncpy(ctrl.user_name, user_name, SMALL_RECORD_SIZE - 1); \ + strncpy(ctrl.user_ip, user_ip, SMALL_RECORD_SIZE - 1); \ } while (0) #define FILL_BROADCAST_BASE_REQ(broadcast_req, _sql_str, _user_name, _user_ip, _mysql_inst_id, _sql_command) \ diff --git a/storage/tianchi/ha_tse_ddl.cc b/storage/tianchi/ha_tse_ddl.cc index 41d6a96..992f589 100644 --- a/storage/tianchi/ha_tse_ddl.cc +++ b/storage/tianchi/ha_tse_ddl.cc @@ -704,28 +704,50 @@ static bool tse_get_datetime_default_value( if (check_zero_date(date_detail)) { char *tmp_zero_date = const_cast("0000-00-00 00:00:00"); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, strlen(tmp_zero_date) + 1); - assert(column->default_text != NULL); - memset(column->default_text, 0, strlen(tmp_zero_date) + 1); - memcpy(column->default_text, tmp_zero_date, strlen(tmp_zero_date) + 1); + int len = strlen(tmp_zero_date); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for datetime default text failed."); + return false; + } + strncpy(column->default_text, tmp_zero_date, len + 1); return true; } - if (field->real_type() == MYSQL_TYPE_TIME2) { - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, - sizeof(char) * (expr_str.length() + 1)); - assert(column->default_text != NULL); - sprintf(column->default_text, "%s", expr_str.c_str()); - } else if (!is_expr_value && field->real_type() == MYSQL_TYPE_TIMESTAMP2) { - char tmp_timestamp[MAX_DATE_STRING_REP_LENGTH]; - int len = my_datetime_to_str(ltime, tmp_timestamp, field->decimals()); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); - assert(column->default_text != NULL); - memset(column->default_text, 0, len + 1); - memcpy(column->default_text, tmp_timestamp, len); - column->default_text[len] = '\0'; - } else { - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, expr_str.length() + 1); - strncpy(column->default_text, expr_str.c_str(), expr_str.length() + 1); + + switch (field->real_type()) { + case MYSQL_TYPE_TIME2: { + int len = expr_str.length(); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (len + 1)); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for datetime default text failed."); + return false; + } + sprintf(column->default_text, "%s", expr_str.c_str()); + break; + } + case MYSQL_TYPE_TIMESTAMP2: { + if (!is_expr_value) { + char tmp_timestamp[MAX_DATE_STRING_REP_LENGTH]; + int len = my_datetime_to_str(ltime, tmp_timestamp, field->decimals()); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for datetime default text failed."); + return false; + } + strncpy(column->default_text, tmp_timestamp, len + 1); + break; + } + } + default: { + int len = expr_str.length(); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for datetime default text failed."); + return false; + } + strncpy(column->default_text, expr_str.c_str(), len + 1); + break; + } } return true; } @@ -776,15 +798,23 @@ static bool tse_get_enum_default_value( if (is_enum == TSE_ENUM_DEFAULT_INVALID) { return false; } - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, 10); - if (column->default_text == nullptr) { - tse_log_error("alloc mem for enum default text failed, mem_start is null"); - return false; - } + column->default_text = nullptr; if (is_enum != TSE_ENUM_DEFAULT_NULL) { + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, 10); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for enum default text failed, mem_start is null"); + return false; + } sprintf(column->default_text, "%d", is_enum); } else { - column->default_text = const_cast(col_obj->default_value_utf8().data()); + char *default_value = const_cast(col_obj->default_value_utf8().data()); + int len = strlen(default_value); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for enum default text failed, mem_start is null"); + return false; + } + strncpy(column->default_text, default_value, len + 1); } return true; } @@ -834,13 +864,14 @@ static bool tse_get_set_default_value( if (!is_get_set_bitmap) { return false; + } else { + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, 64); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for set default text failed, mem_start is null"); + return false; + } + sprintf(column->default_text, "%lld", set_bitmap); } - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, 64); - if (column->default_text == nullptr) { - tse_log_error("alloc mem for set default text failed, mem_start is null"); - return false; - } - sprintf(column->default_text, "%lld", set_bitmap); return true; } @@ -920,15 +951,23 @@ static bool tse_get_numeric_default_value( column->default_text[num_len] = '\0'; } else { field_default_string = expr_item->val_str(&tmp_string)->c_ptr(); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, strlen(field_default_string) + 1); + int default_text_len = strlen(field_default_string); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, default_text_len + 1); if (column->default_text == nullptr) { tse_log_error("alloc mem for set default text failed, mem_start is null"); return false; } - strncpy(column->default_text, field_default_string, strlen(field_default_string) + 1); + strncpy(column->default_text, field_default_string, default_text_len + 1); } } else { - column->default_text = const_cast(col_obj->default_value_utf8().data()); + char *default_value = const_cast(col_obj->default_value_utf8().data()); + int len = strlen(default_value); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for numeric default text failed, mem_start is null"); + return false; + } + strncpy(column->default_text, default_value, len + 1); } return true; } @@ -996,7 +1035,14 @@ static bool tse_ddl_fill_column_default_value( is_blob_type = (column->datatype->datatype != TSE_DDL_TYPE_CLOB); case MYSQL_TYPE_JSON: if (!is_expr_value) { - column->default_text = const_cast(col_obj->default_value_utf8().data()); + char *default_value = const_cast(col_obj->default_value_utf8().data()); + int len = strlen(default_value); + column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + if (column->default_text == nullptr) { + tse_log_error("alloc mem for json default text failed, mem_start is null"); + return false; + } + strncpy(column->default_text, default_value, len + 1); break; } case MYSQL_TYPE_STRING: @@ -1629,7 +1675,7 @@ int ha_tse_truncate_table(tianchi_handler_t *tch, THD *thd, const char *db_name, { TcDb__TseDDLTruncateTableDef req; tc_db__tse_ddltruncate_table_def__init(&req); - char user_name[SMALL_RECORD_SIZE]; + char user_name[SMALL_RECORD_SIZE] = { 0 }; tse_copy_name(user_name, db_name, SMALL_RECORD_SIZE); req.schema = const_cast(user_name); req.name = const_cast(table_name); @@ -1801,10 +1847,12 @@ int fill_create_table_req(HA_CREATE_INFO *create_info, dd::Table *table_def, cha static int tse_ddl_fill_add_part_table_info(TcDb__TseDDLPartitionTableDef *add_part, partition_element &part, char **mem_start, char *mem_end) { - add_part->name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (strlen(part.partition_name) + 1)); - assert(add_part->name != NULL); - memset(add_part->name, 0, (strlen(part.partition_name) + 1)); - strncpy(add_part->name, part.partition_name, strlen(part.partition_name)); + int name_len = strlen(part.partition_name); + add_part->name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); + if (add_part->name == nullptr) { + return HA_ERR_OUT_OF_MEM; + } + strncpy(add_part->name, part.partition_name, name_len + 1); add_part->n_subpart_table_list = part.subpartitions.size(); if (part.subpartitions.size() > 0) { add_part->subpart_table_list = @@ -1820,10 +1868,12 @@ static int tse_ddl_fill_add_part_table_info(TcDb__TseDDLPartitionTableDef *add_p return HA_ERR_OUT_OF_MEM; } tc_db__tse_ddlpartition_table_def__init(subpart_table_list[i]); - subpart_table_list[i]->name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (strlen(sub_part_obj.partition_name) + 1)); - assert(subpart_table_list[i]->name != NULL); - memset(subpart_table_list[i]->name, 0, (strlen(sub_part_obj.partition_name) + 1)); - strncpy(subpart_table_list[i]->name, sub_part_obj.partition_name, strlen(sub_part_obj.partition_name)); + int name_len = strlen(sub_part_obj.partition_name); + subpart_table_list[i]->name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); + if (subpart_table_list[i]->name == NULL) { + return HA_ERR_OUT_OF_MEM; + } + strncpy(subpart_table_list[i]->name, sub_part_obj.partition_name, name_len + 1); i++; } } @@ -1862,11 +1912,13 @@ static int tse_ddl_prepare_alter_partition_info(TcDb__TseDDLAlterTableDef *req, for (auto part : alter_info->modified_part_info->partitions) { switch (part.part_state) { case PART_TO_BE_DROPPED: { + int name_len = strlen(part.partition_name); req->drop_partition_names[req->n_drop_partition_names] = (char *)tse_ddl_alloc_mem(mem_start, mem_end, - sizeof(char) * (strlen(part.partition_name) + 1)); - assert(req->drop_partition_names[req->n_drop_partition_names] != NULL); - memset(req->drop_partition_names[req->n_drop_partition_names], 0, (strlen(part.partition_name) + 1)); - strcpy(req->drop_partition_names[req->n_drop_partition_names], part.partition_name); + sizeof(char) * (name_len + 1)); + if (req->drop_partition_names[req->n_drop_partition_names] == NULL) { + return HA_ERR_OUT_OF_MEM; + } + strncpy(req->drop_partition_names[req->n_drop_partition_names], part.partition_name, name_len + 1); req->n_drop_partition_names++; break; } @@ -2532,10 +2584,10 @@ static int init_tse_ddl_rename_constraints_def(THD *thd, TcDb__TseDDLRenameTable int fill_rename_table_req(const char *from, const char *to, const dd::Table *from_table_def, dd::Table *to_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { - char old_db[SMALL_RECORD_SIZE]; - char new_db[SMALL_RECORD_SIZE]; - char user_name[SMALL_RECORD_SIZE]; - char new_user_name[SMALL_RECORD_SIZE]; + char old_db[SMALL_RECORD_SIZE] = { 0 }; + char new_db[SMALL_RECORD_SIZE] = { 0 }; + char user_name[SMALL_RECORD_SIZE] = { 0 }; + char new_user_name[SMALL_RECORD_SIZE] = { 0 }; tse_split_normalized_name(from, old_db, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_split_normalized_name(to, new_db, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_copy_name(user_name, old_db, SMALL_RECORD_SIZE); @@ -2628,8 +2680,8 @@ int fill_truncate_partition_req(const char *full_name, partition_info *part_info lock_guard lock(m_tse_ddl_protobuf_mem_mutex); char *req_mem_start = tse_ddl_req_mem; char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; - char db_name[SMALL_RECORD_SIZE]; - char user_name[SMALL_RECORD_SIZE]; + char db_name[SMALL_RECORD_SIZE] = { 0 }; + char user_name[SMALL_RECORD_SIZE] = { 0 }; const char *table_name_str = dd_table->name().c_str(); tse_split_normalized_name(full_name, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_copy_name(user_name, db_name, SMALL_RECORD_SIZE); @@ -2700,8 +2752,8 @@ int fill_rebuild_index_req(TABLE *table, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl TcDb__TseDDLAlterTableDef req; char *req_mem_start = tse_ddl_req_mem; char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; - char db_name[SMALL_RECORD_SIZE]; - char table_name[SMALL_RECORD_SIZE]; + char db_name[SMALL_RECORD_SIZE] = { 0 }; + char table_name[SMALL_RECORD_SIZE] = { 0 }; tse_copy_name(db_name, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); tse_copy_name(table_name, thd->lex->query_tables->table_name, SMALL_RECORD_SIZE); diff --git a/storage/tianchi/ha_tsepart.cc b/storage/tianchi/ha_tsepart.cc index 5caed52..cfe7ee9 100644 --- a/storage/tianchi/ha_tsepart.cc +++ b/storage/tianchi/ha_tsepart.cc @@ -1049,7 +1049,7 @@ int ha_tsepart::get_cbo_stats_4share() time_t now = time(nullptr); if (m_part_share->need_fetch_cbo || now - m_part_share->get_cbo_time > ctc_update_analyze_time) { if (m_tch.ctx_addr == INVALID_VALUE64) { - char user_name[SMALL_RECORD_SIZE]; + char user_name[SMALL_RECORD_SIZE] = { 0 }; tse_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); tse_copy_name(user_name, user_name, SMALL_RECORD_SIZE); update_member_tch(m_tch, get_tse_hton(), thd); @@ -1133,15 +1133,16 @@ int ha_tsepart::repair(THD *thd, HA_CHECK_OPT *) } broadcast_req.options |= TSE_NOT_NEED_CANTIAN_EXECUTE; + ct_errno_t ret = CT_SUCCESS; if (IS_METADATA_NORMALIZATION()) { - ct_errno_t ret = (ct_errno_t)ctc_record_sql_for_cantian(&tch, &broadcast_req, false); + ret = (ct_errno_t)ctc_record_sql_for_cantian(&tch, &broadcast_req, false); assert (ret == CT_SUCCESS); } else { - ct_errno_t ret = (ct_errno_t)tse_execute_mysql_ddl_sql(&tch, &broadcast_req, false); + ret = (ct_errno_t)tse_execute_mysql_ddl_sql(&tch, &broadcast_req, false); assert (ret == CT_SUCCESS); } - return HA_ADMIN_OK; + return (int)ret; } uint32 ha_tsepart::calculate_key_hash_value(Field **field_array) diff --git a/storage/tianchi/tse_ddl_rewriter_plugin.cc b/storage/tianchi/tse_ddl_rewriter_plugin.cc index 094e72b..e04dafd 100644 --- a/storage/tianchi/tse_ddl_rewriter_plugin.cc +++ b/storage/tianchi/tse_ddl_rewriter_plugin.cc @@ -481,7 +481,7 @@ static int tse_set_var_meta(MYSQL_THD thd, uint32_t options, const char* base_na FILL_BROADCAST_BASE_REQ(broadcast_req, sql.c_str(), var_name.c_str(), var_value.c_str(), ctc_instance_id, SQLCOM_SET_OPTION); if(base_name != nullptr) { - strncpy(broadcast_req.db_name, base_name, strlen(base_name)); + strncpy(broadcast_req.db_name, base_name, SMALL_RECORD_SIZE - 1); } broadcast_req.options |= options; int ret = tse_execute_mysql_ddl_sql(&tch, &broadcast_req, false); @@ -732,11 +732,10 @@ static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { } else { continue; } - tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, - mdl_type}; + tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, mdl_type}; FILL_USER_INFO_WITH_THD(lock_info, thd); - strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE); - strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE); + strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE - 1); + strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE - 1); int err_code = 0; ret = tse_lock_table(&tch, lock_info.db_name, &lock_info, &err_code); if (ret != 0) { @@ -753,11 +752,10 @@ static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { handlerton* hton = get_tse_hton(); TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, - (int32_t)TL_UNLOCK}; + tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, (int32_t)TL_UNLOCK}; FILL_USER_INFO_WITH_THD(lock_info, thd); - strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE-1); - strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE-1); + strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE - 1); + strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE - 1); ret = tse_unlock_table(&tch, ctc_instance_id, &lock_info); if (ret != 0) { tse_log_error("[TSE_DDL_REWRITE]:unlock table failed, table:%s.%s", lock_info.db_name, lock_info.table_name); @@ -1245,7 +1243,9 @@ static int tse_ddl_rewrite(MYSQL_THD thd, mysql_event_class_t event_class, static_cast(event); assert(event_class == MYSQL_AUDIT_PARSE_CLASS && event_parse->event_subclass == MYSQL_AUDIT_PARSE_POSTPARSE); - + if (event_class != MYSQL_AUDIT_PARSE_CLASS || event_parse->event_subclass != MYSQL_AUDIT_PARSE_POSTPARSE) { + return 1; + } enum enum_sql_command sql_cmd = thd->lex->sql_command; auto it = ddl_cmds.find(sql_cmd); diff --git a/storage/tianchi/tse_srv_mq_stub.cc b/storage/tianchi/tse_srv_mq_stub.cc index 424d157..7874ff5 100644 --- a/storage/tianchi/tse_srv_mq_stub.cc +++ b/storage/tianchi/tse_srv_mq_stub.cc @@ -28,12 +28,6 @@ #define OUTLINE_LOB_LOCATOR_SIZE 44 // 行外LOB数据结构体长度 -#define TSE_RESET_SHM_REQ_ERROR_CODE(_req) \ - do { \ - _req->error_code = 0; \ - _req->error_message[0] = 0; \ - } while (0) - // 双进程模式在 tse_init 中已经提前获取 inst_id int tse_alloc_inst_id(uint32_t *inst_id) { *inst_id = ha_tse_get_inst_id(); @@ -46,18 +40,18 @@ int tse_release_inst_id(uint32_t ) { } int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *user_name) { - assert(strlen(table_name) + 1 < SMALL_RECORD_SIZE); - assert(strlen(user_name) + 1 < SMALL_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); - open_table_request *req = (open_table_request*)alloc_share_mem(shm_inst, sizeof(open_table_request)); + uint64_t len = sizeof(open_table_request); + open_table_request *req = (open_table_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("open_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(open_table_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - memcpy(req->table_name, table_name, strlen(table_name) + 1); - memcpy(req->user_name, user_name, strlen(user_name) + 1); + memset(req, 0, len); + strncpy(req->table_name, table_name, SMALL_RECORD_SIZE - 1); + strncpy(req->user_name, user_name, SMALL_RECORD_SIZE - 1); req->tch = *tch; int result = ERR_CONNECTION_FAILED; @@ -237,14 +231,16 @@ int tse_delete_row(tianchi_handler_t *tch, uint16_t record_len, dml_flag_t flag) int tse_scan_records(tianchi_handler_t *tch, uint64_t *num_rows, char *index_name) { void *shm_inst = get_one_shm_inst(tch); - scan_records_request *req = (scan_records_request*)alloc_share_mem(shm_inst, sizeof(scan_records_request)); + uint64_t len = sizeof(scan_records_request); + scan_records_request *req = (scan_records_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(scan_records_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - memset(req, 0, sizeof(scan_records_request)); - if (index_name != nullptr) { - memcpy(req->index_name, index_name, strlen(index_name) + 1); + memset(req, 0, len); + int index_name_len = index_name ? strlen(index_name) : 0; + if (index_name_len > 0) { + strncpy(req->index_name, index_name, index_name_len + 1); } req->tch = *tch; int result = ERR_CONNECTION_FAILED; @@ -392,6 +388,7 @@ int tse_rnd_pos(tianchi_handler_t *tch, uint16_t pos_length, uint8_t *position, req->tch = *tch; req->record = record_info->record; req->pos_length = pos_length; + memset(req->position, 0, SMALL_RECORD_SIZE); memcpy(req->position, position, pos_length); int result = ERR_CONNECTION_FAILED; @@ -596,14 +593,15 @@ int tse_trx_rollback(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize) { } int tse_srv_set_savepoint(tianchi_handler_t *tch, const char *name) { - assert(strlen(name) + 1 < SMALL_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); - srv_set_savepoint_request *req = (srv_set_savepoint_request*)alloc_share_mem(shm_inst, sizeof(srv_set_savepoint_request)); + uint64_t len = sizeof(srv_set_savepoint_request); + srv_set_savepoint_request *req = (srv_set_savepoint_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(srv_set_savepoint_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - memcpy(req->name, name, strlen(name) + 1); + memset(req, 0, len); + strncpy(req->name, name, SMALL_RECORD_SIZE - 1); req->tch = *tch; int result = ERR_CONNECTION_FAILED; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_SRV_SET_SAVEPOINT, req, tch->msg_buf); @@ -615,14 +613,14 @@ int tse_srv_set_savepoint(tianchi_handler_t *tch, const char *name) { } int tse_srv_rollback_savepoint(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, const char *name) { - assert(strlen(name) + 1 < SMALL_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); srv_rollback_savepoint_request *req = (srv_rollback_savepoint_request*)alloc_share_mem(shm_inst, sizeof(srv_rollback_savepoint_request)); if (req == NULL) { tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(srv_rollback_savepoint_request)); return ERR_ALLOC_MEMORY; } - memcpy(req->name, name, strlen(name) + 1); + memset(req->name, 0, SMALL_RECORD_SIZE); + strncpy(req->name, name, SMALL_RECORD_SIZE - 1); req->tch = *tch; req->csize = csize; req->cursors = cursors; @@ -637,14 +635,15 @@ int tse_srv_rollback_savepoint(tianchi_handler_t *tch, uint64_t *cursors, int32_ } int tse_srv_release_savepoint(tianchi_handler_t *tch, const char *name) { - assert(strlen(name) + 1 < SMALL_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); - srv_release_savepoint_request *req = (srv_release_savepoint_request*)alloc_share_mem(shm_inst, sizeof(srv_release_savepoint_request)); + uint64_t len = sizeof(srv_release_savepoint_request); + srv_release_savepoint_request *req = (srv_release_savepoint_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(srv_release_savepoint_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - memcpy(req->name, name, strlen(name) + 1); + memset(req, 0, len); + strncpy(req->name, name, SMALL_RECORD_SIZE - 1); req->tch = *tch; int result = ERR_CONNECTION_FAILED; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_SRV_RELEASE_SAVEPOINT, req, tch->msg_buf); @@ -715,20 +714,19 @@ int tse_get_max_sessions_per_node(uint32_t *max_sessions) { } int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *table_name, double sampling_ratio) { - assert(strlen(db_name) + 1 <= SMALL_RECORD_SIZE); - assert(strlen(table_name) + 1 <= SMALL_RECORD_SIZE); - void *shm_inst = get_one_shm_inst(tch); - analyze_table_request *req = (analyze_table_request*)alloc_share_mem(shm_inst, sizeof(analyze_table_request)); + uint64_t len = sizeof(analyze_table_request); + analyze_table_request *req = (analyze_table_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("tse_analyze_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(analyze_table_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } + memset(req, 0, len); req->tch = *tch; req->ratio = sampling_ratio; - memcpy(req->table_name, table_name, strlen(table_name) + 1); - memcpy(req->user_name, db_name, strlen(db_name) + 1); + strncpy(req->table_name, table_name, SMALL_RECORD_SIZE - 1); + strncpy(req->user_name, db_name, SMALL_RECORD_SIZE - 1); int result = ERR_CONNECTION_FAILED; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_ANALYZE, req, tch->msg_buf); @@ -765,7 +763,7 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb void *shm_inst_4_columns = get_one_shm_inst(tch); void *shm_inst_4_keys = get_one_shm_inst(tch); void *shm_inst_4_table = get_one_shm_inst(tch); - tse_cbo_stats_column_t* part_columns; + tse_cbo_stats_column_t* part_columns = nullptr; req->stats->ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len); if (req->stats->ndv_keys == NULL) { tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len); @@ -843,19 +841,20 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb int tse_get_index_name(tianchi_handler_t *tch, char *index_name) { void *shm_inst = get_one_shm_inst(tch); - get_index_slot_request *req = (get_index_slot_request*)alloc_share_mem(shm_inst, sizeof(get_index_slot_request)); + uint64_t len = sizeof(get_index_slot_request); + get_index_slot_request *req = (get_index_slot_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%d)", shm_inst, REQUEST_SIZE); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - memset(req, 0, sizeof(get_index_slot_request)); + memset(req, 0, len); req->tch = *tch; int result = ERR_CONNECTION_FAILED; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GET_INDEX_NAME, req, tch->msg_buf); if (ret == CT_SUCCESS) { - memcpy(index_name, req->index_name, strlen(req->index_name) + 1); + strncpy(index_name, req->index_name, strlen(req->index_name) + 1); result = req->result; } else { result = ret; @@ -927,28 +926,24 @@ int tse_drop_tablespace_and_user(tianchi_handler_t *tch, char *error_message) { void *shm_inst = get_one_shm_inst(tch); - drop_tablespace_and_user_request *req = (drop_tablespace_and_user_request*)alloc_share_mem(shm_inst, sizeof(drop_tablespace_and_user_request)); + uint64_t len = sizeof(drop_tablespace_and_user_request); + drop_tablespace_and_user_request *req = (drop_tablespace_and_user_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("drop_tablespace_and_user_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(drop_tablespace_and_user_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - assert(strlen(db_name) + 1 <= sizeof(req->db_name)); - memcpy(req->db_name, db_name, strlen(db_name) + 1); - assert(strlen(sql_str) + 1 <= sizeof(req->sql_str)); - memcpy(req->sql_str, sql_str, strlen(sql_str) + 1); - - assert(strlen(user_name) + 1 <= sizeof(req->user_name)); - memcpy(req->user_name, user_name, strlen(user_name) + 1); - assert(strlen(user_ip) + 1 <= sizeof(req->user_ip)); - memcpy(req->user_ip, user_ip, strlen(user_ip) + 1); - TSE_RESET_SHM_REQ_ERROR_CODE(req); + memset(req, 0, len); + strncpy(req->db_name, db_name, SMALL_RECORD_SIZE - 1); + strncpy(req->sql_str, sql_str, MAX_DDL_SQL_LEN - 1); + strncpy(req->user_name, user_name, SMALL_RECORD_SIZE - 1); + strncpy(req->user_ip, user_ip, SMALL_RECORD_SIZE - 1); req->tch = *tch; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_DROP_TABLESPACE_AND_USER, req, tch->msg_buf); *tch = req->tch; if(req->error_message != NULL && strlen(req->error_message) > 0) { *error_code = req->error_code; - memcpy(error_message, req->error_message, ERROR_MESSAGE_LEN); + strncpy(error_message, req->error_message, ERROR_MESSAGE_LEN); } free_share_mem(shm_inst, req); int result = ERR_CONNECTION_FAILED; @@ -960,16 +955,20 @@ int tse_drop_tablespace_and_user(tianchi_handler_t *tch, int tse_drop_db_pre_check(tianchi_handler_t *tch, const char *db_name, int *error_code, char *error_message) { void *shm_inst = get_one_shm_inst(tch); - drop_db_pre_check_request *req = (drop_db_pre_check_request*)alloc_share_mem(shm_inst, sizeof(drop_db_pre_check_request)); + uint64_t len = sizeof(drop_db_pre_check_request); + drop_db_pre_check_request *req = (drop_db_pre_check_request*)alloc_share_mem(shm_inst, len); + if (req == NULL) { + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + return ERR_ALLOC_MEMORY; + } + memset(req, 0, len); req->tch = *tch; - assert(strlen(db_name) + 1 <= sizeof(req->db_name)); - memcpy(req->db_name, db_name, strlen(db_name) + 1); - TSE_RESET_SHM_REQ_ERROR_CODE(req); + strncpy(req->db_name, db_name, SMALL_RECORD_SIZE - 1); int result = ERR_CONNECTION_FAILED; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_DROP_DB_PRE_CHECK, req, tch->msg_buf); *tch = req->tch; *error_code = req->error_code; - strncpy(error_message, req->error_message, ERROR_MESSAGE_LEN - 1); + strncpy(error_message, req->error_message, ERROR_MESSAGE_LEN); if (ret == CT_SUCCESS) { result = req->result; } @@ -980,22 +979,21 @@ int tse_drop_db_pre_check(tianchi_handler_t *tch, const char *db_name, int *erro int tse_lock_table(tianchi_handler_t *tch, const char *db_name, tse_lock_table_info *lock_info, int *error_code) { void *shm_inst = get_one_shm_inst(tch); - lock_table_request *req = (lock_table_request*)alloc_share_mem(shm_inst, sizeof(lock_table_request)); + uint64_t len = sizeof(lock_table_request); + lock_table_request *req = (lock_table_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("lock_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(lock_table_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - req->db_name[0] = '\0'; + memset(req, 0, len); if (db_name != nullptr) { - strncpy(req->db_name, db_name, strlen(db_name) + 1); + strncpy(req->db_name, db_name, SMALL_RECORD_SIZE - 1); } - req->tch = *tch; req->lock_info = *lock_info; req->mysql_inst_id = tch->inst_id; - TSE_RESET_SHM_REQ_ERROR_CODE(req); int result = ERR_CONNECTION_FAILED; int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_LOCK_TABLE, req, tch->msg_buf); *tch = req->tch; @@ -1011,27 +1009,26 @@ int tse_pre_create_db(tianchi_handler_t *tch, const char *sql_str, tse_db_infos_ int *error_code, char *error_message) { void *shm_inst = get_one_shm_inst(tch); - pre_create_db_request *req = (pre_create_db_request*)alloc_share_mem(shm_inst, sizeof(pre_create_db_request)); + uint64_t len = sizeof(pre_create_db_request); + pre_create_db_request *req = (pre_create_db_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("create_tablespace_and_user_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(pre_create_db_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } - assert(strlen(sql_str) + 1 <= sizeof(req->sql_str)); - memcpy(req->sql_str, sql_str, strlen(sql_str) + 1); - assert(strlen(db_infos->name) + 1 <= sizeof(req->db_name)); - memcpy(req->db_name, db_infos->name, strlen(db_infos->name) + 1); + memset(req, 0, len); + strncpy(req->sql_str, sql_str, MAX_DDL_SQL_LEN - 1); + strncpy(req->db_name, db_infos->name, SMALL_RECORD_SIZE - 1); req->ctc_db_datafile_size = db_infos->datafile_size; req->ctc_db_datafile_autoextend = db_infos->datafile_autoextend; req->ctc_db_datafile_extend_size = db_infos->datafile_extend_size; req->tch = *tch; - TSE_RESET_SHM_REQ_ERROR_CODE(req); int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_PRE_CREATE_DB, req, tch->msg_buf); *tch = req->tch; if(req->error_message != NULL && strlen(req->error_message) > 0) { *error_code = req->error_code; - memcpy(error_message, req->error_message, ERROR_MESSAGE_LEN); + strncpy(error_message, req->error_message, ERROR_MESSAGE_LEN); } free_share_mem(shm_inst, req); int result = ERR_CONNECTION_FAILED; @@ -1273,7 +1270,7 @@ int tse_broadcast_rewrite_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_BROADCAST_REWRITE_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; - memcpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); + strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); if (ret == CT_SUCCESS) { result = req->result; } @@ -1455,15 +1452,17 @@ int tse_search_metadata_status(bool *cantian_metadata_switch, bool *cantian_clus int tse_check_db_table_exists(const char *db, const char *name, bool *is_exists) { void *shm_inst = get_one_shm_inst(NULL); - check_table_exists_request *req = (check_table_exists_request*)alloc_share_mem(shm_inst, sizeof(check_table_exists_request)); + uint64_t len = sizeof(check_table_exists_request); + check_table_exists_request *req = (check_table_exists_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("check_init_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(check_table_exists_request)); + tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } + memset(req, 0, len); int result = ERR_CONNECTION_FAILED; - memcpy(req->db, db, strlen(db) + 1); - memcpy(req->name, name, strlen(name) + 1); + strncpy(req->db, db, SMALL_RECORD_SIZE - 1); + strncpy(req->name, name, SMALL_RECORD_SIZE - 1); int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_CHECK_TABLE_EXIST, req, nullptr); if (ret == CT_SUCCESS) { result = req->result; @@ -1489,7 +1488,7 @@ int ctc_record_sql_for_cantian(tianchi_handler_t *tch, tse_ddl_broadcast_request int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RECORD_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; - memcpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); + strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); if (ret == CT_SUCCESS) { result = req->result; } diff --git a/storage/tianchi/tse_util.cc b/storage/tianchi/tse_util.cc index 310b34d..9904f23 100644 --- a/storage/tianchi/tse_util.cc +++ b/storage/tianchi/tse_util.cc @@ -96,7 +96,7 @@ void tse_split_normalized_name(const char *file_name, char db[], size_t db_buf_l assert(db != nullptr); if (is_tmp_table != nullptr && (*is_tmp_table)) { - (void)strncpy(db, TMP_DIR, db_buf_len); + (void)strncpy(db, TMP_DIR, db_buf_len - 1); db[db_buf_len - 1] = '\0'; } else if (dir_length > 1) { /* Get database */ -- Gitee