Merge CBI change-detection

[project/luci.git] / libs / cbi / luasrc / cbi.lua

diff --git a/libs/cbi/luasrc/cbi.lua b/libs/cbi/luasrc/cbi.lua
index e94e1e2..78f6b7d 100644 (file)
--- a/libs/cbi/luasrc/cbi.lua
+++ b/libs/cbi/luasrc/cbi.lua
@@ -2,7 +2,7 @@
 LuCI - Configuration Bind Interface
 
 Description:
 LuCI - Configuration Bind Interface
 
 Description:

-Offers an interface for binding confiugration values to certain
+Offers an interface for binding configuration values to certain

 data types. Supports value and range validation and basic dependencies.
 
 FileId:
 data types. Supports value and range validation and basic dependencies.
 
 FileId:


@@ -13,9 +13,9 @@ 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.
 
 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 
+You may obtain a copy of the License at

 
 

-       http://www.apache.org/licenses/LICENSE-2.0 
+       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,
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,


@@ -29,42 +29,175 @@ module("luci.cbi", package.seeall)
 require("luci.template")
 require("luci.util")
 require("luci.http")
 require("luci.template")
 require("luci.util")
 require("luci.http")

-require("luci.model.uci")
+require("luci.uvl")
+require("luci.fs")

 
 

+--local event      = require "luci.sys.event"
+local uci        = require("luci.model.uci")

 local class      = luci.util.class
 local instanceof = luci.util.instanceof
 
 local class      = luci.util.class
 local instanceof = luci.util.instanceof
 

+FORM_NODATA  =  0
+FORM_PROCEED =  0
+FORM_VALID   =  1
+FORM_INVALID = -1
+FORM_CHANGED =  2
+
+AUTO = true
+
+CREATE_PREFIX = "cbi.cts."
+REMOVE_PREFIX = "cbi.rts."
+

 -- Loads a CBI map from given file, creating an environment and returns it
 -- Loads a CBI map from given file, creating an environment and returns it

-function load(cbimap)
+function load(cbimap, ...)

        require("luci.fs")
        require("luci.fs")

-       require("luci.i18n")
+       local i18n = require "luci.i18n"

        require("luci.config")
        require("luci.config")

-       require("luci.sys")
-       
-       local cbidir = luci.sys.libpath() .. "/model/cbi/"
-       local func, err = loadfile(cbidir..cbimap..".lua")
-       
-       if not func then
-               return nil
-       end
-       
+       require("luci.util")
+
+       local upldir = "/lib/uci/upload/"
+       local cbidir = luci.util.libpath() .. "/model/cbi/"
+       local func, err = loadfile(cbimap) or loadfile(cbidir..cbimap..".lua")
+       assert(func, err)
+

        luci.i18n.loadc("cbi")
        luci.i18n.loadc("cbi")

-       
-       luci.util.resfenv(func)
-       luci.util.updfenv(func, luci.cbi)
-       luci.util.extfenv(func, "translate", luci.i18n.translate)
-       luci.util.extfenv(func, "translatef", luci.i18n.translatef)
-       
-       local map = func()
-       
-       if not instanceof(map, Map) then
-               error("CBI map returns no valid map object!")
-               return nil
+       luci.i18n.loadc("uvl")
+
+       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 .. '.' ..
+                                               field.option
+                                       ] = true
+                               end
+                       end
+               end

        end
        end

-       
-       return map
+
+       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 )
+                                               if t and 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
+
+local function _uvl_validate_section(node, name)
+       local co = node.map:get()
+
+       luci.uvl.STRICT_UNKNOWN_OPTIONS = false
+       luci.uvl.STRICT_UNKNOWN_SECTIONS = false
+
+       local function tag_fields(e)
+               if e.option and node.fields[e.option] then
+                       if node.fields[e.option].error then
+                               node.fields[e.option].error[name] = e
+                       else
+                               node.fields[e.option].error = { [name] = e }
+                       end
+               elseif e.childs then
+                       for _, c in ipairs(e.childs) do tag_fields(c) end
+               end
+       end
+
+       local function tag_section(e)
+               local s = { }
+               for _, c in ipairs(e.childs) do
+                       if c.childs and not c:is(luci.uvl.errors.ERR_DEPENDENCY) then
+                               table.insert( s, c.childs[1]:string() )
+                       else
+                               table.insert( s, c:string() )
+                       end
+               end
+               if #s > 0 then
+                       if node.error then
+                               node.error[name] = s
+                       else
+                               node.error = { [name] = s }
+                       end
+               end
+       end
+
+       local stat, err = node.map.validator:validate_section(node.config, name, co)
+       if err then
+               node.map.save = false
+               tag_fields(err)
+               tag_section(err)
+       end
+
+end
+
+local function _uvl_strip_remote_dependencies(deps)
+       local clean = {}
+
+       for k, v in pairs(deps) do
+               k = k:gsub("%$config%.%$section%.", "")
+               if k:match("^[%w_]+$") and type(v) == "string" then
+                       clean[k] = v
+               end
+       end
+
+       return clean

 end
 
 end
 

+

 -- Node pseudo abstract class
 Node = class()
 
 -- Node pseudo abstract class
 Node = class()
 


@@ -75,6 +208,29 @@ function Node.__init__(self, title, description)
        self.template = "cbi/node"
 end
 
        self.template = "cbi/node"
 end
 

+-- i18n helper
+function Node._i18n(self, config, section, option, title, description)
+
+       -- i18n loaded?
+       if type(luci.i18n) == "table" then
+
+               local key = config and config:gsub("[^%w]+", "") or ""
+
+               if section then key = key .. "_" .. section:lower():gsub("[^%w]+", "") end
+               if option  then key = key .. "_" .. tostring(option):lower():gsub("[^%w]+", "")  end
+
+               self.title = title or luci.i18n.translate( key, option or section or config )
+               self.description = description or luci.i18n.translate( key .. "_desc", "" )
+       end
+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)
 -- Append child nodes
 function Node.append(self, obj)
        table.insert(self.children, obj)


@@ -113,28 +269,112 @@ function Template.__init__(self, template)
        self.template = template
 end
 
        self.template = template
 end
 

+function Template.render(self)
+       luci.template.render(self.template, {self=self})
+end
+

 
 --[[
 
 --[[

-Map - A map describing a configuration file 
+Map - A map describing a configuration file

 ]]--
 Map = class(Node)
 
 function Map.__init__(self, config, ...)
        Node.__init__(self, ...)
 ]]--
 Map = class(Node)
 
 function Map.__init__(self, config, ...)
        Node.__init__(self, ...)

+       Node._i18n(self, config, nil, nil, ...)
+

        self.config = config
        self.config = config

+       self.parsechain = {self.config}

        self.template = "cbi/map"
        self.template = "cbi/map"

-       self.uci = luci.model.uci.Session()
-       self.ucidata, self.uciorder = self.uci:sections(self.config)
-       if not self.ucidata or not self.uciorder then
+       self.apply_on_parse = nil
+       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
                error("Unable to read UCI data: " .. self.config)
        end

+
+       self.validator = luci.uvl.UVL()
+       self.scheme = self.validator:get_scheme(self.config)
+
+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 luci.http.formvalue("cbi.submit")
+end
+
+-- Chain foreign config
+function Map.chain(self, config)
+       table.insert(self.parsechain, config)

 end
 
 -- Use optimized UCI writing
 end
 
 -- Use optimized UCI writing

-function Map.parse(self, ...)
-       self.uci:t_load(self.config)
-       Node.parse(self, ...)
-       self.uci:t_save(self.config)
+function Map.parse(self)
+       Node.parse(self)
+
+       if self.save then
+               for i, config in ipairs(self.parsechain) do
+                       self.uci:save(config)
+               end
+               if self:submitstate() and (self.autoapply or luci.http.formvalue("cbi.apply")) then
+                       for i, config in ipairs(self.parsechain) do
+                               self.uci:commit(config)
+
+                               -- Refresh data because commit changes section names
+                               self.uci:load(config)
+                       end
+                       if self.apply_on_parse then
+                               self.uci:apply(self.parsechain)
+                       else
+                               self._apply = function()
+                                       local cmd = self.uci:apply(self.parsechain, true)
+                                       return io.popen(cmd)
+                               end
+                       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 self.save then
+                       self.state = self.changed and FORM_CHANGED or FORM_VALID
+               else
+                       self.state = FORM_INVALID
+               end
+       else
+               self.state = FORM_NODATA
+       end
+
+       return self.state
+end
+
+function Map.render(self, ...)
+       Node.render(self, ...)
+       if self._apply then
+               local fp = self._apply()
+               fp:read("*a")
+               fp:close()
+       end

 end
 
 -- Creates a child section
 end
 
 -- Creates a child section


@@ -150,62 +390,148 @@ end
 
 -- UCI add
 function Map.add(self, sectiontype)
 
 -- UCI add
 function Map.add(self, sectiontype)

-       local name = self.uci:t_add(self.config, sectiontype)
-       if name then
-               self.ucidata[name] = {}
-               self.ucidata[name][".type"] = sectiontype
-               table.insert(self.uciorder, name)
-       end
-       return name
+       return self.uci:add(self.config, sectiontype)

 end
 
 -- UCI set
 function Map.set(self, section, option, value)
 end
 
 -- UCI set
 function Map.set(self, section, option, value)

-       local stat = self.uci:t_set(self.config, section, option, value)
-       if stat then
-               local val = self.uci:t_get(self.config, section, option)
-               if option then
-                       self.ucidata[section][option] = val
-               else
-                       if not self.ucidata[section] then
-                               self.ucidata[section] = {}
-                       end
-                       self.ucidata[section][".type"] = val
-                       table.insert(self.uciorder, section)
-               end
+       if option then
+               return self.uci:set(self.config, section, option, value)
+       else
+               return self.uci:set(self.config, section, value)

        end
        end

-       return stat

 end
 
 -- UCI del
 function Map.del(self, section, option)
 end
 
 -- UCI del
 function Map.del(self, section, option)

-       local stat = self.uci:t_del(self.config, section, option)
-       if stat then
-               if option then
-                       self.ucidata[section][option] = nil
-               else
-                       self.ucidata[section] = nil
-                       for i, k in ipairs(self.uciorder) do
-                               if section == k then
-                                       table.remove(self.uciorder, i)
-                               end
-                       end
-               end
+       if option then
+               return self.uci:delete(self.config, section, option)
+       else
+               return self.uci:delete(self.config, section)

        end
        end

-       return stat

 end
 
 end
 

--- UCI get (cached)
+-- UCI get

 function Map.get(self, section, option)
        if not section then
 function Map.get(self, section, option)
        if not section then

-               return self.ucidata, self.uciorder
-       elseif option and self.ucidata[section] then
-               return self.ucidata[section][option]
+               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
+
+
+--[[
+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
+end
+
+function SimpleForm.parse(self, ...)
+       if luci.http.formvalue("cbi.submit") 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])
+               end
+       end
+
+       local state =
+               not self:submitstate() and FORM_NODATA
+               or valid and FORM_VALID
+               or FORM_INVALID
+
+       self.dorender = not self.handle or self:handle(state, self.data) ~= false
+       return state
+end
+
+function SimpleForm.render(self, ...)
+       if self.dorender then
+               Node.render(self, ...)
+       end
+end
+
+function SimpleForm.submitstate(self)
+       return luci.http.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
        else

-               return self.ucidata[section]
+               error("class must be a descendent of AbstractValue")

        end
 end
 
        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
+
+

 
 --[[
 AbstractSection
 
 --[[
 AbstractSection


@@ -218,21 +544,47 @@ function AbstractSection.__init__(self, map, sectiontype, ...)
        self.map = map
        self.config = map.config
        self.optionals = {}
        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
 
 -- Appends a new option
        self.optional = true
        self.addremove = false
        self.dynamic = false
 end
 
 -- Appends a new option

-function AbstractSection.option(self, class, ...)
+function AbstractSection.option(self, class, option, ...)
+       -- Autodetect from UVL
+       if class == true and self.map:get_scheme(self.sectiontype, option) then
+               local vs = self.map:get_scheme(self.sectiontype, option)
+               if vs.type == "boolean" then
+                       class = Flag
+               elseif vs.type == "list" then
+                       class = DynamicList
+               elseif vs.type == "enum" or vs.type == "reference" then
+                       class = ListValue
+               else
+                       class = Value
+               end
+       end
+

        if instanceof(class, AbstractValue) then
        if instanceof(class, AbstractValue) then

-               local obj  = class(self.map, ...)
+               local obj  = class(self.map, self, option, ...)
+
+               Node._i18n(obj, self.config, self.section or self.sectiontype, option, ...)
+

                self:append(obj)
                self:append(obj)

+               self.fields[option] = obj

                return obj
                return obj

+       elseif class == true then
+               error("No valid class was given and autodetection failed.")

        else
        else

-               error("class must be a descendent of AbstractValue")
-       end     
+               error("class must be a descendant of AbstractValue")
+       end

 end
 
 -- Parse optional options
 end
 
 -- Parse optional options


@@ -240,9 +592,9 @@ function AbstractSection.parse_optionals(self, section)
        if not self.optional then
                return
        end
        if not self.optional then
                return
        end

-       
+

        self.optionals[section] = {}
        self.optionals[section] = {}

-       
+

        local field = luci.http.formvalue("cbi.opt."..self.config.."."..section)
        for k,v in ipairs(self.children) do
                if v.optional and not v:cfgvalue(section) then
        local field = luci.http.formvalue("cbi.opt."..self.config.."."..section)
        for k,v in ipairs(self.children) do
                if v.optional and not v:cfgvalue(section) then


@@ -253,7 +605,7 @@ function AbstractSection.parse_optionals(self, section)
                        end
                end
        end
                        end
                end
        end

-       
+

        if field and #field > 0 and self.dynamic then
                self:add_dynamic(field)
        end
        if field and #field > 0 and self.dynamic then
                self:add_dynamic(field)
        end


@@ -270,33 +622,39 @@ function AbstractSection.parse_dynamic(self, section)
        if not self.dynamic then
                return
        end
        if not self.dynamic then
                return
        end

-       
+

        local arr  = luci.util.clone(self:cfgvalue(section))
        local form = luci.http.formvaluetable("cbid."..self.config.."."..section)
        for k, v in pairs(form) do
                arr[k] = v
        end
        local arr  = luci.util.clone(self:cfgvalue(section))
        local form = luci.http.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 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
                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:add_dynamic(key, true)
                end
        end
                if create and key:sub(1, 1) ~= "." then
                        self:add_dynamic(key, true)
                end
        end

-end    
+end

 
 -- Returns the section's UCI table
 function AbstractSection.cfgvalue(self, section)
        return self.map:get(section)
 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)
        return self.map:del(section)
 -- Removes the section
 function AbstractSection.remove(self, section)
        return self.map:del(section)


@@ -304,7 +662,84 @@ end
 
 -- Creates the section
 function AbstractSection.create(self, section)
 
 -- Creates the section
 function AbstractSection.create(self, section)

-       return self.map:set(section, nil, self.sectiontype)
+       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
+
+       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 = {}
+       datasource.config = "table"
+       self.data = data
+
+       function datasource.get(self, section, option)
+               return data[section] and data[section][option]
+       end
+       
+       function datasource.submitstate(self)
+               return luci.http.formvalue("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)
+       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
 
 
 end
 
 


@@ -314,19 +749,30 @@ NamedSection - A fixed configuration section defined by its name
 ]]--
 NamedSection = class(AbstractSection)
 
 ]]--
 NamedSection = class(AbstractSection)
 

-function NamedSection.__init__(self, map, section, ...)
-       AbstractSection.__init__(self, map, ...)
+function NamedSection.__init__(self, map, section, stype, ...)
+       AbstractSection.__init__(self, map, stype, ...)
+       Node._i18n(self, map.config, section, nil, ...)
+
+       -- Defaults
+       self.addremove = false
+
+       -- Use defaults from UVL
+       if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
+               local vs = self.map:get_scheme(self.sectiontype)
+               self.addremove = not vs.unique and not vs.required
+               self.dynamic   = vs.dynamic
+               self.title       = self.title or vs.title
+               self.description = self.description or vs.descr
+       end
+

        self.template = "cbi/nsection"
        self.template = "cbi/nsection"

-       

        self.section = section
        self.section = section

-       self.addremove = false

 end
 
 end
 

-function NamedSection.parse(self)
-       local s = self.section  
+function NamedSection.parse(self, novld)
+       local s = self.section

        local active = self:cfgvalue(s)
        local active = self:cfgvalue(s)

-       
-       
+

        if self.addremove then
                local path = self.config.."."..s
                if active then -- Remove the section
        if self.addremove then
                local path = self.config.."."..s
                if active then -- Remove the section


@@ -334,21 +780,28 @@ function NamedSection.parse(self)
                                return
                        end
                else           -- Create and apply default values
                                return
                        end
                else           -- Create and apply default values

-                       if luci.http.formvalue("cbi.cns."..path) and self:create(s) then
-                               for k,v in pairs(self.children) do
-                                       v:write(s, v.default)
-                               end
+                       if luci.http.formvalue("cbi.cns."..path) then
+                               self:create(s)
+                               return

                        end
                end
        end
                        end
                end
        end

-       
+

        if active then
                AbstractSection.parse_dynamic(self, s)
        if active then
                AbstractSection.parse_dynamic(self, s)

-               if luci.http.formvalue("cbi.submit") then
+               if self.map:submitstate() then

                        Node.parse(self, s)
                        Node.parse(self, s)

+
+                       if not novld and not self.override_scheme and self.map.scheme then
+                               _uvl_validate_section(self, s)
+                       end

                end
                AbstractSection.parse_optionals(self, s)
                end
                AbstractSection.parse_optionals(self, s)

-       end     
+               
+               if self.changed then
+                       self:push_events()
+               end
+       end

 end
 
 
 end
 
 


@@ -356,48 +809,40 @@ 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
 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 
+       validate:       a validation function returning nil if the section is invalid

 ]]--
 TypedSection = class(AbstractSection)
 
 ]]--
 TypedSection = class(AbstractSection)
 

-function TypedSection.__init__(self, ...)
-       AbstractSection.__init__(self, ...)
+function TypedSection.__init__(self, map, type, ...)
+       AbstractSection.__init__(self, map, type, ...)
+       Node._i18n(self, map.config, type, nil, ...)
+

        self.template  = "cbi/tsection"
        self.deps = {}
        self.template  = "cbi/tsection"
        self.deps = {}

-       self.excludes = {}
-       

        self.anonymous = false
        self.anonymous = false

+
+       -- Use defaults from UVL
+       if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
+               local vs = self.map:get_scheme(self.sectiontype)
+               self.addremove = not vs.unique and not vs.required
+               self.dynamic   = vs.dynamic
+               self.anonymous = not vs.named
+               self.title       = self.title or vs.title
+               self.description = self.description or vs.descr
+       end

 end
 
 -- Return all matching UCI sections for this TypedSection
 function TypedSection.cfgsections(self)
        local sections = {}
 end
 
 -- Return all matching UCI sections for this TypedSection
 function TypedSection.cfgsections(self)
        local sections = {}

-       local map, order = self.map:get()
-       
-       for i, k in ipairs(order) do
-               if map[k][".type"] == self.sectiontype then
-                       if self:checkscope(k) then
-                               table.insert(sections, k)
+       self.map.uci:foreach(self.map.config, self.sectiontype,
+               function (section)
+                       if self:checkscope(section[".name"]) then
+                               table.insert(sections, section[".name"])

                        end
                        end

-               end
-       end
-       
-       return sections 
-end
+               end)

 
 

--- Creates a new section of this type with the given name (or anonymous)
-function TypedSection.create(self, name)
-       if name then    
-               self.map:set(name, nil, self.sectiontype)
-       else
-               name = self.map:add(self.sectiontype)
-       end
-       
-       for k,v in pairs(self.children) do
-               if v.default then
-                       self.map:set(name, v.option, v.default)
-               end
-       end
+       return sections

 end
 
 -- Limits scope to sections that have certain option => value pairs
 end
 
 -- Limits scope to sections that have certain option => value pairs


@@ -405,80 +850,97 @@ function TypedSection.depends(self, option, value)
        table.insert(self.deps, {option=option, value=value})
 end
 
        table.insert(self.deps, {option=option, value=value})
 end
 

--- Excludes several sections by name
-function TypedSection.exclude(self, field)
-       self.excludes[field] = true
-end
+function TypedSection.parse(self, novld)
+       if self.addremove then
+               -- Remove
+               local crval = REMOVE_PREFIX .. self.config
+               local name = luci.http.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)
+
+                       if not novld and not self.override_scheme and self.map.scheme then
+                               _uvl_validate_section(self, k)
+                       end
+               end
+               AbstractSection.parse_optionals(self, k)
+       end

 
 

-function TypedSection.parse(self)

        if self.addremove then
                -- Create
        if self.addremove then
                -- Create

-               local crval = "cbi.cts." .. self.config .. "." .. self.sectiontype
+               local created
+               local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype

                local name  = luci.http.formvalue(crval)
                if self.anonymous then
                        if name then
                local name  = luci.http.formvalue(crval)
                if self.anonymous then
                        if name then

-                               self:create()
+                               created = self:create()

                        end
                        end

-               else            
+               else

                        if name then
                                -- Ignore if it already exists
                                if self:cfgvalue(name) then
                                        name = nil;
                                end
                        if name then
                                -- Ignore if it already exists
                                if self:cfgvalue(name) then
                                        name = nil;
                                end

-                               
+

                                name = self:checkscope(name)
                                name = self:checkscope(name)

-                               
+

                                if not name then
                                        self.err_invalid = true
                                if not name then
                                        self.err_invalid = true

-                               end             
-                               
-                               if name and name:len() > 0 then
-                                       self:create(name)
+                               end
+
+                               if name and #name > 0 then
+                                       created = self:create(name) and name
+                                       if not created then
+                                               self.invalid_cts = true
+                                       end

                                end
                        end
                end
                                end
                        end
                end

-               
-               -- Remove
-               crval = "cbi.rts." .. self.config
-               name = luci.http.formvaluetable(crval)
-               for k,v in pairs(name) do
-                       if self:cfgvalue(k) and self:checkscope(k) then
-                               self:remove(k)
-                       end
-               end     
-       end
-       
-       for i, k in ipairs(self:cfgsections()) do
-               AbstractSection.parse_dynamic(self, k)
-               if luci.http.formvalue("cbi.submit") then
-                       Node.parse(self, k)
+
+               if created then
+                       AbstractSection.parse_optionals(self, created)

                end
                end

-               AbstractSection.parse_optionals(self, k)
+       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
        end
 end
 
 -- Verifies scope of sections
 function TypedSection.checkscope(self, section)
        -- Check if we are not excluded

-       if self.excludes[section] then
+       if self.filter and not self:filter(section) then

                return nil
        end
                return nil
        end

-       
+

        -- Check if at least one dependency is met
        if #self.deps > 0 and self:cfgvalue(section) then
                local stat = false
        -- 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
                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
                if not stat then
                        return nil
                end
        end

-       
+

        return self:validate(section)
 end
 
        return self:validate(section)
 end
 


@@ -492,7 +954,7 @@ end
 --[[
 AbstractValue - An abstract Value Type
        null:           Value can be empty
 --[[
 AbstractValue - An abstract Value Type
        null:           Value can be empty

-       valid:          A function returning the value if it is valid otherwise nil 
+       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
        depends:        A table of option => value pairs of which one must be true
        default:        The default value
        size:           The size of the input fields


@@ -501,23 +963,72 @@ AbstractValue - An abstract Value Type
 ]]--
 AbstractValue = class(Node)
 
 ]]--
 AbstractValue = class(Node)
 

-function AbstractValue.__init__(self, map, option, ...)
+function AbstractValue.__init__(self, map, section, option, ...)

        Node.__init__(self, ...)
        Node.__init__(self, ...)

-       self.option = option
-       self.map    = map
-       self.config = map.config
+       self.section = section
+       self.option  = option
+       self.map     = map
+       self.config  = map.config

        self.tag_invalid = {}
        self.tag_invalid = {}

+       self.tag_missing = {}
+       self.tag_reqerror = {}
+       self.tag_error = {}

        self.deps = {}
        self.deps = {}

-       
-       self.rmempty  = false
-       self.default  = nil
-       self.size     = nil
-       self.optional = false
+       --self.cast = "string"
+
+       self.track_missing = false
+       --self.rmempty   = false
+       self.default   = nil
+       self.size      = nil
+       self.optional  = false
+end
+
+function AbstractValue.prepare(self)
+       -- Use defaults from UVL
+       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.rmempty == nil then
+                       self.rmempty = not vs.required
+               end
+               if self.cast == nil then
+                       self.cast = (vs.type == "list") and "list" or "string"
+               end
+               self.title       = self.title or vs.title
+               self.description = self.description or vs.descr
+               if self.default == nil then
+                       self.default = vs.default
+               end
+
+               if vs.depends and not self.override_dependencies then
+                       for i, deps in ipairs(vs.depends) do
+                               deps = _uvl_strip_remote_dependencies(deps)
+                               if next(deps) then
+                                       self:depends(deps)
+                               end
+                       end
+               end
+       end
+
+       self.cast = self.cast or "string"

 end
 
 -- Add a dependencie to another section field
 function AbstractValue.depends(self, field, value)
 end
 
 -- Add a dependencie to another section field
 function AbstractValue.depends(self, field, value)

-       table.insert(self.deps, {field=field, value=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
 end
 
 -- Return whether this object should be created


@@ -528,24 +1039,42 @@ end
 
 -- Returns the formvalue for this object
 function AbstractValue.formvalue(self, section)
 
 -- Returns the formvalue for this object
 function AbstractValue.formvalue(self, section)

-       local key = "cbid."..self.map.config.."."..section.."."..self.option
-       return luci.http.formvalue(key)
+       return luci.http.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.parse(self, section)
        local fvalue = self:formvalue(section)
 end
 
 function AbstractValue.parse(self, section)
        local fvalue = self:formvalue(section)

-       
-       if fvalue and fvalue ~= "" then -- If we have a form value, write it to UCI
-               fvalue = self:validate(fvalue)
+       local cvalue = self:cfgvalue(section)
+
+       if fvalue and #fvalue > 0 then -- If we have a form value, write it to UCI
+               fvalue = self:transform(self:validate(fvalue, section))

                if not fvalue then
                        self.tag_invalid[section] = true
                end
                if not fvalue then
                        self.tag_invalid[section] = true
                end

-               if fvalue and not (fvalue == self:cfgvalue(section)) then
-                       self:write(section, fvalue)
-               end 
+               if fvalue and 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
        else                                                    -- Unset the UCI or error
                if self.rmempty or self.optional then

-                       self:remove(section)
+                       if self:remove(section) then
+                               -- Push events
+                               self.section.changed = true
+                               --luci.util.append(self.map.events, self.events)
+                       end
+               elseif self.track_missing and (not fvalue or fvalue ~= cvalue) then
+                       self.tag_missing[section] = true

                end
        end
 end
                end
        end
 end


@@ -554,14 +1083,46 @@ end
 function AbstractValue.render(self, s, scope)
        if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
                scope = scope or {}
 function AbstractValue.render(self, s, scope)
        if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
                scope = scope or {}

-               scope.section = s
+               scope.section   = s
+               scope.cbid      = self:cbid(s)
+               scope.striptags = luci.util.striptags
+
+               scope.ifattr = function(cond,key,val)
+                       if cond then
+                               return string.format(
+                                       ' %s="%s"', tostring(key),
+                                       luci.util.pcdata(tostring( val
+                                        or scope[key]
+                                        or (type(self[key]) ~= "function" and self[key])
+                                        or "" ))
+                               )
+                       else
+                               return ''
+                       end
+               end
+
+               scope.attr = function(...)
+                       return scope.ifattr( true, ... )
+               end
+

                Node.render(self, scope)
        end
 end
 
 -- Return the UCI value of this object
 function AbstractValue.cfgvalue(self, section)
                Node.render(self, scope)
        end
 end
 
 -- Return the UCI value of this object
 function AbstractValue.cfgvalue(self, section)

-       return self.map:get(section, self.option)
+       local value = self.map:get(section, self.option)
+       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 luci.util.split(value, "%s+", nil, true)
+       end

 end
 
 -- Validate the form value
 end
 
 -- Validate the form value


@@ -569,6 +1130,9 @@ function AbstractValue.validate(self, value)
        return value
 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)
 -- Write to UCI
 function AbstractValue.write(self, section, value)
        return self.map:set(section, self.option, value)


@@ -585,46 +1149,48 @@ end
 --[[
 Value - A one-line value
        maxlength:      The maximum length
 --[[
 Value - A one-line value
        maxlength:      The maximum length

-       isnumber:       The value must be a valid (floating point) number
-       isinteger:  The value must be a valid integer
-       ispositive: The value must be positive (and a number)

 ]]--
 Value = class(AbstractValue)
 
 function Value.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template  = "cbi/value"
 ]]--
 Value = class(AbstractValue)
 
 function Value.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template  = "cbi/value"

-       
-       self.maxlength  = nil
-       self.isnumber   = false
-       self.isinteger  = false
+       self.keylist = {}
+       self.vallist = {}

 end
 
 end
 

--- This validation is a bit more complex
-function Value.validate(self, val)
-       if self.maxlength and tostring(val):len() > self.maxlength then
-               val = nil
-       end
-       
-       return luci.util.validate(val, self.isnumber, self.isinteger)
+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)
 
 end
 
 
 -- DummyValue - This does nothing except being there
 DummyValue = class(AbstractValue)
 

-function DummyValue.__init__(self, map, ...)
-       AbstractValue.__init__(self, map, ...)
+function DummyValue.__init__(self, ...)
+       AbstractValue.__init__(self, ...)

        self.template = "cbi/dvalue"
        self.value = nil
 end
 
        self.template = "cbi/dvalue"
        self.value = nil
 end
 

-function DummyValue.parse(self)
-       
+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
 
 end
 

-function DummyValue.render(self, s)
-       luci.template.render(self.template, {self=self, section=s})
+function DummyValue.parse(self)
+

 end
 
 
 end
 
 


@@ -636,7 +1202,7 @@ Flag = class(AbstractValue)
 function Flag.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template  = "cbi/fvalue"
 function Flag.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template  = "cbi/fvalue"

-       
+

        self.enabled = "1"
        self.disabled = "0"
 end
        self.enabled = "1"
        self.disabled = "0"
 end


@@ -644,17 +1210,17 @@ end
 -- A flag can only have two states: set or unset
 function Flag.parse(self, section)
        local fvalue = self:formvalue(section)
 -- A flag can only have two states: set or unset
 function Flag.parse(self, section)
        local fvalue = self:formvalue(section)

-       
+

        if fvalue then
                fvalue = self.enabled
        else
                fvalue = self.disabled
        if fvalue then
                fvalue = self.enabled
        else
                fvalue = self.disabled

-       end     
-       
-       if fvalue == self.enabled or (not self.optional and not self.rmempty) then              
+       end
+
+       if fvalue == self.enabled or (not self.optional and not self.rmempty) then

                if not(fvalue == self:cfgvalue(section)) then
                        self:write(section, fvalue)
                if not(fvalue == self:cfgvalue(section)) then
                        self:write(section, fvalue)

-               end 
+               end

        else
                self:remove(section)
        end
        else
                self:remove(section)
        end


@@ -671,17 +1237,45 @@ ListValue = class(AbstractValue)
 function ListValue.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template  = "cbi/lvalue"
 function ListValue.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template  = "cbi/lvalue"

+

        self.keylist = {}
        self.vallist = {}
        self.keylist = {}
        self.vallist = {}

-       

        self.size   = 1
        self.widget = "select"
 end
 
        self.size   = 1
        self.widget = "select"
 end
 

-function ListValue.value(self, key, val)
+function ListValue.prepare(self, ...)
+       AbstractValue.prepare(self, ...)
+       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.valuelist and not self.override_values then
+                       for k, v in ipairs(vs.valuelist) do
+                               local deps = {}
+                               if not self.override_dependencies
+                                and vs.enum_depends and vs.enum_depends[v.value] then
+                                       for i, dep in ipairs(vs.enum_depends[v.value]) do
+                                               table.insert(deps, _uvl_strip_remote_dependencies(dep))
+                                       end
+                               end
+                               self:value(v.value, v.title or v.value, unpack(deps))
+                       end
+               end
+       end
+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))
        val = val or key
        table.insert(self.keylist, tostring(key))

-       table.insert(self.vallist, tostring(val)) 
+       table.insert(self.vallist, tostring(val))
+
+       for i, deps in ipairs({...}) do
+               table.insert(self.deps, {add = "-"..key, deps=deps})
+       end

 end
 
 function ListValue.validate(self, val)
 end
 
 function ListValue.validate(self, val)


@@ -704,45 +1298,195 @@ MultiValue = class(AbstractValue)
 function MultiValue.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template = "cbi/mvalue"
 function MultiValue.__init__(self, ...)
        AbstractValue.__init__(self, ...)
        self.template = "cbi/mvalue"

+

        self.keylist = {}
        self.keylist = {}

-       self.vallist = {}       
-       
+       self.vallist = {}
+

        self.widget = "checkbox"
        self.delimiter = " "
 end
 
        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.value(self, key, val)
 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))
        val = val or key
        table.insert(self.keylist, tostring(key))

-       table.insert(self.vallist, tostring(val)) 
+       table.insert(self.vallist, tostring(val))

 end
 
 function MultiValue.valuelist(self, section)
        local val = self:cfgvalue(section)
 end
 
 function MultiValue.valuelist(self, section)
        local val = self:cfgvalue(section)

-       
+

        if not(type(val) == "string") then
                return {}
        end
        if not(type(val) == "string") then
                return {}
        end

-       
+

        return luci.util.split(val, self.delimiter)
 end
 
 function MultiValue.validate(self, val)
        return luci.util.split(val, self.delimiter)
 end
 
 function MultiValue.validate(self, val)

-       if not(type(val) == "string") then
-               return nil
-       end
-       
-       local result = ""
-       
-       for value in val:gmatch("[^\n]+") do
+       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
                if luci.util.contains(self.keylist, value) then

-                       result = result .. self.delimiter .. value
-               end 
+                       result = result and (result .. self.delimiter .. value) or value
+               end

        end
        end

-       
-       if result:len() > 0 then
-               return result:sub(self.delimiter:len() + 1)
+
+       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.vallist, 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.value(self, key, val)
+       val = val or key
+       table.insert(self.keylist, tostring(key))
+       table.insert(self.vallist, tostring(val))
+end
+
+function DynamicList.formvalue(self, section)
+       local value = AbstractValue.formvalue(self, section)
+       value = (type(value) == "table") and value or {value}
+
+       local valid = {}
+       for i, v in ipairs(value) do
+               if v and #v > 0
+                and not luci.http.formvalue("cbi.rle."..section.."."..self.option.."."..i)
+                and not luci.http.formvalue("cbi.rle."..section.."."..self.option.."."..i..".x") then
+                       table.insert(valid, v)
+               end
+       end
+
+       return valid
+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
        else

-               return nil
+               self.map.upload_fields[#self.map.upload_fields+1] = self

        end
        end

-end
\ No newline at end of file
+end
+
+function FileUpload.formcreated(self, section)
+       return AbstractValue.formcreated(self, section) or
+               luci.http.formvalue("cbi.rlf."..section.."."..self.option) or
+               luci.http.formvalue("cbi.rlf."..section.."."..self.option..".x")
+end
+
+function FileUpload.cfgvalue(self, section)
+       local val = AbstractValue.cfgvalue(self, section)
+       if val and luci.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 luci.http.formvalue("cbi.rlf."..section.."."..self.option) and
+                  not luci.http.formvalue("cbi.rlf."..section.."."..self.option..".x")
+               then
+                       return val
+               end
+               luci.fs.unlink(val)
+               self.value = nil
+       end
+       return nil
+end
+
+function FileUpload.remove(self, section)
+       local val = AbstractValue.formvalue(self, section)
+       if val and luci.fs.access(val) then luci.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