Make redbean serialization deterministic

third_party/lua/cosmo.h

@@ -14,7 +14,7 @@ int LuaEncodeUrl(lua_State *);
 int LuaParseUrl(lua_State *);
 int LuaPushHeader(lua_State *, struct HttpMessage *, char *, int);
 int LuaPushHeaders(lua_State *, struct HttpMessage *, const char *);
-void EscapeLuaString(char *, size_t, char **);
+int EscapeLuaString(char *, size_t, char **);
 void LuaPrintStack(lua_State *);
 void LuaPushLatin1(lua_State *, const char *, size_t);
 void LuaPushUrlParams(lua_State *, struct UrlParams *);

third_party/lua/escapeluastring.c

@@ -17,25 +17,32 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/bits/bits.h"
+#include "libc/log/rop.h"
 #include "libc/stdio/append.internal.h"
 #include "libc/str/str.h"
 #include "third_party/lua/cosmo.h"
 #include "third_party/lua/lua.h"
 
-void EscapeLuaString(char *s, size_t len, char **buf) {
-  appendw(buf, '"');
-  for (size_t i = 0; i < len; i++) {
+int EscapeLuaString(char *s, size_t len, char **buf) {
+  int rc;
+  size_t i;
+  RETURN_ON_ERROR(appendw(buf, '"'));
+  for (i = 0; i < len; i++) {
     if (' ' <= s[i] && s[i] <= 0x7e) {
-      appendw(buf, s[i]);
+      RETURN_ON_ERROR(appendw(buf, s[i]));
     } else if (s[i] == '\n') {
-      appendw(buf, '\\' | 'n' << 8);
+      RETURN_ON_ERROR(appendw(buf, '\\' | 'n' << 8));
     } else if (s[i] == '\\' || s[i] == '\'' || s[i] == '\"') {
-      appendw(buf, '\\' | s[i] << 8);
+      RETURN_ON_ERROR(appendw(buf, '\\' | s[i] << 8));
     } else {
-      appendw(buf, '\\' | 'x' << 010 |
-                       "0123456789abcdef"[(s[i] & 0xF0) >> 4] << 020 |
-                       "0123456789abcdef"[(s[i] & 0x0F) >> 0] << 030);
+      RETURN_ON_ERROR(
+          appendw(buf, '\\' | 'x' << 010 |
+                           "0123456789abcdef"[(s[i] & 0xF0) >> 4] << 020 |
+                           "0123456789abcdef"[(s[i] & 0x0F) >> 0] << 030));
     }
   }
-  appendw(buf, '"');
+  RETURN_ON_ERROR(appendw(buf, '"'));
+  return 0;
+OnError:
+  return -1;
 }

third_party/lua/luaencodejsondata.c

@@ -19,9 +19,11 @@
 #include "libc/assert.h"
 #include "libc/bits/bits.h"
 #include "libc/fmt/itoa.h"
+#include "libc/log/rop.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/gc.internal.h"
 #include "libc/stdio/append.internal.h"
+#include "libc/stdio/strlist.internal.h"
 #include "net/http/escape.h"
 #include "third_party/lua/cosmo.h"
 #include "third_party/lua/lauxlib.h"
@@ -32,34 +34,37 @@ static int LuaEncodeJsonDataImpl(lua_State *L, char **buf, int level,
                                  char *numformat, int idx,
                                  struct LuaVisited *visited) {
   char *s;
+  int sli, rc;
   bool isarray;
   size_t tbllen, i, z;
+  struct StrList sl = {0};
   char ibuf[21], fmt[] = "%.14g";
   if (level > 0) {
     switch (lua_type(L, idx)) {
 
       case LUA_TNIL:
-        appendw(buf, READ32LE("null"));
+        RETURN_ON_ERROR(appendw(buf, READ32LE("null")));
         return 0;
 
       case LUA_TBOOLEAN:
-        appendw(buf, lua_toboolean(L, idx) ? READ32LE("true")
-                                           : READ64LE("false\0\0"));
+        RETURN_ON_ERROR(appendw(buf, lua_toboolean(L, idx)
+                                         ? READ32LE("true")
+                                         : READ64LE("false\0\0")));
         return 0;
 
       case LUA_TSTRING:
         s = lua_tolstring(L, idx, &z);
-        s = EscapeJsStringLiteral(s, z, &z);
-        appendw(buf, '"');
-        appendd(buf, s, z);
-        appendw(buf, '"');
+        if (!(s = EscapeJsStringLiteral(s, z, &z))) goto OnError;
+        RETURN_ON_ERROR(appendw(buf, '"'));
+        RETURN_ON_ERROR(appendd(buf, s, z));
+        RETURN_ON_ERROR(appendw(buf, '"'));
         free(s);
         return 0;
 
       case LUA_TNUMBER:
         if (lua_isinteger(L, idx)) {
-          appendd(buf, ibuf,
-                  FormatInt64(ibuf, luaL_checkinteger(L, idx)) - ibuf);
+          RETURN_ON_ERROR(appendd(
+              buf, ibuf, FormatInt64(ibuf, luaL_checkinteger(L, idx)) - ibuf));
         } else {
           // TODO(jart): replace this api
           while (*numformat == '%' || *numformat == '.' ||
@@ -73,16 +78,16 @@ static int LuaEncodeJsonDataImpl(lua_State *L, char **buf, int level,
               fmt[4] = *numformat;
               break;
             default:
-              free(visited->p);
-              luaL_error(L, "numformat string not allowed");
-              unreachable;
+              // prevent format string hacking
+              goto OnError;
           }
-          appendf(buf, fmt, lua_tonumber(L, idx));
+          RETURN_ON_ERROR(appendf(buf, fmt, lua_tonumber(L, idx)));
         }
         return 0;
 
       case LUA_TTABLE:
-        if (LuaPushVisit(visited, lua_topointer(L, idx))) {
+        RETURN_ON_ERROR(rc = LuaPushVisit(visited, lua_topointer(L, idx)));
+        if (!rc) {
           lua_pushvalue(L, idx);  // table ref
           tbllen = lua_rawlen(L, -1);
           // encode tables with numeric indices and empty tables as arrays
@@ -90,12 +95,12 @@ static int LuaEncodeJsonDataImpl(lua_State *L, char **buf, int level,
               tbllen > 0 ||                          // integer keys present
               (lua_pushnil(L), !lua_next(L, -2)) ||  // no non-integer keys
               (lua_pop(L, 2), false);  // pop key/value pushed by lua_next
-          appendw(buf, isarray ? '[' : '{');
           if (isarray) {
             for (i = 1; i <= tbllen; i++) {
-              if (i > 1) appendw(buf, ',');
+              RETURN_ON_ERROR(sli = AppendStrList(&sl));
               lua_rawgeti(L, -1, i);  // table/-2, value/-1
-              LuaEncodeJsonDataImpl(L, buf, level - 1, numformat, -1, visited);
+              RETURN_ON_ERROR(LuaEncodeJsonDataImpl(L, &sl.p[sli], level - 1,
+                                                    numformat, -1, visited));
               lua_pop(L, 1);
             }
           } else {
@@ -103,45 +108,58 @@ static int LuaEncodeJsonDataImpl(lua_State *L, char **buf, int level,
             lua_pushnil(L);  // push the first key
             while (lua_next(L, -2)) {
               if (lua_type(L, -2) != LUA_TSTRING) {
-                free(visited->p);
-                luaL_error(L, "json tables must be arrays or use string keys");
-                unreachable;
+                // json tables must be arrays or use string keys
+                goto OnError;
               }
-              if (i++ > 1) appendw(buf, ',');
-              LuaEncodeJsonDataImpl(L, buf, level - 1, numformat, -2, visited);
-              appendw(buf, ':');
-              LuaEncodeJsonDataImpl(L, buf, level - 1, numformat, -1, visited);
+              RETURN_ON_ERROR(sli = AppendStrList(&sl));
+              RETURN_ON_ERROR(LuaEncodeJsonDataImpl(L, &sl.p[sli], level - 1,
+                                                    numformat, -2, visited));
+              RETURN_ON_ERROR(appendw(&sl.p[sli], ':'));
+              RETURN_ON_ERROR(LuaEncodeJsonDataImpl(L, &sl.p[sli], level - 1,
+                                                    numformat, -1, visited));
               lua_pop(L, 1);  // table/-2, key/-1
             }
             // stack: table/-1, as the key was popped by lua_next
           }
-          appendw(buf, isarray ? ']' : '}');
+          RETURN_ON_ERROR(appendw(buf, isarray ? '[' : '{'));
+          SortStrList(&sl);
+          RETURN_ON_ERROR(JoinStrList(&sl, buf, ','));
+          FreeStrList(&sl);
+          RETURN_ON_ERROR(appendw(buf, isarray ? ']' : '}'));
           LuaPopVisit(visited);
           lua_pop(L, 1);  // table ref
           return 0;
         } else {
-          free(visited->p);
-          luaL_error(L, "can't serialize cyclic data structure to json");
-          unreachable;
+          // cyclic data structure
+          goto OnError;
         }
 
       default:
-        free(visited->p);
-        luaL_error(L, "won't serialize %s to json", luaL_typename(L, idx));
-        unreachable;
+        // unsupported lua type
+        goto OnError;
     }
   } else {
-    free(visited->p);
-    luaL_error(L, "too many nested tables");
-    unreachable;
+    // too much depth
+    goto OnError;
   }
+OnError:
+  FreeStrList(&sl);
+  return -1;
 }
 
+/**
+ * Encodes Lua data structure as JSON.
+ *
+ * @param L is Lua interpreter state
+ * @param buf receives encoded output string
+ * @param numformat controls double formatting
+ * @param idx is index of item on Lua stack
+ * @return 0 on success, or -1 on error
+ */
 int LuaEncodeJsonData(lua_State *L, char **buf, char *numformat, int idx) {
   int rc;
   struct LuaVisited visited = {0};
   rc = LuaEncodeJsonDataImpl(L, buf, 64, numformat, idx, &visited);
-  assert(!visited.n);
   free(visited.p);
   return rc;
 }

third_party/lua/luaencodeluadata.c

@@ -19,9 +19,11 @@
 #include "libc/assert.h"
 #include "libc/bits/bits.h"
 #include "libc/fmt/itoa.h"
+#include "libc/log/rop.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.internal.h"
+#include "libc/stdio/strlist.internal.h"
 #include "libc/x/x.h"
 #include "third_party/lua/cosmo.h"
 #include "third_party/lua/lauxlib.h"
@@ -60,41 +62,45 @@ static int LuaEncodeLuaDataImpl(lua_State *L, char **buf, int level,
   char *s;
   bool isarray;
   lua_Integer i;
-  int ktype, vtype;
+  struct StrList sl = {0};
+  int ktype, vtype, sli, rc;
   size_t tbllen, buflen, slen;
   char ibuf[24], fmt[] = "%.14g";
   if (level > 0) {
     switch (lua_type(L, idx)) {
 
       case LUA_TNIL:
-        appendw(buf, READ32LE("nil"));
+        RETURN_ON_ERROR(appendw(buf, READ32LE("nil")));
         return 0;
 
       case LUA_TSTRING:
         s = lua_tolstring(L, idx, &slen);
-        EscapeLuaString(s, slen, buf);
+        RETURN_ON_ERROR(EscapeLuaString(s, slen, buf));
         return 0;
 
       case LUA_TFUNCTION:
-        appendf(buf, "\"func@%p\"", lua_topointer(L, idx));
+        RETURN_ON_ERROR(
+            appendf(buf, "\"%s@%p\"", "func", lua_topointer(L, idx)));
         return 0;
 
       case LUA_TLIGHTUSERDATA:
-        appendf(buf, "\"light@%p\"", lua_topointer(L, idx));
+        RETURN_ON_ERROR(
+            appendf(buf, "\"%s@%p\"", "light", lua_topointer(L, idx)));
         return 0;
 
       case LUA_TTHREAD:
-        appendf(buf, "\"thread@%p\"", lua_topointer(L, idx));
+        RETURN_ON_ERROR(
+            appendf(buf, "\"%s@%p\"", "thread", lua_topointer(L, idx)));
         return 0;
 
       case LUA_TUSERDATA:
         if (luaL_callmeta(L, idx, "__repr")) {
           if (lua_type(L, -1) == LUA_TSTRING) {
             s = lua_tolstring(L, -1, &slen);
-            appendd(buf, s, slen);
+            RETURN_ON_ERROR(appendd(buf, s, slen));
           } else {
-            appendf(buf, "[[error %s returned a %s value]]", "__repr",
-                    luaL_typename(L, -1));
+            RETURN_ON_ERROR(appendf(buf, "[[error %s returned a %s value]]",
+                                    "__repr", luaL_typename(L, -1)));
           }
           lua_pop(L, 1);
           return 0;
@@ -102,21 +108,23 @@ static int LuaEncodeLuaDataImpl(lua_State *L, char **buf, int level,
         if (luaL_callmeta(L, idx, "__tostring")) {
           if (lua_type(L, -1) == LUA_TSTRING) {
             s = lua_tolstring(L, -1, &slen);
-            EscapeLuaString(s, slen, buf);
+            RETURN_ON_ERROR(EscapeLuaString(s, slen, buf));
           } else {
-            appendf(buf, "[[error %s returned a %s value]]", "__tostring",
-                    luaL_typename(L, -1));
+            RETURN_ON_ERROR(appendf(buf, "[[error %s returned a %s value]]",
+                                    "__tostring", luaL_typename(L, -1)));
           }
           lua_pop(L, 1);
           return 0;
         }
-        appendf(buf, "\"udata@%p\"", lua_touserdata(L, idx));
+        RETURN_ON_ERROR(
+            appendf(buf, "\"%s@%p\"", "udata", lua_touserdata(L, idx)));
         return 0;
 
       case LUA_TNUMBER:
         if (lua_isinteger(L, idx)) {
-          appendd(buf, ibuf,
-                  FormatFlex64(ibuf, luaL_checkinteger(L, idx), 2) - ibuf);
+          RETURN_ON_ERROR(
+              appendd(buf, ibuf,
+                      FormatFlex64(ibuf, luaL_checkinteger(L, idx), 2) - ibuf));
         } else {
           // TODO(jart): replace this api
           while (*numformat == '%' || *numformat == '.' ||
@@ -130,71 +138,87 @@ static int LuaEncodeLuaDataImpl(lua_State *L, char **buf, int level,
               fmt[4] = *numformat;
               break;
             default:
-              free(visited->p);
-              luaL_error(L, "numformat string not allowed");
-              unreachable;
+              // prevent format string hacking
+              goto OnError;
           }
-          appendf(buf, fmt, lua_tonumber(L, idx));
+          RETURN_ON_ERROR(appendf(buf, fmt, lua_tonumber(L, idx)));
         }
         return 0;
 
       case LUA_TBOOLEAN:
-        appendw(buf, lua_toboolean(L, idx) ? READ32LE("true")
-                                           : READ64LE("false\0\0"));
+        RETURN_ON_ERROR(appendw(buf, lua_toboolean(L, idx)
+                                         ? READ32LE("true")
+                                         : READ64LE("false\0\0")));
         return 0;
 
       case LUA_TTABLE:
         i = 0;
-        if (LuaPushVisit(visited, lua_topointer(L, idx))) {
-          appendw(buf, '{');
+        RETURN_ON_ERROR(rc = LuaPushVisit(visited, lua_topointer(L, idx)));
+        if (!rc) {
           lua_pushvalue(L, idx);  // idx becomes invalid once we change stack
           isarray = IsLuaArray(L);
           lua_pushnil(L);  // push the first key
           while (lua_next(L, -2)) {
             ktype = lua_type(L, -2);
             vtype = lua_type(L, -1);
-            if (i++ > 0) appendw(buf, ',' | ' ' << 8);
+            RETURN_ON_ERROR(sli = AppendStrList(&sl));
             if (isarray) {
               // use {v₁′,v₂′,...} for lua-normal integer keys
             } else if (ktype == LUA_TSTRING && IsLuaIdentifier(L, -2)) {
               // use {𝑘=𝑣′} syntax when 𝑘 is legal as a lua identifier
               s = lua_tolstring(L, -2, &slen);
-              appendd(buf, s, slen);
-              appendw(buf, '=');
+              RETURN_ON_ERROR(appendd(&sl.p[sli], s, slen));
+              RETURN_ON_ERROR(appendw(&sl.p[sli], '='));
             } else {
               // use {[𝑘′]=𝑣′} otherwise
-              appendw(buf, '[');
-              LuaEncodeLuaDataImpl(L, buf, level - 1, numformat, -2, visited);
-              appendw(buf, ']' | '=' << 010);
+              RETURN_ON_ERROR(appendw(&sl.p[sli], '['));
+              RETURN_ON_ERROR(LuaEncodeLuaDataImpl(L, &sl.p[sli], level - 1,
+                                                   numformat, -2, visited));
+              RETURN_ON_ERROR(appendw(&sl.p[sli], ']' | '=' << 010));
             }
-            LuaEncodeLuaDataImpl(L, buf, level - 1, numformat, -1, visited);
+            RETURN_ON_ERROR(LuaEncodeLuaDataImpl(L, &sl.p[sli], level - 1,
+                                                 numformat, -1, visited));
             lua_pop(L, 1);  // table/-2, key/-1
           }
           lua_pop(L, 1);  // table ref
+          RETURN_ON_ERROR(appendw(buf, '{'));
+          SortStrList(&sl);
+          RETURN_ON_ERROR(JoinStrList(&sl, buf, READ16LE(", ")));
+          RETURN_ON_ERROR(appendw(buf, '}'));
+          FreeStrList(&sl);
           LuaPopVisit(visited);
-          appendw(buf, '}');
         } else {
-          appendf(buf, "\"cyclic@%p\"", lua_topointer(L, idx));
+          RETURN_ON_ERROR(
+              appendf(buf, "\"%s@%p\"", "cyclic", lua_topointer(L, idx)));
         }
         return 0;
 
       default:
-        free(visited->p);
-        luaL_error(L, "can't serialize value of this type");
-        unreachable;
+        // unsupported lua type
+        goto OnError;
     }
   } else {
-    free(visited->p);
-    luaL_error(L, "too many nested tables");
-    unreachable;
+    // too much depth
+    goto OnError;
   }
+OnError:
+  FreeStrList(&sl);
+  return -1;
 }
 
+/**
+ * Encodes Lua data structure as Lua code string.
+ *
+ * @param L is Lua interpreter state
+ * @param buf receives encoded output string
+ * @param numformat controls double formatting
+ * @param idx is index of item on Lua stack
+ * @return 0 on success, or -1 on error
+ */
 int LuaEncodeLuaData(lua_State *L, char **buf, char *numformat, int idx) {
   int rc;
   struct LuaVisited visited = {0};
   rc = LuaEncodeLuaDataImpl(L, buf, 64, numformat, idx, &visited);
-  assert(!visited.n);
   free(visited.p);
   return rc;
 }

third_party/lua/visitor.c

@@ -20,16 +20,23 @@
 #include "libc/x/x.h"
 #include "third_party/lua/visitor.h"
 
-bool LuaPushVisit(struct LuaVisited *visited, const void *p) {
-  int i;
+int LuaPushVisit(struct LuaVisited *visited, const void *p) {
+  int i, n2;
+  const void **p2;
   for (i = 0; i < visited->n; ++i) {
     if (visited->p[i] == p) {
-      return false;
+      return 1;
     }
   }
-  visited->p = xrealloc(visited->p, ++visited->n * sizeof(*visited->p));
+  n2 = visited->n;
+  if ((p2 = realloc(visited->p, ++n2 * sizeof(*visited->p)))) {
+    visited->p = p2;
+    visited->n = n2;
+  } else {
+    return -1;
+  }
   visited->p[visited->n - 1] = p;
-  return true;
+  return 0;
 }
 
 void LuaPopVisit(struct LuaVisited *visited) {

third_party/lua/visitor.h

@@ -8,7 +8,7 @@ struct LuaVisited {
   const void **p;
 };
 
-bool LuaPushVisit(struct LuaVisited *, const void *);
+int LuaPushVisit(struct LuaVisited *, const void *);
 void LuaPopVisit(struct LuaVisited *);
 
 COSMOPOLITAN_C_END_