Updated for Factorio version 1.1.104.

Author: Rseding91

src/LuaCPPUtilities.hpp

@@ -8,8 +8,12 @@ inline const char* lua_pushstring(lua_State* L, const std::string& s)
 inline const char* lua_pushstring(lua_State* L, std::string_view s)
 { return lua_pushlstring(L, s.data(), s.size()); }
 
-inline void  lua_getfield(lua_State* L, int idx, const std::string& k)
+inline void lua_getfield(lua_State* L, int idx, const std::string& k)
 { lua_getlfield(L, idx, k.c_str(), k.size()); }
 
-inline void  lua_setfield(lua_State* L, int idx, const std::string& k)
+inline void lua_setfield(lua_State* L, int idx, const std::string& k)
 { lua_setlfield(L, idx, k.c_str(), k.size()); }
+
+template<class T>
+inline std::enable_if_t<!std::is_same_v<T, lua_Number>> lua_pushnumber(lua_State* L, T value)
+{ lua_pushnumber(L, lua_Number(value)); }

src/lbaselib.c

@@ -309,21 +309,27 @@ static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
 }
 
 
+/*
+** Loads a chunk and pushes an executer function to the stack. If the loading
+** resulted in an error, pushes nil and an error string. Standard Lua 5.2 allows
+** loading strings containing either Lua code or precompiled bytecode, but
+** bytecode loading has been removed due to it being the entry point for many
+** security vulnerabilities.
+*/
 static int luaB_load (lua_State *L) {
   int status;
   size_t l;
   const char *s = lua_tolstring(L, 1, &l);
-  const char *mode = luaL_optstring(L, 3, "bt");
   int env = (!lua_isnone(L, 4) ? 4 : 0);  /* 'env' index or 0 if no 'env' */
   if (s != NULL) {  /* loading a string? */
     const char *chunkname = luaL_optstring(L, 2, s);
-    status = luaL_loadbufferx(L, s, l, chunkname, mode);
+    status = luaL_loadbufferx(L, s, l, chunkname, "t"); /* always text mode */
   }
   else {  /* loading from a reader function */
     const char *chunkname = luaL_optstring(L, 2, "=(load)");
     luaL_checktype(L, 1, LUA_TFUNCTION);
     lua_settop(L, RESERVEDSLOT);  /* create reserved slot */
-    status = lua_load(L, generic_reader, NULL, chunkname, mode);
+    status = lua_load(L, generic_reader, NULL, chunkname, "t"); /* always text mode */
   }
   return load_aux(L, status, env);
 }

src/ldebug.c

@@ -119,18 +119,21 @@ static const char *findlocal (lua_State *L, CallInfo *ci, int n,
                               StkId *pos) {
   const char *name = NULL;
   StkId base;
+  StkId limit = (ci == L->ci) ? L->top : ci->next->func;
   if (isLua(ci)) {
     if (n < 0)  /* access to vararg values? */
       return findvararg(ci, -n, pos);
     else {
       base = ci->u.l.base;
-      name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
+      if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
+        name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
+      else
+        return NULL;  /* no name */
     }
   }
   else
     base = ci->func + 1;
   if (name == NULL) {  /* no 'standard' name? */
-    StkId limit = (ci == L->ci) ? L->top : ci->next->func;
     if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
       name = "(*temporary)";  /* generic name for any valid slot */
     else

src/ldo.c

@@ -328,6 +328,8 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
   CallInfo *ci;
   int n;  /* number of arguments (Lua) or returns (C) */
   ptrdiff_t funcr = savestack(L, func);
+  if (luaF_hasopenupval_at_or_above(L, func))
+    luaG_runerror(L, "bytecode error, cannot call stack level with open upval at that level or above");
   switch (ttype(func)) {
     case LUA_TLCF:  /* light C function */
       f = fvalue(func);

src/lfunc.c

@@ -44,6 +44,10 @@ UpVal *luaF_newupval (lua_State *L) {
 }
 
 
+bool luaF_hasopenupval_at_or_above(lua_State* L, StkId level) {
+  return L->openupval != NULL && gco2uv(L->openupval)->v >= level;
+}
+
 UpVal *luaF_findupval (lua_State *L, StkId level) {
   global_State *g = G(L);
   GCObject **pp = &L->openupval;

src/lfunc.h

@@ -22,6 +22,7 @@ LUAI_FUNC Proto *luaF_newproto (lua_State *L);
 LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems);
 LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems);
 LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
+LUAI_FUNC bool luaF_hasopenupval_at_or_above(lua_State* L, StkId level);
 LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
 LUAI_FUNC void luaF_close (lua_State *L, StkId level);
 LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);

src/lmathlib.c

@@ -84,16 +84,17 @@ static double custom_atan(double x)
 {
   // Taken from http://golang.org/src/pkg/math/atan.go
 
-  if (x == 0)
-    return x;
-  else if (x > 0)
+  if (x > 0)
     return custom_satan(x);
-  else
+  if (x < 0)
     return -custom_satan(-x);
+  return x;
 }
 
 static double custom_atan2(double y, double x)
 {
+  if (isnan(y) || isnan(x))
+    return NAN;
   if (x > 0)
     return custom_atan(y / x);
   else if (x < 0)

src/lstate.c

@@ -218,7 +218,8 @@ static void preinit_state (lua_State *L, global_State *g) {
   L->nny = 1;
   L->status = LUA_OK;
   L->errfunc = 0;
-  L->userData = 0;
+  L->userData1 = 0;
+  L->userData2 = 0;
 }
 
 

src/lstate.h

@@ -174,7 +174,8 @@ struct lua_State {
   struct lua_longjmp *errorJmp;  /* current error recover point */
   ptrdiff_t errfunc;  /* current error handling function (stack index) */
   CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
-  void* userData; /* custom user-data pointer */
+  void* userData1; /* custom user-data pointer */
+  void* userData2; /* custom user-data pointer */
 };