X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=builtin%2Fgame%2Fauth.lua;h=46fe3d342778c50e15dac1d681ac7929a543a45d;hb=a1346c916e1d0f0cde2ccecc680857896c717a3d;hp=b6cca609c8619e36935664e5b1d2853ab65d85dc;hpb=1cd512913e4d4ad1fb43d4b6e3d7971bb6c67528;p=minetest.git diff --git a/builtin/game/auth.lua b/builtin/game/auth.lua index b6cca609c..46fe3d342 100644 --- a/builtin/game/auth.lua +++ b/builtin/game/auth.lua @@ -4,80 +4,84 @@ -- Authentication handler -- -function minetest.string_to_privs(str, delim) +function core.string_to_privs(str, delim) assert(type(str) == "string") delim = delim or ',' - privs = {} + local privs = {} for _, priv in pairs(string.split(str, delim)) do privs[priv:trim()] = true end return privs end -function minetest.privs_to_string(privs, delim) +function core.privs_to_string(privs, delim) assert(type(privs) == "table") delim = delim or ',' - list = {} + local list = {} for priv, bool in pairs(privs) do if bool then - table.insert(list, priv) + list[#list + 1] = priv end end return table.concat(list, delim) end -assert(minetest.string_to_privs("a,b").b == true) -assert(minetest.privs_to_string({a=true,b=true}) == "a,b") +assert(core.string_to_privs("a,b").b == true) +assert(core.privs_to_string({a=true,b=true}) == "a,b") -minetest.auth_file_path = minetest.get_worldpath().."/auth.txt" -minetest.auth_table = {} +core.auth_file_path = core.get_worldpath().."/auth.txt" +core.auth_table = {} local function read_auth_file() local newtable = {} - local file, errmsg = io.open(minetest.auth_file_path, 'rb') + local file, errmsg = io.open(core.auth_file_path, 'rb') if not file then - minetest.log("info", minetest.auth_file_path.." could not be opened for reading ("..errmsg.."); assuming new world") + core.log("info", core.auth_file_path.." could not be opened for reading ("..errmsg.."); assuming new world") return end for line in file:lines() do if line ~= "" then - local name, password, privilegestring = string.match(line, "([^:]*):([^:]*):([^:]*)") - if not name or not password or not privilegestring then + local fields = line:split(":", true) + local name, password, privilege_string, last_login = unpack(fields) + last_login = tonumber(last_login) + if not (name and password and privilege_string) then error("Invalid line in auth.txt: "..dump(line)) end - local privileges = minetest.string_to_privs(privilegestring) - newtable[name] = {password=password, privileges=privileges} + local privileges = core.string_to_privs(privilege_string) + newtable[name] = {password=password, privileges=privileges, last_login=last_login} end end io.close(file) - minetest.auth_table = newtable - minetest.notify_authentication_modified() + core.auth_table = newtable + core.notify_authentication_modified() end local function save_auth_file() local newtable = {} -- Check table for validness before attempting to save - for name, stuff in pairs(minetest.auth_table) do + for name, stuff in pairs(core.auth_table) do assert(type(name) == "string") assert(name ~= "") assert(type(stuff) == "table") assert(type(stuff.password) == "string") assert(type(stuff.privileges) == "table") + assert(stuff.last_login == nil or type(stuff.last_login) == "number") end - local file, errmsg = io.open(minetest.auth_file_path, 'w+b') + local file, errmsg = io.open(core.auth_file_path, 'w+b') if not file then - error(minetest.auth_file_path.." could not be opened for writing: "..errmsg) + error(core.auth_file_path.." could not be opened for writing: "..errmsg) end - for name, stuff in pairs(minetest.auth_table) do - local privstring = minetest.privs_to_string(stuff.privileges) - file:write(name..":"..stuff.password..":"..privstring..'\n') + for name, stuff in pairs(core.auth_table) do + local priv_string = core.privs_to_string(stuff.privileges) + local parts = {name, stuff.password, priv_string, stuff.last_login or ""} + file:write(table.concat(parts, ":").."\n") end io.close(file) end read_auth_file() -minetest.builtin_auth_handler = { +core.builtin_auth_handler = { get_auth = function(name) assert(type(name) == "string") -- Figure out what password to use for a new player (singleplayer @@ -85,52 +89,55 @@ minetest.builtin_auth_handler = { -- usually empty too) local new_password_hash = "" -- If not in authentication table, return nil - if not minetest.auth_table[name] then + if not core.auth_table[name] then return nil end -- Figure out what privileges the player should have. -- Take a copy of the privilege table local privileges = {} - for priv, _ in pairs(minetest.auth_table[name].privileges) do + for priv, _ in pairs(core.auth_table[name].privileges) do privileges[priv] = true end -- If singleplayer, give all privileges except those marked as give_to_singleplayer = false - if minetest.is_singleplayer() then - for priv, def in pairs(minetest.registered_privileges) do + if core.is_singleplayer() then + for priv, def in pairs(core.registered_privileges) do if def.give_to_singleplayer then privileges[priv] = true end end -- For the admin, give everything - elseif name == minetest.setting_get("name") then - for priv, def in pairs(minetest.registered_privileges) do + elseif name == core.setting_get("name") then + for priv, def in pairs(core.registered_privileges) do privileges[priv] = true end end -- All done return { - password = minetest.auth_table[name].password, + password = core.auth_table[name].password, privileges = privileges, + -- Is set to nil if unknown + last_login = core.auth_table[name].last_login, } end, create_auth = function(name, password) assert(type(name) == "string") assert(type(password) == "string") - minetest.log('info', "Built-in authentication handler adding player '"..name.."'") - minetest.auth_table[name] = { + core.log('info', "Built-in authentication handler adding player '"..name.."'") + core.auth_table[name] = { password = password, - privileges = minetest.string_to_privs(minetest.setting_get("default_privs")), + privileges = core.string_to_privs(core.setting_get("default_privs")), + last_login = os.time(), } save_auth_file() end, set_password = function(name, password) assert(type(name) == "string") assert(type(password) == "string") - if not minetest.auth_table[name] then - minetest.builtin_auth_handler.create_auth(name, password) + if not core.auth_table[name] then + core.builtin_auth_handler.create_auth(name, password) else - minetest.log('info', "Built-in authentication handler setting password of player '"..name.."'") - minetest.auth_table[name].password = password + core.log('info', "Built-in authentication handler setting password of player '"..name.."'") + core.auth_table[name].password = password save_auth_file() end return true @@ -138,51 +145,73 @@ minetest.builtin_auth_handler = { set_privileges = function(name, privileges) assert(type(name) == "string") assert(type(privileges) == "table") - if not minetest.auth_table[name] then - minetest.builtin_auth_handler.create_auth(name, minetest.get_password_hash(name, minetest.setting_get("default_password"))) + if not core.auth_table[name] then + core.builtin_auth_handler.create_auth(name, + core.get_password_hash(name, + core.setting_get("default_password"))) end - minetest.auth_table[name].privileges = privileges - minetest.notify_authentication_modified(name) + core.auth_table[name].privileges = privileges + core.notify_authentication_modified(name) save_auth_file() end, reload = function() read_auth_file() return true end, + record_login = function(name) + assert(type(name) == "string") + assert(core.auth_table[name]).last_login = os.time() + save_auth_file() + end, } -function minetest.register_authentication_handler(handler) - if minetest.registered_auth_handler then - error("Add-on authentication handler already registered by "..minetest.registered_auth_handler_modname) +function core.register_authentication_handler(handler) + if core.registered_auth_handler then + error("Add-on authentication handler already registered by "..core.registered_auth_handler_modname) end - minetest.registered_auth_handler = handler - minetest.registered_auth_handler_modname = minetest.get_current_modname() + core.registered_auth_handler = handler + core.registered_auth_handler_modname = core.get_current_modname() + handler.mod_origin = core.registered_auth_handler_modname end -function minetest.get_auth_handler() - if minetest.registered_auth_handler then - return minetest.registered_auth_handler - end - return minetest.builtin_auth_handler +function core.get_auth_handler() + return core.registered_auth_handler or core.builtin_auth_handler end -function minetest.set_player_password(name, password) - if minetest.get_auth_handler().set_password then - minetest.get_auth_handler().set_password(name, password) +local function auth_pass(name) + return function(...) + local auth_handler = core.get_auth_handler() + if auth_handler[name] then + return auth_handler[name](...) + end + return false end end -function minetest.set_player_privs(name, privs) - if minetest.get_auth_handler().set_privileges then - minetest.get_auth_handler().set_privileges(name, privs) - end -end +core.set_player_password = auth_pass("set_password") +core.set_player_privs = auth_pass("set_privileges") +core.auth_reload = auth_pass("reload") -function minetest.auth_reload() - if minetest.get_auth_handler().reload then - return minetest.get_auth_handler().reload() - end - return false -end +local record_login = auth_pass("record_login") + +core.register_on_joinplayer(function(player) + record_login(player:get_player_name()) +end) +core.register_on_prejoinplayer(function(name, ip) + local auth = core.auth_table + if auth[name] ~= nil then + return + end + + local name_lower = name:lower() + for k in pairs(auth) do + if k:lower() == name_lower then + return string.format("\nCannot create new player called '%s'. ".. + "Another account called '%s' is already registered. ".. + "Please check the spelling if it's your account ".. + "or use a different nickname.", name, k) + end + end +end)