Replace URL decoder with a simpler implementation.

extra/api-stresstest.sh

@@ -14,12 +14,13 @@
 
 WIFIBOX_IP=192.168.5.1
 #WIFIBOX_IP=192.168.10.1
-API_BASE=$WIFIBOX_IP/d3dapi
+#API_BASE=$WIFIBOX_IP/d3dapi
+API_BASE=$WIFIBOX_IP/cgi-bin/d3dapi
 WGET=wget
 #REQUEST_PATH=network/status
 REQUEST_PATH=printer/print
 #POST_PARMS=--post-data=xyzzy
-POST_PARMS=--post-file=lorem.txt
+POST_PARMS=--post-file=200k.gcode
 
 RETRIES=1
 

src/main.lua

@@ -160,7 +160,7 @@ local function init(environment)
 	return true
 end
 
- local function main(environment)
+local function main(environment)
 	local rq = RequestClass.new(environment, postData, confDefaults.DEBUG_API)
 
 	if rq:getRequestMethod() == 'CMDLINE' and rq:get('autowifi') ~= nil then

src/rest/request.lua

@@ -23,7 +23,7 @@ M.resolutionError = nil --non-nil means function could not be resolved
 local function kvTableFromUrlEncodedString(encodedText)
 	local args = {}
 	if (encodedText ~= nil) then
-		urlcode.parsequery(encodedText, args)
+		urlcode.parsequeryNoRegex(encodedText, args)
 	end
 	return args
 

src/test/test_urlcode.lua

@@ -0,0 +1,70 @@
+-- TODO: also test malformed query strings
+local urlcode = require("util.urlcode")
+
+local M = {
+	_is_test = true,
+	_skip = {},
+	_wifibox_only = {}
+}
+
+-- NOTE: the previous approach using #t1 and #t2 was too naive and only worked for tables with contiguous ranges of numeric keys.
+local function compareTables(t1, t2)
+	local len = 0
+
+	for k1,v1 in pairs(t1) do
+		len = len + 1
+		if t2[k1] ~= v1 then return false end
+	end
+
+	for _ in pairs(t2) do len = len - 1 end
+
+	return len == 0 and true or false
+end
+
+local queryTexts = {
+	[1] = "k1=v1&k2=v2x&k3yy=v3",
+	[2] = "k1=v1&k2=v2x&k3yy=v3&",
+	[3] = "k1=v1&k2=v2x&k3yy=v3&=",
+	[4] = "k1=v1&k2=v2x&k3yy=v3& =",
+	[5] = ""
+}
+
+local queryTables = {
+	[1] = { ["k1"] = "v1", ["k2"] = "v2x", ["k3yy"] = "v3" },
+	[2] = { ["k1"] = "v1", ["k2"] = "v2x", ["k3yy"] = "v3" },
+	[3] = { ["k1"] = "v1", ["k2"] = "v2x", ["k3yy"] = "v3" },
+	[4] = { ["k1"] = "v1", ["k2"] = "v2x", ["k3yy"] = "v3", [" "] = "" },
+	[5] = {}
+}
+
+function M:_setup()
+	local longValue = ""
+	for i=1,5000 do
+		longValue = longValue .. i .. ": abcdefghijklmnopqrstuvwxyz\n"
+	end
+
+	table.insert(queryTexts, "shortkey=&longkey=" .. longValue)
+	table.insert(queryTables, { ["shortkey"] = "", ["longkey"] = longValue })
+end
+
+function M:_teardown()
+end
+
+
+function M:test_parsequery()
+	for i=1,#queryTexts do
+		local args = {}
+		urlcode.parsequery(queryTexts[i], args)
+		assert(compareTables(queryTables[i], args))
+	end
+end
+
+function M:test_parsequeryNoRegex()
+	for i=1,#queryTexts do
+		local args = {}
+		urlcode.parsequeryNoRegex(queryTexts[i], args)
+		assert(compareTables(queryTables[i], args))
+	end
+end
+
+return M

src/util/urlcode.lua

@@ -15,32 +15,32 @@ local _M = {}
 
 -- Converts an hexadecimal code in the form %XX to a character
 local function hexcode2char (h)
-return strchar(tonumber(h,16))
+	return strchar(tonumber(h,16))
 end
 
 ----------------------------------------------------------------------------
 -- Decode an URL-encoded string (see RFC 2396)
 ----------------------------------------------------------------------------
 function _M.unescape (str)
-str = gsub (str, "+", " ")
-str = gsub (str, "%%(%x%x)", hexcode2char)
-str = gsub (str, "\r\n", "\n")
-return str
+	str = gsub (str, "+", " ")
+	str = gsub (str, "%%(%x%x)", hexcode2char)
+	str = gsub (str, "\r\n", "\n")
+	return str
 end
 
 -- Converts a character to an hexadecimal code in the form %XX
 local function char2hexcode (c)
-return strformat ("%%%02X", strbyte(c))
+	return strformat ("%%%02X", strbyte(c))
 end
 
 ----------------------------------------------------------------------------
 -- URL-encode a string (see RFC 2396)
 ----------------------------------------------------------------------------
 function _M.escape (str)
-str = gsub (str, "\n", "\r\n")
-str = gsub (str, "([^0-9a-zA-Z ])", char2hexcode) -- locale independent
-str = gsub (str, " ", "+")
-return str
+	str = gsub (str, "\n", "\r\n")
+	str = gsub (str, "([^0-9a-zA-Z ])", char2hexcode) -- locale independent
+	str = gsub (str, " ", "+")
+	return str
 end
 
 ----------------------------------------------------------------------------
@@ -52,21 +52,21 @@ end
 -- (in the order they came).
 ----------------------------------------------------------------------------
 function _M.insertfield (args, name, value)
-if not args[name] then
-args[name] = value
-else
-local t = type (args[name])
-if t == "string" then
-args[name] = {
-args[name],
-value,
-}
-elseif t == "table" then
-tinsert (args[name], value)
-else
-error ("CGILua fatal error (invalid args table)!")
-end
-end
+	if not args[name] then
+		args[name] = value
+	else
+		local t = type (args[name])
+		if t == "string" then
+			args[name] = {
+				args[name],
+				value,
+			}
+		elseif t == "table" then
+			tinsert (args[name], value)
+		else
+			error ("CGILua fatal error (invalid args table)!")
+		end
+	end
 end
 
 ----------------------------------------------------------------------------
@@ -78,13 +78,45 @@ end
 -- @param args Table where to store the pairs.
 ----------------------------------------------------------------------------
 function _M.parsequery (query, args)
-if type(query) == "string" then
-local insertfield, unescape = _M.insertfield, _M.unescape
-gsub (query, "([^&=]+)=([^&=]*)&?",
-function (key, val)
-_M.insertfield (args, unescape(key), unescape(val))
-end)
+	if type(query) == "string" then
+		local insertfield, unescape = _M.insertfield, _M.unescape
+		gsub (query, "([^&=]+)=([^&=]*)&?",
+		function (key, val)
+			_M.insertfield (args, unescape(key), unescape(val))
+		end)
+	end
 end
+
+----------------------------------------------------------------------------
+-- Parse url-encoded request data without using regular expressions
+-- (the query part of the script URL or url-encoded post data)
+--
+-- Each decoded (name=value) pair is inserted into table [[args]]
+-- @param query String to be parsed.
+-- @param args Table where to store the pairs.
+----------------------------------------------------------------------------
+function _M.parsequeryNoRegex (query, args)
+	if type(query) == "string" then
+		local insertfield, unescape = _M.insertfield, _M.unescape
+
+		local k = 1
+		while true do
+			local v = query:find('=', k+1, true) -- look for '=', assuming a key of at least 1 character and do not perform pattern matching
+			if not v then break end -- no k/v pairs left
+
+			v = v + 1
+			local ampersand = query:find('&', v, true)
+			if not ampersand then ampersand = 0 end -- 0 will become -1 in the substring call below...meaning end of string
+
+			local key = query:sub(k, v-1)
+			local value = query:sub(v, ampersand - 1)
+			insertfield (args, unescape(key), unescape(value))
+
+			if ampersand == 0 then break end -- we couldn't find any ampersands anymore so this was the last k/v
+
+			k = ampersand + 1
+		end
+	end
 end
 
 ----------------------------------------------------------------------------
@@ -94,21 +126,21 @@ end
 -- @return String with the resulting encoding.
 ----------------------------------------------------------------------------
 function _M.encodetable (args)
-if args == nil or next(args) == nil then	-- no args or empty args?
-return ""
-end
-local escape = _M.escape
-local strp = ""
-for key, vals in pairs(args) do
-if type(vals) ~= "table" then
-vals = {vals}
-end
-for i,val in ipairs(vals) do
-strp = strp.."&"..escape(key).."="..escape(val)
-end
-end
--- remove first &
-return strsub(strp,2)
+	if args == nil or next(args) == nil then	-- no args or empty args?
+		return ""
+	end
+	local escape = _M.escape
+	local strp = ""
+	for key, vals in pairs(args) do
+		if type(vals) ~= "table" then
+			vals = {vals}
+		end
+		for i,val in ipairs(vals) do
+			strp = strp.."&"..escape(key).."="..escape(val)
+		end
+	end
+	-- remove first &
+	return strsub(strp,2)
 end
 
 return _M