* Load client-side mods into memory before executing them.
This removes the remaining filesystem access that client-sided mods had and it will hopefully make then more secure.
* Lua Virtual filesystem: don't load the files into memory just scan the filenames into memory.
* Fix the issues with backtrace
* fix most of the issues
* fix code style.
* add a comment
-- Minetest: builtin/client/init.lua
-local scriptpath = core.get_builtin_path()..DIR_DELIM
+local scriptpath = core.get_builtin_path()
local clientpath = scriptpath.."client"..DIR_DELIM
local commonpath = scriptpath.."common"..DIR_DELIM
-local scriptpath = core.get_builtin_path()..DIR_DELIM
+local scriptpath = core.get_builtin_path()
local commonpath = scriptpath.."common"..DIR_DELIM
local gamepath = scriptpath.."game"..DIR_DELIM
minetest = core
-- Load other files
-local scriptdir = core.get_builtin_path() .. DIR_DELIM
+local scriptdir = core.get_builtin_path()
local gamepath = scriptdir .. "game" .. DIR_DELIM
local clientpath = scriptdir .. "client" .. DIR_DELIM
local commonpath = scriptdir .. "common" .. DIR_DELIM
-- read_all: whether to ignore certain setting types for GUI or not
-- parse_mods: whether to parse settingtypes.txt in mods and games
local function parse_config_file(read_all, parse_mods)
- local builtin_path = core.get_builtin_path() .. DIR_DELIM .. FILENAME
+ local builtin_path = core.get_builtin_path() .. FILENAME
local file = io.open(builtin_path, "r")
local settings = {}
if not file then
-- Generate minetest.conf.example and settings_translation_file.cpp
---assert(loadfile(core.get_builtin_path()..DIR_DELIM.."mainmenu"..DIR_DELIM.."generate_from_settingtypes.lua"))(parse_config_file(true, false))
+--assert(loadfile(core.get_builtin_path().."mainmenu"..DIR_DELIM.."generate_from_settingtypes.lua"))(parse_config_file(true, false))
defaulttexturedir = core.get_texturepath_share() .. DIR_DELIM .. "base" ..
DIR_DELIM .. "pack" .. DIR_DELIM
-dofile(basepath .. DIR_DELIM .. "common" .. DIR_DELIM .. "async_event.lua")
-dofile(basepath .. DIR_DELIM .. "common" .. DIR_DELIM .. "filterlist.lua")
-dofile(basepath .. DIR_DELIM .. "fstk" .. DIR_DELIM .. "buttonbar.lua")
-dofile(basepath .. DIR_DELIM .. "fstk" .. DIR_DELIM .. "dialog.lua")
-dofile(basepath .. DIR_DELIM .. "fstk" .. DIR_DELIM .. "tabview.lua")
-dofile(basepath .. DIR_DELIM .. "fstk" .. DIR_DELIM .. "ui.lua")
+dofile(basepath .. "common" .. DIR_DELIM .. "async_event.lua")
+dofile(basepath .. "common" .. DIR_DELIM .. "filterlist.lua")
+dofile(basepath .. "fstk" .. DIR_DELIM .. "buttonbar.lua")
+dofile(basepath .. "fstk" .. DIR_DELIM .. "dialog.lua")
+dofile(basepath .. "fstk" .. DIR_DELIM .. "tabview.lua")
+dofile(basepath .. "fstk" .. DIR_DELIM .. "ui.lua")
dofile(menupath .. DIR_DELIM .. "common.lua")
dofile(menupath .. DIR_DELIM .. "gamemgr.lua")
dofile(menupath .. DIR_DELIM .. "modmgr.lua")
return val
end
-local profiler_path = core.get_builtin_path()..DIR_DELIM.."profiler"..DIR_DELIM
+local profiler_path = core.get_builtin_path().."profiler"..DIR_DELIM
local profiler = {}
local sampler = assert(loadfile(profiler_path .. "sampling.lua"))(profiler)
local instrumentation = assert(loadfile(profiler_path .. "instrumentation.lua"))(profiler, sampler, get_bool_default)
--- /dev/null
+print("Loaded example file!, loading more examples")
+dofile("preview:examples/first.lua")
--- /dev/null
+print("loaded first.lua example file")
local modname = core.get_current_modname() or "??"
local modstorage = core.get_mod_storage()
+dofile("preview:example.lua")
-- This is an example function to ensure it's working properly, should be removed before merge
core.register_on_shutdown(function()
print("[PREVIEW] shutdown client")
m_script->setEnv(&m_env);
}
-void Client::initMods()
+void Client::loadMods()
{
- m_script->loadMod(getBuiltinLuaPath() + DIR_DELIM "init.lua", BUILTIN_MOD_NAME);
+ // Load builtin
+ scanModIntoMemory(BUILTIN_MOD_NAME, getBuiltinLuaPath());
// If modding is not enabled, don't load mods, just builtin
if (!m_modding_enabled) {
return;
}
-
ClientModConfiguration modconf(getClientModsLuaPath());
- std::vector<ModSpec> mods = modconf.getMods();
+ m_mods = modconf.getMods();
std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
// complain about mods with unsatisfied dependencies
if (!modconf.isConsistent()) {
// Print mods
infostream << "Client Loading mods: ";
- for (std::vector<ModSpec>::const_iterator i = mods.begin();
- i != mods.end(); ++i) {
- infostream << (*i).name << " ";
- }
-
+ for (const ModSpec &mod : m_mods)
+ infostream << mod.name << " ";
infostream << std::endl;
+
// Load and run "mod" scripts
- for (std::vector<ModSpec>::const_iterator it = mods.begin();
- it != mods.end(); ++it) {
- const ModSpec &mod = *it;
+ for (const ModSpec &mod : m_mods) {
if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
throw ModError("Error loading mod \"" + mod.name +
"\": Mod name does not follow naming conventions: "
"Only characters [a-z0-9_] are allowed.");
}
- std::string script_path = mod.path + DIR_DELIM + "init.lua";
- infostream << " [" << padStringRight(mod.name, 12) << "] [\""
- << script_path << "\"]" << std::endl;
- m_script->loadMod(script_path, mod.name);
+ scanModIntoMemory(mod.name, mod.path);
+ }
+}
+
+void Client::scanModSubfolder(const std::string &mod_name, const std::string &mod_path,
+ std::string mod_subpath)
+{
+ std::string full_path = mod_path + DIR_DELIM + mod_subpath;
+ std::vector<fs::DirListNode> mod = fs::GetDirListing(full_path);
+ for (unsigned int j=0; j < mod.size(); j++){
+ std::string filename = mod[j].name;
+ if (mod[j].dir) {
+ scanModSubfolder(mod_name, mod_path, mod_subpath
+ + filename + DIR_DELIM);
+ continue;
+ }
+ std::replace( mod_subpath.begin(), mod_subpath.end(), DIR_DELIM_CHAR, '/');
+ m_mod_files[mod_name + ":" + mod_subpath + filename] = full_path + filename;
}
}
+void Client::initMods()
+{
+ m_script->loadModFromMemory(BUILTIN_MOD_NAME);
+
+ // If modding is not enabled, don't load mods, just builtin
+ if (!m_modding_enabled) {
+ return;
+ }
+
+ // Load and run "mod" scripts
+ for (const ModSpec &mod : m_mods)
+ m_script->loadModFromMemory(mod.name);
+}
+
const std::string &Client::getBuiltinLuaPath()
{
static const std::string builtin_dir = porting::path_share + DIR_DELIM + "builtin";
return mesh;
}
+const std::string* Client::getModFile(const std::string &filename)
+{
+ StringMap::const_iterator it = m_mod_files.find(filename);
+ if (it == m_mod_files.end()) {
+ errorstream << "Client::getModFile(): File not found: \"" << filename
+ << "\"" << std::endl;
+ return NULL;
+ }
+ return &it->second;
+}
+
bool Client::registerModStorage(ModMetadata *storage)
{
if (m_mod_storages.find(storage->getModName()) != m_mod_storages.end()) {
#include "mapnode.h"
#include "tileanimation.h"
#include "mesh_generator_thread.h"
+#include <fstream>
+#include "filesys.h"
#define CLIENT_CHAT_MESSAGE_LIMIT_PER_10S 10.0f
~Client();
DISABLE_CLASS_COPY(Client);
+ // Load local mods into memory
+ void loadMods();
+ void scanModSubfolder(const std::string &mod_name, const std::string &mod_path,
+ std::string mod_subpath);
+ inline void scanModIntoMemory(const std::string &mod_name, const std::string &mod_path)
+ {
+ scanModSubfolder(mod_name, mod_path, "");
+ }
+
+ // Initizle the mods
void initMods();
/*
bool checkLocalPrivilege(const std::string &priv)
{ return checkPrivilege(priv); }
virtual scene::IAnimatedMesh* getMesh(const std::string &filename);
+ const std::string* getModFile(const std::string &filename);
virtual std::string getModStoragePath() const;
virtual bool registerModStorage(ModMetadata *meta);
// Storage for mesh data for creating multiple instances of the same mesh
StringMap m_mesh_data;
+ StringMap m_mod_files;
+
// own state
LocalClientState m_state;
bool m_modding_enabled;
std::unordered_map<std::string, ModMetadata *> m_mod_storages;
float m_mod_storage_save_timer = 10.0f;
+ std::vector<ModSpec> m_mods;
GameUIFlags *m_game_ui_flags;
bool m_shutdown = false;
fps_control.last_time = RenderingEngine::get_timer_time();
+ client->loadMods();
client->initMods();
while (RenderingEngine::run()) {
std::string script_get_backtrace(lua_State *L)
{
- std::string s;
- lua_getglobal(L, "debug");
- if(lua_istable(L, -1)){
- lua_getfield(L, -1, "traceback");
- if(lua_isfunction(L, -1)) {
- lua_call(L, 0, 1);
- if(lua_isstring(L, -1)){
- s = lua_tostring(L, -1);
- }
- }
- lua_pop(L, 1);
- }
- lua_pop(L, 1);
- return s;
-}
-
-int script_error_handler(lua_State *L) {
- lua_getglobal(L, "debug");
- if (!lua_istable(L, -1)) {
- lua_pop(L, 1);
- return 1;
- }
- lua_getfield(L, -1, "traceback");
- if (!lua_isfunction(L, -1)) {
- lua_pop(L, 2);
- return 1;
- }
- lua_pushvalue(L, 1);
- lua_pushinteger(L, 2);
- lua_call(L, 2, 1);
- return 1;
+ lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_BACKTRACE);
+ lua_call(L, 0, 1);
+ return luaL_checkstring(L, -1);
}
int script_exception_wrapper(lua_State *L, lua_CFunction f)
#define CUSTOM_RIDX_SCRIPTAPI (CUSTOM_RIDX_BASE)
#define CUSTOM_RIDX_GLOBALS_BACKUP (CUSTOM_RIDX_BASE + 1)
#define CUSTOM_RIDX_CURRENT_MOD_NAME (CUSTOM_RIDX_BASE + 2)
-#define CUSTOM_RIDX_ERROR_HANDLER (CUSTOM_RIDX_BASE + 3)
+#define CUSTOM_RIDX_BACKTRACE (CUSTOM_RIDX_BASE + 3)
// Pushes the error handler onto the stack and returns its index
#define PUSH_ERROR_HANDLER(L) \
- (lua_rawgeti((L), LUA_REGISTRYINDEX, CUSTOM_RIDX_ERROR_HANDLER), lua_gettop((L)))
+ (lua_rawgeti((L), LUA_REGISTRYINDEX, CUSTOM_RIDX_BACKTRACE), lua_gettop((L)))
#define PCALL_RESL(L, RES) do { \
int result_ = (RES); \
lua_rawseti(m_luastack, LUA_REGISTRYINDEX, CUSTOM_RIDX_SCRIPTAPI);
// Add and save an error handler
- lua_pushcfunction(m_luastack, script_error_handler);
- lua_rawseti(m_luastack, LUA_REGISTRYINDEX, CUSTOM_RIDX_ERROR_HANDLER);
+ lua_getglobal(m_luastack, "debug");
+ lua_getfield(m_luastack, -1, "traceback");
+ lua_rawseti(m_luastack, LUA_REGISTRYINDEX, CUSTOM_RIDX_BACKTRACE);
+ lua_pop(m_luastack, 1); // pop debug
// If we are using LuaJIT add a C++ wrapper function to catch
// exceptions thrown in Lua -> C++ calls
lua_pop(L, 1); // Pop error handler
}
+#ifndef SERVER
+void ScriptApiBase::loadModFromMemory(const std::string &mod_name)
+{
+ ModNameStorer mod_name_storer(getStack(), mod_name);
+
+ const std::string *init_filename = getClient()->getModFile(mod_name + ":init.lua");
+ const std::string display_filename = mod_name + ":init.lua";
+ if(init_filename == NULL)
+ throw ModError("Mod:\"" + mod_name + "\" lacks init.lua");
+
+ verbosestream << "Loading and running script " << display_filename << std::endl;
+
+ lua_State *L = getStack();
+
+ int error_handler = PUSH_ERROR_HANDLER(L);
+
+ bool ok = ScriptApiSecurity::safeLoadFile(L, init_filename->c_str(), display_filename.c_str());
+ if (ok)
+ ok = !lua_pcall(L, 0, 0, error_handler);
+ if (!ok) {
+ std::string error_msg = luaL_checkstring(L, -1);
+ lua_pop(L, 2); // Pop error message and error handler
+ throw ModError("Failed to load and run mod \"" +
+ mod_name + "\":\n" + error_msg);
+ }
+ lua_pop(L, 1); // Pop error handler
+}
+#endif
+
// Push the list of callbacks (a lua table).
// Then push nargs arguments.
// Then call this function, which
#define setOriginFromTable(index) \
setOriginFromTableRaw(index, __FUNCTION__)
+enum class ScriptingType: u8 {
+ Client,
+ Server,
+ MainMenu
+};
+
class Server;
#ifndef SERVER
class Client;
void loadMod(const std::string &script_path, const std::string &mod_name);
void loadScript(const std::string &script_path);
+#ifndef SERVER
+ void loadModFromMemory(const std::string &mod_name);
+#endif
+
void runCallbacksRaw(int nargs,
RunCallbacksMode mode, const char *fxn);
IGameDef *getGameDef() { return m_gamedef; }
Server* getServer();
+ void setType(ScriptingType type) { m_type = type; }
+ ScriptingType getType() { return m_type; }
#ifndef SERVER
Client* getClient();
#endif
IGameDef *m_gamedef = nullptr;
Environment *m_environment = nullptr;
GUIEngine *m_guiengine = nullptr;
+ ScriptingType m_type;
};
#endif /* S_BASE_H_ */
#include "filesys.h"
#include "porting.h"
#include "server.h"
+#include "client.h"
#include "settings.h"
#include <cerrno>
lua_State *L = getStack();
+ // Backup globals to the registry
+ lua_getglobal(L, "_G");
+ lua_rawseti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_GLOBALS_BACKUP);
- int old_globals = backupGlobals(L);
+ // Replace the global environment with an empty one
+ int thread = getThread(L);
+ createEmptyEnv(L);
+ setLuaEnv(L, thread);
+
+ // Get old globals
+ lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_GLOBALS_BACKUP);
+ int old_globals = lua_gettop(L);
// Copy safe base functions
m_secure = true;
lua_State *L = getStack();
+ int thread = getThread(L);
-
- int old_globals = backupGlobals(L);
-
+ // create an empty environment
+ createEmptyEnv(L);
// Copy safe base functions
lua_getglobal(L, "_G");
+ lua_getfield(L, -2, "_G");
copy_safe(L, whitelist, sizeof(whitelist));
// And replace unsafe ones
SECURE_API(g, dofile);
+ SECURE_API(g, load);
+ SECURE_API(g, loadfile);
SECURE_API(g, loadstring);
SECURE_API(g, require);
- lua_pop(L, 1);
+ lua_pop(L, 2);
// Copy safe OS functions
- lua_getfield(L, old_globals, "os");
+ lua_getglobal(L, "os");
lua_newtable(L);
copy_safe(L, os_whitelist, sizeof(os_whitelist));
- lua_setglobal(L, "os");
+ lua_setfield(L, -3, "os");
lua_pop(L, 1); // Pop old OS
// Copy safe debug functions
- lua_getfield(L, old_globals, "debug");
+ lua_getglobal(L, "debug");
lua_newtable(L);
copy_safe(L, debug_whitelist, sizeof(debug_whitelist));
- lua_setglobal(L, "debug");
+ lua_setfield(L, -3, "debug");
lua_pop(L, 1); // Pop old debug
#if USE_LUAJIT
// Copy safe jit functions, if they exist
- lua_getfield(L, -1, "jit");
- if (!lua_isnil(L, -1)) {
- lua_newtable(L);
- copy_safe(L, jit_whitelist, sizeof(jit_whitelist));
- lua_setglobal(L, "jit");
- }
+ lua_getglobal(L, "jit");
+ lua_newtable(L);
+ copy_safe(L, jit_whitelist, sizeof(jit_whitelist));
+ lua_setfield(L, -3, "jit");
lua_pop(L, 1); // Pop old jit
#endif
- lua_pop(L, 1); // Pop globals_backup
+ // Set the environment to the one we created earlier
+ setLuaEnv(L, thread);
}
-int ScriptApiSecurity::backupGlobals(lua_State *L)
+int ScriptApiSecurity::getThread(lua_State *L)
{
- // Backup globals to the registry
- lua_getglobal(L, "_G");
- lua_rawseti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_GLOBALS_BACKUP);
-
- // Replace the global environment with an empty one
#if LUA_VERSION_NUM <= 501
int is_main = lua_pushthread(L); // Push the main thread
FATAL_ERROR_IF(!is_main, "Security: ScriptApi's Lua state "
"isn't the main Lua thread!");
+ return lua_gettop(L);
#endif
+ return 0;
+}
+
+void ScriptApiSecurity::createEmptyEnv(lua_State *L)
+{
lua_newtable(L); // Create new environment
lua_pushvalue(L, -1);
- lua_setfield(L, -2, "_G"); // Set _G of new environment
+ lua_setfield(L, -2, "_G"); // Create the _G loop
+}
+
+void ScriptApiSecurity::setLuaEnv(lua_State *L, int thread)
+{
#if LUA_VERSION_NUM >= 502 // Lua >= 5.2
// Set the global environment
lua_rawseti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
#else // Lua <= 5.1
// Set the environment of the main thread
- FATAL_ERROR_IF(!lua_setfenv(L, -2), "Security: Unable to set "
+ FATAL_ERROR_IF(!lua_setfenv(L, thread), "Security: Unable to set "
"environment of the main Lua thread!");
lua_pop(L, 1); // Pop thread
#endif
-
- // Get old globals
- lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_GLOBALS_BACKUP);
- return lua_gettop(L);
}
bool ScriptApiSecurity::isSecure(lua_State *L)
}
-bool ScriptApiSecurity::safeLoadFile(lua_State *L, const char *path)
+bool ScriptApiSecurity::safeLoadFile(lua_State *L, const char *path, const char *display_name)
{
FILE *fp;
char *chunk_name;
- if (path == NULL) {
+ if (!display_name)
+ display_name = path;
+ if (!path) {
fp = stdin;
chunk_name = const_cast<char *>("=stdin");
} else {
lua_pushfstring(L, "%s: %s", path, strerror(errno));
return false;
}
- chunk_name = new char[strlen(path) + 2];
+ chunk_name = new char[strlen(display_name) + 2];
chunk_name[0] = '@';
chunk_name[1] = '\0';
- strcat(chunk_name, path);
+ strcat(chunk_name, display_name);
}
size_t start = 0;
int ScriptApiSecurity::sl_g_loadfile(lua_State *L)
{
- const char *path = NULL;
+#ifndef SERVER
+ lua_rawgeti(L, LUA_REGISTRYINDEX, CUSTOM_RIDX_SCRIPTAPI);
+ ScriptApiBase *script = (ScriptApiBase *) lua_touserdata(L, -1);
+ lua_pop(L, 1);
+ if (script->getType() == ScriptingType::Client) {
+ std:: string display_path = lua_tostring(L, 1);
+ const std::string *path = script->getClient()->getModFile(display_path);
+ if (!path) {
+ std::string error_msg = "Coudln't find script called:" + display_path;
+ lua_pushnil(L);
+ lua_pushstring(L, error_msg.c_str());
+ return 2;
+ }
+ if (!safeLoadFile(L, path->c_str(), display_path.c_str())) {
+ lua_pushnil(L);
+ lua_insert(L, -2);
+ return 2;
+ }
+ return 1;
+ }
+#endif
+ const char *path = NULL;
if (lua_isstring(L, 1)) {
path = lua_tostring(L, 1);
CHECK_SECURE_PATH_INTERNAL(L, path, false, NULL);
class ScriptApiSecurity : virtual public ScriptApiBase
{
public:
- int backupGlobals(lua_State *L);
+ int getThread(lua_State *L);
+ // creates an empty Lua environment
+ void createEmptyEnv(lua_State *L);
+ // sets the enviroment to the table thats on top of the stack
+ void setLuaEnv(lua_State *L, int thread);
// Sets up security on the ScriptApi's Lua state
void initializeSecurity();
void initializeSecurityClient();
// Checks if the Lua state has been secured
static bool isSecure(lua_State *L);
// Loads a file as Lua code safely (doesn't allow bytecode).
- static bool safeLoadFile(lua_State *L, const char *path);
+ static bool safeLoadFile(lua_State *L, const char *path, const char *display_name = NULL);
// Checks if mods are allowed to read (and optionally write) to the path
static bool checkPath(lua_State *L, const char *path, bool write_required,
bool *write_allowed=NULL);
}
return 1;
}
+
+// get_builtin_path()
+int ModApiClient::l_get_builtin_path(lua_State *L)
+{
+ lua_pushstring(L, BUILTIN_MOD_NAME ":");
+ return 1;
+}
+
void ModApiClient::Initialize(lua_State *L, int top)
{
API_FCT(get_current_modname);
API_FCT(get_node_def);
API_FCT(take_screenshot);
API_FCT(get_privilege_list);
+ API_FCT(get_builtin_path);
}
// get_privilege_list()
static int l_get_privilege_list(lua_State *L);
+ // get_builtin_path()
+ static int l_get_builtin_path(lua_State *L);
+
public:
static void Initialize(lua_State *L, int top);
};
{
NO_MAP_LOCK_REQUIRED;
- std::string path = porting::path_share + DIR_DELIM + "builtin";
+ std::string path = porting::path_share + DIR_DELIM + "builtin" + DIR_DELIM;
lua_pushstring(L, path.c_str());
return 1;
API_FCT(is_yes);
- API_FCT(get_builtin_path);
-
API_FCT(compress);
API_FCT(decompress);
ScriptApiBase()
{
setGameDef(client);
+ setType(ScriptingType::Client);
SCRIPTAPI_PRECHECKHEADER
lua_pushstring(L, "client");
lua_setglobal(L, "INIT");
+ lua_pushstring(L, "/");
+ lua_setglobal(L, "DIR_DELIM");
+
infostream << "SCRIPTAPI: Initialized client game modules" << std::endl;
}
MainMenuScripting::MainMenuScripting(GUIEngine* guiengine)
{
setGuiEngine(guiengine);
+ setType(ScriptingType::MainMenu);
SCRIPTAPI_PRECHECKHEADER
ServerScripting::ServerScripting(Server* server)
{
setGameDef(server);
+ setType(ScriptingType::Server);
// setEnv(env) is called by ScriptApiEnv::initializeEnvironment()
// once the environment has been created
projects / dragonfireclient.git / commitdiff