Fix possible C stack overflow with json.decode

src/ljson.cpp

@@ -21,7 +21,16 @@ static int encode(lua_State* L) {
 static int decode(lua_State* L)
 {
 	int flags = (int)luaL_optinteger(L, 2, 0);
-	if (auto root = soup::json::decode(pluto_checkstring(L, 1)))
+	soup::UniquePtr<soup::JsonNode> root;
+	try
+	{
+		root = soup::json::decode(pluto_checkstring(L, 1));
+	}
+	catch (const std::exception& e)
+	{
+		luaL_error(L, e.what());
+	}
+	if (root)
 	{
 		pushFromJson(L, *root, flags);
 		return 1;

src/vendor/Soup/soup/JsonArray.cpp

@@ -16,13 +16,13 @@ NAMESPACE_SOUP
 	{
 	}
 
-	JsonArray::JsonArray(const char*& c)
+	JsonArray::JsonArray(const char*& c, int max_depth)
 		: JsonArray()
 	{
 		while (true)
 		{
 			json::handleLeadingSpace(c);
-			auto val = json::decode(c);
+			auto val = json::decode(c, max_depth);
 			if (!val)
 			{
 				break;

src/vendor/Soup/soup/JsonArray.hpp

@@ -35,7 +35,7 @@ NAMESPACE_SOUP
 		std::vector<UniquePtr<JsonNode>> children{};
 
 		explicit JsonArray() noexcept;
-		explicit JsonArray(const char*& c);
+		explicit JsonArray(const char*& c, int max_depth);
 
 		void encodeAndAppendTo(std::string& str) const SOUP_EXCAL final;
 		void encodePrettyAndAppendTo(std::string& str, unsigned depth = 0) const SOUP_EXCAL;

src/vendor/Soup/soup/JsonObject.cpp

@@ -18,7 +18,7 @@ NAMESPACE_SOUP
 	{
 	}
 
-	JsonObject::JsonObject(const char*& c) noexcept
+	JsonObject::JsonObject(const char*& c, int max_depth) noexcept
 		: JsonObject()
 	{
 		while (true)
@@ -28,12 +28,12 @@ NAMESPACE_SOUP
 			{
 				break;
 			}
-			auto key = json::decode(c);
+			auto key = json::decode(c, max_depth);
 			while (string::isSpace(*c) || *c == ':')
 			{
 				++c;
 			}
-			auto val = json::decode(c);
+			auto val = json::decode(c, max_depth);
 			if (!key || !val)
 			{
 				break;

src/vendor/Soup/soup/JsonObject.hpp

@@ -17,7 +17,7 @@ NAMESPACE_SOUP
 		Container children{};
 
 		explicit JsonObject() noexcept;
-		explicit JsonObject(const char*& c) noexcept;
+		explicit JsonObject(const char*& c, int max_depth) noexcept;
 
 		void encodeAndAppendTo(std::string& str) const SOUP_EXCAL final;
 		void encodePrettyAndAppendTo(std::string& str, unsigned depth = 0) const SOUP_EXCAL;

src/vendor/Soup/soup/json.cpp

@@ -12,18 +12,20 @@
 
 NAMESPACE_SOUP
 {
-	UniquePtr<JsonNode> json::decode(const std::string& data)
+	UniquePtr<JsonNode> json::decode(const std::string& data, int max_depth)
 	{
 		if (data.empty())
 		{
 			return {};
 		}
 		const char* c = data.c_str();
-		return decode(c);
+		return decode(c, max_depth);
 	}
 
-	UniquePtr<JsonNode> json::decode(const char*& c)
+	UniquePtr<JsonNode> json::decode(const char*& c, int max_depth)
 	{
+		SOUP_ASSERT(max_depth != 0, "Depth limit exceeded");
+
 		handleLeadingSpace(c);
 
 		switch (*c)
@@ -34,11 +36,11 @@ NAMESPACE_SOUP
 
 		case '[':
 			++c;
-			return soup::make_unique<JsonArray>(c);
+			return soup::make_unique<JsonArray>(c, max_depth - 1);
 
 		case '{':
 			++c;
-			return soup::make_unique<JsonObject>(c);
+			return soup::make_unique<JsonObject>(c, max_depth - 1);
 		}
 
 		std::string buf{};
@@ -122,22 +124,7 @@ NAMESPACE_SOUP
 		return {};
 	}
 
-	void json::decode(UniquePtr<JsonNode>& out, const std::string& data)
-	{
-		out = decode(data);
-	}
-
-	UniquePtr<JsonNode> json::decodeForDedicatedVariable(const std::string& data)
-	{
-		return decode(data);
-	}
-
-	void json::binaryDecode(UniquePtr<JsonNode>& out, Reader& r)
-	{
-		out = binaryDecodeForDedicatedVariable(r);
-	}
-
-	UniquePtr<JsonNode> json::binaryDecodeForDedicatedVariable(Reader& r)
+	UniquePtr<JsonNode> json::binaryDecode(Reader& r)
 	{
 		uint8_t b;
 		if (r.u8(b))
@@ -190,7 +177,7 @@ NAMESPACE_SOUP
 				{
 					UniquePtr<JsonNode> node;
 
-					if (binaryDecode(node, r), !node)
+					if (node = binaryDecode(r), !node)
 					{
 						break;
 					}
@@ -207,11 +194,11 @@ NAMESPACE_SOUP
 					UniquePtr<JsonNode> key;
 					UniquePtr<JsonNode> val;
 
-					if (binaryDecode(key, r), !key)
+					if (key = binaryDecode(r), !key)
 					{
 						break;
 					}
-					if (binaryDecode(val, r), !val)
+					if (val = binaryDecode(r), !val)
 					{
 						break;
 					}

src/vendor/Soup/soup/json.hpp

@@ -19,15 +19,11 @@ NAMESPACE_SOUP
 		// Don't do json::decode(...)->... because:
 		// 1. UniquePtr manages the lifetime, by using the return value as a temporary like that, you will use-after-free.
 		// 2. The returned UniquePtr might be default-constructed in case of a parse error, so you'd be dereferencing a nullptr.
-		[[nodiscard]] static UniquePtr<JsonNode> decode(const std::string& data);
-		[[nodiscard]] static UniquePtr<JsonNode> decode(const char*& c);
-
-		[[deprecated]] static void decode(UniquePtr<JsonNode>& out, const std::string& data);
-		[[deprecated]] static UniquePtr<JsonNode> decodeForDedicatedVariable(const std::string& data);
+		[[nodiscard]] static UniquePtr<JsonNode> decode(const std::string& data, int max_depth = 100);
+		[[nodiscard]] static UniquePtr<JsonNode> decode(const char*& c, int max_depth);
 
 		// specific to soup
-		static void binaryDecode(UniquePtr<JsonNode>& out, Reader& r);
-		[[nodiscard]] static UniquePtr<JsonNode> binaryDecodeForDedicatedVariable(Reader& r);
+		[[nodiscard]] static UniquePtr<JsonNode> binaryDecode(Reader& r);
 
 		// internal
 		static void handleLeadingSpace(const char*& c);

testes/pluto/basic.pluto

@@ -1551,6 +1551,9 @@ do
     assert(json.decode([[{"a":null]]).a == nil)
     assert(json.decode([[{"a":null}]], json.withnull).a == json.null)
 
+    -- Don't want a C stack overflow here
+    assert(not pcall(|| -> require"json".decode("[":rep(10000).."]":rep(10000))))
+
     do
         local t = {
             __order = { "a", "b", "c" },