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