treewide: move server side CBI support to luci-compat

Signed-off-by: Jo-Philipp Wich <jo@mein.io>

1 files changed, 0 insertions, 1977 deletions

diff --git a/modules/luci-base/luasrc/cbi.lua b/modules/luci-base/luasrc/cbi.lua
deleted file mode 100644
index 450e41391..000000000
--- a/modules/luci-base/luasrc/cbi.lua
+++ /dev/null
@@ -1,1977 +0,0 @@
--- Copyright 2008 Steven Barth <steven@midlink.org>
--- Licensed to the public under the Apache License 2.0.
-
-module("luci.cbi", package.seeall)
-
-require("luci.template")
-local util = require("luci.util")
-require("luci.http")
-
-
---local event      = require "luci.sys.event"
-local fs         = require("nixio.fs")
-local uci        = require("luci.model.uci")
-local datatypes  = require("luci.cbi.datatypes")
-local dispatcher = require("luci.dispatcher")
-local class      = util.class
-local instanceof = util.instanceof
-
-FORM_NODATA  =  0
-FORM_PROCEED =  0
-FORM_VALID   =  1
-FORM_DONE	 =  1
-FORM_INVALID = -1
-FORM_CHANGED =  2
-FORM_SKIP    =  4
-
-AUTO = true
-
-CREATE_PREFIX = "cbi.cts."
-REMOVE_PREFIX = "cbi.rts."
-RESORT_PREFIX = "cbi.sts."
-FEXIST_PREFIX = "cbi.cbe."
-
--- Loads a CBI map from given file, creating an environment and returns it
-function load(cbimap, ...)
-	local fs   = require "nixio.fs"
-	local i18n = require "luci.i18n"
-	require("luci.config")
-	require("luci.util")
-
-	local upldir = "/etc/luci-uploads/"
-	local cbidir = luci.util.libpath() .. "/model/cbi/"
-	local func, err
-
-	if fs.access(cbidir..cbimap..".lua") then
-		func, err = loadfile(cbidir..cbimap..".lua")
-	elseif fs.access(cbimap) then
-		func, err = loadfile(cbimap)
-	else
-		func, err = nil, "Model '" .. cbimap .. "' not found!"
-	end
-
-	assert(func, err)
-
-	local env = {
-		translate=i18n.translate,
-		translatef=i18n.translatef,
-	 	arg={...}
-	}
-
-	setfenv(func, setmetatable(env, {__index =
-		function(tbl, key)
-			return rawget(tbl, key) or _M[key] or _G[key]
-		end}))
-
-	local maps       = { func() }
-	local uploads    = { }
-	local has_upload = false
-
-	for i, map in ipairs(maps) do
-		if not instanceof(map, Node) then
-			error("CBI map returns no valid map object!")
-			return nil
-		else
-			map:prepare()
-			if map.upload_fields then
-				has_upload = true
-				for _, field in ipairs(map.upload_fields) do
-					uploads[
-						field.config .. '.' ..
-						(field.section.sectiontype or '1') .. '.' ..
-						field.option
-					] = true
-				end
-			end
-		end
-	end
-
-	if has_upload then
-		local uci = luci.model.uci.cursor()
-		local prm = luci.http.context.request.message.params
-		local fd, cbid
-
-		luci.http.setfilehandler(
-			function( field, chunk, eof )
-				if not field then return end
-				if field.name and not cbid then
-					local c, s, o = field.name:gmatch(
-						"cbid%.([^%.]+)%.([^%.]+)%.([^%.]+)"
-					)()
-
-					if c and s and o then
-						local t = uci:get( c, s ) or s
-						if uploads[c.."."..t.."."..o] then
-							local path = upldir .. field.name
-							fd = io.open(path, "w")
-							if fd then
-								cbid = field.name
-								prm[cbid] = path
-							end
-						end
-					end
-				end
-
-				if field.name == cbid and fd then
-					fd:write(chunk)
-				end
-
-				if eof and fd then
-					fd:close()
-					fd   = nil
-					cbid = nil
-				end
-			end
-		)
-	end
-
-	return maps
-end
-
---
--- Compile a datatype specification into a parse tree for evaluation later on
---
-local cdt_cache = { }
-
-function compile_datatype(code)
-	local i
-	local pos = 0
-	local esc = false
-	local depth = 0
-	local stack = { }
-
-	for i = 1, #code+1 do
-		local byte = code:byte(i) or 44
-		if esc then
-			esc = false
-		elseif byte == 92 then
-			esc = true
-		elseif byte == 40 or byte == 44 then
-			if depth <= 0 then
-				if pos < i then
-					local label = code:sub(pos, i-1)
-						:gsub("\\(.)", "%1")
-						:gsub("^%s+", "")
-						:gsub("%s+$", "")
-
-					if #label > 0 and tonumber(label) then
-						stack[#stack+1] = tonumber(label)
-					elseif label:match("^'.*'$") or label:match('^".*"$') then
-						stack[#stack+1] = label:gsub("[\"'](.*)[\"']", "%1")
-					elseif type(datatypes[label]) == "function" then
-						stack[#stack+1] = datatypes[label]
-						stack[#stack+1] = { }
-					else
-						error("Datatype error, bad token %q" % label)
-					end
-				end
-				pos = i + 1
-			end
-			depth = depth + (byte == 40 and 1 or 0)
-		elseif byte == 41 then
-			depth = depth - 1
-			if depth <= 0 then
-				if type(stack[#stack-1]) ~= "function" then
-					error("Datatype error, argument list follows non-function")
-				end
-				stack[#stack] = compile_datatype(code:sub(pos, i-1))
-				pos = i + 1
-			end
-		end
-	end
-
-	return stack
-end
-
-function verify_datatype(dt, value)
-	if dt and #dt > 0 then
-		if not cdt_cache[dt] then
-			local c = compile_datatype(dt)
-			if c and type(c[1]) == "function" then
-				cdt_cache[dt] = c
-			else
-				error("Datatype error, not a function expression")
-			end
-		end
-		if cdt_cache[dt] then
-			return cdt_cache[dt][1](value, unpack(cdt_cache[dt][2]))
-		end
-	end
-	return true
-end
-
-
--- Node pseudo abstract class
-Node = class()
-
-function Node.__init__(self, title, description)
-	self.children = {}
-	self.title = title or ""
-	self.description = description or ""
-	self.template = "cbi/node"
-end
-
--- hook helper
-function Node._run_hook(self, hook)
-	if type(self[hook]) == "function" then
-		return self[hook](self)
-	end
-end
-
-function Node._run_hooks(self, ...)
-	local f
-	local r = false
-	for _, f in ipairs(arg) do
-		if type(self[f]) == "function" then
-			self[f](self)
-			r = true
-		end
-	end
-	return r
-end
-
--- Prepare nodes
-function Node.prepare(self, ...)
-	for k, child in ipairs(self.children) do
-		child:prepare(...)
-	end
-end
-
--- Append child nodes
-function Node.append(self, obj)
-	table.insert(self.children, obj)
-end
-
--- Parse this node and its children
-function Node.parse(self, ...)
-	for k, child in ipairs(self.children) do
-		child:parse(...)
-	end
-end
-
--- Render this node
-function Node.render(self, scope)
-	scope = scope or {}
-	scope.self = self
-
-	luci.template.render(self.template, scope)
-end
-
--- Render the children
-function Node.render_children(self, ...)
-	local k, node
-	for k, node in ipairs(self.children) do
-		node.last_child = (k == #self.children)
-		node.index = k
-		node:render(...)
-	end
-end
-
-
---[[
-A simple template element
-]]--
-Template = class(Node)
-
-function Template.__init__(self, template)
-	Node.__init__(self)
-	self.template = template
-end
-
-function Template.render(self)
-	luci.template.render(self.template, {self=self})
-end
-
-function Template.parse(self, readinput)
-	self.readinput = (readinput ~= false)
-	return Map.formvalue(self, "cbi.submit") and FORM_DONE or FORM_NODATA
-end
-
-
---[[
-Map - A map describing a configuration file
-]]--
-Map = class(Node)
-
-function Map.__init__(self, config, ...)
-	Node.__init__(self, ...)
-
-	self.config = config
-	self.parsechain = {self.config}
-	self.template = "cbi/map"
-	self.apply_on_parse = nil
-	self.readinput = true
-	self.proceed = false
-	self.flow = {}
-
-	self.uci = uci.cursor()
-	self.save = true
-
-	self.changed = false
-
-	local path = "%s/%s" %{ self.uci:get_confdir(), self.config }
-	if fs.stat(path, "type") ~= "reg" then
-		fs.writefile(path, "")
-	end
-
-	local ok, err = self.uci:load(self.config)
-	if not ok then
-		local url = dispatcher.build_url(unpack(dispatcher.context.request))
-		local source = self:formvalue("cbi.source")
-		if type(source) == "string" then
-			fs.writefile(path, source:gsub("\r\n", "\n"))
-			ok, err = self.uci:load(self.config)
-			if ok then
-				luci.http.redirect(url)
-			end
-		end
-		self.save = false
-	end
-
-	if not ok then
-		self.template   = "cbi/error"
-		self.error      = err
-		self.source     = fs.readfile(path) or ""
-		self.pageaction = false
-	end
-end
-
-function Map.formvalue(self, key)
-	return self.readinput and luci.http.formvalue(key) or nil
-end
-
-function Map.formvaluetable(self, key)
-	return self.readinput and luci.http.formvaluetable(key) or {}
-end
-
-function Map.get_scheme(self, sectiontype, option)
-	if not option then
-		return self.scheme and self.scheme.sections[sectiontype]
-	else
-		return self.scheme and self.scheme.variables[sectiontype]
-		 and self.scheme.variables[sectiontype][option]
-	end
-end
-
-function Map.submitstate(self)
-	return self:formvalue("cbi.submit")
-end
-
--- Chain foreign config
-function Map.chain(self, config)
-	table.insert(self.parsechain, config)
-end
-
-function Map.state_handler(self, state)
-	return state
-end
-
--- Use optimized UCI writing
-function Map.parse(self, readinput, ...)
-	if self:formvalue("cbi.skip") then
-		self.state = FORM_SKIP
-	elseif not self.save then
-		self.state = FORM_INVALID
-	elseif not self:submitstate() then
-		self.state = FORM_NODATA
-	end
-
-	-- Back out early to prevent unauthorized changes on the subsequent parse
-	if self.state ~= nil then
-		return self:state_handler(self.state)
-	end
-
-	self.readinput = (readinput ~= false)
-	self:_run_hooks("on_parse")
-
-	Node.parse(self, ...)
-
-	if self.save then
-		self:_run_hooks("on_save", "on_before_save")
-		local i, config
-		for i, config in ipairs(self.parsechain) do
-			self.uci:save(config)
-		end
-		self:_run_hooks("on_after_save")
-		if (not self.proceed and self.flow.autoapply) or luci.http.formvalue("cbi.apply") then
-			self:_run_hooks("on_before_commit")
-			if self.apply_on_parse == false then
-				for i, config in ipairs(self.parsechain) do
-					self.uci:commit(config)
-				end
-			end
-			self:_run_hooks("on_commit", "on_after_commit", "on_before_apply")
-			if self.apply_on_parse == true or self.apply_on_parse == false then
-				self.uci:apply(self.apply_on_parse)
-				self:_run_hooks("on_apply", "on_after_apply")
-			else
-				-- This is evaluated by the dispatcher and delegated to the
-				-- template which in turn fires XHR to perform the actual
-				-- apply actions.
-				self.apply_needed = true
-			end
-
-			-- Reparse sections
-			Node.parse(self, true)
-		end
-		for i, config in ipairs(self.parsechain) do
-			self.uci:unload(config)
-		end
-		if type(self.commit_handler) == "function" then
-			self:commit_handler(self:submitstate())
-		end
-	end
-
-	if not self.save then
-		self.state = FORM_INVALID
-	elseif self.proceed then
-		self.state = FORM_PROCEED
-	elseif self.changed then
-		self.state = FORM_CHANGED
-	else
-		self.state = FORM_VALID
-	end
-
-	return self:state_handler(self.state)
-end
-
-function Map.render(self, ...)
-	self:_run_hooks("on_init")
-	Node.render(self, ...)
-end
-
--- Creates a child section
-function Map.section(self, class, ...)
-	if instanceof(class, AbstractSection) then
-		local obj  = class(self, ...)
-		self:append(obj)
-		return obj
-	else
-		error("class must be a descendent of AbstractSection")
-	end
-end
-
--- UCI add
-function Map.add(self, sectiontype)
-	return self.uci:add(self.config, sectiontype)
-end
-
--- UCI set
-function Map.set(self, section, option, value)
-	if type(value) ~= "table" or #value > 0 then
-		if option then
-			return self.uci:set(self.config, section, option, value)
-		else
-			return self.uci:set(self.config, section, value)
-		end
-	else
-		return Map.del(self, section, option)
-	end
-end
-
--- UCI del
-function Map.del(self, section, option)
-	if option then
-		return self.uci:delete(self.config, section, option)
-	else
-		return self.uci:delete(self.config, section)
-	end
-end
-
--- UCI get
-function Map.get(self, section, option)
-	if not section then
-		return self.uci:get_all(self.config)
-	elseif option then
-		return self.uci:get(self.config, section, option)
-	else
-		return self.uci:get_all(self.config, section)
-	end
-end
-
---[[
-Compound - Container
-]]--
-Compound = class(Node)
-
-function Compound.__init__(self, ...)
-	Node.__init__(self)
-	self.template = "cbi/compound"
-	self.children = {...}
-end
-
-function Compound.populate_delegator(self, delegator)
-	for _, v in ipairs(self.children) do
-		v.delegator = delegator
-	end
-end
-
-function Compound.parse(self, ...)
-	local cstate, state = 0
-
-	for k, child in ipairs(self.children) do
-		cstate = child:parse(...)
-		state = (not state or cstate < state) and cstate or state
-	end
-
-	return state
-end
-
-
---[[
-Delegator - Node controller
-]]--
-Delegator = class(Node)
-function Delegator.__init__(self, ...)
-	Node.__init__(self, ...)
-	self.nodes = {}
-	self.defaultpath = {}
-	self.pageaction = false
-	self.readinput = true
-	self.allow_reset = false
-	self.allow_cancel = false
-	self.allow_back = false
-	self.allow_finish = false
-	self.template = "cbi/delegator"
-end
-
-function Delegator.set(self, name, node)
-	assert(not self.nodes[name], "Duplicate entry")
-
-	self.nodes[name] = node
-end
-
-function Delegator.add(self, name, node)
-	node = self:set(name, node)
-	self.defaultpath[#self.defaultpath+1] = name
-end
-
-function Delegator.insert_after(self, name, after)
-	local n = #self.chain + 1
-	for k, v in ipairs(self.chain) do
-		if v == after then
-			n = k + 1
-			break
-		end
-	end
-	table.insert(self.chain, n, name)
-end
-
-function Delegator.set_route(self, ...)
-	local n, chain, route = 0, self.chain, {...}
-	for i = 1, #chain do
-		if chain[i] == self.current then
-			n = i
-			break
-		end
-	end
-	for i = 1, #route do
-		n = n + 1
-		chain[n] = route[i]
-	end
-	for i = n + 1, #chain do
-		chain[i] = nil
-	end
-end
-
-function Delegator.get(self, name)
-	local node = self.nodes[name]
-
-	if type(node) == "string" then
-		node = load(node, name)
-	end
-
-	if type(node) == "table" and getmetatable(node) == nil then
-		node = Compound(unpack(node))
-	end
-
-	return node
-end
-
-function Delegator.parse(self, ...)
-	if self.allow_cancel and Map.formvalue(self, "cbi.cancel") then
-		if self:_run_hooks("on_cancel") then
-			return FORM_DONE
-		end
-	end
-
-	if not Map.formvalue(self, "cbi.delg.current") then
-		self:_run_hooks("on_init")
-	end
-
-	local newcurrent
-	self.chain = self.chain or self:get_chain()
-	self.current = self.current or self:get_active()
-	self.active = self.active or self:get(self.current)
-	assert(self.active, "Invalid state")
-
-	local stat = FORM_DONE
-	if type(self.active) ~= "function" then
-		self.active:populate_delegator(self)
-		stat = self.active:parse()
-	else
-		self:active()
-	end
-
-	if stat > FORM_PROCEED then
-		if Map.formvalue(self, "cbi.delg.back") then
-			newcurrent = self:get_prev(self.current)
-		else
-			newcurrent = self:get_next(self.current)
-		end
-	elseif stat < FORM_PROCEED then
-		return stat
-	end
-
-
-	if not Map.formvalue(self, "cbi.submit") then
-		return FORM_NODATA
-	elseif stat > FORM_PROCEED
-	and (not newcurrent or not self:get(newcurrent)) then
-		return self:_run_hook("on_done") or FORM_DONE
-	else
-		self.current = newcurrent or self.current
-		self.active = self:get(self.current)
-		if type(self.active) ~= "function" then
-			self.active:populate_delegator(self)
-			local stat = self.active:parse(false)
-			if stat == FORM_SKIP then
-				return self:parse(...)
-			else
-				return FORM_PROCEED
-			end
-		else
-			return self:parse(...)
-		end
-	end
-end
-
-function Delegator.get_next(self, state)
-	for k, v in ipairs(self.chain) do
-		if v == state then
-			return self.chain[k+1]
-		end
-	end
-end
-
-function Delegator.get_prev(self, state)
-	for k, v in ipairs(self.chain) do
-		if v == state then
-			return self.chain[k-1]
-		end
-	end
-end
-
-function Delegator.get_chain(self)
-	local x = Map.formvalue(self, "cbi.delg.path") or self.defaultpath
-	return type(x) == "table" and x or {x}
-end
-
-function Delegator.get_active(self)
-	return Map.formvalue(self, "cbi.delg.current") or self.chain[1]
-end
-
---[[
-Page - A simple node
-]]--
-
-Page = class(Node)
-Page.__init__ = Node.__init__
-Page.parse    = function() end
-
-
---[[
-SimpleForm - A Simple non-UCI form
-]]--
-SimpleForm = class(Node)
-
-function SimpleForm.__init__(self, config, title, description, data)
-	Node.__init__(self, title, description)
-	self.config = config
-	self.data = data or {}
-	self.template = "cbi/simpleform"
-	self.dorender = true
-	self.pageaction = false
-	self.readinput = true
-end
-
-SimpleForm.formvalue = Map.formvalue
-SimpleForm.formvaluetable = Map.formvaluetable
-
-function SimpleForm.parse(self, readinput, ...)
-	self.readinput = (readinput ~= false)
-
-	if self:formvalue("cbi.skip") then
-		return FORM_SKIP
-	end
-
-	if self:formvalue("cbi.cancel") and self:_run_hooks("on_cancel") then
-		return FORM_DONE
-	end
-
-	if self:submitstate() then
-		Node.parse(self, 1, ...)
-	end
-
-	local valid = true
-	for k, j in ipairs(self.children) do
-		for i, v in ipairs(j.children) do
-			valid = valid
-			 and (not v.tag_missing or not v.tag_missing[1])
-			 and (not v.tag_invalid or not v.tag_invalid[1])
-			 and (not v.error)
-		end
-	end
-
-	local state =
-		not self:submitstate() and FORM_NODATA
-		or valid and FORM_VALID
-		or FORM_INVALID
-
-	self.dorender = not self.handle
-	if self.handle then
-		local nrender, nstate = self:handle(state, self.data)
-		self.dorender = self.dorender or (nrender ~= false)
-		state = nstate or state
-	end
-	return state
-end
-
-function SimpleForm.render(self, ...)
-	if self.dorender then
-		Node.render(self, ...)
-	end
-end
-
-function SimpleForm.submitstate(self)
-	return self:formvalue("cbi.submit")
-end
-
-function SimpleForm.section(self, class, ...)
-	if instanceof(class, AbstractSection) then
-		local obj  = class(self, ...)
-		self:append(obj)
-		return obj
-	else
-		error("class must be a descendent of AbstractSection")
-	end
-end
-
--- Creates a child field
-function SimpleForm.field(self, class, ...)
-	local section
-	for k, v in ipairs(self.children) do
-		if instanceof(v, SimpleSection) then
-			section = v
-			break
-		end
-	end
-	if not section then
-		section = self:section(SimpleSection)
-	end
-
-	if instanceof(class, AbstractValue) then
-		local obj  = class(self, section, ...)
-		obj.track_missing = true
-		section:append(obj)
-		return obj
-	else
-		error("class must be a descendent of AbstractValue")
-	end
-end
-
-function SimpleForm.set(self, section, option, value)
-	self.data[option] = value
-end
-
-
-function SimpleForm.del(self, section, option)
-	self.data[option] = nil
-end
-
-
-function SimpleForm.get(self, section, option)
-	return self.data[option]
-end
-
-
-function SimpleForm.get_scheme()
-	return nil
-end
-
-
-Form = class(SimpleForm)
-
-function Form.__init__(self, ...)
-	SimpleForm.__init__(self, ...)
-	self.embedded = true
-end
-
-
---[[
-AbstractSection
-]]--
-AbstractSection = class(Node)
-
-function AbstractSection.__init__(self, map, sectiontype, ...)
-	Node.__init__(self, ...)
-	self.sectiontype = sectiontype
-	self.map = map
-	self.config = map.config
-	self.optionals = {}
-	self.defaults = {}
-	self.fields = {}
-	self.tag_error = {}
-	self.tag_invalid = {}
-	self.tag_deperror = {}
-	self.changed = false
-
-	self.optional = true
-	self.addremove = false
-	self.dynamic = false
-end
-
--- Define a tab for the section
-function AbstractSection.tab(self, tab, title, desc)
-	self.tabs      = self.tabs      or { }
-	self.tab_names = self.tab_names or { }
-
-	self.tab_names[#self.tab_names+1] = tab
-	self.tabs[tab] = {
-		title       = title,
-		description = desc,
-		childs      = { }
-	}
-end
-
--- Check whether the section has tabs
-function AbstractSection.has_tabs(self)
-	return (self.tabs ~= nil) and (next(self.tabs) ~= nil)
-end
-
--- Appends a new option
-function AbstractSection.option(self, class, option, ...)
-	if instanceof(class, AbstractValue) then
-		local obj  = class(self.map, self, option, ...)
-		self:append(obj)
-		self.fields[option] = obj
-		return obj
-	elseif class == true then
-		error("No valid class was given and autodetection failed.")
-	else
-		error("class must be a descendant of AbstractValue")
-	end
-end
-
--- Appends a new tabbed option
-function AbstractSection.taboption(self, tab, ...)
-
-	assert(tab and self.tabs and self.tabs[tab],
-		"Cannot assign option to not existing tab %q" % tostring(tab))
-
-	local l = self.tabs[tab].childs
-	local o = AbstractSection.option(self, ...)
-
-	if o then l[#l+1] = o end
-
-	return o
-end
-
--- Render a single tab
-function AbstractSection.render_tab(self, tab, ...)
-
-	assert(tab and self.tabs and self.tabs[tab],
-		"Cannot render not existing tab %q" % tostring(tab))
-
-	local k, node
-	for k, node in ipairs(self.tabs[tab].childs) do
-		node.last_child = (k == #self.tabs[tab].childs)
-		node.index = k
-		node:render(...)
-	end
-end
-
--- Parse optional options
-function AbstractSection.parse_optionals(self, section, noparse)
-	if not self.optional then
-		return
-	end
-
-	self.optionals[section] = {}
-
-	local field = nil
-	if not noparse then
-		field = self.map:formvalue("cbi.opt."..self.config.."."..section)
-	end
-
-	for k,v in ipairs(self.children) do
-		if v.optional and not v:cfgvalue(section) and not self:has_tabs() then
-			if field == v.option then
-				field = nil
-				self.map.proceed = true
-			else
-				table.insert(self.optionals[section], v)
-			end
-		end
-	end
-
-	if field and #field > 0 and self.dynamic then
-		self:add_dynamic(field)
-	end
-end
-
--- Add a dynamic option
-function AbstractSection.add_dynamic(self, field, optional)
-	local o = self:option(Value, field, field)
-	o.optional = optional
-end
-
--- Parse all dynamic options
-function AbstractSection.parse_dynamic(self, section)
-	if not self.dynamic then
-		return
-	end
-
-	local arr  = luci.util.clone(self:cfgvalue(section))
-	local form = self.map:formvaluetable("cbid."..self.config.."."..section)
-	for k, v in pairs(form) do
-		arr[k] = v
-	end
-
-	for key,val in pairs(arr) do
-		local create = true
-
-		for i,c in ipairs(self.children) do
-			if c.option == key then
-				create = false
-			end
-		end
-
-		if create and key:sub(1, 1) ~= "." then
-			self.map.proceed = true
-			self:add_dynamic(key, true)
-		end
-	end
-end
-
--- Returns the section's UCI table
-function AbstractSection.cfgvalue(self, section)
-	return self.map:get(section)
-end
-
--- Push events
-function AbstractSection.push_events(self)
-	--luci.util.append(self.map.events, self.events)
-	self.map.changed = true
-end
-
--- Removes the section
-function AbstractSection.remove(self, section)
-	self.map.proceed = true
-	return self.map:del(section)
-end
-
--- Creates the section
-function AbstractSection.create(self, section)
-	local stat
-
-	if section then
-		stat = section:match("^[%w_]+$") and self.map:set(section, nil, self.sectiontype)
-	else
-		section = self.map:add(self.sectiontype)
-		stat = section
-	end
-
-	if stat then
-		for k,v in pairs(self.children) do
-			if v.default then
-				self.map:set(section, v.option, v.default)
-			end
-		end
-
-		for k,v in pairs(self.defaults) do
-			self.map:set(section, k, v)
-		end
-	end
-
-	self.map.proceed = true
-
-	return stat
-end
-
-
-SimpleSection = class(AbstractSection)
-
-function SimpleSection.__init__(self, form, ...)
-	AbstractSection.__init__(self, form, nil, ...)
-	self.template = "cbi/nullsection"
-end
-
-
-Table = class(AbstractSection)
-
-function Table.__init__(self, form, data, ...)
-	local datasource = {}
-	local tself = self
-	datasource.config = "table"
-	self.data = data or {}
-
-	datasource.formvalue = Map.formvalue
-	datasource.formvaluetable = Map.formvaluetable
-	datasource.readinput = true
-
-	function datasource.get(self, section, option)
-		return tself.data[section] and tself.data[section][option]
-	end
-
-	function datasource.submitstate(self)
-		return Map.formvalue(self, "cbi.submit")
-	end
-
-	function datasource.del(...)
-		return true
-	end
-
-	function datasource.get_scheme()
-		return nil
-	end
-
-	AbstractSection.__init__(self, datasource, "table", ...)
-	self.template = "cbi/tblsection"
-	self.rowcolors = true
-	self.anonymous = true
-end
-
-function Table.parse(self, readinput)
-	self.map.readinput = (readinput ~= false)
-	for i, k in ipairs(self:cfgsections()) do
-		if self.map:submitstate() then
-			Node.parse(self, k)
-		end
-	end
-end
-
-function Table.cfgsections(self)
-	local sections = {}
-
-	for i, v in luci.util.kspairs(self.data) do
-		table.insert(sections, i)
-	end
-
-	return sections
-end
-
-function Table.update(self, data)
-	self.data = data
-end
-
-
-
---[[
-NamedSection - A fixed configuration section defined by its name
-]]--
-NamedSection = class(AbstractSection)
-
-function NamedSection.__init__(self, map, section, stype, ...)
-	AbstractSection.__init__(self, map, stype, ...)
-
-	-- Defaults
-	self.addremove = false
-	self.template = "cbi/nsection"
-	self.section = section
-end
-
-function NamedSection.prepare(self)
-	AbstractSection.prepare(self)
-	AbstractSection.parse_optionals(self, self.section, true)
-end
-
-function NamedSection.parse(self, novld)
-	local s = self.section
-	local active = self:cfgvalue(s)
-
-	if self.addremove then
-		local path = self.config.."."..s
-		if active then -- Remove the section
-			if self.map:formvalue("cbi.rns."..path) and self:remove(s) then
-				self:push_events()
-				return
-			end
-		else           -- Create and apply default values
-			if self.map:formvalue("cbi.cns."..path) then
-				self:create(s)
-				return
-			end
-		end
-	end
-
-	if active then
-		AbstractSection.parse_dynamic(self, s)
-		if self.map:submitstate() then
-			Node.parse(self, s)
-		end
-		AbstractSection.parse_optionals(self, s)
-
-		if self.changed then
-			self:push_events()
-		end
-	end
-end
-
-
---[[
-TypedSection - A (set of) configuration section(s) defined by the type
-	addremove: 	Defines whether the user can add/remove sections of this type
-	anonymous:  Allow creating anonymous sections
-	validate: 	a validation function returning nil if the section is invalid
-]]--
-TypedSection = class(AbstractSection)
-
-function TypedSection.__init__(self, map, type, ...)
-	AbstractSection.__init__(self, map, type, ...)
-
-	self.template = "cbi/tsection"
-	self.deps = {}
-	self.anonymous = false
-end
-
-function TypedSection.prepare(self)
-	AbstractSection.prepare(self)
-
-	local i, s
-	for i, s in ipairs(self:cfgsections()) do
-		AbstractSection.parse_optionals(self, s, true)
-	end
-end
-
--- Return all matching UCI sections for this TypedSection
-function TypedSection.cfgsections(self)
-	local sections = {}
-	self.map.uci:foreach(self.map.config, self.sectiontype,
-		function (section)
-			if self:checkscope(section[".name"]) then
-				table.insert(sections, section[".name"])
-			end
-		end)
-
-	return sections
-end
-
--- Limits scope to sections that have certain option => value pairs
-function TypedSection.depends(self, option, value)
-	table.insert(self.deps, {option=option, value=value})
-end
-
-function TypedSection.parse(self, novld)
-	if self.addremove then
-		-- Remove
-		local crval = REMOVE_PREFIX .. self.config
-		local name = self.map:formvaluetable(crval)
-		for k,v in pairs(name) do
-			if k:sub(-2) == ".x" then
-				k = k:sub(1, #k - 2)
-			end
-			if self:cfgvalue(k) and self:checkscope(k) then
-				self:remove(k)
-			end
-		end
-	end
-
-	local co
-	for i, k in ipairs(self:cfgsections()) do
-		AbstractSection.parse_dynamic(self, k)
-		if self.map:submitstate() then
-			Node.parse(self, k, novld)
-		end
-		AbstractSection.parse_optionals(self, k)
-	end
-
-	if self.addremove then
-		-- Create
-		local created
-		local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
-		local origin, name = next(self.map:formvaluetable(crval))
-		if self.anonymous then
-			if name then
-				created = self:create(nil, origin)
-			end
-		else
-			if name then
-				-- Ignore if it already exists
-				if self:cfgvalue(name) then
-					name = nil
-					self.err_invalid = true
-				else
-					name = self:checkscope(name)
-
-					if not name then
-						self.err_invalid = true
-					end
-
-					if name and #name > 0 then
-						created = self:create(name, origin) and name
-						if not created then
-							self.invalid_cts = true
-						end
-					end
-				end
-			end
-		end
-
-		if created then
-			AbstractSection.parse_optionals(self, created)
-		end
-	end
-
-	if self.sortable then
-		local stval = RESORT_PREFIX .. self.config .. "." .. self.sectiontype
-		local order = self.map:formvalue(stval)
-		if order and #order > 0 then
-			local sids, sid = { }, nil
-			for sid in util.imatch(order) do
-				sids[#sids+1] = sid
-			end
-			if #sids > 0 then
-				self.map.uci:reorder(self.config, sids)
-				self.changed = true
-			end
-		end
-	end
-
-	if created or self.changed then
-		self:push_events()
-	end
-end
-
--- Verifies scope of sections
-function TypedSection.checkscope(self, section)
-	-- Check if we are not excluded
-	if self.filter and not self:filter(section) then
-		return nil
-	end
-
-	-- Check if at least one dependency is met
-	if #self.deps > 0 and self:cfgvalue(section) then
-		local stat = false
-
-		for k, v in ipairs(self.deps) do
-			if self:cfgvalue(section)[v.option] == v.value then
-				stat = true
-			end
-		end
-
-		if not stat then
-			return nil
-		end
-	end
-
-	return self:validate(section)
-end
-
-
--- Dummy validate function
-function TypedSection.validate(self, section)
-	return section
-end
-
-
---[[
-AbstractValue - An abstract Value Type
-	null:		Value can be empty
-	valid:		A function returning the value if it is valid otherwise nil
-	depends:	A table of option => value pairs of which one must be true
-	default:	The default value
-	size:		The size of the input fields
-	rmempty:	Unset value if empty
-	optional:	This value is optional (see AbstractSection.optionals)
-]]--
-AbstractValue = class(Node)
-
-function AbstractValue.__init__(self, map, section, option, ...)
-	Node.__init__(self, ...)
-	self.section = section
-	self.option  = option
-	self.map     = map
-	self.config  = map.config
-	self.tag_invalid = {}
-	self.tag_missing = {}
-	self.tag_reqerror = {}
-	self.tag_error = {}
-	self.deps = {}
-	--self.cast = "string"
-
-	self.track_missing = false
-	self.rmempty   = true
-	self.default   = nil
-	self.size      = nil
-	self.optional  = false
-end
-
-function AbstractValue.prepare(self)
-	self.cast = self.cast or "string"
-end
-
--- Add a dependencie to another section field
-function AbstractValue.depends(self, field, value)
-	local deps
-	if type(field) == "string" then
-		deps = {}
-	 	deps[field] = value
-	else
-		deps = field
-	end
-
-	table.insert(self.deps, deps)
-end
-
--- Serialize dependencies
-function AbstractValue.deplist2json(self, section, deplist)
-	local deps, i, d = { }
-
-	if type(self.deps) == "table" then
-		for i, d in ipairs(deplist or self.deps) do
-			local a, k, v = { }
-			for k, v in pairs(d) do
-				if k:find("!", 1, true) then
-					a[k] = v
-				elseif k:find(".", 1, true) then
-					a['cbid.%s' % k] = v
-				else
-					a['cbid.%s.%s.%s' %{ self.config, section, k }] = v
-				end
-			end
-			deps[#deps+1] = a
-		end
-	end
-
-	return util.serialize_json(deps)
-end
-
--- Serialize choices
-function AbstractValue.choices(self)
-	if type(self.keylist) == "table" and #self.keylist > 0 then
-		local i, k, v = nil, nil, {}
-		for i, k in ipairs(self.keylist) do
-			v[k] = self.vallist[i] or k
-		end
-		return v
-	end
-	return nil
-end
-
--- Generates the unique CBID
-function AbstractValue.cbid(self, section)
-	return "cbid."..self.map.config.."."..section.."."..self.option
-end
-
--- Return whether this object should be created
-function AbstractValue.formcreated(self, section)
-	local key = "cbi.opt."..self.config.."."..section
-	return (self.map:formvalue(key) == self.option)
-end
-
--- Returns the formvalue for this object
-function AbstractValue.formvalue(self, section)
-	return self.map:formvalue(self:cbid(section))
-end
-
-function AbstractValue.additional(self, value)
-	self.optional = value
-end
-
-function AbstractValue.mandatory(self, value)
-	self.rmempty = not value
-end
-
-function AbstractValue.add_error(self, section, type, msg)
-	self.error = self.error or { }
-	self.error[section] = msg or type
-
-	self.section.error = self.section.error or { }
-	self.section.error[section] = self.section.error[section] or { }
-	table.insert(self.section.error[section], msg or type)
-
-	if type == "invalid" then
-		self.tag_invalid[section] = true
-	elseif type == "missing" then
-		self.tag_missing[section] = true
-	end
-
-	self.tag_error[section] = true
-	self.map.save = false
-end
-
-function AbstractValue.parse(self, section, novld)
-	local fvalue = self:formvalue(section)
-	local cvalue = self:cfgvalue(section)
-
-	-- If favlue and cvalue are both tables and have the same content
-	-- make them identical
-	if type(fvalue) == "table" and type(cvalue) == "table" then
-		local equal = #fvalue == #cvalue
-		if equal then
-			for i=1, #fvalue do
-				if cvalue[i] ~= fvalue[i] then
-					equal = false
-				end
-			end
-		end
-		if equal then
-			fvalue = cvalue
-		end
-	end
-
-	if fvalue and #fvalue > 0 then -- If we have a form value, write it to UCI
-		local val_err
-		fvalue, val_err = self:validate(fvalue, section)
-		fvalue = self:transform(fvalue)
-
-		if not fvalue and not novld then
-			self:add_error(section, "invalid", val_err)
-		end
-
-		if self.alias then
-			self.section.aliased = self.section.aliased or {}
-			self.section.aliased[section] = self.section.aliased[section] or {}
-			self.section.aliased[section][self.alias] = true
-		end
-
-		if fvalue and (self.forcewrite or not (fvalue == cvalue)) then
-			if self:write(section, fvalue) then
-				-- Push events
-				self.section.changed = true
-				--luci.util.append(self.map.events, self.events)
-			end
-		end
-	else							-- Unset the UCI or error
-		if self.rmempty or self.optional then
-			if not self.alias or
-			   not self.section.aliased or
-			   not self.section.aliased[section] or
-			   not self.section.aliased[section][self.alias]
-			then
-				if self:remove(section) then
-					-- Push events
-					self.section.changed = true
-					--luci.util.append(self.map.events, self.events)
-				end
-			end
-		elseif cvalue ~= fvalue and not novld then
-			-- trigger validator with nil value to get custom user error msg.
-			local _, val_err = self:validate(nil, section)
-			self:add_error(section, "missing", val_err)
-		end
-	end
-end
-
--- Render if this value exists or if it is mandatory
-function AbstractValue.render(self, s, scope)
-	if not self.optional or self.section:has_tabs() or self:cfgvalue(s) or self:formcreated(s) then
-		scope = scope or {}
-		scope.section = s
-		scope.cbid    = self:cbid(s)
-		Node.render(self, scope)
-	end
-end
-
--- Return the UCI value of this object
-function AbstractValue.cfgvalue(self, section)
-	local value
-	if self.tag_error[section] then
-		value = self:formvalue(section)
-	else
-		value = self.map:get(section, self.alias or self.option)
-	end
-
-	if not value then
-		return nil
-	elseif not self.cast or self.cast == type(value) then
-		return value
-	elseif self.cast == "string" then
-		if type(value) == "table" then
-			return value[1]
-		end
-	elseif self.cast == "table" then
-		return { value }
-	end
-end
-
--- Validate the form value
-function AbstractValue.validate(self, value)
-	if self.datatype and value then
-		if type(value) == "table" then
-			local v
-			for _, v in ipairs(value) do
-				if v and #v > 0 and not verify_datatype(self.datatype, v) then
-					return nil
-				end
-			end
-		else
-			if not verify_datatype(self.datatype, value) then
-				return nil
-			end
-		end
-	end
-
-	return value
-end
-
-AbstractValue.transform = AbstractValue.validate
-
-
--- Write to UCI
-function AbstractValue.write(self, section, value)
-	return self.map:set(section, self.alias or self.option, value)
-end
-
--- Remove from UCI
-function AbstractValue.remove(self, section)
-	return self.map:del(section, self.alias or self.option)
-end
-
-
-
-
---[[
-Value - A one-line value
-	maxlength:	The maximum length
-]]--
-Value = class(AbstractValue)
-
-function Value.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template  = "cbi/value"
-	self.keylist = {}
-	self.vallist = {}
-	self.readonly = nil
-end
-
-function Value.reset_values(self)
-	self.keylist = {}
-	self.vallist = {}
-end
-
-function Value.value(self, key, val)
-	val = val or key
-	table.insert(self.keylist, tostring(key))
-	table.insert(self.vallist, tostring(val))
-end
-
-function Value.parse(self, section, novld)
-	if self.readonly then return end
-	AbstractValue.parse(self, section, novld)
-end
-
--- DummyValue - This does nothing except being there
-DummyValue = class(AbstractValue)
-
-function DummyValue.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template = "cbi/dvalue"
-	self.value = nil
-end
-
-function DummyValue.cfgvalue(self, section)
-	local value
-	if self.value then
-		if type(self.value) == "function" then
-			value = self:value(section)
-		else
-			value = self.value
-		end
-	else
-		value = AbstractValue.cfgvalue(self, section)
-	end
-	return value
-end
-
-function DummyValue.parse(self)
-
-end
-
-
---[[
-Flag - A flag being enabled or disabled
-]]--
-Flag = class(AbstractValue)
-
-function Flag.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template  = "cbi/fvalue"
-
-	self.enabled  = "1"
-	self.disabled = "0"
-	self.default  = self.disabled
-end
-
--- A flag can only have two states: set or unset
-function Flag.parse(self, section, novld)
-	local fexists = self.map:formvalue(
-		FEXIST_PREFIX .. self.config .. "." .. section .. "." .. self.option)
-
-	if fexists then
-		local fvalue = self:formvalue(section) and self.enabled or self.disabled
-		local cvalue = self:cfgvalue(section)
-		local val_err
-		fvalue, val_err = self:validate(fvalue, section)
-		if not fvalue then
-			if not novld then
-				self:add_error(section, "invalid", val_err)
-			end
-			return
-		end
-		if fvalue == self.default and (self.optional or self.rmempty) then
-			self:remove(section)
-		else
-			self:write(section, fvalue)
-		end
-		if (fvalue ~= cvalue) then self.section.changed = true end
-	else
-		self:remove(section)
-		self.section.changed = true
-	end
-end
-
-function Flag.cfgvalue(self, section)
-	return AbstractValue.cfgvalue(self, section) or self.default
-end
-function Flag.validate(self, value)
-	return value
-end
-
---[[
-ListValue - A one-line value predefined in a list
-	widget: The widget that will be used (select, radio)
-]]--
-ListValue = class(AbstractValue)
-
-function ListValue.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template  = "cbi/lvalue"
-
-	self.size   = 1
-	self.widget = "select"
-
-	self:reset_values()
-end
-
-function ListValue.reset_values(self)
-	self.keylist = {}
-	self.vallist = {}
-	self.deplist = {}
-end
-
-function ListValue.value(self, key, val, ...)
-	if luci.util.contains(self.keylist, key) then
-		return
-	end
-
-	val = val or key
-	table.insert(self.keylist, tostring(key))
-	table.insert(self.vallist, tostring(val))
-	table.insert(self.deplist, {...})
-end
-
-function ListValue.validate(self, val)
-	if luci.util.contains(self.keylist, val) then
-		return val
-	else
-		return nil
-	end
-end
-
-
-
---[[
-MultiValue - Multiple delimited values
-	widget: The widget that will be used (select, checkbox)
-	delimiter: The delimiter that will separate the values (default: " ")
-]]--
-MultiValue = class(AbstractValue)
-
-function MultiValue.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template = "cbi/mvalue"
-
-	self.widget = "checkbox"
-	self.delimiter = " "
-
-	self:reset_values()
-end
-
-function MultiValue.render(self, ...)
-	if self.widget == "select" and not self.size then
-		self.size = #self.vallist
-	end
-
-	AbstractValue.render(self, ...)
-end
-
-function MultiValue.reset_values(self)
-	self.keylist = {}
-	self.vallist = {}
-	self.deplist = {}
-end
-
-function MultiValue.value(self, key, val)
-	if luci.util.contains(self.keylist, key) then
-		return
-	end
-
-	val = val or key
-	table.insert(self.keylist, tostring(key))
-	table.insert(self.vallist, tostring(val))
-end
-
-function MultiValue.valuelist(self, section)
-	local val = self:cfgvalue(section)
-
-	if not(type(val) == "string") then
-		return {}
-	end
-
-	return luci.util.split(val, self.delimiter)
-end
-
-function MultiValue.validate(self, val)
-	val = (type(val) == "table") and val or {val}
-
-	local result
-
-	for i, value in ipairs(val) do
-		if luci.util.contains(self.keylist, value) then
-			result = result and (result .. self.delimiter .. value) or value
-		end
-	end
-
-	return result
-end
-
-
-StaticList = class(MultiValue)
-
-function StaticList.__init__(self, ...)
-	MultiValue.__init__(self, ...)
-	self.cast = "table"
-	self.valuelist = self.cfgvalue
-
-	if not self.override_scheme
-	 and self.map:get_scheme(self.section.sectiontype, self.option) then
-		local vs = self.map:get_scheme(self.section.sectiontype, self.option)
-		if self.value and vs.values and not self.override_values then
-			for k, v in pairs(vs.values) do
-				self:value(k, v)
-			end
-		end
-	end
-end
-
-function StaticList.validate(self, value)
-	value = (type(value) == "table") and value or {value}
-
-	local valid = {}
-	for i, v in ipairs(value) do
-		if luci.util.contains(self.keylist, v) then
-			table.insert(valid, v)
-		end
-	end
-	return valid
-end
-
-
-DynamicList = class(AbstractValue)
-
-function DynamicList.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template  = "cbi/dynlist"
-	self.cast = "table"
-	self:reset_values()
-end
-
-function DynamicList.reset_values(self)
-	self.keylist = {}
-	self.vallist = {}
-end
-
-function DynamicList.value(self, key, val)
-	val = val or key
-	table.insert(self.keylist, tostring(key))
-	table.insert(self.vallist, tostring(val))
-end
-
-function DynamicList.write(self, section, value)
-	local t = { }
-
-	if type(value) == "table" then
-		local x
-		for _, x in ipairs(value) do
-			if x and #x > 0 then
-				t[#t+1] = x
-			end
-		end
-	else
-		t = { value }
-	end
-
-	if self.cast == "string" then
-		value = table.concat(t, " ")
-	else
-		value = t
-	end
-
-	return AbstractValue.write(self, section, value)
-end
-
-function DynamicList.cfgvalue(self, section)
-	local value = AbstractValue.cfgvalue(self, section)
-
-	if type(value) == "string" then
-		local x
-		local t = { }
-		for x in value:gmatch("%S+") do
-			if #x > 0 then
-				t[#t+1] = x
-			end
-		end
-		value = t
-	end
-
-	return value
-end
-
-function DynamicList.formvalue(self, section)
-	local value = AbstractValue.formvalue(self, section)
-
-	if type(value) == "string" then
-		if self.cast == "string" then
-			local x
-			local t = { }
-			for x in value:gmatch("%S+") do
-				t[#t+1] = x
-			end
-			value = t
-		else
-			value = { value }
-		end
-	end
-
-	return value
-end
-
-
-DropDown = class(MultiValue)
-
-function DropDown.__init__(self, ...)
-	ListValue.__init__(self, ...)
-	self.template = "cbi/dropdown"
-	self.delimiter = " "
-end
-
-
---[[
-TextValue - A multi-line value
-	rows:	Rows
-]]--
-TextValue = class(AbstractValue)
-
-function TextValue.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template  = "cbi/tvalue"
-end
-
---[[
-Button
-]]--
-Button = class(AbstractValue)
-
-function Button.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template  = "cbi/button"
-	self.inputstyle = nil
-	self.rmempty = true
-        self.unsafeupload = false
-end
-
-
-FileUpload = class(AbstractValue)
-
-function FileUpload.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template = "cbi/upload"
-	if not self.map.upload_fields then
-		self.map.upload_fields = { self }
-	else
-		self.map.upload_fields[#self.map.upload_fields+1] = self
-	end
-end
-
-function FileUpload.formcreated(self, section)
-	if self.unsafeupload then
-		return AbstractValue.formcreated(self, section) or
-			self.map:formvalue("cbi.rlf."..section.."."..self.option) or
-			self.map:formvalue("cbi.rlf."..section.."."..self.option..".x") or
-			self.map:formvalue("cbid."..self.map.config.."."..section.."."..self.option..".textbox")
-	else
-		return AbstractValue.formcreated(self, section) or
-			self.map:formvalue("cbid."..self.map.config.."."..section.."."..self.option..".textbox")
-	end
-end
-
-function FileUpload.cfgvalue(self, section)
-	local val = AbstractValue.cfgvalue(self, section)
-	if val and fs.access(val) then
-		return val
-	end
-	return nil
-end
-
--- If we have a new value, use it
--- otherwise use old value
--- deletion should be managed by a separate button object
--- unless self.unsafeupload is set in which case if the user
--- choose to remove the old file we do so.
--- Also, allow to specify (via textbox) a file already on router
-function FileUpload.formvalue(self, section)
-	local val = AbstractValue.formvalue(self, section)
-	if val then
-		if self.unsafeupload then
-			if not self.map:formvalue("cbi.rlf."..section.."."..self.option) and
-		   	    not self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
-			then
-				return val
-			end
-			fs.unlink(val)
-			self.value = nil
-			return nil
-                elseif val ~= "" then
-			return val
-                end
-	end
-	val = luci.http.formvalue("cbid."..self.map.config.."."..section.."."..self.option..".textbox")
-	if val == "" then
-		val = nil
-	end
-        if not self.unsafeupload then
-		if not val then
-			val = self.map:formvalue("cbi.rlf."..section.."."..self.option)
-		end
-        end
-	return val
-end
-
-function FileUpload.remove(self, section)
-	if self.unsafeupload then
-		local val = AbstractValue.formvalue(self, section)
-		if val and fs.access(val) then fs.unlink(val) end
-		return AbstractValue.remove(self, section)
-	else
-		return nil
-	end
-end
-
-FileBrowser = class(AbstractValue)
-
-function FileBrowser.__init__(self, ...)
-	AbstractValue.__init__(self, ...)
-	self.template = "cbi/browser"
-end