--- /dev/null
+--[[
+LuCI - Configuration Bind Interface
+
+Description:
+Offers an interface for binding configuration values to certain
+data types. Supports value and range validation and basic dependencies.
+
+FileId:
+$Id$
+
+License:
+Copyright 2008 Steven Barth <steven@midlink.org>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+]]--
+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 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 = "/lib/uci/upload/"
+ 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: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
+
+ if not self.uci:load(self.config) then
+ error("Unable to read UCI data: " .. self.config)
+ end
+end
+
+function Map.formvalue(self, key)
+ return self.readinput and luci.http.formvalue(key)
+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, ...)
+ self.readinput = (readinput ~= false)
+ self:_run_hooks("on_parse")
+
+ if self:formvalue("cbi.skip") then
+ self.state = FORM_SKIP
+ return self:state_handler(self.state)
+ end
+
+ Node.parse(self, ...)
+
+ if self.save then
+ self:_run_hooks("on_save", "on_before_save")
+ for i, config in ipairs(self.parsechain) do
+ self.uci:save(config)
+ end
+ self:_run_hooks("on_after_save")
+ if self:submitstate() and ((not self.proceed and self.flow.autoapply) or luci.http.formvalue("cbi.apply")) then
+ self:_run_hooks("on_before_commit")
+ for i, config in ipairs(self.parsechain) do
+ self.uci:commit(config)
+
+ -- Refresh data because commit changes section names
+ self.uci:load(config)
+ end
+ self:_run_hooks("on_commit", "on_after_commit", "on_before_apply")
+ if self.apply_on_parse then
+ self.uci:apply(self.parsechain)
+ 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 self:submitstate() then
+ if not self.save then
+ self.state = FORM_INVALID
+ elseif self.proceed then
+ self.state = FORM_PROCEED
+ else
+ self.state = self.changed and FORM_CHANGED or FORM_VALID
+ end
+ else
+ self.state = FORM_NODATA
+ 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:render(...)
+ end
+end
+
+-- Parse optional options
+function AbstractSection.parse_optionals(self, section)
+ if not self.optional then
+ return
+ end
+
+ self.optionals[section] = {}
+
+ local field = self.map:formvalue("cbi.opt."..self.config.."."..section)
+ 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.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
+
+-- 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;
+ end
+
+ 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
+
+ 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 sid
+ local num = 0
+ for sid in util.imatch(order) do
+ self.map.uci:reorder(self.config, sid, num)
+ num = num + 1
+ end
+ self.changed = (num > 0)
+ 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.subdeps = {}
+ --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=deps, add=""})
+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 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 self:remove(section) then
+ -- Push events
+ self.section.changed = true
+ --luci.util.append(self.map.events, self.events)
+ 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.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.option, value)
+end
+
+-- Remove from UCI
+function AbstractValue.remove(self, section)
+ return self.map:del(section, 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 = {}
+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
+
+
+-- 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)
+ 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
+ if fvalue ~= self.default or (not self.optional and not self.rmempty) then
+ self:write(section, fvalue)
+ else
+ self:remove(section)
+ end
+ else
+ self:remove(section)
+ end
+end
+
+function Flag.cfgvalue(self, section)
+ return AbstractValue.cfgvalue(self, section) or self.default
+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.keylist = {}
+ self.vallist = {}
+ self.size = 1
+ self.widget = "select"
+end
+
+function ListValue.reset_values(self)
+ self.keylist = {}
+ self.vallist = {}
+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))
+
+ for i, deps in ipairs({...}) do
+ self.subdeps[#self.subdeps + 1] = {add = "-"..key, deps=deps}
+ end
+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.keylist = {}
+ self.vallist = {}
+
+ self.widget = "checkbox"
+ self.delimiter = " "
+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 = {}
+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.keylist = {}
+ self.vallist = {}
+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
+
+
+--[[
+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
+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)
+ return AbstractValue.formcreated(self, section) or
+ self.map:formvalue("cbi.rlf."..section.."."..self.option) or
+ self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
+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
+
+function FileUpload.formvalue(self, section)
+ local val = AbstractValue.formvalue(self, section)
+ if val 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
+ end
+ return nil
+end
+
+function FileUpload.remove(self, section)
+ local val = AbstractValue.formvalue(self, section)
+ if val and fs.access(val) then fs.unlink(val) end
+ return AbstractValue.remove(self, section)
+end
+
+
+FileBrowser = class(AbstractValue)
+
+function FileBrowser.__init__(self, ...)
+ AbstractValue.__init__(self, ...)
+ self.template = "cbi/browser"
+end
projects / project / luci.git / blobdiff