Move CRemoteCalls.h higher

Author: qaisjp

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

@@ -79,41 +79,28 @@ std::string CLuaCryptDefs::Base64decode(std::string str)
     return SharedUtil::Base64decode(str);
 }
 
-std::variant<std::string, bool> CLuaCryptDefs::PasswordHash(lua_State* luaVM, std::string password, PasswordHashFunction algorithm,
-                                                            std::unordered_map<std::string, std::string> options, std::optional<CLuaFunctionRef> luaFunctionRef)
+int CLuaCryptDefs::PasswordHash(lua_State* luaVM)
 {
     //  string password_hash(string password, string algorithm, table options = {} [, function callback])
-    if (algorithm != PasswordHashFunction::Bcrypt)
-    {
-        throw std::invalid_argument("Invalid algorithm");
-    }
-
-    // Set default value to 10
-    if (options["cost"].empty())
-        options["cost"] = "10";
+    SString              password;
+    PasswordHashFunction algorithm;
+    CStringMap           options;
+    CLuaFunctionRef      luaFunctionRef;
 
-    std::stringstream ss(options["cost"]);
-    std::size_t       cost;
-    ss >> cost;
-
-    if (ss.fail())
-        throw std::invalid_argument("Invalid value for field 'cost'");
+    CScriptArgReader argStream(luaVM);
+    argStream.ReadString(password);
+    argStream.ReadEnumString(algorithm);
+    argStream.ReadStringMap(options);
 
-    // Sync
-    if (!luaFunctionRef.has_value())
+    if (argStream.NextIsFunction())
     {
-        SString hash = SharedUtil::BcryptHash(password, options["salt"], cost);
-        if (!hash.empty())
-        {
-            return hash;
-        }
-        else
-            throw std::invalid_argument("Invalid value for field 'salt'");
+        argStream.ReadFunction(luaFunctionRef);
+        argStream.ReadFunctionComplete();
     }
-    else            // Async
+
+    if (!argStream.HasErrors())
     {
-        CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
-        if (pLuaMain)
+        if (algorithm == PasswordHashFunction::Bcrypt)
         {
             // Set default value to 10
             if (options["cost"].empty())
@@ -149,26 +136,46 @@ std::variant<std::string, bool> CLuaCryptDefs::PasswordHash(lua_State* luaVM, st
                     CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM);
                     if (pLuaMain)
                     {
-                        CLuaArguments arguments;
+                        CLuaShared::GetAsyncTaskScheduler()->PushTask<SString>(
+                            [password, salt = options["salt"], cost] {
+                                // Execute time-consuming task
+                                return SharedUtil::BcryptHash(password, salt, cost);
+                            },
+                            [luaFunctionRef](const SString& hash) {
+                                CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaFunctionRef.GetLuaVM());
+                                if (pLuaMain)
+                                {
+                                    CLuaArguments arguments;
 
-                        if (hash.empty())
-                        {
-                            m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
-                            arguments.PushBoolean(false);
-                        }
-                        else
-                            arguments.PushString(hash);
+                                    if (hash.empty())
+                                    {
+                                        m_pScriptDebugging->LogCustom(pLuaMain->GetVM(), "Invalid value for field 'salt'");
+                                        arguments.PushBoolean(false);
+                                    }
+                                    else
+                                        arguments.PushString(hash);
 
-                        arguments.Call(pLuaMain, luaFunctionRef.value());
-                    }
-                });
+                                    arguments.Call(pLuaMain, luaFunctionRef);
+                                }
+                            });
 
-            return true;
+                        lua_pushboolean(luaVM, true);
+                        return 1;
+                    }
+                }
+            }
+            else
+                m_pScriptDebugging->LogWarning(luaVM, "Invalid value for field 'cost'");
         }
-        return false;
     }
+    else
+        m_pScriptDebugging->LogCustom(luaVM, argStream.GetFullErrorMessage());
+
+    lua_pushboolean(luaVM, false);
+    return 1;
 }
 
+
 int CLuaCryptDefs::PasswordVerify(lua_State* luaVM)
 {
     //  bool passwordVerify(string password, string hash [, table options, function callback])

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

@@ -26,9 +26,7 @@ class CLuaCryptDefs : public CLuaDefs
     static std::string TeaDecode(std::string str, std::string key);
     static std::string Base64encode(std::string str);
     static std::string Base64decode(std::string str);
-    static std::variant<std::string, bool> PasswordHash(lua_State* luaVM, std::string password, PasswordHashFunction algorithm,
-                                                        std::unordered_map<std::string, std::string> options,
-                             std::optional<CLuaFunctionRef> luaFunctionRef);
+    LUA_DECLARE(PasswordHash);
     static std::string Sha256(std::string strSourceData);
     LUA_DECLARE(PasswordVerify);
     LUA_DECLARE(EncodeString);