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