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