Reimplemented Lua packages in C++

Similar design to before, but in C++: use require, and package.loaded is
enabled.

Pure Lua modules must be placed correctly in either:
<resource>/?.lua
<resource>/?/init.lua

Lua C Modules must be placed in:
/server/mods/deathmatch/modules/?.dll

To easily test or use modules for Windows: Download and install Lua for
Windows.  Copy contents of C:\Program Files (x86)\Lua\5.1\clibs into
/server/mods/deathmatch/modules.  Use e.g. require"lfs"

To-do:
* Port over to clientside (without C module support)
* More detailed error messages for Pure lua packages
* ACL support for C modules.
* Extensive testing

Author: darkdreamingdan

Server/mods/deathmatch/logic/lua/CLuaMain.cpp

@@ -126,7 +126,6 @@ void CLuaMain::InitSecurity ( void )
 {
     lua_register ( m_luaVM, "dofile", CLuaUtilDefs::DisabledFunction );
     lua_register ( m_luaVM, "loadfile", CLuaUtilDefs::DisabledFunction );
-    lua_register ( m_luaVM, "require", CLuaUtilDefs::DisabledFunction );
     lua_register ( m_luaVM, "loadlib", CLuaUtilDefs::DisabledFunction );
     lua_register ( m_luaVM, "getfenv", CLuaUtilDefs::DisabledFunction );
     lua_register ( m_luaVM, "newproxy", CLuaUtilDefs::DisabledFunction );
@@ -192,6 +191,9 @@ void CLuaMain::InitVM ( void )
     luaopen_debug ( m_luaVM );
     luaopen_utf8 ( m_luaVM );
 
+    // Initialize packages system
+    InitPackageStorage(m_luaVM);
+
     // Initialize security restrictions. Very important to prevent lua trojans and viruses!
     InitSecurity ();
 
@@ -250,7 +252,7 @@ void CLuaMain::InstructionCountHook ( lua_State* luaVM, lua_Debug* pDebug )
 }
 
 
-bool CLuaMain::LoadScriptFromBuffer ( const char* cpInBuffer, unsigned int uiInSize, const char* szFileName )
+bool CLuaMain::LoadScriptFromBuffer(const char* cpInBuffer, unsigned int uiInSize, const char* szFileName, bool bClearReturnValues )
 {
     SString strNiceFilename = ConformResourcePath( szFileName );
 
@@ -320,7 +322,7 @@ bool CLuaMain::LoadScriptFromBuffer ( const char* cpInBuffer, unsigned int uiInS
                 g_pGame->GetScriptDebugging()->LogPCallError( m_luaVM, strRes, true );
             }
             // Cleanup any return values
-            if ( lua_gettop ( m_luaVM ) > luaSavedTop )
+            if ( bClearReturnValues && lua_gettop ( m_luaVM ) > luaSavedTop )
                 lua_settop( m_luaVM, luaSavedTop );
             return true;
         }
@@ -686,3 +688,164 @@ int CLuaMain::OnUndump( const char* p, size_t n )
     }
     return 1;
 }
+
+
+///////////////////////////////////////////////////////////////
+//
+// CLuaMain::InitPackageStorage
+//
+// Create a table for storage of Lua packages - stored in the Lua VM
+//
+///////////////////////////////////////////////////////////////
+void CLuaMain::InitPackageStorage(lua_State* L)
+{
+    lua_newtable(L);                                            // stack: [tbl_new]
+    lua_pushstring(L, "loaded");                                // stack: [tbl_new,"loaded"]
+    lua_newtable(L);                                            // stack: [tbl_new,"loaded",tbl_new2]
+
+    // We push our default Lua libs are loaded packages
+    std::vector<const char*> szDefaultLibs = { "math", "string", "table", "debug", "utf8" };
+    for (auto it : szDefaultLibs)
+    {
+        lua_pushstring(L, it);                                  // stack: [tbl_new,"loaded",tbl_new2,"math"]
+        lua_getglobal(L, it);                                   // stack: [tbl_new,"loaded",tbl_new2,"math",_G.math]
+        lua_settable(L, -3);                                    // stack: [tbl_new,"loaded",tbl_new2]
+    }
+
+    // Finally, store our original table as package.loaded
+    lua_settable(L, -3);                                        // stack: [tbl_new]
+    lua_setglobal(L, "package");                                // stack: []
+}
+
+///////////////////////////////////////////////////////////////
+//
+// CLuaMain::SetPackage
+//
+// Pop the top most value as a package
+//
+///////////////////////////////////////////////////////////////
+void CLuaMain::SetPackage(lua_State* L, SString &strName )
+{
+    // We set varPkg, which is already on the stack, into package.loaded.moduleName = varPkg.
+                                                    // stack: [varPkg]
+    int iPkg = luaL_ref(L, LUA_REGISTRYINDEX);      // stack: []
+    lua_getglobal(L, "package");                    // stack: [tbl_package]
+    if (lua_type(L, -1) == LUA_TNIL )
+        InitPackageStorage(L);
+
+    lua_pushstring(L, "loaded");                    // stack: [tbl_package,"loaded"]
+    lua_rawget(L, -2);                              // stack: [tbl_package,tbl_loaded]
+    if (lua_type(L, -1) == LUA_TNIL)
+        InitPackageStorage(L);
+
+
+    lua_pushstring(L, strName.c_str());             // stack: [tbl_package,tbl_loaded,"moduleName"]
+    lua_rawgeti(L, LUA_REGISTRYINDEX, iPkg);        // stack: [tbl_package,tbl_loaded,"moduleName",varPkg]
+    lua_rawset(L, -3);                              // stack: [tbl_package,tbl_loaded]
+    lua_pop(L, 2);                                  // stack: []
+    lua_rawgeti(L, LUA_REGISTRYINDEX, iPkg);        // stack: [varPkg]
+
+    // Cleanup our used registry entry, REGISTRY[i] = nil.
+    lua_pushnil(L);                                 // stack: [varPkg,nil]
+    lua_rawseti(L, LUA_REGISTRYINDEX, iPkg);        // stack: [varPkg]
+}
+
+///////////////////////////////////////////////////////////////
+//
+// CLuaMain::GetPackage
+//
+// Push the value of a package of name to the stack
+//
+///////////////////////////////////////////////////////////////
+void CLuaMain::GetPackage(lua_State* L, SString &strName)
+{
+    lua_getglobal(L, "package");                    // stack: [tbl_package]
+    if (lua_type(L, -1) == LUA_TNIL )
+        InitPackageStorage(m_luaVM);
+
+    lua_pushstring(L, "loaded");                    // stack: [tbl_package,"loaded"]
+    if (lua_type(L, -1) == LUA_TNIL)
+        InitPackageStorage(m_luaVM);
+
+    lua_rawget(L, -2);                              // stack: [tbl_package,tbl_loaded]
+    lua_pushstring(L, strName.c_str());             // stack: [tbl_package,tbl_loaded,"moduleName"]
+    lua_rawget(L, -2);                              // stack: [tbl_package,varPkg]
+    lua_remove(L, -2);                              // stack: [varPkg]
+}
+
+///////////////////////////////////////////////////////////////
+//
+// CLuaMain::LoadLuaLib
+//
+// Load a Lua lib of a given name
+//
+///////////////////////////////////////////////////////////////
+bool CLuaMain::LoadLuaLib(lua_State *L, SString strName)
+{
+    SString strPath = strName;
+    // Name format shouldn't include slashes.  Subdirs are dots.
+    ReplaceOccurrencesInString(strPath, "\\", "");
+    ReplaceOccurrencesInString(strPath, "/", "");
+    ReplaceOccurrencesInString(strPath, ".", "/");
+
+    SString strResPath = m_pResource->IsResourceZip() ? m_pResource->GetResourceCacheDirectoryPath() : m_pResource->GetResourceDirectoryPath();
+
+    std::vector < char > buffer;
+    // Try <resource>/?.lua
+    SString strFilePath = PathJoin(strResPath, strPath + ".lua");
+    if (FileExists(strFilePath))
+        FileLoad(strFilePath, buffer);
+    else
+    {
+        // Try <resource>/?/init.lua
+        strFilePath = PathJoin(strResPath, strPath, "init.lua");
+        if (FileExists(strFilePath))
+            FileLoad(strFilePath, buffer);
+    }
+
+    if (buffer.size() > 0)
+    {
+        int luaSavedTop = lua_gettop(L);
+        LoadScriptFromBuffer(&buffer.at(0), buffer.size(), strFilePath.c_str(), false);
+        // Only keep the first return value
+        if (lua_gettop(L) > luaSavedTop)
+            lua_settop(L, luaSavedTop+1);
+
+        SetPackage(L, strName);  // Store our package into package.loaded
+        GetPackage(L, strName);  // Grab it back as a return value.
+        return true;
+    }
+
+    return false;
+}
+
+///////////////////////////////////////////////////////////////
+//
+// CLuaMain::LoadClib
+//
+// Load a C lib of a given name
+//
+///////////////////////////////////////////////////////////////
+bool CLuaMain::LoadClib(lua_State* L, SString strName)
+{
+    SString strPath = strName;
+    // Name format shouldn't include slashes.  Subdirs are dots.
+    ReplaceOccurrencesInString(strPath, "\\", "");
+    ReplaceOccurrencesInString(strPath, "/", "");
+    ReplaceOccurrencesInString(strPath, ".", "/");
+
+    strPath = PathJoin(g_pServerInterface->GetModManager()->GetServerPath(), SERVER_BIN_PATH_MOD, "modules", strPath);
+
+#ifdef WIN32
+    strPath += ".dll";
+#else
+    strPath += ".so";
+#endif
+
+    luaL_loader_C(L, strName.c_str(), strPath.c_str());
+    if (lua_type(L, -1) == LUA_TNIL)
+        return false;
+
+    SetPackage(L, strName);
+    return true;
+}

Server/mods/deathmatch/logic/lua/CLuaMain.h

@@ -59,7 +59,7 @@ class CLuaMain //: public CClient
 
                                     ~CLuaMain               ( void );
 
-    bool                            LoadScriptFromBuffer    ( const char* cpBuffer, unsigned int uiSize, const char* szFileName );
+    bool                            LoadScriptFromBuffer    ( const char* cpBuffer, unsigned int uiSize, const char* szFileName, bool bClearReturnValues = true );
     bool                            LoadScript              ( const char* szLUAScript );
     void                            UnloadScript            ( void );
 
@@ -120,6 +120,12 @@ class CLuaMain //: public CClient
     static int                      LuaLoadBuffer           ( lua_State *L, const char *buff, size_t sz, const char *name );
     static int                      OnUndump                ( const char* p, size_t n );
 
+    void                            InitPackageStorage      ( lua_State* L );  // Create a psuedo package.loaded table
+    void                            GetPackage              ( lua_State *L, SString &strName ); // Push the package value to the top of the stack
+    void                            SetPackage              ( lua_State *L, SString &strName ); // Set the package to the value at the top of the stack
+    bool                            LoadLuaLib              ( lua_State *L, SString strName ); // Load a lua library of a given name
+    bool                            LoadClib                ( lua_State *L, SString strName ); // Load a C Lib of a given name
+
 private:
     void                            InitSecurity            ( void );
     void                            InitClasses             ( lua_State* luaVM );

Shared/mods/deathmatch/logic/luadefs/CLuaUtilDefs.cpp

@@ -38,6 +38,9 @@ void CLuaUtilDefs::LoadFunctions ( void )
     CLuaCFunctions::AddFunction ( "pregFind", PregFind );
     CLuaCFunctions::AddFunction ( "pregReplace", PregReplace );
     CLuaCFunctions::AddFunction ( "pregMatch", PregMatch );
+
+    // Package functions
+    CLuaCFunctions::AddFunction ( "require", Require );
 }
 
 int CLuaUtilDefs::DisabledFunction ( lua_State* luaVM )
@@ -559,3 +562,38 @@ int CLuaUtilDefs::PregMatch ( lua_State* luaVM )
     lua_pushboolean ( luaVM, false );
     return 1;
 }
+
+int CLuaUtilDefs::Require(lua_State* luaVM)
+{
+#ifndef MTA_CLIENT
+    //  table require ( string name )
+    SString strMod;
+
+    CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
+    CScriptArgReader argStream(luaVM);
+    argStream.ReadString(strMod);
+
+    if (!argStream.HasErrors())
+    {
+        // Check if package exists already, if so load it
+                                                        // stack: ["moduleName"]
+        pLuaMain->GetPackage(luaVM, strMod);            // stack: ["moduleName",pkgModule/nil]
+        if (lua_type(luaVM, -1) != LUA_TNIL)
+            return 1;
+        lua_pop(luaVM,1);                               // stack: ["moduleName"]
+
+        // Check whether the appropriate pure lua module exists
+        if (pLuaMain->LoadLuaLib(luaVM, strMod))        // stack: ["moduleName",pkgLuaMod/nil]
+            return 1;
+
+        // Check if a C library exists
+        if (pLuaMain->LoadClib(luaVM, strMod))          // stack: ["moduleName",fncModule/nil]
+            return 1;
+        lua_pop(luaVM,2);                               // stack: []
+    }
+    else
+        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
+#endif
+    lua_pushboolean(luaVM, false);
+    return 1;
+}

Shared/mods/deathmatch/logic/luadefs/CLuaUtilDefs.h

@@ -45,4 +45,7 @@ class CLuaUtilDefs : public CLuaDefs
     LUA_DECLARE ( PregFind );
     LUA_DECLARE ( PregReplace );
     LUA_DECLARE ( PregMatch );
+
+    // Package functions
+    LUA_DECLARE ( Require );
 };

vendor/lua/src/lauxlib.h

@@ -172,3 +172,8 @@ LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
 #endif
 
 
+/////////////////////////////
+// MTA EXTENSIONS
+/////////////////////////////
+LUALIB_API int luaL_loader_C(lua_State *L, const char* name, const char* filename);
+

vendor/lua/src/loadlib.c

@@ -664,3 +664,15 @@ LUALIB_API int luaopen_package (lua_State *L) {
   return 1;  /* return 'package' table */
 }
 
+
+/////////////////////////////
+// MTA EXTENSIONS
+/////////////////////////////
+
+// API to direct load a C library.
+LUA_API int luaL_loader_C(lua_State *L, const char* name, const char* filename) {
+    const char* funcname = mkfuncname(L, name);
+    if (ll_loadfunc(L, filename, funcname) != 0)
+        loaderror(L, filename);
+    return 1;  /* library loaded successfully */
+}