/* Check if network packet size is enough. */

Key_Values local_configs = {{"max_allowed_packet", ""}};

int err =

mysql_service_clone_protocol->mysql_clone_get_configs(thd, local_configs);

if (err != 0) {

return (err);

}

const std::string &val_str = local_configs[0].second;

long long val = 0;

bool is_exception = false;

try {

val = std::stoll(val_str);

} catch (...) {

is_exception = true; /* purecov: inspected */

}

if (is_exception || val <= 0) {

/* purecov: begin deadcode */

assert(false);

my_error(ER_INTERNAL_ERROR, MYF(0),

"Error extracting integer value for"

"'max_allowed_packet' configuration");

return (ER_INTERNAL_ERROR);

/* purecov: end */

}

if (val < longlong{CLONE_MIN_NET_BLOCK}) {

err = ER_CLONE_NETWORK_PACKET;

my_error(err, MYF(0), CLONE_MIN_NET_BLOCK, val);

}

return (err);

Donor_Callback callback) {

size_t comma_pos = 0;

size_t begin_pos = 0;

try {

/* Don't allow space in donor list. */

auto space_pos = donor_list.find(" ");

if (space_pos != std::string::npos) {

return (false);

}

/* Scan through all entries. */

while (comma_pos != std::string::npos) {

comma_pos = donor_list.find(",", begin_pos);

auto entry_len = comma_pos;

if (entry_len != std::string::npos) {

if (comma_pos <= begin_pos) {

return (false);

}

/* Exclude the comma separator. */

entry_len = comma_pos - begin_pos;

}

std::string entry = donor_list.substr(begin_pos, entry_len);

auto colon_pos = entry.find(":");

/* Bad entry if no separator is found or found in beginning. */

if (colon_pos == std::string::npos || colon_pos == 0) {

return (false);

}

auto port_str = entry.substr(colon_pos + 1);

/* Allow only decimal digit in PORT. */

for (char &digit : port_str) {

if (std::isdigit(digit) == 0) {

return (false);

}

}

auto valid_port = static_cast<uint32_t>(std::stoi(port_str));

auto valid_host = entry.substr(0, colon_pos);

bool match = callback(valid_host, valid_port);

if (match) {

return (true);

}

/* Set next begin position. */

begin_pos = comma_pos + 1;

}

} catch (...) { /* purecov: inspected */

/* If entry format is bad, return. */

return (false); /* purecov: inspected */

}

return (true);

uint port) {

myclone::Key_Values configs = {{"clone_valid_donor_list", ""}};

/* Get Clone configuration parameter value safely. */

auto err =

mysql_service_clone_protocol->mysql_clone_get_configs(thd, configs);

if (err != 0) {

return (err);

}

auto &valid_str = configs[0].second;

bool found = false;

Donor_Callback callback = [&](std::string &valid_host, uint32_t valid_port) {

/* Host in MySQL is case insensitive and converted to lower case. */

auto transform_lower = [](unsigned char c) {

return static_cast<unsigned char>(std::tolower(c));

};

std::transform(valid_host.begin(), valid_host.end(), valid_host.begin(),

transform_lower);

/* Check if input matches with configured host and port. */

if (0 == valid_host.compare(host) && port == valid_port) {

found = true;

}

return (found);

};

static_cast<void>(scan_donor_list(valid_str, callback));

if (found) {

return (0);

}

char err_buf[MYSYS_ERRMSG_SIZE];

snprintf(err_buf, sizeof(err_buf),

"%s:%u is not found in "

"clone_valid_donor_list: %s",

host, port, valid_str.c_str());

my_error(ER_CLONE_SYS_CONFIG, MYF(0), err_buf);

return (ER_CLONE_SYS_CONFIG);

void *save, struct st_mysql_value *value) {

char temp_buffer[STRING_BUFFER_USUAL_SIZE];

auto buf_len = static_cast<int>(sizeof(temp_buffer));

auto addrs_cstring = value->val_str(value, temp_buffer, &buf_len);

if (addrs_cstring && (addrs_cstring == temp_buffer)) {

addrs_cstring = thd_strmake(thd, addrs_cstring, buf_len);

}

if (addrs_cstring == nullptr) {

/* purecov: begin deadcode */

(*(const char **)save) = nullptr;

/* NULL is a valid value */

return (0);

/* purecov: end */

}

std::string addrs(addrs_cstring);

Donor_Callback callback = [](std::string, uint32_t) { return (false); };

bool success = scan_donor_list(addrs_cstring, callback);

if (!success) {

(*(const char **)save) = nullptr;

my_error(ER_CLONE_SYS_CONFIG, MYF(0),

"Invalid Format. Please enter "

"\"<hostname1>:<port1>,...\"' with no extra space");

return (ER_CLONE_SYS_CONFIG);

}

*(const char **)save = addrs_cstring;

return (0);

/* Acquire registry and log service handles. */

if (init_logging_service_for_plugin(&mysql_service_registry, &log_bi,

&log_bs)) {

return (-1);

}

my_h_service service;

/* Acquire backup lock service handle. */

if (mysql_service_registry->acquire("mysql_backup_lock", &service)) {

return (-1);

}

mysql_service_mysql_backup_lock =

reinterpret_cast<SERVICE_TYPE(mysql_backup_lock) *>(service);

/* Acquire clone protocol service handle. */

if (mysql_service_registry->acquire("clone_protocol", &service)) {

return (-1);

}

mysql_service_clone_protocol =

reinterpret_cast<SERVICE_TYPE(clone_protocol) *>(service);

auto error = clone_handle_create(clone_plugin_name);

/* During DB creation skip PFS dynamic tables. PFS is not fully initialized

bool skip_pfs_tables = false;

if (error == ER_INIT_BOOTSTRAP_COMPLETE) {

skip_pfs_tables = true;

} else if (error != 0) {

return (error);

}

if (!skip_pfs_tables && myclone::Table_pfs::acquire_services()) {

LogPluginErr(ERROR_LEVEL, ER_CLONE_CLIENT_TRACE,

"PFS table creation failed");

return (-1);

}

#ifdef HAVE_PSI_INTERFACE

/* Register memory key */

int count = static_cast<int>(sizeof(clone_memory) / sizeof(clone_memory[0]));

mysql_memory_register(clone_plugin_name, clone_memory, count);

/* Register thread keys */

count = static_cast<int>(sizeof(clone_threads) / sizeof(clone_threads[0]));

mysql_thread_register(clone_plugin_name, clone_threads, count);

/* Register statement keys */

count = static_cast<int>(sizeof(clone_stmts) / sizeof(clone_stmts[0]));

mysql_statement_register(clone_plugin_name, clone_stmts, count);

/* Set the statement key values */

assert(count >= 3);

clone_stmt_local_key = clone_stmts[0].m_key;

clone_stmt_client_key = clone_stmts[1].m_key;

clone_stmt_server_key = clone_stmts[2].m_key;

#endif

return (0);

/* If service registry is uninitialized, return. */

if (mysql_service_registry == nullptr) {

return (0);

}

auto error = clone_handle_drop();

if (error != ER_INIT_BOOTSTRAP_COMPLETE) {

myclone::Table_pfs::release_services();

}

using backup_lock_t = SERVICE_TYPE_NO_CONST(mysql_backup_lock);

mysql_service_registry->release(reinterpret_cast<my_h_service>(

const_cast<backup_lock_t *>(mysql_service_mysql_backup_lock)));

mysql_service_mysql_backup_lock = nullptr;

using clone_protocol_t = SERVICE_TYPE_NO_CONST(clone_protocol);

mysql_service_registry->release(reinterpret_cast<my_h_service>(

const_cast<clone_protocol_t *>(mysql_service_clone_protocol)));

mysql_service_clone_protocol = nullptr;

deinit_logging_service_for_plugin(&mysql_service_registry, &log_bi, &log_bs);

return (0);

myclone::Client_Share client_share(nullptr, 0, nullptr, nullptr, data_dir, 0);

myclone::Server server(thd, MYSQL_INVALID_SOCKET);

/* Update session and statement PFS keys */

assert(thd != nullptr);

mysql_service_clone_protocol->mysql_clone_start_statement(

thd, PSI_NOT_INSTRUMENTED, clone_stmt_local_key);

myclone::Local clone_inst(thd, &server, &client_share, 0, true);

auto error = clone_inst.clone();

return (error);

uint remote_port, const char *remote_user,

const char *remote_passwd,

const char *data_dir, int ssl_mode) {

/* Validate that donor address matches with preconfigured value. */

auto error = match_valid_donor_address(thd, remote_host, remote_port);

if (error != 0) {

return (error);

}

myclone::Client_Share client_share(remote_host, remote_port, remote_user,

remote_passwd, data_dir, ssl_mode);

/* Update session and statement PFS keys */

assert(thd != nullptr);

mysql_service_clone_protocol->mysql_clone_start_statement(

thd, PSI_NOT_INSTRUMENTED, clone_stmt_client_key);

myclone::Client clone_inst(thd, &client_share, 0, true);

error = clone_inst.clone();

return (error);

myclone::Server clone_inst(thd, socket);

auto err = clone_inst.clone();

return (err);