libs/cbi/luasrc/cbi.lua

   1 --[[
   2 LuCI - Configuration Bind Interface
   3
   4 Description:
   5 Offers an interface for binding configuration values to certain
   6 data types. Supports value and range validation and basic dependencies.
   7
   8 FileId:
   9 $Id$
  10
  11 License:
  12 Copyright 2008 Steven Barth <steven@midlink.org>
  13
  14 Licensed under the Apache License, Version 2.0 (the "License");
  15 you may not use this file except in compliance with the License.
  16 You may obtain a copy of the License at
  17
  18         http://www.apache.org/licenses/LICENSE-2.0
  19
  20 Unless required by applicable law or agreed to in writing, software
  21 distributed under the License is distributed on an "AS IS" BASIS,
  22 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  23 See the License for the specific language governing permissions and
  24 limitations under the License.
  25
  26 ]]--
  27 module("luci.cbi", package.seeall)
  28
  29 require("luci.template")
  30 local util = require("luci.util")
  31 require("luci.http")
  32 require("luci.uvl")
  33
  34
  35 --local event      = require "luci.sys.event"
  36 local fs         = require("nixio.fs")
  37 local uci        = require("luci.model.uci")
  38 local class      = util.class
  39 local instanceof = util.instanceof
  40
  41 FORM_NODATA  =  0
  42 FORM_PROCEED =  0
  43 FORM_VALID   =  1
  44 FORM_DONE        =  1
  45 FORM_INVALID = -1
  46 FORM_CHANGED =  2
  47 FORM_SKIP    =  4
  48
  49 AUTO = true
  50
  51 CREATE_PREFIX = "cbi.cts."
  52 REMOVE_PREFIX = "cbi.rts."
  53
  54 -- Loads a CBI map from given file, creating an environment and returns it
  55 function load(cbimap, ...)
  56         local fs   = require "nixio.fs"
  57         local i18n = require "luci.i18n"
  58         require("luci.config")
  59         require("luci.util")
  60
  61         local upldir = "/lib/uci/upload/"
  62         local cbidir = luci.util.libpath() .. "/model/cbi/"
  63         local func, err
  64
  65         if fs.access(cbimap) then
  66                 func, err = loadfile(cbimap)
  67         elseif fs.access(cbidir..cbimap..".lua") then
  68                 func, err = loadfile(cbidir..cbimap..".lua")
  69         elseif fs.access(cbidir..cbimap..".lua.gz") then
  70                 func, err = loadfile(cbidir..cbimap..".lua.gz")
  71         else
  72                 func, err = nil, "Model '" .. cbimap .. "' not found!"
  73         end
  74
  75         assert(func, err)
  76
  77         luci.i18n.loadc("cbi")
  78         luci.i18n.loadc("uvl")
  79
  80         local env = {
  81                 translate=i18n.translate,
  82                 translatef=i18n.translatef,
  83                 arg={...}
  84         }
  85
  86         setfenv(func, setmetatable(env, {__index =
  87                 function(tbl, key)
  88                         return rawget(tbl, key) or _M[key] or _G[key]
  89                 end}))
  90
  91         local maps       = { func() }
  92         local uploads    = { }
  93         local has_upload = false
  94
  95         for i, map in ipairs(maps) do
  96                 if not instanceof(map, Node) then
  97                         error("CBI map returns no valid map object!")
  98                         return nil
  99                 else
 100                         map:prepare()
 101                         if map.upload_fields then
 102                                 has_upload = true
 103                                 for _, field in ipairs(map.upload_fields) do
 104                                         uploads[
 105                                                 field.config .. '.' ..
 106                                                 field.section.sectiontype .. '.' ..
 107                                                 field.option
 108                                         ] = true
 109                                 end
 110                         end
 111                 end
 112         end
 113
 114         if has_upload then
 115                 local uci = luci.model.uci.cursor()
 116                 local prm = luci.http.context.request.message.params
 117                 local fd, cbid
 118
 119                 luci.http.setfilehandler(
 120                         function( field, chunk, eof )
 121                                 if not field then return end
 122                                 if field.name and not cbid then
 123                                         local c, s, o = field.name:gmatch(
 124                                                 "cbid%.([^%.]+)%.([^%.]+)%.([^%.]+)"
 125                                         )()
 126
 127                                         if c and s and o then
 128                                                 local t = uci:get( c, s )
 129                                                 if t and uploads[c.."."..t.."."..o] then
 130                                                         local path = upldir .. field.name
 131                                                         fd = io.open(path, "w")
 132                                                         if fd then
 133                                                                 cbid = field.name
 134                                                                 prm[cbid] = path
 135                                                         end
 136                                                 end
 137                                         end
 138                                 end
 139
 140                                 if field.name == cbid and fd then
 141                                         fd:write(chunk)
 142                                 end
 143
 144                                 if eof and fd then
 145                                         fd:close()
 146                                         fd   = nil
 147                                         cbid = nil
 148                                 end
 149                         end
 150                 )
 151         end
 152
 153         return maps
 154 end
 155
 156 local function _uvl_validate_section(node, name)
 157         local co = node.map:get()
 158
 159         luci.uvl.STRICT_UNKNOWN_OPTIONS = false
 160         luci.uvl.STRICT_UNKNOWN_SECTIONS = false
 161
 162         local function tag_fields(e)
 163                 if e.option and node.fields[e.option] then
 164                         if node.fields[e.option].error then
 165                                 node.fields[e.option].error[name] = e
 166                         else
 167                                 node.fields[e.option].error = { [name] = e }
 168                         end
 169                 elseif e.childs then
 170                         for _, c in ipairs(e.childs) do tag_fields(c) end
 171                 end
 172         end
 173
 174         local function tag_section(e)
 175                 local s = { }
 176                 for _, c in ipairs(e.childs or { e }) do
 177                         if c.childs and not c:is(luci.uvl.errors.ERR_DEPENDENCY) then
 178                                 table.insert( s, c.childs[1]:string() )
 179                         else
 180                                 table.insert( s, c:string() )
 181                         end
 182                 end
 183                 if #s > 0 then
 184                         if node.error then
 185                                 node.error[name] = s
 186                         else
 187                                 node.error = { [name] = s }
 188                         end
 189                 end
 190         end
 191
 192         local stat, err = node.map.validator:validate_section(node.config, name, co)
 193         if err then
 194                 node.map.save = false
 195                 tag_fields(err)
 196                 tag_section(err)
 197         end
 198
 199 end
 200
 201 local function _uvl_strip_remote_dependencies(deps)
 202         local clean = {}
 203
 204         for k, v in pairs(deps) do
 205                 k = k:gsub("%$config%.%$section%.", "")
 206                 if k:match("^[%w_]+$") and type(v) == "string" then
 207                         clean[k] = v
 208                 end
 209         end
 210
 211         return clean
 212 end
 213
 214
 215 -- Node pseudo abstract class
 216 Node = class()
 217
 218 function Node.__init__(self, title, description)
 219         self.children = {}
 220         self.title = title or ""
 221         self.description = description or ""
 222         self.template = "cbi/node"
 223 end
 224
 225 -- i18n helper
 226 function Node._i18n(self, config, section, option, title, description)
 227
 228         -- i18n loaded?
 229         if type(luci.i18n) == "table" then
 230
 231                 local key = config and config:gsub("[^%w]+", "") or ""
 232
 233                 if section then key = key .. "_" .. section:lower():gsub("[^%w]+", "") end
 234                 if option  then key = key .. "_" .. tostring(option):lower():gsub("[^%w]+", "")  end
 235
 236                 self.title = title or luci.i18n.translate( key, option or section or config )
 237                 self.description = description or luci.i18n.translate( key .. "_desc", "" )
 238         end
 239 end
 240
 241 -- Prepare nodes
 242 function Node.prepare(self, ...)
 243         for k, child in ipairs(self.children) do
 244                 child:prepare(...)
 245         end
 246 end
 247
 248 -- Append child nodes
 249 function Node.append(self, obj)
 250         table.insert(self.children, obj)
 251 end
 252
 253 -- Parse this node and its children
 254 function Node.parse(self, ...)
 255         for k, child in ipairs(self.children) do
 256                 child:parse(...)
 257         end
 258 end
 259
 260 -- Render this node
 261 function Node.render(self, scope)
 262         scope = scope or {}
 263         scope.self = self
 264
 265         luci.template.render(self.template, scope)
 266 end
 267
 268 -- Render the children
 269 function Node.render_children(self, ...)
 270         for k, node in ipairs(self.children) do
 271                 node:render(...)
 272         end
 273 end
 274
 275
 276 --[[
 277 A simple template element
 278 ]]--
 279 Template = class(Node)
 280
 281 function Template.__init__(self, template)
 282         Node.__init__(self)
 283         self.template = template
 284 end
 285
 286 function Template.render(self)
 287         luci.template.render(self.template, {self=self})
 288 end
 289
 290 function Template.parse(self, readinput)
 291         self.readinput = (readinput ~= false)
 292         return Map.formvalue(self, "cbi.submit") and FORM_DONE or FORM_NODATA
 293 end
 294
 295
 296 --[[
 297 Map - A map describing a configuration file
 298 ]]--
 299 Map = class(Node)
 300
 301 function Map.__init__(self, config, ...)
 302         Node.__init__(self, ...)
 303         Node._i18n(self, config, nil, nil, ...)
 304
 305         self.config = config
 306         self.parsechain = {self.config}
 307         self.template = "cbi/map"
 308         self.apply_on_parse = nil
 309         self.readinput = true
 310         self.proceed = false
 311         self.flow = {}
 312
 313         self.uci = uci.cursor()
 314         self.save = true
 315
 316         self.changed = false
 317
 318         if not self.uci:load(self.config) then
 319                 error("Unable to read UCI data: " .. self.config)
 320         end
 321
 322         self.validator = luci.uvl.UVL()
 323         self.scheme = self.validator:get_scheme(self.config)
 324
 325 end
 326
 327 function Map.formvalue(self, key)
 328         return self.readinput and luci.http.formvalue(key)
 329 end
 330
 331 function Map.formvaluetable(self, key)
 332         return self.readinput and luci.http.formvaluetable(key) or {}
 333 end
 334
 335 function Map.get_scheme(self, sectiontype, option)
 336         if not option then
 337                 return self.scheme and self.scheme.sections[sectiontype]
 338         else
 339                 return self.scheme and self.scheme.variables[sectiontype]
 340                  and self.scheme.variables[sectiontype][option]
 341         end
 342 end
 343
 344 function Map.submitstate(self)
 345         return self:formvalue("cbi.submit")
 346 end
 347
 348 -- Chain foreign config
 349 function Map.chain(self, config)
 350         table.insert(self.parsechain, config)
 351 end
 352
 353 function Map.state_handler(self, state)
 354         return state
 355 end
 356
 357 -- Use optimized UCI writing
 358 function Map.parse(self, readinput, ...)
 359         self.readinput = (readinput ~= false)
 360
 361         if self:formvalue("cbi.skip") then
 362                 self.state = FORM_SKIP
 363                 return self:state_handler(self.state)
 364         end
 365
 366         Node.parse(self, ...)
 367
 368         if self.save then
 369                 for i, config in ipairs(self.parsechain) do
 370                         self.uci:save(config)
 371                 end
 372                 if self:submitstate() and not self.proceed and (self.flow.autoapply or luci.http.formvalue("cbi.apply")) then
 373                         for i, config in ipairs(self.parsechain) do
 374                                 self.uci:commit(config)
 375
 376                                 -- Refresh data because commit changes section names
 377                                 self.uci:load(config)
 378                         end
 379                         if self.apply_on_parse then
 380                                 self.uci:apply(self.parsechain)
 381                         else
 382                                 self._apply = function()
 383                                         local cmd = self.uci:apply(self.parsechain, true)
 384                                         return io.popen(cmd)
 385                                 end
 386                         end
 387
 388                         -- Reparse sections
 389                         Node.parse(self, true)
 390
 391                 end
 392                 for i, config in ipairs(self.parsechain) do
 393                         self.uci:unload(config)
 394                 end
 395                 if type(self.commit_handler) == "function" then
 396                         self:commit_handler(self:submitstate())
 397                 end
 398         end
 399
 400         if self:submitstate() then
 401                 if not self.save then
 402                         self.state = FORM_INVALID
 403                 elseif self.proceed then
 404                         self.state = FORM_PROCEED
 405                 else
 406                         self.state = self.changed and FORM_CHANGED or FORM_VALID
 407                 end
 408         else
 409                 self.state = FORM_NODATA
 410         end
 411
 412         return self:state_handler(self.state)
 413 end
 414
 415 function Map.render(self, ...)
 416         Node.render(self, ...)
 417         if self._apply then
 418                 local fp = self._apply()
 419                 fp:read("*a")
 420                 fp:close()
 421         end
 422 end
 423
 424 -- Creates a child section
 425 function Map.section(self, class, ...)
 426         if instanceof(class, AbstractSection) then
 427                 local obj  = class(self, ...)
 428                 self:append(obj)
 429                 return obj
 430         else
 431                 error("class must be a descendent of AbstractSection")
 432         end
 433 end
 434
 435 -- UCI add
 436 function Map.add(self, sectiontype)
 437         return self.uci:add(self.config, sectiontype)
 438 end
 439
 440 -- UCI set
 441 function Map.set(self, section, option, value)
 442         if option then
 443                 return self.uci:set(self.config, section, option, value)
 444         else
 445                 return self.uci:set(self.config, section, value)
 446         end
 447 end
 448
 449 -- UCI del
 450 function Map.del(self, section, option)
 451         if option then
 452                 return self.uci:delete(self.config, section, option)
 453         else
 454                 return self.uci:delete(self.config, section)
 455         end
 456 end
 457
 458 -- UCI get
 459 function Map.get(self, section, option)
 460         if not section then
 461                 return self.uci:get_all(self.config)
 462         elseif option then
 463                 return self.uci:get(self.config, section, option)
 464         else
 465                 return self.uci:get_all(self.config, section)
 466         end
 467 end
 468
 469 --[[
 470 Compound - Container
 471 ]]--
 472 Compound = class(Node)
 473
 474 function Compound.__init__(self, ...)
 475         Node.__init__(self)
 476         self.template = "cbi/compound"
 477         self.children = {...}
 478 end
 479
 480 function Compound.populate_delegator(self, delegator)
 481         for _, v in ipairs(self.children) do
 482                 v.delegator = delegator
 483         end
 484 end
 485
 486 function Compound.parse(self, ...)
 487         local cstate, state = 0
 488
 489         for k, child in ipairs(self.children) do
 490                 cstate = child:parse(...)
 491                 state = (not state or cstate < state) and cstate or state
 492         end
 493
 494         return state
 495 end
 496
 497
 498 --[[
 499 Delegator - Node controller
 500 ]]--
 501 Delegator = class(Node)
 502 function Delegator.__init__(self, ...)
 503         Node.__init__(self, ...)
 504         self.nodes = {}
 505         self.defaultpath = {}
 506         self.pageaction = false
 507         self.readinput = true
 508         self.allow_reset = false
 509         self.allow_back = false
 510         self.allow_finish = false
 511         self.template = "cbi/delegator"
 512 end
 513
 514 function Delegator.set(self, name, node)
 515         if type(node) == "table" and getmetatable(node) == nil then
 516                 node = Compound(unpack(node))
 517         end
 518         assert(type(node) == "function" or instanceof(node, Compound), "Invalid")
 519         assert(not self.nodes[name], "Duplicate entry")
 520
 521         self.nodes[name] = node
 522 end
 523
 524 function Delegator.add(self, name, node)
 525         node = self:set(name, node)
 526         self.defaultpath[#self.defaultpath+1] = name
 527 end
 528
 529 function Delegator.insert_after(self, name, after)
 530         local n = #self.chain
 531         for k, v in ipairs(self.chain) do
 532                 if v == state then
 533                         n = k + 1
 534                         break
 535                 end
 536         end
 537         table.insert(self.chain, n, name)
 538 end
 539
 540 function Delegator.set_route(self, ...)
 541         local n, chain, route = 0, self.chain, {...}
 542         for i = 1, #chain do
 543                 if chain[i] == self.current then
 544                         n = i
 545                         break
 546                 end
 547         end
 548         for i = 1, #route do
 549                 n = n + 1
 550                 chain[n] = route[i]
 551         end
 552         for i = n + 1, #chain do
 553                 chain[i] = nil
 554         end
 555 end
 556
 557 function Delegator.get(self, name)
 558         return self.nodes[name]
 559 end
 560
 561 function Delegator.parse(self, ...)
 562         local newcurrent
 563         self.chain = self.chain or self:get_chain()
 564         self.current = self.current or self:get_active()
 565         self.active = self.active or self:get(self.current)
 566         assert(self.active, "Invalid state")
 567
 568         local stat = FORM_DONE
 569         if type(self.active) ~= "function" then
 570                 self.active:populate_delegator(self)
 571                 stat = self.active:parse()
 572         else
 573                 self:active()
 574         end
 575
 576         if stat > FORM_PROCEED then
 577                 if Map.formvalue(self, "cbi.delg.back") then
 578                         newcurrent = self:get_prev(self.current)
 579                 else
 580                         newcurrent = self:get_next(self.current)
 581                 end
 582         elseif stat < FORM_PROCEED then
 583                 return stat
 584         end
 585
 586
 587         if not Map.formvalue(self, "cbi.submit") then
 588                 return FORM_NODATA
 589         elseif not newcurrent or not self:get(newcurrent) then
 590                 return FORM_DONE
 591         else
 592                 self.current = newcurrent
 593                 self.active = self:get(self.current)
 594                 if type(self.active) ~= "function" then
 595                         self.active:parse(false)
 596                         return FROM_PROCEED
 597                 else
 598                         return self:parse(...)
 599                 end
 600         end
 601 end
 602
 603 function Delegator.get_next(self, state)
 604         for k, v in ipairs(self.chain) do
 605                 if v == state then
 606                         return self.chain[k+1]
 607                 end
 608         end
 609 end
 610
 611 function Delegator.get_prev(self, state)
 612         for k, v in ipairs(self.chain) do
 613                 if v == state then
 614                         return self.chain[k-1]
 615                 end
 616         end
 617 end
 618
 619 function Delegator.get_chain(self)
 620         local x = Map.formvalue(self, "cbi.delg.path") or self.defaultpath
 621         return type(x) == "table" and x or {x}
 622 end
 623
 624 function Delegator.get_active(self)
 625         return Map.formvalue(self, "cbi.delg.current") or self.chain[1]
 626 end
 627
 628 --[[
 629 Page - A simple node
 630 ]]--
 631
 632 Page = class(Node)
 633 Page.__init__ = Node.__init__
 634 Page.parse    = function() end
 635
 636
 637 --[[
 638 SimpleForm - A Simple non-UCI form
 639 ]]--
 640 SimpleForm = class(Node)
 641
 642 function SimpleForm.__init__(self, config, title, description, data)
 643         Node.__init__(self, title, description)
 644         self.config = config
 645         self.data = data or {}
 646         self.template = "cbi/simpleform"
 647         self.dorender = true
 648         self.pageaction = false
 649         self.readinput = true
 650 end
 651
 652 SimpleForm.formvalue = Map.formvalue
 653 SimpleForm.formvaluetable = Map.formvaluetable
 654
 655 function SimpleForm.parse(self, readinput, ...)
 656         self.readinput = (readinput ~= false)
 657
 658         if self:formvalue("cbi.skip") then
 659                 return FORM_SKIP
 660         end
 661
 662         if self:submitstate() then
 663                 Node.parse(self, 1, ...)
 664         end
 665
 666         local valid = true
 667         for k, j in ipairs(self.children) do
 668                 for i, v in ipairs(j.children) do
 669                         valid = valid
 670                          and (not v.tag_missing or not v.tag_missing[1])
 671                          and (not v.tag_invalid or not v.tag_invalid[1])
 672                          and (not v.error)
 673                 end
 674         end
 675
 676         local state =
 677                 not self:submitstate() and FORM_NODATA
 678                 or valid and FORM_VALID
 679                 or FORM_INVALID
 680
 681         self.dorender = not self.handle
 682         if self.handle then
 683                 local nrender, nstate = self:handle(state, self.data)
 684                 self.dorender = self.dorender or (nrender ~= false)
 685                 state = nstate or state
 686         end
 687         return state
 688 end
 689
 690 function SimpleForm.render(self, ...)
 691         if self.dorender then
 692                 Node.render(self, ...)
 693         end
 694 end
 695
 696 function SimpleForm.submitstate(self)
 697         return self:formvalue("cbi.submit")
 698 end
 699
 700 function SimpleForm.section(self, class, ...)
 701         if instanceof(class, AbstractSection) then
 702                 local obj  = class(self, ...)
 703                 self:append(obj)
 704                 return obj
 705         else
 706                 error("class must be a descendent of AbstractSection")
 707         end
 708 end
 709
 710 -- Creates a child field
 711 function SimpleForm.field(self, class, ...)
 712         local section
 713         for k, v in ipairs(self.children) do
 714                 if instanceof(v, SimpleSection) then
 715                         section = v
 716                         break
 717                 end
 718         end
 719         if not section then
 720                 section = self:section(SimpleSection)
 721         end
 722
 723         if instanceof(class, AbstractValue) then
 724                 local obj  = class(self, section, ...)
 725                 obj.track_missing = true
 726                 section:append(obj)
 727                 return obj
 728         else
 729                 error("class must be a descendent of AbstractValue")
 730         end
 731 end
 732
 733 function SimpleForm.set(self, section, option, value)
 734         self.data[option] = value
 735 end
 736
 737
 738 function SimpleForm.del(self, section, option)
 739         self.data[option] = nil
 740 end
 741
 742
 743 function SimpleForm.get(self, section, option)
 744         return self.data[option]
 745 end
 746
 747
 748 function SimpleForm.get_scheme()
 749         return nil
 750 end
 751
 752
 753 Form = class(SimpleForm)
 754
 755 function Form.__init__(self, ...)
 756         SimpleForm.__init__(self, ...)
 757         self.embedded = true
 758 end
 759
 760
 761 --[[
 762 AbstractSection
 763 ]]--
 764 AbstractSection = class(Node)
 765
 766 function AbstractSection.__init__(self, map, sectiontype, ...)
 767         Node.__init__(self, ...)
 768         self.sectiontype = sectiontype
 769         self.map = map
 770         self.config = map.config
 771         self.optionals = {}
 772         self.defaults = {}
 773         self.fields = {}
 774         self.tag_error = {}
 775         self.tag_invalid = {}
 776         self.tag_deperror = {}
 777         self.changed = false
 778
 779         self.optional = true
 780         self.addremove = false
 781         self.dynamic = false
 782 end
 783
 784 -- Appends a new option
 785 function AbstractSection.option(self, class, option, ...)
 786         -- Autodetect from UVL
 787         if class == true and self.map:get_scheme(self.sectiontype, option) then
 788                 local vs = self.map:get_scheme(self.sectiontype, option)
 789                 if vs.type == "boolean" then
 790                         class = Flag
 791                 elseif vs.type == "list" then
 792                         class = DynamicList
 793                 elseif vs.type == "enum" or vs.type == "reference" then
 794                         class = ListValue
 795                 else
 796                         class = Value
 797                 end
 798         end
 799
 800         if instanceof(class, AbstractValue) then
 801                 local obj  = class(self.map, self, option, ...)
 802
 803                 Node._i18n(obj, self.config, self.section or self.sectiontype, option, ...)
 804
 805                 self:append(obj)
 806                 self.fields[option] = obj
 807                 return obj
 808         elseif class == true then
 809                 error("No valid class was given and autodetection failed.")
 810         else
 811                 error("class must be a descendant of AbstractValue")
 812         end
 813 end
 814
 815 -- Parse optional options
 816 function AbstractSection.parse_optionals(self, section)
 817         if not self.optional then
 818                 return
 819         end
 820
 821         self.optionals[section] = {}
 822
 823         local field = self.map:formvalue("cbi.opt."..self.config.."."..section)
 824         for k,v in ipairs(self.children) do
 825                 if v.optional and not v:cfgvalue(section) then
 826                         if field == v.option then
 827                                 field = nil
 828                                 self.map.proceed = true
 829                         else
 830                                 table.insert(self.optionals[section], v)
 831                         end
 832                 end
 833         end
 834
 835         if field and #field > 0 and self.dynamic then
 836                 self:add_dynamic(field)
 837         end
 838 end
 839
 840 -- Add a dynamic option
 841 function AbstractSection.add_dynamic(self, field, optional)
 842         local o = self:option(Value, field, field)
 843         o.optional = optional
 844 end
 845
 846 -- Parse all dynamic options
 847 function AbstractSection.parse_dynamic(self, section)
 848         if not self.dynamic then
 849                 return
 850         end
 851
 852         local arr  = luci.util.clone(self:cfgvalue(section))
 853         local form = self.map:formvaluetable("cbid."..self.config.."."..section)
 854         for k, v in pairs(form) do
 855                 arr[k] = v
 856         end
 857
 858         for key,val in pairs(arr) do
 859                 local create = true
 860
 861                 for i,c in ipairs(self.children) do
 862                         if c.option == key then
 863                                 create = false
 864                         end
 865                 end
 866
 867                 if create and key:sub(1, 1) ~= "." then
 868                         self.map.proceed = true
 869                         self:add_dynamic(key, true)
 870                 end
 871         end
 872 end
 873
 874 -- Returns the section's UCI table
 875 function AbstractSection.cfgvalue(self, section)
 876         return self.map:get(section)
 877 end
 878
 879 -- Push events
 880 function AbstractSection.push_events(self)
 881         --luci.util.append(self.map.events, self.events)
 882         self.map.changed = true
 883 end
 884
 885 -- Removes the section
 886 function AbstractSection.remove(self, section)
 887         self.map.proceed = true
 888         return self.map:del(section)
 889 end
 890
 891 -- Creates the section
 892 function AbstractSection.create(self, section)
 893         local stat
 894
 895         if section then
 896                 stat = section:match("^%w+$") and self.map:set(section, nil, self.sectiontype)
 897         else
 898                 section = self.map:add(self.sectiontype)
 899                 stat = section
 900         end
 901
 902         if stat then
 903                 for k,v in pairs(self.children) do
 904                         if v.default then
 905                                 self.map:set(section, v.option, v.default)
 906                         end
 907                 end
 908
 909                 for k,v in pairs(self.defaults) do
 910                         self.map:set(section, k, v)
 911                 end
 912         end
 913
 914         self.map.proceed = true
 915
 916         return stat
 917 end
 918
 919
 920 SimpleSection = class(AbstractSection)
 921
 922 function SimpleSection.__init__(self, form, ...)
 923         AbstractSection.__init__(self, form, nil, ...)
 924         self.template = "cbi/nullsection"
 925 end
 926
 927
 928 Table = class(AbstractSection)
 929
 930 function Table.__init__(self, form, data, ...)
 931         local datasource = {}
 932         local tself = self
 933         datasource.config = "table"
 934         self.data = data or {}
 935
 936         datasource.formvalue = Map.formvalue
 937         datasource.formvaluetable = Map.formvaluetable
 938         datasource.readinput = true
 939
 940         function datasource.get(self, section, option)
 941                 return tself.data[section] and tself.data[section][option]
 942         end
 943
 944         function datasource.submitstate(self)
 945                 return Map.formvalue(self, "cbi.submit")
 946         end
 947
 948         function datasource.del(...)
 949                 return true
 950         end
 951
 952         function datasource.get_scheme()
 953                 return nil
 954         end
 955
 956         AbstractSection.__init__(self, datasource, "table", ...)
 957         self.template = "cbi/tblsection"
 958         self.rowcolors = true
 959         self.anonymous = true
 960 end
 961
 962 function Table.parse(self, readinput)
 963         self.map.readinput = (readinput ~= false)
 964         for i, k in ipairs(self:cfgsections()) do
 965                 if self.map:submitstate() then
 966                         Node.parse(self, k)
 967                 end
 968         end
 969 end
 970
 971 function Table.cfgsections(self)
 972         local sections = {}
 973
 974         for i, v in luci.util.kspairs(self.data) do
 975                 table.insert(sections, i)
 976         end
 977
 978         return sections
 979 end
 980
 981 function Table.update(self, data)
 982         self.data = data
 983 end
 984
 985
 986
 987 --[[
 988 NamedSection - A fixed configuration section defined by its name
 989 ]]--
 990 NamedSection = class(AbstractSection)
 991
 992 function NamedSection.__init__(self, map, section, stype, ...)
 993         AbstractSection.__init__(self, map, stype, ...)
 994         Node._i18n(self, map.config, section, nil, ...)
 995
 996         -- Defaults
 997         self.addremove = false
 998
 999         -- Use defaults from UVL
1000         if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
1001                 local vs = self.map:get_scheme(self.sectiontype)
1002                 self.addremove = not vs.unique and not vs.required
1003                 self.dynamic   = vs.dynamic
1004                 self.title       = self.title or vs.title
1005                 self.description = self.description or vs.descr
1006         end
1007
1008         self.template = "cbi/nsection"
1009         self.section = section
1010 end
1011
1012 function NamedSection.parse(self, novld)
1013         local s = self.section
1014         local active = self:cfgvalue(s)
1015
1016         if self.addremove then
1017                 local path = self.config.."."..s
1018                 if active then -- Remove the section
1019                         if self.map:formvalue("cbi.rns."..path) and self:remove(s) then
1020                                 self:push_events()
1021                                 return
1022                         end
1023                 else           -- Create and apply default values
1024                         if self.map:formvalue("cbi.cns."..path) then
1025                                 self:create(s)
1026                                 return
1027                         end
1028                 end
1029         end
1030
1031         if active then
1032                 AbstractSection.parse_dynamic(self, s)
1033                 if self.map:submitstate() then
1034                         Node.parse(self, s)
1035
1036                         if not novld and not self.override_scheme and self.map.scheme then
1037                                 _uvl_validate_section(self, s)
1038                         end
1039                 end
1040                 AbstractSection.parse_optionals(self, s)
1041
1042                 if self.changed then
1043                         self:push_events()
1044                 end
1045         end
1046 end
1047
1048
1049 --[[
1050 TypedSection - A (set of) configuration section(s) defined by the type
1051         addremove:      Defines whether the user can add/remove sections of this type
1052         anonymous:  Allow creating anonymous sections
1053         validate:       a validation function returning nil if the section is invalid
1054 ]]--
1055 TypedSection = class(AbstractSection)
1056
1057 function TypedSection.__init__(self, map, type, ...)
1058         AbstractSection.__init__(self, map, type, ...)
1059         Node._i18n(self, map.config, type, nil, ...)
1060
1061         self.template  = "cbi/tsection"
1062         self.deps = {}
1063         self.anonymous = false
1064
1065         -- Use defaults from UVL
1066         if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
1067                 local vs = self.map:get_scheme(self.sectiontype)
1068                 self.addremove = not vs.unique and not vs.required
1069                 self.dynamic   = vs.dynamic
1070                 self.anonymous = not vs.named
1071                 self.title       = self.title or vs.title
1072                 self.description = self.description or vs.descr
1073         end
1074 end
1075
1076 -- Return all matching UCI sections for this TypedSection
1077 function TypedSection.cfgsections(self)
1078         local sections = {}
1079         self.map.uci:foreach(self.map.config, self.sectiontype,
1080                 function (section)
1081                         if self:checkscope(section[".name"]) then
1082                                 table.insert(sections, section[".name"])
1083                         end
1084                 end)
1085
1086         return sections
1087 end
1088
1089 -- Limits scope to sections that have certain option => value pairs
1090 function TypedSection.depends(self, option, value)
1091         table.insert(self.deps, {option=option, value=value})
1092 end
1093
1094 function TypedSection.parse(self, novld)
1095         if self.addremove then
1096                 -- Remove
1097                 local crval = REMOVE_PREFIX .. self.config
1098                 local name = self.map:formvaluetable(crval)
1099                 for k,v in pairs(name) do
1100                         if k:sub(-2) == ".x" then
1101                                 k = k:sub(1, #k - 2)
1102                         end
1103                         if self:cfgvalue(k) and self:checkscope(k) then
1104                                 self:remove(k)
1105                         end
1106                 end
1107         end
1108
1109         local co
1110         for i, k in ipairs(self:cfgsections()) do
1111                 AbstractSection.parse_dynamic(self, k)
1112                 if self.map:submitstate() then
1113                         Node.parse(self, k, novld)
1114
1115                         if not novld and not self.override_scheme and self.map.scheme then
1116                                 _uvl_validate_section(self, k)
1117                         end
1118                 end
1119                 AbstractSection.parse_optionals(self, k)
1120         end
1121
1122         if self.addremove then
1123                 -- Create
1124                 local created
1125                 local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
1126                 local name  = self.map:formvalue(crval)
1127                 if self.anonymous then
1128                         if name then
1129                                 created = self:create()
1130                         end
1131                 else
1132                         if name then
1133                                 -- Ignore if it already exists
1134                                 if self:cfgvalue(name) then
1135                                         name = nil;
1136                                 end
1137
1138                                 name = self:checkscope(name)
1139
1140                                 if not name then
1141                                         self.err_invalid = true
1142                                 end
1143
1144                                 if name and #name > 0 then
1145                                         created = self:create(name) and name
1146                                         if not created then
1147                                                 self.invalid_cts = true
1148                                         end
1149                                 end
1150                         end
1151                 end
1152
1153                 if created then
1154                         AbstractSection.parse_optionals(self, created)
1155                 end
1156         end
1157
1158         if created or self.changed then
1159                 self:push_events()
1160         end
1161 end
1162
1163 -- Verifies scope of sections
1164 function TypedSection.checkscope(self, section)
1165         -- Check if we are not excluded
1166         if self.filter and not self:filter(section) then
1167                 return nil
1168         end
1169
1170         -- Check if at least one dependency is met
1171         if #self.deps > 0 and self:cfgvalue(section) then
1172                 local stat = false
1173
1174                 for k, v in ipairs(self.deps) do
1175                         if self:cfgvalue(section)[v.option] == v.value then
1176                                 stat = true
1177                         end
1178                 end
1179
1180                 if not stat then
1181                         return nil
1182                 end
1183         end
1184
1185         return self:validate(section)
1186 end
1187
1188
1189 -- Dummy validate function
1190 function TypedSection.validate(self, section)
1191         return section
1192 end
1193
1194
1195 --[[
1196 AbstractValue - An abstract Value Type
1197         null:           Value can be empty
1198         valid:          A function returning the value if it is valid otherwise nil
1199         depends:        A table of option => value pairs of which one must be true
1200         default:        The default value
1201         size:           The size of the input fields
1202         rmempty:        Unset value if empty
1203         optional:       This value is optional (see AbstractSection.optionals)
1204 ]]--
1205 AbstractValue = class(Node)
1206
1207 function AbstractValue.__init__(self, map, section, option, ...)
1208         Node.__init__(self, ...)
1209         self.section = section
1210         self.option  = option
1211         self.map     = map
1212         self.config  = map.config
1213         self.tag_invalid = {}
1214         self.tag_missing = {}
1215         self.tag_reqerror = {}
1216         self.tag_error = {}
1217         self.deps = {}
1218         --self.cast = "string"
1219
1220         self.track_missing = false
1221         self.rmempty   = true
1222         self.default   = nil
1223         self.size      = nil
1224         self.optional  = false
1225 end
1226
1227 function AbstractValue.prepare(self)
1228         -- Use defaults from UVL
1229         if not self.override_scheme
1230          and self.map:get_scheme(self.section.sectiontype, self.option) then
1231                 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1232                 if self.cast == nil then
1233                         self.cast = (vs.type == "list") and "list" or "string"
1234                 end
1235                 self.title       = self.title or vs.title
1236                 self.description = self.description or vs.descr
1237                 if self.default == nil then
1238                         self.default = vs.default
1239                 end
1240
1241                 if vs.depends and not self.override_dependencies then
1242                         for i, deps in ipairs(vs.depends) do
1243                                 deps = _uvl_strip_remote_dependencies(deps)
1244                                 if next(deps) then
1245                                         self:depends(deps)
1246                                 end
1247                         end
1248                 end
1249         end
1250
1251         self.cast = self.cast or "string"
1252 end
1253
1254 -- Add a dependencie to another section field
1255 function AbstractValue.depends(self, field, value)
1256         local deps
1257         if type(field) == "string" then
1258                 deps = {}
1259                 deps[field] = value
1260         else
1261                 deps = field
1262         end
1263
1264         table.insert(self.deps, {deps=deps, add=""})
1265 end
1266
1267 -- Generates the unique CBID
1268 function AbstractValue.cbid(self, section)
1269         return "cbid."..self.map.config.."."..section.."."..self.option
1270 end
1271
1272 -- Return whether this object should be created
1273 function AbstractValue.formcreated(self, section)
1274         local key = "cbi.opt."..self.config.."."..section
1275         return (self.map:formvalue(key) == self.option)
1276 end
1277
1278 -- Returns the formvalue for this object
1279 function AbstractValue.formvalue(self, section)
1280         return self.map:formvalue(self:cbid(section))
1281 end
1282
1283 function AbstractValue.additional(self, value)
1284         self.optional = value
1285 end
1286
1287 function AbstractValue.mandatory(self, value)
1288         self.rmempty = not value
1289 end
1290
1291 function AbstractValue.parse(self, section, novld)
1292         local fvalue = self:formvalue(section)
1293         local cvalue = self:cfgvalue(section)
1294
1295         if fvalue and #fvalue > 0 then -- If we have a form value, write it to UCI
1296                 fvalue = self:transform(self:validate(fvalue, section))
1297                 if not fvalue and not novld then
1298                         if self.error then
1299                                 self.error[section] = "invalid"
1300                         else
1301                                 self.error = { [section] = "invalid" }
1302                         end
1303                         if self.section.error then
1304                                 table.insert(self.section.error[section], "invalid")
1305                         else
1306                                 self.section.error = {[section] = {"invalid"}}
1307                         end
1308                         self.map.save = false
1309                 end
1310                 if fvalue and not (fvalue == cvalue) then
1311                         if self:write(section, fvalue) then
1312                                 -- Push events
1313                                 self.section.changed = true
1314                                 --luci.util.append(self.map.events, self.events)
1315                         end
1316                 end
1317         else                                                    -- Unset the UCI or error
1318                 if self.rmempty or self.optional then
1319                         if self:remove(section) then
1320                                 -- Push events
1321                                 self.section.changed = true
1322                                 --luci.util.append(self.map.events, self.events)
1323                         end
1324                 elseif cvalue ~= fvalue and not novld then
1325                         self:write(section, fvalue or "")
1326                         if self.error then
1327                                 self.error[section] = "missing"
1328                         else
1329                                 self.error = { [section] = "missing" }
1330                         end
1331                         self.map.save = false
1332                 end
1333         end
1334 end
1335
1336 -- Render if this value exists or if it is mandatory
1337 function AbstractValue.render(self, s, scope)
1338         if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
1339                 scope = scope or {}
1340                 scope.section   = s
1341                 scope.cbid      = self:cbid(s)
1342                 scope.striptags = luci.util.striptags
1343
1344                 scope.ifattr = function(cond,key,val)
1345                         if cond then
1346                                 return string.format(
1347                                         ' %s="%s"', tostring(key),
1348                                         luci.util.pcdata(tostring( val
1349                                          or scope[key]
1350                                          or (type(self[key]) ~= "function" and self[key])
1351                                          or "" ))
1352                                 )
1353                         else
1354                                 return ''
1355                         end
1356                 end
1357
1358                 scope.attr = function(...)
1359                         return scope.ifattr( true, ... )
1360                 end
1361
1362                 Node.render(self, scope)
1363         end
1364 end
1365
1366 -- Return the UCI value of this object
1367 function AbstractValue.cfgvalue(self, section)
1368         local value = self.map:get(section, self.option)
1369         if not value then
1370                 return nil
1371         elseif not self.cast or self.cast == type(value) then
1372                 return value
1373         elseif self.cast == "string" then
1374                 if type(value) == "table" then
1375                         return value[1]
1376                 end
1377         elseif self.cast == "table" then
1378                 return luci.util.split(value, "%s+", nil, true)
1379         end
1380 end
1381
1382 -- Validate the form value
1383 function AbstractValue.validate(self, value)
1384         return value
1385 end
1386
1387 AbstractValue.transform = AbstractValue.validate
1388
1389
1390 -- Write to UCI
1391 function AbstractValue.write(self, section, value)
1392         return self.map:set(section, self.option, value)
1393 end
1394
1395 -- Remove from UCI
1396 function AbstractValue.remove(self, section)
1397         return self.map:del(section, self.option)
1398 end
1399
1400
1401
1402
1403 --[[
1404 Value - A one-line value
1405         maxlength:      The maximum length
1406 ]]--
1407 Value = class(AbstractValue)
1408
1409 function Value.__init__(self, ...)
1410         AbstractValue.__init__(self, ...)
1411         self.template  = "cbi/value"
1412         self.keylist = {}
1413         self.vallist = {}
1414 end
1415
1416 function Value.value(self, key, val)
1417         val = val or key
1418         table.insert(self.keylist, tostring(key))
1419         table.insert(self.vallist, tostring(val))
1420 end
1421
1422
1423 -- DummyValue - This does nothing except being there
1424 DummyValue = class(AbstractValue)
1425
1426 function DummyValue.__init__(self, ...)
1427         AbstractValue.__init__(self, ...)
1428         self.template = "cbi/dvalue"
1429         self.value = nil
1430 end
1431
1432 function DummyValue.cfgvalue(self, section)
1433         local value
1434         if self.value then
1435                 if type(self.value) == "function" then
1436                         value = self:value(section)
1437                 else
1438                         value = self.value
1439                 end
1440         else
1441                 value = AbstractValue.cfgvalue(self, section)
1442         end
1443         return value
1444 end
1445
1446 function DummyValue.parse(self)
1447
1448 end
1449
1450
1451 --[[
1452 Flag - A flag being enabled or disabled
1453 ]]--
1454 Flag = class(AbstractValue)
1455
1456 function Flag.__init__(self, ...)
1457         AbstractValue.__init__(self, ...)
1458         self.template  = "cbi/fvalue"
1459
1460         self.enabled = "1"
1461         self.disabled = "0"
1462 end
1463
1464 -- A flag can only have two states: set or unset
1465 function Flag.parse(self, section)
1466         local fvalue = self:formvalue(section)
1467
1468         if fvalue then
1469                 fvalue = self.enabled
1470         else
1471                 fvalue = self.disabled
1472         end
1473
1474         if fvalue == self.enabled or (not self.optional and not self.rmempty) then
1475                 if not(fvalue == self:cfgvalue(section)) then
1476                         self:write(section, fvalue)
1477                 end
1478         else
1479                 self:remove(section)
1480         end
1481 end
1482
1483
1484
1485 --[[
1486 ListValue - A one-line value predefined in a list
1487         widget: The widget that will be used (select, radio)
1488 ]]--
1489 ListValue = class(AbstractValue)
1490
1491 function ListValue.__init__(self, ...)
1492         AbstractValue.__init__(self, ...)
1493         self.template  = "cbi/lvalue"
1494
1495         self.keylist = {}
1496         self.vallist = {}
1497         self.size   = 1
1498         self.widget = "select"
1499 end
1500
1501 function ListValue.prepare(self, ...)
1502         AbstractValue.prepare(self, ...)
1503         if not self.override_scheme
1504          and self.map:get_scheme(self.section.sectiontype, self.option) then
1505                 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1506                 if self.value and vs.valuelist and not self.override_values then
1507                         for k, v in ipairs(vs.valuelist) do
1508                                 local deps = {}
1509                                 if not self.override_dependencies
1510                                  and vs.enum_depends and vs.enum_depends[v.value] then
1511                                         for i, dep in ipairs(vs.enum_depends[v.value]) do
1512                                                 table.insert(deps, _uvl_strip_remote_dependencies(dep))
1513                                         end
1514                                 end
1515                                 self:value(v.value, v.title or v.value, unpack(deps))
1516                         end
1517                 end
1518         end
1519 end
1520
1521 function ListValue.value(self, key, val, ...)
1522         if luci.util.contains(self.keylist, key) then
1523                 return
1524         end
1525
1526         val = val or key
1527         table.insert(self.keylist, tostring(key))
1528         table.insert(self.vallist, tostring(val))
1529
1530         for i, deps in ipairs({...}) do
1531                 table.insert(self.deps, {add = "-"..key, deps=deps})
1532         end
1533 end
1534
1535 function ListValue.validate(self, val)
1536         if luci.util.contains(self.keylist, val) then
1537                 return val
1538         else
1539                 return nil
1540         end
1541 end
1542
1543
1544
1545 --[[
1546 MultiValue - Multiple delimited values
1547         widget: The widget that will be used (select, checkbox)
1548         delimiter: The delimiter that will separate the values (default: " ")
1549 ]]--
1550 MultiValue = class(AbstractValue)
1551
1552 function MultiValue.__init__(self, ...)
1553         AbstractValue.__init__(self, ...)
1554         self.template = "cbi/mvalue"
1555
1556         self.keylist = {}
1557         self.vallist = {}
1558
1559         self.widget = "checkbox"
1560         self.delimiter = " "
1561 end
1562
1563 function MultiValue.render(self, ...)
1564         if self.widget == "select" and not self.size then
1565                 self.size = #self.vallist
1566         end
1567
1568         AbstractValue.render(self, ...)
1569 end
1570
1571 function MultiValue.value(self, key, val)
1572         if luci.util.contains(self.keylist, key) then
1573                 return
1574         end
1575
1576         val = val or key
1577         table.insert(self.keylist, tostring(key))
1578         table.insert(self.vallist, tostring(val))
1579 end
1580
1581 function MultiValue.valuelist(self, section)
1582         local val = self:cfgvalue(section)
1583
1584         if not(type(val) == "string") then
1585                 return {}
1586         end
1587
1588         return luci.util.split(val, self.delimiter)
1589 end
1590
1591 function MultiValue.validate(self, val)
1592         val = (type(val) == "table") and val or {val}
1593
1594         local result
1595
1596         for i, value in ipairs(val) do
1597                 if luci.util.contains(self.keylist, value) then
1598                         result = result and (result .. self.delimiter .. value) or value
1599                 end
1600         end
1601
1602         return result
1603 end
1604
1605
1606 StaticList = class(MultiValue)
1607
1608 function StaticList.__init__(self, ...)
1609         MultiValue.__init__(self, ...)
1610         self.cast = "table"
1611         self.valuelist = self.cfgvalue
1612
1613         if not self.override_scheme
1614          and self.map:get_scheme(self.section.sectiontype, self.option) then
1615                 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1616                 if self.value and vs.values and not self.override_values then
1617                         for k, v in pairs(vs.values) do
1618                                 self:value(k, v)
1619                         end
1620                 end
1621         end
1622 end
1623
1624 function StaticList.validate(self, value)
1625         value = (type(value) == "table") and value or {value}
1626
1627         local valid = {}
1628         for i, v in ipairs(value) do
1629                 if luci.util.contains(self.keylist, v) then
1630                         table.insert(valid, v)
1631                 end
1632         end
1633         return valid
1634 end
1635
1636
1637 DynamicList = class(AbstractValue)
1638
1639 function DynamicList.__init__(self, ...)
1640         AbstractValue.__init__(self, ...)
1641         self.template  = "cbi/dynlist"
1642         self.cast = "table"
1643         self.keylist = {}
1644         self.vallist = {}
1645 end
1646
1647 function DynamicList.value(self, key, val)
1648         val = val or key
1649         table.insert(self.keylist, tostring(key))
1650         table.insert(self.vallist, tostring(val))
1651 end
1652
1653 function DynamicList.write(self, ...)
1654         self.map.proceed = true
1655         return AbstractValue.write(self, ...)
1656 end
1657
1658 function DynamicList.formvalue(self, section)
1659         local value = AbstractValue.formvalue(self, section)
1660         value = (type(value) == "table") and value or {value}
1661
1662         local valid = {}
1663         for i, v in ipairs(value) do
1664                 if v and #v > 0
1665                  and not self.map:formvalue("cbi.rle."..section.."."..self.option.."."..i)
1666                  and not self.map:formvalue("cbi.rle."..section.."."..self.option.."."..i..".x") then
1667                         table.insert(valid, v)
1668                 end
1669         end
1670
1671         return valid
1672 end
1673
1674
1675 --[[
1676 TextValue - A multi-line value
1677         rows:   Rows
1678 ]]--
1679 TextValue = class(AbstractValue)
1680
1681 function TextValue.__init__(self, ...)
1682         AbstractValue.__init__(self, ...)
1683         self.template  = "cbi/tvalue"
1684 end
1685
1686 --[[
1687 Button
1688 ]]--
1689 Button = class(AbstractValue)
1690
1691 function Button.__init__(self, ...)
1692         AbstractValue.__init__(self, ...)
1693         self.template  = "cbi/button"
1694         self.inputstyle = nil
1695         self.rmempty = true
1696 end
1697
1698
1699 FileUpload = class(AbstractValue)
1700
1701 function FileUpload.__init__(self, ...)
1702         AbstractValue.__init__(self, ...)
1703         self.template = "cbi/upload"
1704         if not self.map.upload_fields then
1705                 self.map.upload_fields = { self }
1706         else
1707                 self.map.upload_fields[#self.map.upload_fields+1] = self
1708         end
1709 end
1710
1711 function FileUpload.formcreated(self, section)
1712         return AbstractValue.formcreated(self, section) or
1713                 self.map:formvalue("cbi.rlf."..section.."."..self.option) or
1714                 self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1715 end
1716
1717 function FileUpload.cfgvalue(self, section)
1718         local val = AbstractValue.cfgvalue(self, section)
1719         if val and fs.access(val) then
1720                 return val
1721         end
1722         return nil
1723 end
1724
1725 function FileUpload.formvalue(self, section)
1726         local val = AbstractValue.formvalue(self, section)
1727         if val then
1728                 if not self.map:formvalue("cbi.rlf."..section.."."..self.option) and
1729                    not self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1730                 then
1731                         return val
1732                 end
1733                 fs.unlink(val)
1734                 self.value = nil
1735         end
1736         return nil
1737 end
1738
1739 function FileUpload.remove(self, section)
1740         local val = AbstractValue.formvalue(self, section)
1741         if val and fs.access(val) then fs.unlink(val) end
1742         return AbstractValue.remove(self, section)
1743 end
1744
1745
1746 FileBrowser = class(AbstractValue)
1747
1748 function FileBrowser.__init__(self, ...)
1749         AbstractValue.__init__(self, ...)
1750         self.template = "cbi/browser"
1751 end