#include "sql/auth/sql_auth_cache.h"

#include <stdarg.h>

#include <boost/graph/properties.hpp>

#include <new>

#include "m_ctype.h"

#include "m_string.h" // LEX_CSTRING

#include "mutex_lock.h"

#include "my_base.h"

#include "my_compiler.h"

#include "my_dbug.h"

#include "my_loglevel.h"

#include "my_macros.h"

#include "mysql/components/services/bits/psi_bits.h"

#include "mysql/components/services/bits/psi_mutex_bits.h"

#include "mysql/components/services/log_builtins.h"

#include "mysql/plugin.h"

#include "mysql/plugin_audit.h"

#include "mysql/plugin_auth.h" // st_mysql_auth

#include "mysql/psi/mysql_mutex.h"

#include "mysql/service_mysql_alloc.h"

#include "mysqld_error.h"

#include "prealloced_array.h"

#include "sql/auth/auth_acls.h"

#include "sql/auth/auth_common.h" // ACL_internal_schema_access

#include "sql/auth/auth_internal.h" // auth_plugin_is_built_in

#include "sql/auth/auth_utility.h"

#include "sql/auth/dynamic_privilege_table.h"

#include "sql/auth/sql_authentication.h" // g_cached_authentication_plugins

#include "sql/auth/sql_security_ctx.h"

#include "sql/auth/sql_user_table.h"

#include "sql/auth/user_table.h" // read_user_table

#include "sql/current_thd.h" // current_thd

#include "sql/debug_sync.h"

#include "sql/error_handler.h" // Internal_error_handler

#include "sql/field.h" // Field

#include "sql/handler.h"

#include "sql/iterators/row_iterator.h"

#include "sql/key.h"

#include "sql/mdl.h"

#include "sql/mysqld.h" // my_localhost

#include "sql/psi_memory_key.h" // key_memory_acl_mem

#include "sql/set_var.h"

#include "sql/sql_audit.h"

#include "sql/sql_base.h" // open_and_lock_tables

#include "sql/sql_class.h" // THD

#include "sql/sql_const.h"

#include "sql/sql_error.h"

#include "sql/sql_executor.h" // unique_ptr_destroy_only<RowIterator>

#include "sql/sql_lex.h"

#include "sql/sql_plugin.h" // my_plugin_lock_by_name

#include "sql/sql_plugin_ref.h"

#include "sql/ssl_acceptor_context_operator.h"

#include "sql/system_variables.h"

#include "sql/table.h" // TABLE

#include "sql/thd_raii.h"

#include "sql/thr_malloc.h"

#include "sql/tztime.h" // Time_zone

#include "sql/xa.h"

#include "sql_string.h"

#include "thr_lock.h"

#include "thr_mutex.h"

#define INVALID_DATE "0000-00-00 00:00:00"

#include <algorithm>

#include <functional>

#include <unordered_map>

#include <utility>

#include <vector>

using std::make_unique;

using std::min;

using std::string;

using std::unique_ptr;

PSI_mutex_key key_LOCK_acl_cache_flush;

PSI_mutex_info all_acl_cache_mutexes[] = {

{&key_LOCK_acl_cache_flush, "LOCK_acl_cache_flush", PSI_FLAG_SINGLETON, 0,

PSI_DOCUMENT_ME}};

Acl_cache *g_acl_cache = nullptr;

Acl_cache *get_global_acl_cache() { return g_acl_cache; }

ulong get_global_acl_cache_size() { return g_acl_cache->size(); }

void init_acl_cache();

extern Role_index_map *g_authid_to_vertex;

extern Granted_roles_graph *g_granted_roles;

#include <boost/property_map/property_map.hpp>

struct ACL_internal_schema_registry_entry {

const LEX_CSTRING *m_name;

const ACL_internal_schema_access *m_access;

};

static ACL_internal_schema_registry_entry registry_array[2];

static uint m_registry_array_size = 0;

MEM_ROOT global_acl_memory;

MEM_ROOT memex;

Prealloced_array<ACL_USER, ACL_PREALLOC_SIZE> *acl_users = nullptr;

Prealloced_array<ACL_PROXY_USER, ACL_PREALLOC_SIZE> *acl_proxy_users = nullptr;

Prealloced_array<ACL_DB, ACL_PREALLOC_SIZE> *acl_dbs = nullptr;

Prealloced_array<ACL_HOST_AND_IP, ACL_PREALLOC_SIZE> *acl_wild_hosts = nullptr;

Db_access_map acl_db_map;

Default_roles *g_default_roles = nullptr;

std::vector<Role_id> *g_mandatory_roles = nullptr;

unique_ptr<

malloc_unordered_multimap<string, unique_ptr_destroy_only<GRANT_TABLE>>>

column_priv_hash;

unique_ptr<

malloc_unordered_multimap<string, unique_ptr_destroy_only<GRANT_NAME>>>

proc_priv_hash, func_priv_hash;

malloc_unordered_map<std::string, unique_ptr_my_free<acl_entry>> db_cache{

key_memory_acl_cache};

collation_unordered_map<std::string, ACL_USER *> *acl_check_hosts = nullptr;

unique_ptr<Acl_restrictions> acl_restrictions = nullptr;

typedef std::unordered_map<

std::string, Acl_user_ptr_list, std::hash<std::string>,

std::equal_to<std::string>,

Acl_cache_allocator<std::pair<const std::string, Acl_user_ptr_list>>>

Name_to_userlist;

Name_to_userlist *name_to_userlist = nullptr;

bool initialized = false;

bool skip_grant_tables(void) { return !initialized; }

bool acl_cache_initialized = false;

bool allow_all_hosts = true;

uint grant_version = 0; /* Version of priv tables */

bool validate_user_plugins = true;

#define IP_ADDR_STRLEN (3 + 1 + 3 + 1 + 3 + 1 + 3)

#define ACL_KEY_LENGTH (IP_ADDR_STRLEN + 1 + NAME_LEN + 1 + USERNAME_LENGTH + 1)

static void set_username(char **user, const char *user_arg, MEM_ROOT *mem) {

assert(user != nullptr);

*user = (user_arg && *user_arg) ? strdup_root(mem, user_arg) : nullptr;

}

static void set_hostname(ACL_HOST_AND_IP *host, const char *host_arg,

}

void init_acl_memory() {

init_sql_alloc(key_memory_acl_mem, &global_acl_memory, ACL_ALLOC_BLOCK_SIZE);

}

void ACL_internal_schema_registry::register_schema(

}

const ACL_internal_schema_access *ACL_internal_schema_registry::lookup(

const char *name) {

assert(name != nullptr);

uint i;

for (i = 0; i < m_registry_array_size; i++) {

if (my_strcasecmp(system_charset_info, registry_array[i].m_name->str,

name) == 0)

return registry_array[i].m_access;

}

return nullptr;

}

bool ACL_HOST_AND_IP::calc_cidr_mask(const char *ip_arg, long *val) {

}

bool ACL_HOST_AND_IP::calc_ip_mask(const char *ip_arg, long *val) {

}

const char *ACL_HOST_AND_IP::calc_ip(const char *ip_arg, long *val) {

long ip_val, tmp;

if (!(ip_arg = str2int(ip_arg, 10, 0, 255, &ip_val)) || *ip_arg != '.')

return nullptr;

ip_val <<= 24;

if (!(ip_arg = str2int(ip_arg + 1, 10, 0, 255, &tmp)) || *ip_arg != '.')

return nullptr;

ip_val += tmp << 16;

if (!(ip_arg = str2int(ip_arg + 1, 10, 0, 255, &tmp)) || *ip_arg != '.')

return nullptr;

ip_val += tmp << 8;

if (!(ip_arg = str2int(ip_arg + 1, 10, 0, 255, &tmp))) return nullptr;

*val = ip_val + tmp;

return ip_arg;

}

void ACL_HOST_AND_IP::update_hostname(const char *host_arg) {

}

bool ACL_HOST_AND_IP::compare_hostname(const char *host_arg,

}

ACL_USER::ACL_USER() {

}

void ACL_USER::Password_locked_state::set_temporary_lock_state_parameters(

uint remaining_login_attempts, long daynr_locked) {

m_remaining_login_attempts = remaining_login_attempts;

m_daynr_locked = daynr_locked;

}

void ACL_USER::Password_locked_state::set_parameters(

int password_lock_time_days, uint failed_login_attempts) {

m_password_lock_time_days = password_lock_time_days;

m_failed_login_attempts = failed_login_attempts;

set_temporary_lock_state_parameters(failed_login_attempts, 0);

assert(is_default() == true);

}

bool ACL_USER::Password_locked_state::update(THD *thd, bool successful_login,

long *ret_days_remaining) {

/* stop if the user is not tracking failed logins */

if (!is_active()) return false;

/* reset on a successful login if the account is not locked */

if (successful_login && m_daynr_locked == 0) {

m_remaining_login_attempts = m_failed_login_attempts;

return false;

}

/* decreases the remaining login attempts if any */

if (!successful_login && m_remaining_login_attempts > 0) {

m_remaining_login_attempts--;

assert(m_daynr_locked == 0);

}

if (m_remaining_login_attempts) return false;

long now_day;

/* fetch the current day */

MYSQL_TIME tm_now;

thd->time_zone()->gmt_sec_to_TIME(&tm_now, thd->query_start_timeval_trunc(6));

now_day = calc_daynr(tm_now.year, tm_now.month, tm_now.day);

DBUG_EXECUTE_IF("account_lock_daynr_add_one", { now_day += 1; });

DBUG_EXECUTE_IF("account_lock_daynr_add_ten", { now_day += 10; });

/* last unsuccessful login. lock the account */

if (m_daynr_locked == 0) {

assert(!successful_login);

m_daynr_locked = now_day;

*ret_days_remaining = m_password_lock_time_days;

return true;

};

/* if the lock should never expire we stop here */

if (m_daynr_locked > 0 && m_password_lock_time_days < 0) return true;

/* check if the account is still to be locked */

if (now_day - m_daynr_locked < (long)m_password_lock_time_days) {

*ret_days_remaining =

((long)m_password_lock_time_days) - (now_day - m_daynr_locked);

return true;

}

/* reset the account lock if the time has expired */

if (now_day - m_daynr_locked >= (long)m_password_lock_time_days) {

m_daynr_locked = 0;

m_remaining_login_attempts = m_failed_login_attempts;

return false;

}

/* it should never get to here */

assert(false);

return false;

}

ACL_USER *ACL_USER::copy(MEM_ROOT *root) {

ACL_USER *dst = (ACL_USER *)root->Alloc(sizeof(ACL_USER));

if (!dst) return nullptr;

*dst = *this;

dst->user = safe_strdup_root(root, user);

dst->ssl_cipher = safe_strdup_root(root, ssl_cipher);

dst->x509_issuer = safe_strdup_root(root, x509_issuer);

dst->x509_subject = safe_strdup_root(root, x509_subject);

/*

if (auth_plugin_is_built_in(dst->plugin.str))

dst->plugin = plugin;

else {

dst->plugin.str = strmake_root(root, plugin.str, plugin.length);

dst->plugin.length = plugin.length;

}

for (int i = 0; i < NUM_CREDENTIALS; ++i) {

dst->credentials[i].m_auth_string.str =

safe_strdup_root(root, credentials[i].m_auth_string.str);

dst->credentials[i].m_auth_string.length =

credentials[i].m_auth_string.length;

dst->credentials[i].m_salt_len = credentials[i].m_salt_len;

memcpy(dst->credentials[i].m_salt, credentials[i].m_salt,

credentials[i].m_salt_len);

}

dst->host.update_hostname(safe_strdup_root(root, host.get_host()));

dst->password_require_current = password_require_current;

dst->password_locked_state = password_locked_state;

dst->set_mfa(root, m_mfa);

return dst;

}

void ACL_USER::set_user(MEM_ROOT *mem, const char *user_arg) {

set_username(&user, user_arg, mem);

}

void ACL_USER::set_host(MEM_ROOT *mem, const char *host_arg) {

set_hostname(&host, host_arg, mem);

}

void ACL_USER::set_mfa(MEM_ROOT *mem, I_multi_factor_auth *m) {

}

void ACL_PROXY_USER::init(const char *host_arg, const char *user_arg,

}

void ACL_PROXY_USER::init(MEM_ROOT *mem, const char *host_arg,

}

void ACL_PROXY_USER::init(TABLE *table, MEM_ROOT *mem) {

}

bool ACL_PROXY_USER::check_validity(bool check_no_resolve) {

}

bool ACL_PROXY_USER::matches(const char *host_arg, const char *user_arg,

}

bool ACL_PROXY_USER::pk_equals(ACL_PROXY_USER *grant) {

}

void ACL_PROXY_USER::print_grant(THD *thd, String *str) {

}

int ACL_PROXY_USER::store_pk(TABLE *table, const LEX_CSTRING &hostname,

}

int ACL_PROXY_USER::store_with_grant(TABLE *table, bool with_grant) {

}

int ACL_PROXY_USER::store_data_record(TABLE *table, const LEX_CSTRING &hostname,

}

void ACL_PROXY_USER::set_user(MEM_ROOT *mem, const char *user_arg) {

set_username(const_cast<char **>(&user), user_arg, mem);

}

void ACL_PROXY_USER::set_host(MEM_ROOT *mem, const char *host_arg) {

set_hostname(&host, host_arg, mem);

}

void ACL_DB::set_user(MEM_ROOT *mem, const char *user_arg) {

set_username(&user, user_arg, mem);

}

void ACL_DB::set_host(MEM_ROOT *mem, const char *host_arg) {

set_hostname(&host, host_arg, mem);

}

void append_auth_id(const THD *thd, ACL_USER *acl_user, String *str) {

}

void append_auth_id_string(const THD *thd, const char *user, size_t user_len,

}

int wild_case_compare(CHARSET_INFO *cs, const char *str, size_t str_len,

}

int wild_case_compare(CHARSET_INFO *cs, const char *str, const char *wildstr) {

return wild_case_compare(cs, str, strlen(str), wildstr, strlen(wildstr));

}

ulong get_sort(uint count, ...) {

}

bool hostname_requires_resolving(const char *hostname) {

}

GRANT_COLUMN::GRANT_COLUMN(String &c, Access_bitmask y)

: rights(y), column(c.ptr(), c.length()) {}

void GRANT_NAME::set_user_details(const char *h, const char *d, const char *u,

}

GRANT_NAME::GRANT_NAME(const char *h, const char *d, const char *u,

}

GRANT_TABLE::GRANT_TABLE(const char *h, const char *d, const char *u,

hash_columns(system_charset_info, key_memory_acl_memex) {}

GRANT_NAME::GRANT_NAME(TABLE *form, bool is_routine) {

}

GRANT_TABLE::GRANT_TABLE(TABLE *form)