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