luci-base: move some generic classes into a separate luci-base-libs package

The new package luci-base-libs provides the modules that not strictly relate
to the web-interface of luci. By separating these libs they can be used by
other packages without having to install the web-components.
This change was inspired by providing a shell-only interface for 4MB-flash
devices, by keeping as much code common with a full install.

Signed-off-by: Sven Roederer <freifunk@it-solutions.geroedel.de>

6 files changed, 0 insertions, 2356 deletions

diff --git a/modules/luci-base/luasrc/debug.lua b/modules/luci-base/luasrc/debug.lua
deleted file mode 100644
index 8ff1bb6981..0000000000
--- a/modules/luci-base/luasrc/debug.lua
+++ /dev/null
@@ -1,37 +0,0 @@
-local debug = require "debug"
-local io = require "io"
-local collectgarbage, floor = collectgarbage, math.floor
-
-module "luci.debug"
-__file__ = debug.getinfo(1, 'S').source:sub(2)
-
--- Enables the memory tracer with given flags and returns a function to disable the tracer again
-function trap_memtrace(flags, dest)
-	flags = flags or "clr"
-	local tracefile = io.open(dest or "/tmp/memtrace", "w")
-	local peak = 0
-
-	local function trap(what, line)
-		local info = debug.getinfo(2, "Sn")
-		local size = floor(collectgarbage("count"))
-		if size > peak then
-			peak = size
-		end
-		if tracefile then
-			tracefile:write(
-				"[", what, "] ", info.source, ":", (line or "?"), "\t",
-				(info.namewhat or ""), "\t",
-				(info.name or ""), "\t",
-				size, " (", peak, ")\n"
-			)
-		end
-	end
-
-	debug.sethook(trap, flags)
-
-	return function()
-		debug.sethook()
-		tracefile:close()
-	end
-end
-
diff --git a/modules/luci-base/luasrc/http.lua b/modules/luci-base/luasrc/http.lua
deleted file mode 100644
index 20b55f2854..0000000000
--- a/modules/luci-base/luasrc/http.lua
+++ /dev/null
@@ -1,554 +0,0 @@
--- Copyright 2008 Steven Barth <steven@midlink.org>
--- Copyright 2010-2018 Jo-Philipp Wich <jo@mein.io>
--- Licensed to the public under the Apache License 2.0.
-
-local util  = require "luci.util"
-local coroutine = require "coroutine"
-local table = require "table"
-local lhttp = require "lucihttp"
-local nixio = require "nixio"
-local ltn12 = require "luci.ltn12"
-
-local table, ipairs, pairs, type, tostring, tonumber, error =
-	table, ipairs, pairs, type, tostring, tonumber, error
-
-module "luci.http"
-
-HTTP_MAX_CONTENT      = 1024*100		-- 100 kB maximum content size
-
-context = util.threadlocal()
-
-Request = util.class()
-function Request.__init__(self, env, sourcein, sinkerr)
-	self.input = sourcein
-	self.error = sinkerr
-
-
-	-- File handler nil by default to let .content() work
-	self.filehandler = nil
-
-	-- HTTP-Message table
-	self.message = {
-		env = env,
-		headers = {},
-		params = urldecode_params(env.QUERY_STRING or ""),
-	}
-
-	self.parsed_input = false
-end
-
-function Request.formvalue(self, name, noparse)
-	if not noparse and not self.parsed_input then
-		self:_parse_input()
-	end
-
-	if name then
-		return self.message.params[name]
-	else
-		return self.message.params
-	end
-end
-
-function Request.formvaluetable(self, prefix)
-	local vals = {}
-	prefix = prefix and prefix .. "." or "."
-
-	if not self.parsed_input then
-		self:_parse_input()
-	end
-
-	local void = self.message.params[nil]
-	for k, v in pairs(self.message.params) do
-		if k:find(prefix, 1, true) == 1 then
-			vals[k:sub(#prefix + 1)] = tostring(v)
-		end
-	end
-
-	return vals
-end
-
-function Request.content(self)
-	if not self.parsed_input then
-		self:_parse_input()
-	end
-
-	return self.message.content, self.message.content_length
-end
-
-function Request.getcookie(self, name)
-	return lhttp.header_attribute("cookie; " .. (self:getenv("HTTP_COOKIE") or ""), name)
-end
-
-function Request.getenv(self, name)
-	if name then
-		return self.message.env[name]
-	else
-		return self.message.env
-	end
-end
-
-function Request.setfilehandler(self, callback)
-	self.filehandler = callback
-
-	if not self.parsed_input then
-		return
-	end
-
-	-- If input has already been parsed then uploads are stored as unlinked
-	-- temporary files pointed to by open file handles in the parameter
-	-- value table. Loop all params, and invoke the file callback for any
-	-- param with an open file handle.
-	local name, value
-	for name, value in pairs(self.message.params) do
-		if type(value) == "table" then
-			while value.fd do
-				local data = value.fd:read(1024)
-				local eof = (not data or data == "")
-
-				callback(value, data, eof)
-
-				if eof then
-					value.fd:close()
-					value.fd = nil
-				end
-			end
-		end
-	end
-end
-
-function Request._parse_input(self)
-	parse_message_body(
-		 self.input,
-		 self.message,
-		 self.filehandler
-	)
-	self.parsed_input = true
-end
-
-function close()
-	if not context.eoh then
-		context.eoh = true
-		coroutine.yield(3)
-	end
-
-	if not context.closed then
-		context.closed = true
-		coroutine.yield(5)
-	end
-end
-
-function content()
-	return context.request:content()
-end
-
-function formvalue(name, noparse)
-	return context.request:formvalue(name, noparse)
-end
-
-function formvaluetable(prefix)
-	return context.request:formvaluetable(prefix)
-end
-
-function getcookie(name)
-	return context.request:getcookie(name)
-end
-
--- or the environment table itself.
-function getenv(name)
-	return context.request:getenv(name)
-end
-
-function setfilehandler(callback)
-	return context.request:setfilehandler(callback)
-end
-
-function header(key, value)
-	if not context.headers then
-		context.headers = {}
-	end
-	context.headers[key:lower()] = value
-	coroutine.yield(2, key, value)
-end
-
-function prepare_content(mime)
-	if not context.headers or not context.headers["content-type"] then
-		if mime == "application/xhtml+xml" then
-			if not getenv("HTTP_ACCEPT") or
-			  not getenv("HTTP_ACCEPT"):find("application/xhtml+xml", nil, true) then
-				mime = "text/html; charset=UTF-8"
-			end
-			header("Vary", "Accept")
-		end
-		header("Content-Type", mime)
-	end
-end
-
-function source()
-	return context.request.input
-end
-
-function status(code, message)
-	code = code or 200
-	message = message or "OK"
-	context.status = code
-	coroutine.yield(1, code, message)
-end
-
--- This function is as a valid LTN12 sink.
--- If the content chunk is nil this function will automatically invoke close.
-function write(content, src_err)
-	if not content then
-		if src_err then
-			error(src_err)
-		else
-			close()
-		end
-		return true
-	elseif #content == 0 then
-		return true
-	else
-		if not context.eoh then
-			if not context.status then
-				status()
-			end
-			if not context.headers or not context.headers["content-type"] then
-				header("Content-Type", "text/html; charset=utf-8")
-			end
-			if not context.headers["cache-control"] then
-				header("Cache-Control", "no-cache")
-				header("Expires", "0")
-			end
-			if not context.headers["x-frame-options"] then
-				header("X-Frame-Options", "SAMEORIGIN")
-			end
-			if not context.headers["x-xss-protection"] then
-				header("X-XSS-Protection", "1; mode=block")
-			end
-			if not context.headers["x-content-type-options"] then
-				header("X-Content-Type-Options", "nosniff")
-			end
-
-			context.eoh = true
-			coroutine.yield(3)
-		end
-		coroutine.yield(4, content)
-		return true
-	end
-end
-
-function splice(fd, size)
-	coroutine.yield(6, fd, size)
-end
-
-function redirect(url)
-	if url == "" then url = "/" end
-	status(302, "Found")
-	header("Location", url)
-	close()
-end
-
-function build_querystring(q)
-	local s, n, k, v = {}, 1, nil, nil
-
-	for k, v in pairs(q) do
-		s[n+0] = (n == 1) and "?" or "&"
-		s[n+1] = util.urlencode(k)
-		s[n+2] = "="
-		s[n+3] = util.urlencode(v)
-		n = n + 4
-	end
-
-	return table.concat(s, "")
-end
-
-urldecode = util.urldecode
-
-urlencode = util.urlencode
-
-function write_json(x)
-	util.serialize_json(x, write)
-end
-
--- from given url or string. Returns a table with urldecoded values.
--- Simple parameters are stored as string values associated with the parameter
--- name within the table. Parameters with multiple values are stored as array
--- containing the corresponding values.
-function urldecode_params(url, tbl)
-	local parser, name
-	local params = tbl or { }
-
-	parser = lhttp.urlencoded_parser(function (what, buffer, length)
-		if what == parser.TUPLE then
-			name, value = nil, nil
-		elseif what == parser.NAME then
-			name = lhttp.urldecode(buffer)
-		elseif what == parser.VALUE and name then
-			params[name] = lhttp.urldecode(buffer) or ""
-		end
-
-		return true
-	end)
-
-	if parser then
-		parser:parse((url or ""):match("[^?]*$"))
-		parser:parse(nil)
-	end
-
-	return params
-end
-
--- separated by "&". Tables are encoded as parameters with multiple values by
--- repeating the parameter name with each value.
-function urlencode_params(tbl)
-	local k, v
-	local n, enc = 1, {}
-	for k, v in pairs(tbl) do
-		if type(v) == "table" then
-			local i, v2
-			for i, v2 in ipairs(v) do
-				if enc[1] then
-					enc[n] = "&"
-					n = n + 1
-				end
-
-				enc[n+0] = lhttp.urlencode(k)
-				enc[n+1] = "="
-				enc[n+2] = lhttp.urlencode(v2)
-				n = n + 3
-			end
-		else
-			if enc[1] then
-				enc[n] = "&"
-				n = n + 1
-			end
-
-			enc[n+0] = lhttp.urlencode(k)
-			enc[n+1] = "="
-			enc[n+2] = lhttp.urlencode(v)
-			n = n + 3
-		end
-	end
-
-	return table.concat(enc, "")
-end
-
--- Content-Type. Stores all extracted data associated with its parameter name
--- in the params table within the given message object. Multiple parameter
--- values are stored as tables, ordinary ones as strings.
--- If an optional file callback function is given then it is fed with the
--- file contents chunk by chunk and only the extracted file name is stored
--- within the params table. The callback function will be called subsequently
--- with three arguments:
---  o Table containing decoded (name, file) and raw (headers) mime header data
---  o String value containing a chunk of the file data
---  o Boolean which indicates whether the current chunk is the last one (eof)
-function mimedecode_message_body(src, msg, file_cb)
-	local parser, header, field
-	local len, maxlen = 0, tonumber(msg.env.CONTENT_LENGTH or nil)
-
-	parser, err = lhttp.multipart_parser(msg.env.CONTENT_TYPE, function (what, buffer, length)
-		if what == parser.PART_INIT then
-			field = { }
-
-		elseif what == parser.HEADER_NAME then
-			header = buffer:lower()
-
-		elseif what == parser.HEADER_VALUE and header then
-			if header:lower() == "content-disposition" and
-			   lhttp.header_attribute(buffer, nil) == "form-data"
-			then
-				field.name = lhttp.header_attribute(buffer, "name")
-				field.file = lhttp.header_attribute(buffer, "filename")
-				field[1] = field.file
-			end
-
-			if field.headers then
-				field.headers[header] = buffer
-			else
-				field.headers = { [header] = buffer }
-			end
-
-		elseif what == parser.PART_BEGIN then
-			return not field.file
-
-		elseif what == parser.PART_DATA and field.name and length > 0 then
-			if field.file then
-				if file_cb then
-					file_cb(field, buffer, false)
-					msg.params[field.name] = msg.params[field.name] or field
-				else
-					if not field.fd then
-						field.fd = nixio.mkstemp(field.name)
-					end
-
-					if field.fd then
-						field.fd:write(buffer)
-						msg.params[field.name] = msg.params[field.name] or field
-					end
-				end
-			else
-				field.value = buffer
-			end
-
-		elseif what == parser.PART_END and field.name then
-			if field.file and msg.params[field.name] then
-				if file_cb then
-					file_cb(field, "", true)
-				elseif field.fd then
-					field.fd:seek(0, "set")
-				end
-			else
-				local val = msg.params[field.name]
-
-				if type(val) == "table" then
-					val[#val+1] = field.value or ""
-				elseif val ~= nil then
-					msg.params[field.name] = { val, field.value or "" }
-				else
-					msg.params[field.name] = field.value or ""
-				end
-			end
-
-			field = nil
-
-		elseif what == parser.ERROR then
-			err = buffer
-		end
-
-		return true
-	end, HTTP_MAX_CONTENT)
-
-	return ltn12.pump.all(src, function (chunk)
-		len = len + (chunk and #chunk or 0)
-
-		if maxlen and len > maxlen + 2 then
-			return nil, "Message body size exceeds Content-Length"
-		end
-
-		if not parser or not parser:parse(chunk) then
-			return nil, err
-		end
-
-		return true
-	end)
-end
-
--- Content-Type. Stores all extracted data associated with its parameter name
--- in the params table within the given message object. Multiple parameter
--- values are stored as tables, ordinary ones as strings.
-function urldecode_message_body(src, msg)
-	local err, name, value, parser
-	local len, maxlen = 0, tonumber(msg.env.CONTENT_LENGTH or nil)
-
-	parser = lhttp.urlencoded_parser(function (what, buffer, length)
-		if what == parser.TUPLE then
-			name, value = nil, nil
-		elseif what == parser.NAME then
-			name = lhttp.urldecode(buffer, lhttp.DECODE_PLUS)
-		elseif what == parser.VALUE and name then
-			local val = msg.params[name]
-
-			if type(val) == "table" then
-				val[#val+1] = lhttp.urldecode(buffer, lhttp.DECODE_PLUS) or ""
-			elseif val ~= nil then
-				msg.params[name] = { val, lhttp.urldecode(buffer, lhttp.DECODE_PLUS) or "" }
-			else
-				msg.params[name] = lhttp.urldecode(buffer, lhttp.DECODE_PLUS) or ""
-			end
-		elseif what == parser.ERROR then
-			err = buffer
-		end
-
-		return true
-	end, HTTP_MAX_CONTENT)
-
-	return ltn12.pump.all(src, function (chunk)
-		len = len + (chunk and #chunk or 0)
-
-		if maxlen and len > maxlen + 2 then
-			return nil, "Message body size exceeds Content-Length"
-		elseif len > HTTP_MAX_CONTENT then
-			return nil, "Message body size exceeds maximum allowed length"
-		end
-
-		if not parser or not parser:parse(chunk) then
-			return nil, err
-		end
-
-		return true
-	end)
-end
-
--- This function will examine the Content-Type within the given message object
--- to select the appropriate content decoder.
--- Currently the application/x-www-urlencoded and application/form-data
--- mime types are supported. If the encountered content encoding can't be
--- handled then the whole message body will be stored unaltered as "content"
--- property within the given message object.
-function parse_message_body(src, msg, filecb)
-	if msg.env.CONTENT_LENGTH or msg.env.REQUEST_METHOD == "POST" then
-		local ctype = lhttp.header_attribute(msg.env.CONTENT_TYPE, nil)
-
-		-- Is it multipart/mime ?
-		if ctype == "multipart/form-data" then
-			return mimedecode_message_body(src, msg, filecb)
-
-		-- Is it application/x-www-form-urlencoded ?
-		elseif ctype == "application/x-www-form-urlencoded" then
-			return urldecode_message_body(src, msg)
-
-		end
-
-		-- Unhandled encoding
-		-- If a file callback is given then feed it chunk by chunk, else
-		-- store whole buffer in message.content
-		local sink
-
-		-- If we have a file callback then feed it
-		if type(filecb) == "function" then
-			local meta = {
-				name = "raw",
-				encoding = msg.env.CONTENT_TYPE
-			}
-			sink = function( chunk )
-				if chunk then
-					return filecb(meta, chunk, false)
-				else
-					return filecb(meta, nil, true)
-				end
-			end
-		-- ... else append to .content
-		else
-			msg.content = ""
-			msg.content_length = 0
-
-			sink = function( chunk )
-				if chunk then
-					if ( msg.content_length + #chunk ) <= HTTP_MAX_CONTENT then
-						msg.content        = msg.content        .. chunk
-						msg.content_length = msg.content_length + #chunk
-						return true
-					else
-						return nil, "POST data exceeds maximum allowed length"
-					end
-				end
-				return true
-			end
-		end
-
-		-- Pump data...
-		while true do
-			local ok, err = ltn12.pump.step( src, sink )
-
-			if not ok and err then
-				return nil, err
-			elseif not ok then -- eof
-				return true
-			end
-		end
-
-		return true
-	end
-
-	return false
-end
diff --git a/modules/luci-base/luasrc/http.luadoc b/modules/luci-base/luasrc/http.luadoc
deleted file mode 100644
index 8f6f380d8b..0000000000
--- a/modules/luci-base/luasrc/http.luadoc
+++ /dev/null
@@ -1,260 +0,0 @@
----[[
-LuCI Web Framework high-level HTTP functions.
-]]
-module "luci.http"
-
----[[
-Close the HTTP-Connection.
-
-@class			function
-@name			close
-]]
-
----[[
-Return the request content if the request was of unknown type.
-
-@class			function
-@name			content
-@return			HTTP request body
-@return			HTTP request body length
-]]
-
----[[
-Get a certain HTTP input value or a table of all input values.
-
-@class			function
-@name			formvalue
-@param name		Name of the GET or POST variable to fetch
-@param noparse	Don't parse POST data before getting the value
-@return			HTTP input value or table of all input value
-]]
-
----[[
-Get a table of all HTTP input values with a certain prefix.
-
-@class			function
-@name			formvaluetable
-@param prefix	Prefix
-@return			Table of all HTTP input values with given prefix
-]]
-
----[[
-Get the value of a certain HTTP-Cookie.
-
-@class			function
-@name			getcookie
-@param name		Cookie Name
-@return			String containing cookie data
-]]
-
----[[
-Get the value of a certain HTTP environment variable
-or the environment table itself.
-
-@class			function
-@name			getenv
-@param name		Environment variable
-@return			HTTP environment value or environment table
-]]
-
----[[
-Set a handler function for incoming user file uploads.
-
-@class			function
-@name			setfilehandler
-@param callback	Handler function
-]]
-
----[[
-Send a HTTP-Header.
-
-@class			function
-@name			header
-@param key		Header key
-@param value	Header value
-]]
-
----[[
-Set the mime type of following content data.
-
-@class			function
-@name			prepare_content
-@param mime		Mimetype of following content
-]]
-
----[[
-Get the RAW HTTP input source
-
-@class			function
-@name			source
-@return			HTTP LTN12 source
-]]
-
----[[
-Set the HTTP status code and status message.
-
-@class			function
-@name			status
-@param code		Status code
-@param message	Status message
-]]
-
----[[
-Send a chunk of content data to the client.
-
-This function is as a valid LTN12 sink.
-If the content chunk is nil this function will automatically invoke close.
-
-@class			function
-@name			write
-@param content	Content chunk
-@param src_err	Error object from source (optional)
-@see close
-]]
-
----[[
-Splice data from a filedescriptor to the client.
-
-@class			function
-@name			splice
-@param fp		File descriptor
-@param size		Bytes to splice (optional)
-]]
-
----[[
-Redirects the client to a new URL and closes the connection.
-
-@class			function
-@name			redirect
-@param url		Target URL
-]]
-
----[[
-Create a querystring out of a table of key - value pairs.
-
-@class			function
-@name			build_querystring
-@param table	Query string source table
-@return			Encoded HTTP query string
-]]
-
----[[
-Return the URL-decoded equivalent of a string.
-
-@class			function
-@name			urldecode
-@param str		URL-encoded string
-@param no_plus	Don't decode + to " "
-@return			URL-decoded string
-@see			urlencode
-]]
-
----[[
-Return the URL-encoded equivalent of a string.
-
-@class			function
-@name			urlencode
-@param str		Source string
-@return			URL-encoded string
-@see			urldecode
-]]
-
----[[
-Send the given data as JSON encoded string.
-
-@class			function
-@name			write_json
-@param data		Data to send
-]]
-
----[[
-Extract and split urlencoded data pairs, separated bei either "&" or ";"
-from given url or string. Returns a table with urldecoded values.
-
-Simple parameters are stored as string values associated with the parameter
-name within the table. Parameters with multiple values are stored as array
-containing the corresponding values.
-
-@class			function
-@name			urldecode_params
-@param url		The url or string which contains x-www-urlencoded form data
-@param tbl		Use the given table for storing values (optional)
-@return			Table containing the urldecoded parameters
-@see			urlencode_params
-]]
-
----[[
-Encode each key-value-pair in given table to x-www-urlencoded format,
-separated by "&".
-
-Tables are encoded as parameters with multiple values by repeating the
-parameter name with each value.
-
-@class			function
-@name			urlencode_params
-@param tbl		Table with the values
-@return			String containing encoded values
-@see			urldecode_params
-]]
-
----[[
-Decode a mime encoded http message body with multipart/form-data Content-Type.
-
-Stores all extracted data associated with its parameter name
-in the params table within the given message object. Multiple parameter
-values are stored as tables, ordinary ones as strings.
-
-If an optional file callback function is given then it is fed with the
-file contents chunk by chunk and only the extracted file name is stored
-within the params table. The callback function will be called subsequently
-with three arguments:
- o Table containing decoded (name, file) and raw (headers) mime header data
- o String value containing a chunk of the file data
- o Boolean which indicates whether the current chunk is the last one (eof)
-
-@class			function
-@name			mimedecode_message_body
-@param src		Ltn12 source function
-@param msg		HTTP message object
-@param filecb	File callback function (optional)
-@return			Value indicating successful operation (not nil means "ok")
-@return			String containing the error if unsuccessful
-@see			parse_message_header
-]]
-
----[[
-Decode an urlencoded http message body with application/x-www-urlencoded
-Content-Type.
-
-Stores all extracted data associated with its parameter name in the params
-table within the given message object. Multiple parameter values are stored
-as tables, ordinary ones as strings.
-
-@class			function
-@name			urldecode_message_body
-@param src		Ltn12 source function
-@param msg		HTTP message object
-@return			Value indicating successful operation (not nil means "ok")
-@return			String containing the error if unsuccessful
-@see			parse_message_header
-]]
-
----[[
-Try to extract and decode a http message body from the given ltn12 source.
-This function will examine the Content-Type within the given message object
-to select the appropriate content decoder.
-
-Currently the application/x-www-urlencoded and application/form-data
-mime types are supported. If the encountered content encoding can't be
-handled then the whole message body will be stored unaltered as "content"
-property within the given message object.
-
-@class			function
-@name			parse_message_body
-@param src		Ltn12 source function
-@param msg		HTTP message object
-@param filecb	File data callback (optional, see mimedecode_message_body())
-@return			Value indicating successful operation (not nil means "ok")
-@return			String containing the error if unsuccessful
-@see			parse_message_header
-]]
diff --git a/modules/luci-base/luasrc/ltn12.lua b/modules/luci-base/luasrc/ltn12.lua
deleted file mode 100644
index 3a7268ccae..0000000000
--- a/modules/luci-base/luasrc/ltn12.lua
+++ /dev/null
@@ -1,316 +0,0 @@
---[[
-LuaSocket 2.0.2 license
-Copyright � 2004-2007 Diego Nehab
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-]]--
---[[
-	Changes made by LuCI project:
-		* Renamed to luci.ltn12 to avoid collisions with luasocket
-		* Added inline documentation
-]]--
------------------------------------------------------------------------------
--- LTN12 - Filters, sources, sinks and pumps.
--- LuaSocket toolkit.
--- Author: Diego Nehab
--- RCS ID: $Id$
------------------------------------------------------------------------------
-
------------------------------------------------------------------------------
--- Declare module
------------------------------------------------------------------------------
-local string = require("string")
-local table = require("table")
-local base = _G
-
--- See http://lua-users.org/wiki/FiltersSourcesAndSinks for design concepts 
-module("luci.ltn12")
-
-filter = {}
-source = {}
-sink = {}
-pump = {}
-
--- 2048 seems to be better in windows...
-BLOCKSIZE = 2048
-_VERSION = "LTN12 1.0.1"
-
------------------------------------------------------------------------------
--- Filter stuff
------------------------------------------------------------------------------
-
-
--- by passing it each chunk and updating a context between calls. 
-function filter.cycle(low, ctx, extra)
-    base.assert(low)
-    return function(chunk)
-        local ret
-        ret, ctx = low(ctx, chunk, extra)
-        return ret
-    end
-end
-
--- (thanks to Wim Couwenberg)
-function filter.chain(...)
-    local n = table.getn(arg)
-    local top, index = 1, 1
-    local retry = ""
-    return function(chunk)
-        retry = chunk and retry
-        while true do
-            if index == top then
-                chunk = arg[index](chunk)
-                if chunk == "" or top == n then return chunk
-                elseif chunk then index = index + 1
-                else
-                    top = top+1
-                    index = top
-                end
-            else
-                chunk = arg[index](chunk or "")
-                if chunk == "" then
-                    index = index - 1
-                    chunk = retry
-                elseif chunk then
-                    if index == n then return chunk
-                    else index = index + 1 end
-                else base.error("filter returned inappropriate nil") end
-            end
-        end
-    end
-end
-
------------------------------------------------------------------------------
--- Source stuff
------------------------------------------------------------------------------
-
-
--- create an empty source
-local function empty()
-    return nil
-end
-
-function source.empty()
-    return empty
-end
-
-function source.error(err)
-    return function()
-        return nil, err
-    end
-end
-
-function source.file(handle, io_err)
-    if handle then
-        return function()
-            local chunk = handle:read(BLOCKSIZE)
-            if chunk and chunk:len() == 0 then chunk = nil end
-            if not chunk then handle:close() end
-            return chunk
-        end
-    else return source.error(io_err or "unable to open file") end
-end
-
-function source.simplify(src)
-    base.assert(src)
-    return function()
-        local chunk, err_or_new = src()
-        src = err_or_new or src
-        if not chunk then return nil, err_or_new
-        else return chunk end
-    end
-end
-
-function source.string(s)
-    if s then
-        local i = 1
-        return function()
-            local chunk = string.sub(s, i, i+BLOCKSIZE-1)
-            i = i + BLOCKSIZE
-            if chunk ~= "" then return chunk
-            else return nil end
-        end
-    else return source.empty() end
-end
-
-function source.rewind(src)
-    base.assert(src)
-    local t = {}
-    return function(chunk)
-        if not chunk then
-            chunk = table.remove(t)
-            if not chunk then return src()
-            else return chunk end
-        else
-            t[#t+1] = chunk
-        end
-    end
-end
-
-function source.chain(src, f)
-    base.assert(src and f)
-    local last_in, last_out = "", ""
-    local state = "feeding"
-    local err
-    return function()
-        if not last_out then
-            base.error('source is empty!', 2)
-        end
-        while true do
-            if state == "feeding" then
-                last_in, err = src()
-                if err then return nil, err end
-                last_out = f(last_in)
-                if not last_out then
-                    if last_in then
-                        base.error('filter returned inappropriate nil')
-                    else
-                        return nil
-                    end
-                elseif last_out ~= "" then
-                    state = "eating"
-                    if last_in then last_in = "" end
-                    return last_out
-                end
-            else
-                last_out = f(last_in)
-                if last_out == "" then
-                    if last_in == "" then
-                        state = "feeding"
-                    else
-                        base.error('filter returned ""')
-                    end
-                elseif not last_out then
-                    if last_in then
-                        base.error('filter returned inappropriate nil')
-                    else
-                        return nil
-                    end
-                else
-                    return last_out
-                end
-            end
-        end
-    end
-end
-
--- Sources will be used one after the other, as if they were concatenated
--- (thanks to Wim Couwenberg)
-function source.cat(...)
-    local src = table.remove(arg, 1)
-    return function()
-        while src do
-            local chunk, err = src()
-            if chunk then return chunk end
-            if err then return nil, err end
-            src = table.remove(arg, 1)
-        end
-    end
-end
-
------------------------------------------------------------------------------
--- Sink stuff
------------------------------------------------------------------------------
-
-
-function sink.table(t)
-    t = t or {}
-    local f = function(chunk, err)
-        if chunk then t[#t+1] = chunk end
-        return 1
-    end
-    return f, t
-end
-
-function sink.simplify(snk)
-    base.assert(snk)
-    return function(chunk, err)
-        local ret, err_or_new = snk(chunk, err)
-        if not ret then return nil, err_or_new end
-        snk = err_or_new or snk
-        return 1
-    end
-end
-
-function sink.file(handle, io_err)
-    if handle then
-        return function(chunk, err)
-            if not chunk then
-                handle:close()
-                return 1
-            else return handle:write(chunk) end
-        end
-    else return sink.error(io_err or "unable to open file") end
-end
-
--- creates a sink that discards data
-local function null()
-    return 1
-end
-
-function sink.null()
-    return null
-end
-
-function sink.error(err)
-    return function()
-        return nil, err
-    end
-end
-
-function sink.chain(f, snk)
-    base.assert(f and snk)
-    return function(chunk, err)
-        if chunk ~= "" then
-            local filtered = f(chunk)
-            local done = chunk and ""
-            while true do
-                local ret, snkerr = snk(filtered, err)
-                if not ret then return nil, snkerr end
-                if filtered == done then return 1 end
-                filtered = f(done)
-            end
-        else return 1 end
-    end
-end
-
------------------------------------------------------------------------------
--- Pump stuff
------------------------------------------------------------------------------
-
-
-function pump.step(src, snk)
-    local chunk, src_err = src()
-    local ret, snk_err = snk(chunk, src_err)
-    if chunk and ret then return 1
-    else return nil, src_err or snk_err end
-end
-
-function pump.all(src, snk, step)
-    base.assert(src and snk)
-    step = step or pump.step
-    while true do
-        local ret, err = step(src, snk)
-        if not ret then
-            if err then return nil, err
-            else return 1 end
-        end
-    end
-end
-
diff --git a/modules/luci-base/luasrc/util.lua b/modules/luci-base/luasrc/util.lua
deleted file mode 100644
index a30e8b72f3..0000000000
--- a/modules/luci-base/luasrc/util.lua
+++ /dev/null
@@ -1,776 +0,0 @@
--- Copyright 2008 Steven Barth <steven@midlink.org>
--- Licensed to the public under the Apache License 2.0.
-
-local io = require "io"
-local math = require "math"
-local table = require "table"
-local debug = require "debug"
-local ldebug = require "luci.debug"
-local string = require "string"
-local coroutine = require "coroutine"
-local tparser = require "luci.template.parser"
-local json = require "luci.jsonc"
-local lhttp = require "lucihttp"
-
-local _ubus = require "ubus"
-local _ubus_connection = nil
-
-local getmetatable, setmetatable = getmetatable, setmetatable
-local rawget, rawset, unpack, select = rawget, rawset, unpack, select
-local tostring, type, assert, error = tostring, type, assert, error
-local ipairs, pairs, next, loadstring = ipairs, pairs, next, loadstring
-local require, pcall, xpcall = require, pcall, xpcall
-local collectgarbage, get_memory_limit = collectgarbage, get_memory_limit
-
-module "luci.util"
-
---
--- Pythonic string formatting extension
---
-getmetatable("").__mod = function(a, b)
-	local ok, res
-
-	if not b then
-		return a
-	elseif type(b) == "table" then
-		local k, _
-		for k, _ in pairs(b) do if type(b[k]) == "userdata" then b[k] = tostring(b[k]) end end
-
-		ok, res = pcall(a.format, a, unpack(b))
-		if not ok then
-			error(res, 2)
-		end
-		return res
-	else
-		if type(b) == "userdata" then b = tostring(b) end
-
-		ok, res = pcall(a.format, a, b)
-		if not ok then
-			error(res, 2)
-		end
-		return res
-	end
-end
-
-
---
--- Class helper routines
---
-
--- Instantiates a class
-local function _instantiate(class, ...)
-	local inst = setmetatable({}, {__index = class})
-
-	if inst.__init__ then
-		inst:__init__(...)
-	end
-
-	return inst
-end
-
--- The class object can be instantiated by calling itself.
--- Any class functions or shared parameters can be attached to this object.
--- Attaching a table to the class object makes this table shared between
--- all instances of this class. For object parameters use the __init__ function.
--- Classes can inherit member functions and values from a base class.
--- Class can be instantiated by calling them. All parameters will be passed
--- to the __init__ function of this class - if such a function exists.
--- The __init__ function must be used to set any object parameters that are not shared
--- with other objects of this class. Any return values will be ignored.
-function class(base)
-	return setmetatable({}, {
-		__call  = _instantiate,
-		__index = base
-	})
-end
-
-function instanceof(object, class)
-	local meta = getmetatable(object)
-	while meta and meta.__index do
-		if meta.__index == class then
-			return true
-		end
-		meta = getmetatable(meta.__index)
-	end
-	return false
-end
-
-
---
--- Scope manipulation routines
---
-
-coxpt = setmetatable({}, { __mode = "kv" })
-
-local tl_meta = {
-	__mode = "k",
-
-	__index = function(self, key)
-		local t = rawget(self, coxpt[coroutine.running()]
-		 or coroutine.running() or 0)
-		return t and t[key]
-	end,
-
-	__newindex = function(self, key, value)
-		local c = coxpt[coroutine.running()] or coroutine.running() or 0
-		local r = rawget(self, c)
-		if not r then
-			rawset(self, c, { [key] = value })
-		else
-			r[key] = value
-		end
-	end
-}
-
--- the current active coroutine. A thread local store is private a table object
--- whose values can't be accessed from outside of the running coroutine.
-function threadlocal(tbl)
-	return setmetatable(tbl or {}, tl_meta)
-end
-
-
---
--- Debugging routines
---
-
-function perror(obj)
-	return io.stderr:write(tostring(obj) .. "\n")
-end
-
-function dumptable(t, maxdepth, i, seen)
-	i = i or 0
-	seen = seen or setmetatable({}, {__mode="k"})
-
-	for k,v in pairs(t) do
-		perror(string.rep("\t", i) .. tostring(k) .. "\t" .. tostring(v))
-		if type(v) == "table" and (not maxdepth or i < maxdepth) then
-			if not seen[v] then
-				seen[v] = true
-				dumptable(v, maxdepth, i+1, seen)
-			else
-				perror(string.rep("\t", i) .. "*** RECURSION ***")
-			end
-		end
-	end
-end
-
-
---
--- String and data manipulation routines
---
-
-function pcdata(value)
-	return value and tparser.pcdata(tostring(value))
-end
-
-function urlencode(value)
-	if value ~= nil then
-		local str = tostring(value)
-		return lhttp.urlencode(str, lhttp.ENCODE_IF_NEEDED + lhttp.ENCODE_FULL)
-			or str
-	end
-	return nil
-end
-
-function urldecode(value, decode_plus)
-	if value ~= nil then
-		local flag = decode_plus and lhttp.DECODE_PLUS or 0
-		local str = tostring(value)
-		return lhttp.urldecode(str, lhttp.DECODE_IF_NEEDED + flag)
-			or str
-	end
-	return nil
-end
-
-function striptags(value)
-	return value and tparser.striptags(tostring(value))
-end
-
-function shellquote(value)
-	return string.format("'%s'", string.gsub(value or "", "'", "'\\''"))
-end
-
--- for bash, ash and similar shells single-quoted strings are taken
--- literally except for single quotes (which terminate the string)
--- (and the exception noted below for dash (-) at the start of a
--- command line parameter).
-function shellsqescape(value)
-   local res
-   res, _ = string.gsub(value, "'", "'\\''")
-   return res
-end
-
--- bash, ash and other similar shells interpret a dash (-) at the start
--- of a command-line parameters as an option indicator regardless of
--- whether it is inside a single-quoted string.  It must be backlash
--- escaped to resolve this.  This requires in some funky special-case
--- handling.  It may actually be a property of the getopt function
--- rather than the shell proper.
-function shellstartsqescape(value)
-   res, _ = string.gsub(value, "^%-", "\\-")
-   return shellsqescape(res)
-end
-
--- containing the resulting substrings. The optional max parameter specifies
--- the number of bytes to process, regardless of the actual length of the given
--- string. The optional last parameter, regex, specifies whether the separator
--- sequence is interpreted as regular expression.
---					pattern as regular expression (optional, default is false)
-function split(str, pat, max, regex)
-	pat = pat or "\n"
-	max = max or #str
-
-	local t = {}
-	local c = 1
-
-	if #str == 0 then
-		return {""}
-	end
-
-	if #pat == 0 then
-		return nil
-	end
-
-	if max == 0 then
-		return str
-	end
-
-	repeat
-		local s, e = str:find(pat, c, not regex)
-		max = max - 1
-		if s and max < 0 then
-			t[#t+1] = str:sub(c)
-		else
-			t[#t+1] = str:sub(c, s and s - 1)
-		end
-		c = e and e + 1 or #str + 1
-	until not s or max < 0
-
-	return t
-end
-
-function trim(str)
-	return (str:gsub("^%s*(.-)%s*$", "%1"))
-end
-
-function cmatch(str, pat)
-	local count = 0
-	for _ in str:gmatch(pat) do count = count + 1 end
-	return count
-end
-
--- one token per invocation, the tokens are separated by whitespace. If the
--- input value is a table, it is transformed into a string first. A nil value
--- will result in a valid iterator which aborts with the first invocation.
-function imatch(v)
-	if type(v) == "table" then
-		local k = nil
-		return function()
-			k = next(v, k)
-			return v[k]
-		end
-
-	elseif type(v) == "number" or type(v) == "boolean" then
-		local x = true
-		return function()
-			if x then
-				x = false
-				return tostring(v)
-			end
-		end
-
-	elseif type(v) == "userdata" or type(v) == "string" then
-		return tostring(v):gmatch("%S+")
-	end
-
-	return function() end
-end
-
--- value or 0 if the unit is unknown. Upper- or lower case is irrelevant.
--- Recognized units are:
---	o "y"	- one year   (60*60*24*366)
---  o "m"	- one month  (60*60*24*31)
---  o "w"	- one week   (60*60*24*7)
---  o "d"	- one day    (60*60*24)
---  o "h"	- one hour	 (60*60)
---  o "min"	- one minute (60)
---  o "kb"  - one kilobyte (1024)
---  o "mb"	- one megabyte (1024*1024)
---  o "gb"	- one gigabyte (1024*1024*1024)
---  o "kib" - one si kilobyte (1000)
---  o "mib"	- one si megabyte (1000*1000)
---  o "gib"	- one si gigabyte (1000*1000*1000)
-function parse_units(ustr)
-
-	local val = 0
-
-	-- unit map
-	local map = {
-		-- date stuff
-		y   = 60 * 60 * 24 * 366,
-		m   = 60 * 60 * 24 * 31,
-		w   = 60 * 60 * 24 * 7,
-		d   = 60 * 60 * 24,
-		h   = 60 * 60,
-		min = 60,
-
-		-- storage sizes
-		kb  = 1024,
-		mb  = 1024 * 1024,
-		gb  = 1024 * 1024 * 1024,
-
-		-- storage sizes (si)
-		kib = 1000,
-		mib = 1000 * 1000,
-		gib = 1000 * 1000 * 1000
-	}
-
-	-- parse input string
-	for spec in ustr:lower():gmatch("[0-9%.]+[a-zA-Z]*") do
-
-		local num = spec:gsub("[^0-9%.]+$","")
-		local spn = spec:gsub("^[0-9%.]+", "")
-
-		if map[spn] or map[spn:sub(1,1)] then
-			val = val + num * ( map[spn] or map[spn:sub(1,1)] )
-		else
-			val = val + num
-		end
-	end
-
-
-	return val
-end
-
--- also register functions above in the central string class for convenience
-string.pcdata      = pcdata
-string.striptags   = striptags
-string.split       = split
-string.trim        = trim
-string.cmatch      = cmatch
-string.parse_units = parse_units
-
-
-function append(src, ...)
-	for i, a in ipairs({...}) do
-		if type(a) == "table" then
-			for j, v in ipairs(a) do
-				src[#src+1] = v
-			end
-		else
-			src[#src+1] = a
-		end
-	end
-	return src
-end
-
-function combine(...)
-	return append({}, ...)
-end
-
-function contains(table, value)
-	for k, v in pairs(table) do
-		if value == v then
-			return k
-		end
-	end
-	return false
-end
-
--- Both table are - in fact - merged together.
-function update(t, updates)
-	for k, v in pairs(updates) do
-		t[k] = v
-	end
-end
-
-function keys(t)
-	local keys = { }
-	if t then
-		for k, _ in kspairs(t) do
-			keys[#keys+1] = k
-		end
-	end
-	return keys
-end
-
-function clone(object, deep)
-	local copy = {}
-
-	for k, v in pairs(object) do
-		if deep and type(v) == "table" then
-			v = clone(v, deep)
-		end
-		copy[k] = v
-	end
-
-	return setmetatable(copy, getmetatable(object))
-end
-
-
--- Serialize the contents of a table value.
-function _serialize_table(t, seen)
-	assert(not seen[t], "Recursion detected.")
-	seen[t] = true
-
-	local data  = ""
-	local idata = ""
-	local ilen  = 0
-
-	for k, v in pairs(t) do
-		if type(k) ~= "number" or k < 1 or math.floor(k) ~= k or ( k - #t ) > 3 then
-			k = serialize_data(k, seen)
-			v = serialize_data(v, seen)
-			data = data .. ( #data > 0 and ", " or "" ) ..
-				'[' .. k .. '] = ' .. v
-		elseif k > ilen then
-			ilen = k
-		end
-	end
-
-	for i = 1, ilen do
-		local v = serialize_data(t[i], seen)
-		idata = idata .. ( #idata > 0 and ", " or "" ) .. v
-	end
-
-	return idata .. ( #data > 0 and #idata > 0 and ", " or "" ) .. data
-end
-
--- with loadstring().
-function serialize_data(val, seen)
-	seen = seen or setmetatable({}, {__mode="k"})
-
-	if val == nil then
-		return "nil"
-	elseif type(val) == "number" then
-		return val
-	elseif type(val) == "string" then
-		return "%q" % val
-	elseif type(val) == "boolean" then
-		return val and "true" or "false"
-	elseif type(val) == "function" then
-		return "loadstring(%q)" % get_bytecode(val)
-	elseif type(val) == "table" then
-		return "{ " .. _serialize_table(val, seen) .. " }"
-	else
-		return '"[unhandled data type:' .. type(val) .. ']"'
-	end
-end
-
-function restore_data(str)
-	return loadstring("return " .. str)()
-end
-
-
---
--- Byte code manipulation routines
---
-
--- will be stripped before it is returned.
-function get_bytecode(val)
-	local code
-
-	if type(val) == "function" then
-		code = string.dump(val)
-	else
-		code = string.dump( loadstring( "return " .. serialize_data(val) ) )
-	end
-
-	return code -- and strip_bytecode(code)
-end
-
--- numbers and debugging numbers will be discarded. Original version by
--- Peter Cawley (http://lua-users.org/lists/lua-l/2008-02/msg01158.html)
-function strip_bytecode(code)
-	local version, format, endian, int, size, ins, num, lnum = code:byte(5, 12)
-	local subint
-	if endian == 1 then
-		subint = function(code, i, l)
-			local val = 0
-			for n = l, 1, -1 do
-				val = val * 256 + code:byte(i + n - 1)
-			end
-			return val, i + l
-		end
-	else
-		subint = function(code, i, l)
-			local val = 0
-			for n = 1, l, 1 do
-				val = val * 256 + code:byte(i + n - 1)
-			end
-			return val, i + l
-		end
-	end
-
-	local function strip_function(code)
-		local count, offset = subint(code, 1, size)
-		local stripped = { string.rep("\0", size) }
-		local dirty = offset + count
-		offset = offset + count + int * 2 + 4
-		offset = offset + int + subint(code, offset, int) * ins
-		count, offset = subint(code, offset, int)
-		for n = 1, count do
-			local t
-			t, offset = subint(code, offset, 1)
-			if t == 1 then
-				offset = offset + 1
-			elseif t == 4 then
-				offset = offset + size + subint(code, offset, size)
-			elseif t == 3 then
-				offset = offset + num
-			elseif t == 254 or t == 9 then
-				offset = offset + lnum
-			end
-		end
-		count, offset = subint(code, offset, int)
-		stripped[#stripped+1] = code:sub(dirty, offset - 1)
-		for n = 1, count do
-			local proto, off = strip_function(code:sub(offset, -1))
-			stripped[#stripped+1] = proto
-			offset = offset + off - 1
-		end
-		offset = offset + subint(code, offset, int) * int + int
-		count, offset = subint(code, offset, int)
-		for n = 1, count do
-			offset = offset + subint(code, offset, size) + size + int * 2
-		end
-		count, offset = subint(code, offset, int)
-		for n = 1, count do
-			offset = offset + subint(code, offset, size) + size
-		end
-		stripped[#stripped+1] = string.rep("\0", int * 3)
-		return table.concat(stripped), offset
-	end
-
-	return code:sub(1,12) .. strip_function(code:sub(13,-1))
-end
-
-
---
--- Sorting iterator functions
---
-
-function _sortiter( t, f )
-	local keys = { }
-
-	local k, v
-	for k, v in pairs(t) do
-		keys[#keys+1] = k
-	end
-
-	local _pos = 0
-
-	table.sort( keys, f )
-
-	return function()
-		_pos = _pos + 1
-		if _pos <= #keys then
-			return keys[_pos], t[keys[_pos]], _pos
-		end
-	end
-end
-
--- the provided callback function.
-function spairs(t,f)
-	return _sortiter( t, f )
-end
-
--- The table pairs are sorted by key.
-function kspairs(t)
-	return _sortiter( t )
-end
-
--- The table pairs are sorted by value.
-function vspairs(t)
-	return _sortiter( t, function (a,b) return t[a] < t[b] end )
-end
-
-
---
--- System utility functions
---
-
-function bigendian()
-	return string.byte(string.dump(function() end), 7) == 0
-end
-
-function exec(command)
-	local pp   = io.popen(command)
-	local data = pp:read("*a")
-	pp:close()
-
-	return data
-end
-
-function execi(command)
-	local pp = io.popen(command)
-
-	return pp and function()
-		local line = pp:read()
-
-		if not line then
-			pp:close()
-		end
-
-		return line
-	end
-end
-
--- Deprecated
-function execl(command)
-	local pp   = io.popen(command)
-	local line = ""
-	local data = {}
-
-	while true do
-		line = pp:read()
-		if (line == nil) then break end
-		data[#data+1] = line
-	end
-	pp:close()
-
-	return data
-end
-
-
-local ubus_codes = {
-	"INVALID_COMMAND",
-	"INVALID_ARGUMENT",
-	"METHOD_NOT_FOUND",
-	"NOT_FOUND",
-	"NO_DATA",
-	"PERMISSION_DENIED",
-	"TIMEOUT",
-	"NOT_SUPPORTED",
-	"UNKNOWN_ERROR",
-	"CONNECTION_FAILED"
-}
-
-local function ubus_return(...)
-	if select('#', ...) == 2 then
-		local rv, err = select(1, ...), select(2, ...)
-		if rv == nil and type(err) == "number" then
-			return nil, err, ubus_codes[err]
-		end
-	end
-
-	return ...
-end
-
-function ubus(object, method, data)
-	if not _ubus_connection then
-		_ubus_connection = _ubus.connect()
-		assert(_ubus_connection, "Unable to establish ubus connection")
-	end
-
-	if object and method then
-		if type(data) ~= "table" then
-			data = { }
-		end
-		return ubus_return(_ubus_connection:call(object, method, data))
-	elseif object then
-		return _ubus_connection:signatures(object)
-	else
-		return _ubus_connection:objects()
-	end
-end
-
-function serialize_json(x, cb)
-	local js = json.stringify(x)
-	if type(cb) == "function" then
-		cb(js)
-	else
-		return js
-	end
-end
-
-
-function libpath()
-	return require "nixio.fs".dirname(ldebug.__file__)
-end
-
-function checklib(fullpathexe, wantedlib)
-	local fs = require "nixio.fs"
-	local haveldd = fs.access('/usr/bin/ldd')
-	local haveexe = fs.access(fullpathexe)
-	if not haveldd or not haveexe then
-		return false
-	end
-	local libs = exec(string.format("/usr/bin/ldd %s", shellquote(fullpathexe)))
-	if not libs then
-		return false
-	end
-	for k, v in ipairs(split(libs)) do
-		if v:find(wantedlib) then
-			return true
-		end
-	end
-	return false
-end
-
--------------------------------------------------------------------------------
--- Coroutine safe xpcall and pcall versions
---
--- Encapsulates the protected calls with a coroutine based loop, so errors can
--- be dealed without the usual Lua 5.x pcall/xpcall issues with coroutines
--- yielding inside the call to pcall or xpcall.
---
--- Authors: Roberto Ierusalimschy and Andre Carregal
--- Contributors: Thomas Harning Jr., Ignacio Burgueño, Fabio Mascarenhas
---
--- Copyright 2005 - Kepler Project
---
--- $Id: coxpcall.lua,v 1.13 2008/05/19 19:20:02 mascarenhas Exp $
--------------------------------------------------------------------------------
-
--------------------------------------------------------------------------------
--- Implements xpcall with coroutines
--------------------------------------------------------------------------------
-local coromap = setmetatable({}, { __mode = "k" })
-
-local function handleReturnValue(err, co, status, ...)
-	if not status then
-		return false, err(debug.traceback(co, (...)), ...)
-	end
-	if coroutine.status(co) == 'suspended' then
-		return performResume(err, co, coroutine.yield(...))
-	else
-		return true, ...
-	end
-end
-
-function performResume(err, co, ...)
-	return handleReturnValue(err, co, coroutine.resume(co, ...))
-end
-
-local function id(trace, ...)
-	return trace
-end
-
-function coxpcall(f, err, ...)
-	local current = coroutine.running()
-	if not current then
-		if err == id then
-			return pcall(f, ...)
-		else
-			if select("#", ...) > 0 then
-				local oldf, params = f, { ... }
-				f = function() return oldf(unpack(params)) end
-			end
-			return xpcall(f, err)
-		end
-	else
-		local res, co = pcall(coroutine.create, f)
-		if not res then
-			local newf = function(...) return f(...) end
-			co = coroutine.create(newf)
-		end
-		coromap[co] = current
-		coxpt[co] = coxpt[current] or current or 0
-		return performResume(err, co, ...)
-	end
-end
-
-function copcall(f, ...)
-	return coxpcall(f, id, ...)
-end
diff --git a/modules/luci-base/luasrc/util.luadoc b/modules/luci-base/luasrc/util.luadoc
deleted file mode 100644
index 4ec68dd1ef..0000000000
--- a/modules/luci-base/luasrc/util.luadoc
+++ /dev/null
@@ -1,413 +0,0 @@
----[[
-LuCI utility functions.
-]]
-module "luci.util"
-
----[[
-Create a Class object (Python-style object model).
-
-The class object can be instantiated by calling itself.
-Any class functions or shared parameters can be attached to this object.
-Attaching a table to the class object makes this table shared between
-all instances of this class. For object parameters use the __init__ function.
-Classes can inherit member functions and values from a base class.
-Class can be instantiated by calling them. All parameters will be passed
-to the __init__ function of this class - if such a function exists.
-The __init__ function must be used to set any object parameters that are not shared
-with other objects of this class. Any return values will be ignored.
-
-@class				function
-@name				class
-@param base			The base class to inherit from (optional)
-@return				A class object
-@see				instanceof
-@see				clone
-]]
-
----[[
-Test whether the given object is an instance of the given class.
-
-@class				function
-@name				instanceof
-@param object		Object instance
-@param class		Class object to test against
-@return				Boolean indicating whether the object is an instance
-@see				class
-@see				clone
-]]
-
----[[
-Create a new or get an already existing thread local store associated with
-the current active coroutine.
-
-A thread local store is private a table object
-whose values can't be accessed from outside of the running coroutine.
-
-@class				function
-@name				threadlocal
-@return				Table value representing the corresponding thread local store
-]]
-
----[[
-Write given object to stderr.
-
-@class				function
-@name				perror
-@param obj			Value to write to stderr
-@return				Boolean indicating whether the write operation was successful
-]]
-
----[[
-Recursively dumps a table to stdout, useful for testing and debugging.
-
-@class				function
-@name				dumptable
-@param t			Table value to dump
-@param maxdepth		Maximum depth
-@return				Always nil
-]]
-
----[[
-Create valid XML PCDATA from given string.
-
-@class				function
-@name				pcdata
-@param value		String value containing the data to escape
-@return				String value containing the escaped data
-]]
-
----[[
-Decode an URL-encoded string - optionally decoding the "+" sign to space.
-
-@class				function
-@name				urldecode
-@param str			Input string in x-www-urlencoded format
-@param decode_plus	Decode "+" signs to spaces if true (optional)
-@return				The decoded string
-@see				urlencode
-]]
-
----[[
-URL-encode given string.
-
-@class				function
-@name				urlencode
-@param str			String to encode
-@return				String containing the encoded data
-@see				urldecode
-]]
-
----[[
-Strip HTML tags from given string.
-
-@class				function
-@name				striptags
-@param value		String containing the HTML text
-@return				String with HTML tags stripped of
-]]
-
----[[
-Safely quote value for use in shell commands.
-
-@class				function
-@name				shellquote
-@param value		String containing the value to quote
-@return 			Single-quote enclosed string with embedded quotes escaped
-]]
-
----[[
-Splits given string on a defined separator sequence and return a table
-containing the resulting substrings.
-
-The optional max parameter specifies the number of bytes to process,
-regardless of the actual length of the given string. The optional last
-parameter, regex, specifies whether the separator sequence is
-nterpreted as regular expression.
-
-@class				function
-@name				split
-@param str			String value containing the data to split up
-@param pat			String with separator pattern (optional, defaults to "\n")
-@param max			Maximum times to split (optional)
-@param regex		Boolean indicating whether to interpret the separator
---					pattern as regular expression (optional, default is false)
-@return				Table containing the resulting substrings
-]]
-
----[[
-Remove leading and trailing whitespace from given string value.
-
-@class				function
-@name				trim
-@param str			String value containing whitespace padded data
-@return				String value with leading and trailing space removed
-]]
-
----[[
-Count the occurrences of given substring in given string.
-
-@class				function
-@name				cmatch
-@param str			String to search in
-@param pattern		String containing pattern to find
-@return				Number of found occurrences
-]]
-
----[[
-Return a matching iterator for the given value.
-
-The iterator will return one token per invocation, the tokens are separated by
-whitespace. If the input value is a table, it is transformed into a string first.
-A nil value will result in a valid iterator which aborts with the first invocation.
-
-@class				function
-@name				imatch
-@param val			The value to scan (table, string or nil)
-@return				Iterator which returns one token per call
-]]
-
----[[
-Parse certain units from the given string and return the canonical integer
-value or 0 if the unit is unknown.
-
-Upper- or lower case is irrelevant.
-Recognized units are:
-
---	o "y"	- one year   (60*60*24*366)
- o "m"	- one month  (60*60*24*31)
- o "w"	- one week   (60*60*24*7)
- o "d"	- one day    (60*60*24)
- o "h"	- one hour	 (60*60)
- o "min"	- one minute (60)
- o "kb"  - one kilobyte (1024)
- o "mb"	- one megabyte (1024*1024)
- o "gb"	- one gigabyte (1024*1024*1024)
- o "kib" - one si kilobyte (1000)
- o "mib"	- one si megabyte (1000*1000)
- o "gib"	- one si gigabyte (1000*1000*1000)
-
-@class				function
-@name				parse_units
-@param ustr			String containing a numerical value with trailing unit
-@return				Number containing the canonical value
-]]
-
----[[
-Appends numerically indexed tables or single objects to a given table.
-
-@class				function
-@name				append
-@param src			Target table
-@param ...			Objects to insert
-@return				Target table
-]]
-
----[[
-Combines two or more numerically indexed tables and single objects into one table.
-
-@class				function
-@name				combine
-@param tbl1			Table value to combine
-@param tbl2			Table value to combine
-@param ...			More tables to combine
-@return				Table value containing all values of given tables
-]]
-
----[[
-Checks whether the given table contains the given value.
-
-@class				function
-@name				contains
-@param table		Table value
-@param value		Value to search within the given table
-@return				Number indicating the first index at which the given value occurs
---					within table or false.
-]]
-
----[[
-Update values in given table with the values from the second given table.
-
-Both table are - in fact - merged together.
-
-@class				function
-@name				update
-@param t			Table which should be updated
-@param updates		Table containing the values to update
-@return				Always nil
-]]
-
----[[
-Retrieve all keys of given associative table.
-
-@class				function
-@name				keys
-@param t			Table to extract keys from
-@return				Sorted table containing the keys
-]]
-
----[[
-Clones the given object and return it's copy.
-
-@class				function
-@name				clone
-@param object		Table value to clone
-@param deep			Boolean indicating whether to do recursive cloning
-@return				Cloned table value
-]]
-
----[[
-Recursively serialize given data to lua code, suitable for restoring
-with loadstring().
-
-@class				function
-@name				serialize_data
-@param val			Value containing the data to serialize
-@return				String value containing the serialized code
-@see				restore_data
-@see				get_bytecode
-]]
-
----[[
-Restore data previously serialized with serialize_data().
-
-@class				function
-@name				restore_data
-@param str			String containing the data to restore
-@return				Value containing the restored data structure
-@see				serialize_data
-@see				get_bytecode
-]]
-
----[[
-Return the current runtime bytecode of the given data. The byte code
-will be stripped before it is returned.
-
-@class				function
-@name				get_bytecode
-@param val			Value to return as bytecode
-@return				String value containing the bytecode of the given data
-]]
-
----[[
-Strips unnecessary lua bytecode from given string.
-
-Information like line numbers and debugging numbers will be discarded.
-Original version by Peter Cawley (http://lua-users.org/lists/lua-l/2008-02/msg01158.html)
-
-@class				function
-@name				strip_bytecode
-@param code			String value containing the original lua byte code
-@return				String value containing the stripped lua byte code
-]]
-
----[[
-Return a key, value iterator which returns the values sorted according to
-the provided callback function.
-
-@class				function
-@name				spairs
-@param t			The table to iterate
-@param f 			A callback function to decide the order of elements
-@return				Function value containing the corresponding iterator
-]]
-
----[[
-Return a key, value iterator for the given table.
-
-The table pairs are sorted by key.
-
-@class				function
-@name				kspairs
-@param t			The table to iterate
-@return				Function value containing the corresponding iterator
-]]
-
----[[
-Return a key, value iterator for the given table.
-
-The table pairs are sorted by value.
-
-@class				function
-@name				vspairs
-@param t			The table to iterate
-@return				Function value containing the corresponding iterator
-]]
-
----[[
-Test whether the current system is operating in big endian mode.
-
-@class				function
-@name				bigendian
-@return				Boolean value indicating whether system is big endian
-]]
-
----[[
-Execute given commandline and gather stdout.
-
-@class				function
-@name				exec
-@param command		String containing command to execute
-@return				String containing the command's stdout
-]]
-
----[[
-Return a line-buffered iterator over the output of given command.
-
-@class				function
-@name				execi
-@param command		String containing the command to execute
-@return				Iterator
-]]
-
----[[
-Issue an ubus call.
-
-@class				function
-@name				ubus
-@param object		String containing the ubus object to call
-@param method		String containing the ubus method to call
-@param values		Table containing the values to pass
-@return				Table containin the ubus result
-]]
-
----[[
-Convert data structure to JSON
-
-@class				function
-@name				serialize_json
-@param data			The data to serialize
-@param writer		A function to write a chunk of JSON data (optional)
-@return				String containing the JSON if called without write callback
-]]
-
----[[
-Returns the absolute path to LuCI base directory.
-
-@class				function
-@name				libpath
-@return				String containing the directory path
-]]
-
----[[
-This is a coroutine-safe drop-in replacement for Lua's "xpcall"-function
-
-@class				function
-@name				coxpcall
-@param f			Lua function to be called protected
-@param err			Custom error handler
-@param ...			Parameters passed to the function
-@return				A boolean whether the function call succeeded and the return
---					values of either the function or the error handler
-]]
-
----[[
-This is a coroutine-safe drop-in replacement for Lua's "pcall"-function
-
-@class				function
-@name				copcall
-@param f			Lua function to be called protected
-@param ...			Parameters passed to the function
-@return				A boolean whether the function call succeeded and the returns
---					values of the function or the error object
-]]
-