|
Member
|
03-31-2020
, 17:38
Re: is_user_admin(id) , does not check after map change
|
#64
|
Quote:
Originally Posted by Bugsy
I just tested it myself and I retain flags after a map change. I am not going to keep tweaking the code to make it comply with your other plugins.
|
I believe the whole idea of my thread was to find a plugin to comply with my server. In the beginning, I clearly stated that I worked with AmxBans, now with GM-x and only needed a resolution for this issue, which is basically the thread title. You were the one who proposed to write a plugin if I recall?
This is the plugin which handles the flags, it would be great if you can implement the veteran feature in there..
PHP Code:
#include <amxmodx>
#include <uac>
#include <grip>
#include <gmx>
#include <gmx_cache>
#pragma semicolon 1
#define LOG_ADMIN_ACTIVITY // Just added the function, no calibrating is made
// #define LOAD_USERS_INI //Load admins from filename
#define CHANGE_NICK_HOOK 2 // 0 - amxmodx, 1 - fakemeta, 2 - reapi
#if CHANGE_NICK_HOOK == 1
#include <fakemeta>
#elseif CHANGE_NICK_HOOK == 2
#include <reapi>
#endif
#if defined LOG_ADMIN_ACTIVITY
new LogFile;
#endif
#define CHECK_NATIVE_ARGS_NUM(%1,%2,%3) \
if (%1 < %2) { \
log_error(AMX_ERR_NATIVE, "Invalid num of arguments %d. Expected %d", %1, %2); \
return %3; \
}
#define CHECK_NATIVE_PLAYER(%1,%2) \
if (!is_user_connected(%1)) { \
log_error(AMX_ERR_NATIVE, "Invalid player %d", %1); \
return %2; \
}
#define TIMEOUT_TASK_ID 1
const MAX_KEY_LENGTH = MAX_AUTHID_LENGTH + 2;
enum {
FWD_Loading,
FWD_Loaded,
FWD_Checking,
FWD_Checked,
FWD_Pushing,
FWD_Pushed,
FWD_LAST
};
new Forwards[FWD_LAST], FReturn;
enum _:LoadStatus {
LoadSource,
bool:LoadLoaded
};
new LoadStatusList[5][LoadStatus], LoadStatusNum, PluginLoadedNum;
enum {
STATUS_LOADING,
STATUS_LOADED
};
new Status;
new bool:NeedRecheck = false;
enum (+=1) {
MODE_DISABLE = 0,
MODE_NORMAL,
MODE_KICK
}
// Mode of logging to a server
// 0 - disable logging, players won't be checked (and access won't be set)
// 1 - normal mode which obey flags set in accounts
// 2 - kick all players not on list
new Mode;
/**
* s - STEAM_ID
* i - IP
* n - NAME
* c - CASESENSITIVE
* t - CLAN TAG
*/
new SearchPriority[32];
new KickReason[64];
new PasswordField[10];
enum {
DefaultAccessCvar,
DefaultAccessFlags
}
enum (+=1) {
DefaultAccessPlayer = 0,
DefaultAccessHLTV,
DefaultAccessBOT,
DefaultAccessLast
}
new DefaultAccess[DefaultAccessLast][2];
enum (<<=1) {
STATE_DISCONNECTED = 1,
STATE_CONNECTING,
STATE_CONNECTED,
}
#define STATES_SET_ID 1
#define add_user_state(%1,%2) set_user_flags(%1, %2, STATES_SET_ID)
#define get_user_state(%1,%2) (get_user_flags(%1, STATES_SET_ID) & %2)
#define remove_user_state(%1,%2) remove_user_flags(%1, %2, STATES_SET_ID)
#define clear_user_state(%1) remove_user_flags(%1, -1, STATES_SET_ID)
#define clear_privilege() arrayset(Privilege, 0 , sizeof Privilege)
#define clear_user_privilege(%1) arrayset(UsersPrivilege[%1], 0 , sizeof UsersPrivilege[])
enum CheckResult {
CHECK_IGNORE,
CHECK_DEFAULT,
CHECK_SUCCESS,
CHECK_KICK,
};
enum _:PrivilegeStruct {
PrivilegeSource,
PrivilegeId,
PrivilegeAccess,
PrivilegeFlags,
PrivilegePassword[UAC_MAX_PASSWORD_LENGTH],
PrivilegePrefix[UAC_MAX_PREFIX_LENGTH],
PrivilegeExpired,
PrivilegeOptions
};
new PluginId;
new Trie:Privileges, Privilege[PrivilegeStruct];
new UsersPrivilege[MAX_PLAYERS + 1][PrivilegeStruct];
new Snapshot:PrivilegesSnapshot = Invalid_Snapshot, PrivilegesIterate = 0;
new bool:Loaded = false;
new bool:GMXLoaded = false, bool:UACLoading = false;
enum {
GMX_REQ_STATUS_ERROR = 0,
GMX_REQ_STATUS_OK = 1
};
enum AUTH_TYPE {
AUTH_TYPE_STEAM,
AUTH_TYPE_STEAM_AND_PASS,
AUTH_TYPE_NICK_AND_PASS,
AUTH_TYPE_STEAM_AND_HASH,
AUTH_TYPE_NICK_AND_HASH
};
enum _:GroupInfo {
GroupId,
GroupTitle[UAC_GROUP_MAX_TITLE_LENGTH],
GroupFlags,
GroupPriority,
GroupPrefix[UAC_MAX_PREFIX_LENGTH]
}
new Array:Groups = Invalid_Array, GroupsNum, Group[GroupInfo];
public plugin_init() {
PluginId = register_plugin("[UAC] Core", UAC_VERSION_STR, "GM-X Team");
register_concmd("dex_reloadadmins", "CmdReload", ADMIN_CVAR);
#if defined _reapi_included
RegisterHookChain(RG_CBasePlayer_SetClientUserInfoName, "CBasePlayer_SetClientUserInfoName_Post", true);
#elseif defined _fakemeta_included
register_forward(FM_SetClientKeyValue, "SetCleintKeyValue_Post", true);
#endif
new pcvar;
pcvar = create_cvar("dex_mode", "1", .has_min=true, .min_val=0.0, .has_max=true, .max_val=2.0);
bind_pcvar_num(pcvar, Mode);
pcvar = create_cvar("pmm_search_priority", "sinct");
bind_pcvar_string(pcvar, SearchPriority, charsmax(SearchPriority));
pcvar = create_cvar("dex_password_field", "_dex");
bind_pcvar_string(pcvar, PasswordField, charsmax(PasswordField));
DefaultAccess[DefaultAccessPlayer][DefaultAccessCvar] = create_cvar("dex_default_access", "z");
DefaultAccess[DefaultAccessHLTV][DefaultAccessCvar] = create_cvar("pmm_hltv_access", "a");
DefaultAccess[DefaultAccessBOT][DefaultAccessCvar] = create_cvar("pmm_bot_access", "a");
hook_cvar_change(DefaultAccess[DefaultAccessPlayer][DefaultAccessCvar], "CvarChangeAccess");
hook_cvar_change(DefaultAccess[DefaultAccessHLTV][DefaultAccessCvar], "CvarChangeAccess");
hook_cvar_change(DefaultAccess[DefaultAccessBOT][DefaultAccessCvar], "CvarChangeAccess");
Privileges = TrieCreate();
Forwards[FWD_Loading] = CreateMultiForward("UAC_Loading", ET_IGNORE);
Forwards[FWD_Loaded] = CreateMultiForward("UAC_Loaded", ET_IGNORE);
Forwards[FWD_Checking] = CreateMultiForward("UAC_Checking", ET_STOP, FP_CELL);
Forwards[FWD_Checked] = CreateMultiForward("UAC_Checked", ET_IGNORE, FP_CELL, FP_CELL);
Forwards[FWD_Pushing] = CreateMultiForward("UAC_Pushing", ET_IGNORE);
Forwards[FWD_Pushed] = CreateMultiForward("UAC_Pushed", ET_IGNORE);
loadStart();
}
public plugin_cfg() {
Mode = get_cvar_num("dex_mode");
for (new i = 0, flags[32]; i < DefaultAccessLast; i++) {
get_pcvar_string(DefaultAccess[i][DefaultAccessCvar], flags, charsmax(flags));
DefaultAccess[i][DefaultAccessFlags] = read_flags(flags);
}
checkAPIVersion();
#if defined LOG_ADMIN_ACTIVITY
new path[128];
get_localinfo("amxx_logs", path, charsmax(path));
add(path, charsmax(path), "/user-access-control");
if (!dir_exists(path)) {
mkdir(path);
}
new time[16];
get_time("/L%Y%m%d.log", time, charsmax(time));
add(path, charsmax(path), time);
new map[64];
get_mapname(map, charsmax(map));
LogFile = fopen(path, "at");
if (!LogFile) {
set_fail_state("Couldn't open %s for write. Check permissions.", path);
} else {
fprintf(LogFile, "Start of log session (map %s)", map);
}
#endif
}
public plugin_end() {
TrieDestroy(Privileges);
for (new i = 0; i < FWD_LAST; i++) {
DestroyForward(Forwards[i]);
}
if (PrivilegesSnapshot != Invalid_Snapshot) {
TrieSnapshotDestroy(PrivilegesSnapshot);
}
#if defined LOG_ADMIN_ACTIVITY
fclose(LogFile);
#endif
}
public CvarChangeAccess(const pcvar, const oldValue[], const newValue[]) {
for (new i = 0; i < DefaultAccessLast; i++) {
if (pcvar == DefaultAccess[i][DefaultAccessCvar]) {
DefaultAccess[i][DefaultAccessFlags] = read_flags(newValue);
break;
}
}
}
public CmdReload(id, level) {
if (~get_user_flags(id) & level) {
console_print(id, "You have no access to that command");
return PLUGIN_HANDLED;
}
TrieClear(Privileges);
NeedRecheck = true;
loadStart();
return PLUGIN_HANDLED;
}
public client_connect(id) {
if (Status == STATUS_LOADING) {
NeedRecheck = true;
}
clear_user_state(id);
clear_user_privilege(id);
remove_user_flags(id, -1);
}
public client_authorized(id) {
add_user_state(id, STATE_CONNECTING);
makeUserAccess(id, checkUserFlags(id));
}
public client_putinserver(id) {
if (get_user_state(id, STATE_CONNECTING)) {
remove_user_state(id, STATE_CONNECTING);
} else {
makeUserAccess(id, checkUserFlags(id));
}
add_user_state(id, STATE_CONNECTED);
}
public client_disconnected(id) {
clear_user_state(id);
add_user_state(id, STATE_DISCONNECTED);
remove_user_flags(id, -1);
set_user_flags(id, DefaultAccess[DefaultAccessPlayer][DefaultAccessFlags]);
}
public TaskLoadTimeout() {
loadFinish();
}
#if defined _reapi_included
public CBasePlayer_SetClientUserInfoName_Post(const id, const infobuffer[], const name[]) {
remove_user_flags(id, -1);
makeUserAccess(id, checkUserFlags(id, name));
}
#elseif defined _fakemeta_included
public SetCleintKeyValue_Post(const id, const infobuffer[], const key[], const value[]) {
if(strcmp(key, "name") == 0) {
remove_user_flags(id, -1);
makeUserAccess(id, checkUserFlags(id, value));
}
}
#else
public client_infochanged(id) {
if (!is_user_connected(id)) {
return PLUGIN_CONTINUE;
}
new oldname[MAX_NAME_LENGTH], newname[MAX_NAME_LENGTH];
get_user_name(id, oldname, charsmax(oldname));
get_user_info(id, "name", newname, charsmax(newname));
if (strcmp(oldname, newname) != 0) {
remove_user_flags(id, -1);
makeUserAccess(id, checkUserFlags(id, newname));
}
return PLUGIN_CONTINUE;
}
#endif
loadStart() {
Status = STATUS_LOADING;
PluginLoadedNum = 0;
for (new i = 0; i < sizeof LoadStatusList; i++) {
arrayset(LoadStatusList[i], 0, sizeof LoadStatusList[]);
}
LoadStatusNum = 0;
ExecuteForward(Forwards[FWD_Loading], FReturn);
set_task(5.0, "TaskLoadTimeout", TIMEOUT_TASK_ID);
}
loadFinish() {
Status = STATUS_LOADED;
if (NeedRecheck) {
for (new player = 1; player <= MaxClients; player++) {
if (is_user_connected(player)) {
makeUserAccess(player, checkUserFlags(player));
}
}
}
if (PrivilegesSnapshot != Invalid_Snapshot) {
TrieSnapshotDestroy(PrivilegesSnapshot);
}
PrivilegesSnapshot = TrieSnapshotCreate(Privileges);
ExecuteForward(Forwards[FWD_Loaded], FReturn);
}
makeUserAccess(const id, CheckResult:result) {
switch (result) {
case CHECK_DEFAULT: {
remove_user_flags(id);
if (is_user_bot(id)) {
set_user_flags(id, DefaultAccess[DefaultAccessBOT][DefaultAccessFlags]);
} else {
set_user_flags(id, DefaultAccess[DefaultAccessPlayer][DefaultAccessFlags]);
}
}
case CHECK_SUCCESS: {
remove_user_flags(id);
set_user_flags(id, Privilege[PrivilegeAccess]);
UsersPrivilege[id] = Privilege;
printConsole(id, "* Privileges set");
}
case CHECK_KICK: {
server_cmd("kick #%d ^"%s^"", get_user_userid(id), KickReason);
}
}
ExecuteForward(Forwards[FWD_Checked], FReturn, id, result);
}
CheckResult:checkUserFlags(const id, const name[] = "") {
ExecuteForward(Forwards[FWD_Checking], FReturn, id);
if (FReturn == PLUGIN_HANDLED) {
return CHECK_IGNORE;
}
if (Mode == MODE_DISABLE) {
return CHECK_IGNORE;
}
if (is_user_hltv(id)) {
set_user_flags(id, DefaultAccess[DefaultAccessHLTV][DefaultAccessFlags]);
return CHECK_IGNORE;
}
if (is_user_bot(id)) {
return CHECK_DEFAULT;
}
#define MAX_AUTH_LENGTH 32
new auth[MAX_AUTH_LENGTH], key[MAX_KEY_LENGTH], i = 0, flags, CheckResult:result = CHECK_DEFAULT;
do {
switch (SearchPriority[i]) {
case 's': {
get_user_authid(id, auth, charsmax(auth));
flags = FLAG_AUTHID;
}
case 'i': {
get_user_ip(id, auth, charsmax(auth), 1);
flags = FLAG_IP;
}
case 'n', 'c': {
if (name[0] != EOS) {
copy(auth, charsmax(auth), name);
} else {
get_user_name(id, auth, charsmax(auth));
}
if (SearchPriority[i] == 'c') {
strtolower(auth);
flags = FLAG_CASE_SENSITIVE;
} else {
flags = 0;
}
}
default: {
flags = -1;
}
}
if (flags == -1) {
continue;
}
makeKey(auth, flags, key, charsmax(key));
if (TrieKeyExists(Privileges, key)) {
TrieGetArray(Privileges, key, Privilege, sizeof Privilege);
new CheckResult:checked = setUserAccess(id);
if (checked > result) {
result = checked;
}
}
} while (SearchPriority[++i] != EOS);
if (Mode == MODE_KICK && result == CHECK_DEFAULT) {
KickReason = "You have no entry to the server...";
return CHECK_KICK;
}
return result;
}
CheckResult:setUserAccess(const id) {
if (Privilege[PrivilegeFlags] & FLAG_NOPASS) {
return CHECK_SUCCESS;
} else {
new password[UAC_MAX_PASSWORD_LENGTH];
if (Privilege[PrivilegeOptions] & UAC_OPTIONS_MD5) {
new infoPass[40];
get_user_info(id, PasswordField, infoPass, charsmax(infoPass));
hash_string(infoPass, Hash_Md5, password, charsmax(password));
} else {
get_user_info(id, PasswordField, password, charsmax(password));
}
if (strcmp(password, Privilege[PrivilegePassword]) == 0) {
return CHECK_SUCCESS;
} else if (Privilege[PrivilegeFlags] & FLAG_KICK) {
KickReason = "Invalid Password!";
return CHECK_KICK;
} else {
return CHECK_DEFAULT;
}
}
}
makeKey(const auth[], const flags, key[], len) {
if (flags & FLAG_AUTHID) {
formatex(key, len, "s%s", auth);
} else if (flags & FLAG_IP) {
formatex(key, len, "i%s", auth);
} else if (flags & FLAG_CASE_SENSITIVE) {
formatex(key, len, "c%s", auth);
strtolower(key);
} else {
formatex(key, len, "n%s", auth);
}
}
getLoadStatus(const source) {
for (new i = 0; i < LoadStatusNum; i++) {
if (LoadStatusList[i][LoadSource] == source) {
return i;
}
}
return -1;
}
getLoadStatusCount(const bool:loaded = true) {
new result = 0;
for (new i = 0; i < LoadStatusNum; i++) {
if (LoadStatusList[LoadStatusNum][LoadLoaded] == loaded) {
result++;
}
}
return result;
}
printConsole(id, const msg[]) {
message_begin(MSG_ONE, SVC_PRINT, .player = id);
write_string(msg);
message_end();
}
// NATIVES
public plugin_natives() {
register_native("UAC_Push", "NativePush", 0);
register_native("UAC_StartLoad", "NativeStartLoad", 0);
register_native("UAC_FinishLoad", "NativeFinishLoad", 0);
register_native("UAC_GetSource", "NativeGetSource", 0);
register_native("UAC_GetId", "NativeGetId", 0);
register_native("UAC_GetAccess", "NativeGetAccess", 0);
register_native("UAC_GetFlags", "NativeGetFlags", 0);
register_native("UAC_GetPassword", "NativeGetPassword", 0);
register_native("UAC_GetPrefix", "NativeGetPrefix", 0);
register_native("UAC_GetExpired", "NativeGetExpired", 0);
register_native("UAC_SetAccess", "NativeSetAccess", 0);
register_native("UAC_GetOptions", "NativeGetOptions", 0);
register_native("UAC_CheckPlayer", "NativeCheckPlayer", 0);
register_native("UAC_IterReset", "NativeIterReset", 0);
register_native("UAC_IterEnded", "NativeIterEnded", 0);
register_native("UAC_IterNext", "NativeIterNext", 0);
register_native("UAC_GetPlayerPrivilege", "NativeGetPlayerPrivilege", 0);
register_native("UAC_GetPlayerExpired", "NativeGetPlayerExpired", 0);
}
public NativeStartLoad(plugin) {
if (Status == STATUS_LOADED) {
return 0;
}
LoadStatusList[LoadStatusNum][LoadSource] = plugin;
LoadStatusList[LoadStatusNum][LoadLoaded] = false;
LoadStatusNum++;
log_amx("Loading privileges");
return 1;
}
public NativeFinishLoad(plugin) {
if (Status == STATUS_LOADED) {
return 0;
}
new status = getLoadStatus(plugin);
if (status == -1) {
return 0;
}
LoadStatusList[status][LoadLoaded] = true;
log_amx("Loaded %d privileges", PluginLoadedNum);
PluginLoadedNum = 0;
if (getLoadStatusCount(true) != LoadStatusNum) {
return 1;
}
remove_task(TIMEOUT_TASK_ID);
loadFinish();
return 1;
}
public NativePush(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 8, 0)
enum { arg_id = 1, arg_auth, arg_password, arg_access, arg_flags, arg_prefix, arg_expired, arg_options };
clear_privilege();
new auth[MAX_AUTHID_LENGTH], key[MAX_KEY_LENGTH];
Privilege[PrivilegeSource] = plugin;
Privilege[PrivilegeId] = get_param(arg_id);
get_string(arg_auth, auth, charsmax(auth));
get_string(arg_password, Privilege[PrivilegePassword], charsmax(Privilege[PrivilegePassword]));
Privilege[PrivilegeAccess] = get_param(arg_access);
Privilege[PrivilegeFlags] = get_param(arg_flags);
get_string(arg_prefix, Privilege[PrivilegePrefix], charsmax(Privilege[PrivilegePrefix]));
Privilege[PrivilegeExpired] = get_param(arg_expired);
Privilege[PrivilegeOptions] = get_param(arg_options);
makeKey(auth, Privilege[PrivilegeFlags], key, charsmax(key));
TrieSetArray(Privileges, key, Privilege, sizeof Privilege);
PluginLoadedNum++;
if (Status == STATUS_LOADED) {
if (PrivilegesSnapshot != Invalid_Snapshot) {
TrieSnapshotDestroy(PrivilegesSnapshot);
}
PrivilegesSnapshot = TrieSnapshotCreate(Privileges);
}
return 1;
}
public NativeGetSource(plugin, argc) {
return Privilege[PrivilegeSource];
}
public NativeGetId(plugin, argc) {
return Privilege[PrivilegeId];
}
public NativeGetAccess(plugin, argc) {
return Privilege[PrivilegeAccess];
}
public NativeGetFlags(plugin, argc) {
return Privilege[PrivilegeFlags];
}
public NativeGetPassword(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 2, 0)
enum { arg_dest = 1, arg_length };
return set_string(arg_dest, Privilege[PrivilegePassword], get_param(arg_length));
}
public NativeGetPrefix(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 2, 0)
enum { arg_dest = 1, arg_length };
return set_string(arg_dest, Privilege[PrivilegePrefix], get_param(arg_length));
}
public NativeGetExpired(plugin, argc) {
return Privilege[PrivilegeExpired];
}
public NativeGetOptions(plugin, argc) {
return Privilege[PrivilegeOptions];
}
public NativeSetAccess(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 1, 0)
enum { arg_access = 1 };
Privilege[PrivilegeAccess] = get_param(arg_access);
return 1;
}
public CheckResult:NativeCheckPlayer(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 1, CHECK_IGNORE)
enum { arg_player = 1 };
new player = get_param(arg_player);
CHECK_NATIVE_PLAYER(player, CHECK_IGNORE)
remove_user_flags(player, -1);
new CheckResult:result = checkUserFlags(player);
makeUserAccess(player, result);
return result;
}
public NativeIterReset(plugin, argc) {
PrivilegesIterate = 0;
return 1;
}
public bool:NativeIterEnded(plugin, argc) {
return bool:(PrivilegesIterate >= TrieSnapshotLength(PrivilegesSnapshot) - 1);
}
public NativeIterNext(plugin, argc) {
PrivilegesIterate++;
new key[MAX_KEY_LENGTH];
TrieSnapshotGetKey(PrivilegesSnapshot, PrivilegesIterate, key, charsmax(key));
TrieGetArray(Privileges, key, Privilege, sizeof Privilege);
return 1;
}
public NativeGetPlayerPrivilege(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 1, 0)
enum { arg_player = 1 };
new player = get_param(arg_player);
CHECK_NATIVE_PLAYER(player, 0)
Privilege = UsersPrivilege[player];
return 1;
}
public NativeGetPlayerExpired(plugin, argc) {
CHECK_NATIVE_ARGS_NUM(argc, 1, -1)
enum { arg_player = 1 };
new player = get_param(arg_player);
CHECK_NATIVE_PLAYER(player, -1)
return UsersPrivilege[player][PrivilegeExpired];
}
checkAPIVersion() {
for(new i, n = get_pluginsnum(), status[2], func; i < n; i++) {
if(i == PluginId) {
continue;
}
get_plugin(i, .status = status, .len5 = charsmax(status));
//status debug || status running
if(status[0] != 'd' && status[0] != 'r') {
continue;
}
func = get_func_id("__uac_version_check", i);
if(func == -1) {
continue;
}
if(callfunc_begin_i(func, i) == 1) {
callfunc_push_int(UAC_MAJOR_VERSION);
callfunc_push_int(UAC_MINOR_VERSION);
callfunc_end();
}
}
}
#if defined LOG_ADMIN_ACTIVITY
public UAC_Checked(const id, const UAC_CheckResult:found) {
if (found != UAC_CHECK_SUCCESS) {
return;
}
new name[MAX_NAME_LENGTH], steamid[MAX_AUTHID_LENGTH], ip[MAX_IP_LENGTH], access[32], prefix[UAC_MAX_PREFIX_LENGTH], expired[32];
get_user_name(id, name, charsmax(name));
get_user_authid(id, steamid, charsmax(steamid));
get_user_ip(id, ip, charsmax(ip), 1);
get_flags(UAC_GetAccess(), access, charsmax(access));
UAC_GetPrefix(prefix, charsmax(prefix));
if (UAC_GetExpired() > 0) {
format_time(expired, charsmax(expired), "%d.%m.%Y - %H:%M:%S", UAC_GetExpired());
} else {
expired = "never";
}
fprintf(
LogFile,
"Player '%s' (steamid '%s')(ip '%s') became an admin (access ^"%s^") (prefix ^"%s^") (id %d) (expires %s)^n",
name, steamid, ip, access, prefix, UAC_GetId(), expired
);
server_print(
"Player '%s' (steamid '%s')(ip '%s') became an admin (access ^"%s^") (prefix ^"%s^") (id %d) (expires %s)",
name, steamid, ip, access, prefix, UAC_GetId(), expired
);
}
#endif
#if defined LOAD_USERS_INI
public UAC_Loading() {
UAC_StartLoad();
new fileName[128];
get_localinfo("amxx_configsdir", fileName, charsmax(fileName));
add(fileName, charsmax(fileName), "/users.ini");
new file = fopen(fileName, "rt");
if (!file) {
UAC_FinishLoad();
return;
}
new line[512], semicolonPos = 0;
new sysTime = get_systime();
new id = 0;
new auth[MAX_AUTHID_LENGTH], password[UAC_MAX_PASSWORD_LENGTH], access[32], flags[32], expired[32], staticBanTime[2], expiredTime, options;
while (!feof(file)) {
arrayset(line, 0, sizeof line);
fgets(file, line, charsmax(line));
if ((semicolonPos = contain(line, ";")) > 0) {
line[semicolonPos] = EOS;
}
trim(line);
id++;
if (line[0] == EOS || line[0]==';') {
continue;
}
arrayset(auth, 0, sizeof auth);
arrayset(password, 0, sizeof password);
arrayset(access, 0, sizeof access);
arrayset(flags, 0, sizeof flags);
arrayset(expired, 0, sizeof expired);
arrayset(staticBanTime, 0, sizeof staticBanTime);
if (parse(line, auth, charsmax(auth), password, charsmax(password), access, charsmax(access), flags, charsmax(flags),
staticBanTime, charsmax(staticBanTime), expired, charsmax(expired)) < 4) {
continue;
}
options = 0;
if (!staticBanTime[0] || str_to_num(staticBanTime)) {
options |= UAC_OPTIONS_STATIC_BANTIME;
}
expiredTime = expired[0] != EOS && strcmp(expired, "0") != 0 ? parse_time(expired, "%d.%m.%Y") : 0;
new hashFile = 1;
if (hashFile == 1 || (hashFile == 2 && isMD5(password))) {
options |= UAC_OPTIONS_MD5;
}
if (expiredTime == 0 || expiredTime > sysTime) {
UAC_Push(id, auth, password, read_flags(access), read_flags(flags), "", expiredTime, options);
}
}
fclose(file);
UAC_FinishLoad();
}
stock bool:isMD5(const value[]) {
new len = strlen(value);
if (len != 32) {
return false;
}
for (new i = 0; i < len; i++) {
if (!('0' <= value[i] <= '9') && !('a' <= value[i] <= 'f') && !('A' <= value[i] <= 'F')) {
return false;
}
}
return true;
}
#endif
public GMX_CfgLoaded() {
if (GMXLoaded) {
return;
}
GMXLoaded = true;
if (!UACLoading) {
return;
}
GMX_MakeRequest("server/privileges", Invalid_GripJSONValue, "OnResponse");
UACLoading = false;
}
public UAC_Loading() {
UAC_StartLoad();
UACLoading = true;
new bool:needRequest = true, GripJSONValue:data;
if (!Loaded && GMX_CacheLoad("privileges", data)) {
needRequest = !parseData(data);
grip_destroy_json_value(data);
Loaded = true;
}
if (!needRequest) {
UAC_FinishLoad();
} else if (GMXLoaded) {
GMX_MakeRequest("server/privileges", Invalid_GripJSONValue, "OnResponse");
} else {
UACLoading = true;
}
}
public OnResponse(const GmxResponseStatus:status, const GripJSONValue:data) {
if (status != GmxResponseStatusOk) {
UAC_FinishLoad();
return;
}
parseData(data);
GMX_CacheSave("privileges", data);
UAC_FinishLoad();
}
bool:parseData(const GripJSONValue:data) {
if (grip_json_get_type(data) != GripJSONObject) {
return false;
}
new GripJSONValue:tmp;
tmp = grip_json_object_get_value(data, "groups");
parseGroups(tmp);
grip_destroy_json_value(tmp);
tmp = grip_json_object_get_value(data, "privileges");
parsePrivileges(tmp);
grip_destroy_json_value(tmp);
return true;
}
parseGroups(const GripJSONValue:data) {
if (Groups == Invalid_Array) {
Groups = ArrayCreate(GroupInfo, 1);
} else {
ArrayClear(Groups);
}
for (new i = 0, n = grip_json_array_get_count(data), GripJSONValue:tmp; i < n; i++) {
tmp = grip_json_array_get_value(data, i);
if (grip_json_get_type(tmp) == GripJSONObject) {
arrayset(Group, 0, sizeof Group);
Group[GroupId] = grip_json_object_get_number(tmp, "id");
grip_json_object_get_string(tmp, "title", Group[GroupTitle], charsmax(Group[GroupTitle]));
Group[GroupFlags] = grip_json_object_get_number(tmp, "flags");
Group[GroupPriority] = grip_json_object_get_number(tmp, "priority");
new GripJSONValue:prefix = grip_json_object_get_value(tmp, "prefix");
if (grip_json_get_type(prefix) != GripJSONNull) {
grip_json_get_string(prefix, Group[GroupPrefix], charsmax(Group[GroupPrefix]));
}
grip_destroy_json_value(prefix);
ArrayPushArray(Groups, Group, sizeof Group);
}
grip_destroy_json_value(tmp);
}
GroupsNum = ArraySize(Groups);
}
parsePrivileges(const GripJSONValue:data) {
new now = get_systime(0);
new id, auth[MAX_AUTHID_LENGTH], password[UAC_MAX_PASSWORD_LENGTH], access, flags, expired, prefix[UAC_MAX_PREFIX_LENGTH], options, authTypeStr[32];
for (new i = 0, n = grip_json_array_get_count(data), GripJSONValue:tmp, GripJSONValue:passwordValue, GripJSONValue:prefixValue; i < n; i++) {
tmp = grip_json_array_get_value(data, i);
if (grip_json_get_type(tmp) != GripJSONObject) {
grip_destroy_json_value(tmp);
continue;
}
arrayset(auth, 0, sizeof auth);
arrayset(password, 0, sizeof password);
arrayset(prefix, 0, sizeof prefix);
access = 0;
flags = 0;
expired = 0;
options = 0;
id = grip_json_object_get_number(tmp, "id");
passwordValue = grip_json_object_get_value(tmp, "password");
if (grip_json_get_type(passwordValue) != GripJSONNull) {
grip_json_get_string(passwordValue, password, charsmax(password));
}
grip_destroy_json_value(passwordValue);
prefixValue = grip_json_object_get_value(tmp, "prefix");
if (grip_json_get_type(prefixValue) != GripJSONNull) {
grip_json_get_string(prefixValue, prefix, charsmax(prefix));
}
grip_destroy_json_value(prefixValue);
grip_json_object_get_string(tmp, "auth_type", authTypeStr, charsmax(authTypeStr));
switch (getAuthType(authTypeStr)) {
case AUTH_TYPE_STEAM: {
flags |= FLAG_AUTHID | FLAG_NOPASS;
grip_json_object_get_string(tmp, "steamid", auth, charsmax(auth));
}
case AUTH_TYPE_STEAM_AND_PASS: {
flags |= FLAG_AUTHID | FLAG_KICK;
grip_json_object_get_string(tmp, "steamid", auth, charsmax(auth));
options |= UAC_OPTIONS_MD5;
}
case AUTH_TYPE_NICK_AND_PASS: {
flags |= FLAG_KICK;
grip_json_object_get_string(tmp, "nick", auth, charsmax(auth));
options |= UAC_OPTIONS_MD5;
}
}
new GripJSONValue:privileges = grip_json_object_get_value(tmp, "privileges");
for (new j = 0, k = grip_json_array_get_count(privileges), GripJSONValue:privilege, GripJSONValue:expiredVal, group_id, priority = -1; j < k; j++) {
privilege = grip_json_array_get_value(privileges, j);
group_id = grip_json_object_get_number(privilege, "group_id");
if (!getGroup(group_id)) {
grip_destroy_json_value(privilege);
continue;
}
access |= Group[GroupFlags];
if (Group[GroupPriority] > priority) {
priority = Group[GroupPriority];
expiredVal = grip_json_object_get_value(privilege, "expired_at");
expired = grip_json_get_type(expiredVal) != GripJSONNull ? grip_json_get_number(expiredVal) : 0;
grip_destroy_json_value(expiredVal);
if (prefix[0] == EOS) {
copy(prefix, charsmax(prefix), Group[GroupPrefix]);
}
}
grip_destroy_json_value(privilege);
}
grip_destroy_json_value(privileges);
if (expired == 0 || expired >= now) {
UAC_Push(id, auth, password, access, flags, prefix, expired, options);
}
grip_destroy_json_value(tmp);
}
}
AUTH_TYPE:getAuthType(const authType[]) {
if (strcmp(authType, "steamid_pass") == 0) {
return AUTH_TYPE_STEAM_AND_PASS;
} else if (strcmp(authType, "nick_pass") == 0) {
return AUTH_TYPE_NICK_AND_PASS;
} else if (strcmp(authType, "steamid_hash") == 0) {
return AUTH_TYPE_STEAM_AND_HASH;
} else if (strcmp(authType, "nick_hash") == 0) {
return AUTH_TYPE_NICK_AND_HASH;
} else {
return AUTH_TYPE_STEAM;
}
}
bool:getGroup(const id) {
if (id == 0) {
return false;
}
for (new i = 0; i < GroupsNum; i++) {
if (ArrayGetArray(Groups, i, Group, sizeof Group) && Group[GroupId] == id) {
return true;
}
}
return false;
}
Last edited by DJBosma; 03-31-2020 at 17:42.
|
|
Linear Mode
