Merge pull request #1767 from SvenRoederer/patch-2
[project/luci.git] / applications / luci-app-ddns / luasrc / model / cbi / ddns / detail.lua
1 -- Copyright 2008 Steven Barth <steven@midlink.org>
2 -- Copyright 2008 Jo-Philipp Wich <jow@openwrt.org>
3 -- Copyright 2013 Manuel Munz <freifunk at somakoma dot de>
4 -- Copyright 2014-2016 Christian Schoenebeck <christian dot schoenebeck at gmail dot com>
5 -- Licensed to the public under the Apache License 2.0.
6
7 local NX   = require "nixio"
8 local NXFS = require "nixio.fs"
9 local SYS  = require "luci.sys"
10 local UTIL = require "luci.util"
11 local HTTP = require "luci.http"
12 local DISP = require "luci.dispatcher"
13 local WADM = require "luci.tools.webadmin"
14 local DTYP = require "luci.cbi.datatypes"
15 local CTRL = require "luci.controller.ddns"     -- this application's controller
16 local DDNS = require "luci.tools.ddns"          -- ddns multiused functions
17
18 -- takeover arguments -- #######################################################
19 local section = arg[1]
20
21 -- html constants -- ###########################################################
22 local font_red  = "<font color='red'>"
23 local font_off  = "</font>"
24 local bold_on   = "<strong>"
25 local bold_off  = "</strong>"
26
27 -- error text constants -- #####################################################
28 local err_ipv6_plain = translate("IPv6 not supported") .. " - " ..
29                 translate("please select 'IPv4' address version")
30 local err_ipv6_basic = bold_on ..
31                         font_red ..
32                                 translate("IPv6 not supported") ..
33                         font_off ..
34                         "<br />" .. translate("please select 'IPv4' address version") ..
35                  bold_off
36 local err_ipv6_other = bold_on ..
37                         font_red ..
38                                 translate("IPv6 not supported") ..
39                         font_off ..
40                         "<br />" .. translate("please select 'IPv4' address version in") .. " " ..
41                         [[<a href="]] ..
42                                         DISP.build_url("admin", "services", "ddns", "detail", section) ..
43                                         "?tab.dns." .. section .. "=basic" ..
44                                 [[">]] ..
45                                 translate("Basic Settings") ..
46                         [[</a>]] ..
47                  bold_off
48
49 function err_tab_basic(self)
50         return translate("Basic Settings") .. " - " .. self.title .. ": "
51 end
52 function err_tab_adv(self)
53         return translate("Advanced Settings") .. " - " .. self.title .. ": "
54 end
55 function err_tab_timer(self)
56         return translate("Timer Settings") .. " - " .. self.title .. ": "
57 end
58
59 -- read services/services_ipv6 files -- ########################################
60 local services4 = { }           -- IPv4 --
61 local fd4 = io.open("/etc/ddns/services", "r")
62 if fd4 then
63         local ln, s, t
64         repeat
65                 ln = fd4:read("*l")
66                 s  = ln and ln:match('^%s*".*') -- only handle lines beginning with "
67                 s  = s  and  s:gsub('"','')     -- remove "
68                 t  = s  and UTIL.split(s,"(%s+)",nil,true)      -- split on whitespaces
69                 if t then services4[t[1]]=t[2] end
70         until not ln
71         fd4:close()
72 end
73
74 local services6 = { }           -- IPv6 --
75 local fd6 = io.open("/etc/ddns/services_ipv6", "r")
76 if fd6 then
77         local ln, s, t
78         repeat
79                 ln = fd6:read("*l")
80                 s  = ln and ln:match('^%s*".*') -- only handle lines beginning with "
81                 s  = s  and  s:gsub('"','')     -- remove "
82                 t  = s  and UTIL.split(s,"(%s+)",nil,true)      -- split on whitespaces
83                 if t then services6[t[1]]=t[2] end
84         until not ln
85         fd6:close()
86 end
87
88 -- multi-used functions -- ####################################################
89 -- function to verify settings around ip_source
90 -- will use dynamic_dns_lucihelper to check if
91 -- local IP can be read
92 local function _verify_ip_source()
93         -- section is globally defined here be calling agrument (see above)
94         local _arg
95
96         local _ipv6   = usev6:formvalue(section)
97         local _source = (_ipv6 == "1")
98                         and src6:formvalue(section)
99                         or  src4:formvalue(section)
100
101         local command = CTRL.luci_helper .. [[ -]]
102         if (_ipv6 == "1")  then command = command .. [[6]] end
103
104         if _source == "network" then
105                 _arg = (_ipv6 == "1")
106                         and ipn6:formvalue(section)
107                         or  ipn4:formvalue(section)
108                 command = command .. [[n ]] .. _arg
109         elseif _source == "web" then
110                 _arg = (_ipv6 == "1")
111                         and iurl6:formvalue(section)
112                         or  iurl4:formvalue(section)
113                 command = command .. [[u ]] .. _arg
114
115                 -- proxy only needed for checking url
116                 _arg = (pxy) and pxy:formvalue(section) or ""
117                 if (_arg and #_arg > 0) then
118                         command = command .. [[ -p ]] .. _arg
119                 end
120         elseif _source == "interface" then
121                 command = command .. [[i ]] .. ipi:formvalue(section)
122         elseif _source == "script" then
123                 command = command .. [[s ]] .. ips:formvalue(section)
124         end
125         command = command .. [[ -- get_local_ip]]
126         return (SYS.call(command) == 0)
127 end
128
129 -- function to check if option is used inside url or script
130 -- return -1 on error, 0 NOT required, 1 required
131 local function _option_used(option, urlscript)
132         local surl      -- search string for url
133         local ssh       -- search string for script
134         local required  -- option used inside url or script
135
136         if     option == "domain"    then surl, ssh = '%[DOMAIN%]', '%$domain'
137         elseif option == "username"  then surl, ssh = '%[USERNAME%]', '%$username'
138         elseif option == "password"  then surl, ssh = '%[PASSWORD%]', '%$password'
139         elseif option == "param_enc" then surl, ssh = '%[PARAMENC%]', '%$param_enc'
140         elseif option == "param_opt" then surl, ssh = '%[PARAMOPT%]', '%$param_opt'
141         else
142                 error("undefined option")
143                 return -1       -- return on error
144         end
145
146         local required = false
147         -- handle url
148         if urlscript:find('http') then
149                 required = ( urlscript:find(surl) )
150         -- handle script
151         else
152                 if not urlscript:find("/") then
153                         -- might be inside ddns-scripts directory
154                         urlscript = "/usr/lib/ddns/" .. urlscript
155                 end
156                 -- problem with script exit here
157                 if not NXFS.access(urlscript) then return -1 end
158
159                 local f = io.input(urlscript)
160                 -- still problem with script exit here
161                 if not f then return -1 end
162                 for l in f:lines() do
163                         repeat
164                                 if l:find('^#') then break end  -- continue on comment lines
165                                 required = ( l:find(surl) or l:find(ssh) )
166                         until true
167                         if required then break end
168                 end
169                 f:close()
170         end
171         return (required and 1 or 0)
172 end
173
174 -- function to verify if option is valid
175 local function _option_validate(self, value)
176         -- section is globally defined here be calling agrument (see above)
177         local fusev6 = usev6:formvalue(section) or "0"
178         local fsvc4  = svc4:formvalue(section) or "-"
179         local fsvc6  = svc6:formvalue(section) or "-"
180         local urlsh, used
181
182         -- IP-Version dependent custom service selected
183         if (fusev6 == "0" and fsvc4 == "-") or
184            (fusev6 == "1" and fsvc6 == "-") then
185                 -- read custom url
186                 urlsh = uurl:formvalue(section) or ""
187                 -- no url then read custom script
188                 if (#urlsh == 0) then
189                         urlsh = ush:formvalue(section) or ""
190                 end
191         -- IPv4 read from services4 table
192         elseif (fusev6 == "0") then
193                 urlsh = services4[fsvc4] or ""
194         -- IPv6 read from services6 table
195         else
196                 urlsh = services6[fsvc6] or ""
197         end
198         -- problem with url or script exit here
199         -- error handled somewhere else
200         if (#urlsh == 0) then return "" end
201
202         used = _option_used(self.option, urlsh)
203         -- on error or not used return empty sting
204         if used < 1 then return "" end
205         -- needed but no data then return error
206         if not value or (#value == 0) then
207                 return nil, err_tab_basic(self) .. translate("missing / required")
208         end
209         return value
210 end
211
212 -- cbi-map definition -- #######################################################
213 local m         = Map("ddns")
214 m.title         = CTRL.app_title_back()
215 m.description   = CTRL.app_description()
216 m.redirect      = DISP.build_url("admin", "services", "ddns")
217
218 m.on_after_commit = function(self)
219         if self.changed then    -- changes ?
220                 local pid = DDNS.get_pid(section)
221                 if pid > 0 then -- running ?
222                         local tmp = NX.kill(pid, 1)     -- send SIGHUP
223                 end
224         end
225 end
226
227 -- provider switch was requested, save and reload page
228 if m:formvalue("cbid.ddns.%s._switch" % section) then   -- section == arg[1]
229         local fsvc
230         local fusev6 = m:formvalue("cbid.ddns.%s.use_ipv6" % section) or "0"
231         if fusev6 == "1" then
232                 fsvc = m:formvalue("cbid.ddns.%s.ipv6_service_name" % section) or ""
233         else
234                 fsvc = m:formvalue("cbid.ddns.%s.ipv4_service_name" % section) or ""
235         end
236
237         if fusev6 ~= (m:get(section, "use_ipv6") or "0") then   -- IPv6 was changed
238                 m:set(section, "use_ipv6", fusev6)              -- save it
239         end
240
241         if fsvc ~= "-" then                                     -- NOT "custom"
242                 m:set(section, "service_name", fsvc)            -- save it
243         else                                                    -- else
244                 m:del(section, "service_name")                  -- delete it
245         end
246         m.uci:save(m.config)
247
248         -- reload page
249         HTTP.redirect( DISP.build_url("admin", "services", "ddns", "detail", section) )
250         return
251 end
252
253 -- read application settings -- ################################################
254 -- log directory
255 local logdir = m.uci:get(m.config, "global", "ddns_logdir") or "/var/log/ddns"
256
257 -- cbi-section definition -- ###################################################
258 local ns = m:section( NamedSection, section, "service",
259         translate("Details for") .. ([[: <strong>%s</strong>]] % section),
260         translate("Configure here the details for selected Dynamic DNS service.") )
261 ns.instance = section   -- arg [1]
262 ns:tab("basic", translate("Basic Settings"), nil )
263 ns:tab("advanced", translate("Advanced Settings"), nil )
264 ns:tab("timer", translate("Timer Settings"), nil )
265 ns:tab("logview", translate("Log File Viewer"), nil )
266
267 -- TAB: Basic  #####################################################################################
268 -- enabled -- #################################################################
269 en = ns:taboption("basic", Flag, "enabled",
270         translate("Enabled"),
271         translate("If this service section is disabled it could not be started." .. "<br />" ..
272                 "Neither from LuCI interface nor from console") )
273 en.orientation = "horizontal"
274
275 -- IPv4/IPv6 - lookup_host -- #################################################
276 luh = ns:taboption("basic", Value, "lookup_host",
277                 translate("Lookup Hostname"),
278                 translate("Hostname/FQDN to validate, if IP update happen or necessary") )
279 luh.rmempty     = false
280 luh.placeholder = "myhost.example.com"
281 function luh.validate(self, value)
282         if not value
283         or not (#value > 0)
284         or not DTYP.hostname(value) then
285                 return nil, err_tab_basic(self) .. translate("invalid FQDN / required - Sample") .. ": 'myhost.example.com'"
286         else
287                 return UTIL.trim(value)
288         end
289 end
290 function luh.parse(self, section, novld)
291         DDNS.value_parse(self, section, novld)
292 end
293
294 -- use_ipv6 -- ################################################################
295 usev6 = ns:taboption("basic", ListValue, "use_ipv6",
296         translate("IP address version"),
297         translate("Defines which IP address 'IPv4/IPv6' is send to the DDNS provider") )
298 usev6.widget  = "radio"
299 usev6.default = "0"
300 usev6:value("0", translate("IPv4-Address") )
301 function usev6.cfgvalue(self, section)
302         local value = AbstractValue.cfgvalue(self, section) or "0"
303         if DDNS.has_ipv6 or (value == "1" and not DDNS.has_ipv6) then
304                 self:value("1", translate("IPv6-Address") )
305         end
306         if value == "1" and not DDNS.has_ipv6 then
307                 self.description = err_ipv6_basic
308         end
309         return value
310 end
311 function usev6.validate(self, value)
312         if (value == "1" and DDNS.has_ipv6) or value == "0" then
313                 return value
314         end
315         return nil, err_tab_basic(self) .. err_ipv6_plain
316 end
317 function usev6.parse(self, section, novld)
318         DDNS.value_parse(self, section, novld)
319 end
320
321 -- IPv4 - service_name -- #####################################################
322 svc4 = ns:taboption("basic", ListValue, "ipv4_service_name",
323         translate("DDNS Service provider") .. " [IPv4]" )
324 svc4.default    = "-"
325 svc4:depends("use_ipv6", "0")   -- only show on IPv4
326 function svc4.cfgvalue(self, section)
327         local v =  DDNS.read_value(self, section, "service_name")
328         if v and (#v > 0) then
329                 for s, u in UTIL.kspairs(services4) do
330                         if v == s then return v end
331                 end
332         end
333         return "-"
334 end
335 function svc4.validate(self, value)
336         if usev6:formvalue(section) ~= "1" then -- do only on IPv4
337                 return value
338         else
339                 return ""       -- suppress validate error
340         end
341 end
342 function svc4.write(self, section, value)
343         if usev6:formvalue(section) ~= "1" then -- do only IPv4 here
344                 self.map:del(section, self.option)      -- to be shure
345                 if value ~= "-" then                    -- and write "service_name
346                         self.map:del(section, "update_url")     -- delete update_url
347                         self.map:del(section, "update_script")  -- delete update_script
348                         return self.map:set(section, "service_name", value)
349                 else
350                         return self.map:del(section, "service_name")
351                 end
352         end
353 end
354 function svc4.parse(self, section, novld)
355         DDNS.value_parse(self, section, novld)
356 end
357
358 -- IPv6 - service_name -- #####################################################
359 svc6 = ns:taboption("basic", ListValue, "ipv6_service_name",
360         translate("DDNS Service provider") .. " [IPv6]" )
361 svc6.default    = "-"
362 svc6:depends("use_ipv6", "1")   -- only show on IPv6
363 if not DDNS.has_ipv6 then
364         svc6.description = err_ipv6_basic
365 end
366 function svc6.cfgvalue(self, section)
367         local v =  DDNS.read_value(self, section, "service_name")
368         if v and (#v > 0) then
369                 for s, u in UTIL.kspairs(services4) do
370                         if v == s then return v end
371                 end
372         end
373         return "-"
374 end
375 function svc6.validate(self, value)
376         if usev6:formvalue(section) == "1" then -- do only on IPv6
377                 if DDNS.has_ipv6 then return value end
378                 return nil, err_tab_basic(self) .. err_ipv6_plain
379         else
380                 return ""       -- suppress validate error
381         end
382 end
383 function svc6.write(self, section, value)
384         if usev6:formvalue(section) == "1" then         -- do only when IPv6
385                 self.map:del(section, self.option)      -- delete "ipv6_service_name" helper
386                 if value ~= "-" then                    -- and write "service_name
387                         self.map:del(section, "update_url")     -- delete update_url
388                         self.map:del(section, "update_script")  -- delete update_script
389                         return self.map:set(section, "service_name", value)
390                 else
391                         return self.map:del(section, "service_name")
392                 end
393         end
394 end
395 function svc6.parse(self, section, novld)
396         DDNS.value_parse(self, section, novld)
397 end
398
399 -- IPv4/IPv6 - change Provider -- #############################################
400 svs             = ns:taboption("basic", Button, "_switch")
401 svs.title      = translate("Really change DDNS provider?")
402 svs.inputtitle = translate("Change provider")
403 svs.inputstyle = "apply"
404
405 -- IPv4/IPv6 - update_url -- ##################################################
406 uurl = ns:taboption("basic", Value, "update_url",
407         translate("Custom update-URL"),
408         translate("Update URL to be used for updating your DDNS Provider." .. "<br />" ..
409                 "Follow instructions you will find on their WEB page.") )
410 function uurl.validate(self, value)
411         local fush   = ush:formvalue(section)
412         local fusev6 = usev6:formvalue(section)
413
414         if (fusev6 ~= "1" and svc4:formvalue(section) ~= "-") or
415            (fusev6 == "1" and svc6:formvalue(section) ~= "-") then
416                 return ""       -- suppress validate error
417         elseif not value or (#value == 0) then
418                 if not fush or (#fush == 0) then
419                         return nil, err_tab_basic(self) .. translate("missing / required")
420                 else
421                         return ""       -- suppress validate error / update_script is given
422                 end
423         elseif (#fush > 0) then
424                 return nil, err_tab_basic(self) .. translate("either url or script could be set")
425         end
426
427         local url = DDNS.parse_url(value)
428         if not url.scheme == "http" then
429                 return nil, err_tab_basic(self) .. translate("must start with 'http://'")
430         elseif not url.query then
431                 return nil, err_tab_basic(self) .. "<QUERY> " .. translate("missing / required")
432         elseif not url.host then
433                 return nil, err_tab_basic(self) .. "<HOST> " .. translate("missing / required")
434         elseif SYS.call([[nslookup ]] .. url.host .. [[ >/dev/null 2>&1]]) ~= 0 then
435                 return nil, err_tab_basic(self) .. translate("can not resolve host: ") .. url.host
436         end
437
438         return value
439 end
440 function uurl.parse(self, section, novld)
441         DDNS.value_parse(self, section, novld)
442 end
443
444 -- IPv4/IPv6 - update_script -- ###############################################
445 ush = ns:taboption("basic", Value, "update_script",
446         translate("Custom update-script"),
447         translate("Custom update script to be used for updating your DDNS Provider.") )
448 function ush.validate(self, value)
449         local fuurl  = uurl:formvalue(section)
450         local fusev6 = usev6:formvalue(section)
451
452         if (fusev6 ~= "1" and svc4:formvalue(section) ~= "-") or
453            (fusev6 == "1" and svc6:formvalue(section) ~= "-") then
454                 return ""       -- suppress validate error
455         elseif not value or (#value == 0) then
456                 if not fuurl or (#fuurl == 0) then
457                         return nil, err_tab_basic(self) .. translate("missing / required")
458                 else
459                         return ""       -- suppress validate error / update_url is given
460                 end
461         elseif (#fuurl > 0) then
462                 return nil, err_tab_basic(self) .. translate("either url or script could be set")
463         elseif not NXFS.access(value) then
464                 return nil, err_tab_basic(self) .. translate("File not found")
465         end
466         return value
467 end
468 function ush.parse(self, section, novld)
469         DDNS.value_parse(self, section, novld)
470 end
471
472 -- IPv4/IPv6 - domain -- ######################################################
473 dom = ns:taboption("basic", Value, "domain",
474                 translate("Domain"),
475                 translate("Replaces [DOMAIN] in Update-URL") )
476 dom.placeholder = "myhost.example.com"
477 function dom.validate(self, value)
478         return _option_validate(self, value)
479 end
480 function dom.parse(self, section, novld)
481         DDNS.value_parse(self, section, novld)
482 end
483
484 -- IPv4/IPv6 - username -- ####################################################
485 user = ns:taboption("basic", Value, "username",
486                 translate("Username"),
487                 translate("Replaces [USERNAME] in Update-URL (URL-encoded)") )
488 function user.validate(self, value)
489         return _option_validate(self, value)
490 end
491 function user.parse(self, section, novld)
492         DDNS.value_parse(self, section, novld)
493 end
494
495 -- IPv4/IPv6 - password -- ####################################################
496 pw = ns:taboption("basic", Value, "password",
497                 translate("Password"),
498                 translate("Replaces [PASSWORD] in Update-URL (URL-encoded)") )
499 pw.password = true
500 function pw.validate(self, value)
501         return _option_validate(self, value)
502 end
503 function pw.parse(self, section, novld)
504         DDNS.value_parse(self, section, novld)
505 end
506
507 -- IPv4/IPv6 - param_enc -- ###################################################
508 pe = ns:taboption("basic", Value, "param_enc",
509                 translate("Optional Encoded Parameter"),
510                 translate("Optional: Replaces [PARAMENC] in Update-URL (URL-encoded)") )
511 function pe.validate(self, value)
512         return _option_validate(self, value)
513 end
514 function pe.parse(self, section, novld)
515         DDNS.value_parse(self, section, novld)
516 end
517
518 -- IPv4/IPv6 - param_enc -- ###################################################
519 po = ns:taboption("basic", Value, "param_opt",
520                 translate("Optional Parameter"),
521                 translate("Optional: Replaces [PARAMOPT] in Update-URL (NOT URL-encoded)") )
522 function po.validate(self, value)
523         return _option_validate(self, value)
524 end
525 function po.parse(self, section, novld)
526         DDNS.value_parse(self, section, novld)
527 end
528
529 -- handled service dependent show/display -- ##################################
530 -- IPv4 --
531 local cv4 = svc4:cfgvalue(section)
532 if cv4 ~= "-" then
533         svs:depends ("ipv4_service_name", "-" ) -- show only if "-"
534         ush:depends ("ipv4_service_name", "?")
535         uurl:depends("ipv4_service_name", "?")
536 else
537         uurl:depends("ipv4_service_name", "-")
538         ush:depends ("ipv4_service_name", "-")
539         dom:depends("ipv4_service_name", "-" )
540         user:depends("ipv4_service_name", "-" )
541         pw:depends("ipv4_service_name", "-" )
542         pe:depends("ipv4_service_name", "-" )
543         po:depends("ipv4_service_name", "-" )
544 end
545 for s, u in UTIL.kspairs(services4) do
546         svc4:value(s)   -- fill DropDown-List
547         if cv4 ~= s then
548                 svs:depends("ipv4_service_name", s )
549         else
550                 dom:depends ("ipv4_service_name", ((_option_used(dom.option, u) == 1) and s or "?") )
551                 user:depends("ipv4_service_name", ((_option_used(user.option, u) == 1) and s or "?") )
552                 pw:depends  ("ipv4_service_name", ((_option_used(pw.option, u) == 1) and s or "?") )
553                 pe:depends  ("ipv4_service_name", ((_option_used(pe.option, u) == 1) and s or "?") )
554                 po:depends  ("ipv4_service_name", ((_option_used(po.option, u) == 1) and s or "?") )
555         end
556 end
557 svc4:value("-", translate("-- custom --") )
558
559 -- IPv6 --
560 local cv6 = svc6:cfgvalue(section)
561 if cv6 ~= "-" then
562         svs:depends ("ipv6_service_name", "-" )
563         uurl:depends("ipv6_service_name", "?")
564         ush:depends ("ipv6_service_name", "?")
565 else
566         uurl:depends("ipv6_service_name", "-")
567         ush:depends ("ipv6_service_name", "-")
568         dom:depends("ipv6_service_name", "-" )
569         user:depends("ipv6_service_name", "-" )
570         pw:depends("ipv6_service_name", "-" )
571         pe:depends("ipv6_service_name", "-" )
572         po:depends("ipv6_service_name", "-" )
573 end
574 for s, u in UTIL.kspairs(services6) do
575         svc6:value(s)   -- fill DropDown-List
576         if cv6 ~= s then
577                 svs:depends("ipv6_service_name", s )
578         else
579                 dom:depends ("ipv6_service_name", ((_option_used(dom.option, u) == 1) and s or "?") )
580                 user:depends("ipv6_service_name", ((_option_used(user.option, u) == 1) and s or "?") )
581                 pw:depends  ("ipv6_service_name", ((_option_used(pw.option, u) == 1) and s or "?") )
582                 pe:depends  ("ipv6_service_name", ((_option_used(pe.option, u) == 1) and s or "?") )
583                 po:depends  ("ipv6_service_name", ((_option_used(po.option, u) == 1) and s or "?") )
584         end
585 end
586 svc6:value("-", translate("-- custom --") )
587
588 -- IPv4/IPv6 - use_https -- ###################################################
589 if DDNS.has_ssl or ( ( m:get(section, "use_https") or "0" ) == "1" ) then
590         https = ns:taboption("basic", Flag, "use_https",
591                 translate("Use HTTP Secure") )
592         https.orientation = "horizontal"
593         function https.cfgvalue(self, section)
594                 local value = AbstractValue.cfgvalue(self, section)
595                 if not DDNS.has_ssl and value == "1" then
596                         self.description = bold_on .. font_red ..
597                                 translate("HTTPS not supported") .. font_off .. "<br />" ..
598                                 translate("please disable") .. " !" .. bold_off
599                 else
600                         self.description = translate("Enable secure communication with DDNS provider")
601                 end
602                 return value
603         end
604         function https.validate(self, value)
605                 if (value == "1" and DDNS.has_ssl ) or value == "0" then return value end
606                 return nil, err_tab_basic(self) .. translate("HTTPS not supported") .. " !"
607         end
608         function https.write(self, section, value)
609                 if value == "1" then
610                         return self.map:set(section, self.option, value)
611                 else
612                         self.map:del(section, "cacert")
613                         return self.map:del(section, self.option)
614                 end
615         end
616 end
617
618 -- IPv4/IPv6 - cacert -- ######################################################
619 if DDNS.has_ssl then
620         cert = ns:taboption("basic", Value, "cacert",
621                 translate("Path to CA-Certificate"),
622                 translate("directory or path/file") .. "<br />" ..
623                 translate("or") .. bold_on .. " IGNORE " .. bold_off ..
624                 translate("to run HTTPS without verification of server certificates (insecure)") )
625         cert:depends("use_https", "1")
626         cert.placeholder = "/etc/ssl/certs"
627         cert.forcewrite = true
628         function cert.validate(self, value)
629                 if https:formvalue(section) ~= "1" then
630                         return ""       -- suppress validate error if NOT https
631                 end
632                 if value then   -- otherwise errors in datatype check
633                         if DTYP.directory(value)
634                         or DTYP.file(value)
635                         or (value == "IGNORE")
636                         or (#value == 0) then
637                                 return value
638                         end
639                 end
640                 return nil, err_tab_basic(self) ..
641                         translate("file or directory not found or not 'IGNORE'") .. " !"
642         end
643         function cert.parse(self, section, novld)
644                 DDNS.value_parse(self, section, novld)
645         end
646 end
647
648 -- TAB: Advanced  #################################################################################
649 -- IPv4 - ip_source -- ########################################################
650 src4 = ns:taboption("advanced", ListValue, "ipv4_source",
651         translate("IP address source") .. " [IPv4]",
652         translate("Defines the source to read systems IPv4-Address from, that will be send to the DDNS provider") )
653 src4:depends("use_ipv6", "0")   -- IPv4 selected
654 src4.default = "network"
655 src4:value("network", translate("Network"))
656 src4:value("web", translate("URL"))
657 src4:value("interface", translate("Interface"))
658 src4:value("script", translate("Script"))
659 function src4.cfgvalue(self, section)
660         return DDNS.read_value(self, section, "ip_source")
661 end
662 function src4.validate(self, value)
663         if usev6:formvalue(section) == "1" then
664                 return ""       -- ignore on IPv6 selected
665         elseif not _verify_ip_source() then
666                 return nil, err_tab_adv(self) ..
667                         translate("can not detect local IP. Please select a different Source combination")
668         else
669                 return value
670         end
671 end
672 function src4.write(self, section, value)
673         if usev6:formvalue(section) == "1" then
674                 return true     -- ignore on IPv6 selected
675         elseif value == "network" then
676                 self.map:del(section, "ip_url")         -- delete not need parameters
677                 self.map:del(section, "ip_interface")
678                 self.map:del(section, "ip_script")
679         elseif value == "web" then
680                 self.map:del(section, "ip_network")     -- delete not need parameters
681                 self.map:del(section, "ip_interface")
682                 self.map:del(section, "ip_script")
683         elseif value == "interface" then
684                 self.map:del(section, "ip_network")     -- delete not need parameters
685                 self.map:del(section, "ip_url")
686                 self.map:del(section, "ip_script")
687         elseif value == "script" then
688                 self.map:del(section, "ip_network")
689                 self.map:del(section, "ip_url")         -- delete not need parameters
690                 self.map:del(section, "ip_interface")
691         end
692         self.map:del(section, self.option)               -- delete "ipv4_source" helper
693         return self.map:set(section, "ip_source", value) -- and write "ip_source
694 end
695 function src4.parse(self, section, novld)
696         DDNS.value_parse(self, section, novld)
697 end
698
699 -- IPv6 - ip_source -- ########################################################
700 src6 = ns:taboption("advanced", ListValue, "ipv6_source",
701         translate("IP address source") .. " [IPv6]",
702         translate("Defines the source to read systems IPv6-Address from, that will be send to the DDNS provider") )
703 src6:depends("use_ipv6", 1)     -- IPv6 selected
704 src6.default = "network"
705 src6:value("network", translate("Network"))
706 src6:value("web", translate("URL"))
707 src6:value("interface", translate("Interface"))
708 src6:value("script", translate("Script"))
709 if not DDNS.has_ipv6 then
710         src6.description = err_ipv6_other
711 end
712 function src6.cfgvalue(self, section)
713         return DDNS.read_value(self, section, "ip_source")
714 end
715 function src6.validate(self, value)
716         if usev6:formvalue(section) ~= "1" then
717                 return ""       -- ignore on IPv4 selected
718         elseif not DDNS.has_ipv6 then
719                 return nil, err_tab_adv(self) .. err_ipv6_plain
720         elseif not _verify_ip_source() then
721                 return nil, err_tab_adv(self) ..
722                         translate("can not detect local IP. Please select a different Source combination")
723         else
724                 return value
725         end
726 end
727 function src6.write(self, section, value)
728         if usev6:formvalue(section) ~= "1" then
729                 return true     -- ignore on IPv4 selected
730         elseif value == "network" then
731                 self.map:del(section, "ip_url")         -- delete not need parameters
732                 self.map:del(section, "ip_interface")
733                 self.map:del(section, "ip_script")
734         elseif value == "web" then
735                 self.map:del(section, "ip_network")     -- delete not need parameters
736                 self.map:del(section, "ip_interface")
737                 self.map:del(section, "ip_script")
738         elseif value == "interface" then
739                 self.map:del(section, "ip_network")     -- delete not need parameters
740                 self.map:del(section, "ip_url")
741                 self.map:del(section, "ip_script")
742         elseif value == "script" then
743                 self.map:del(section, "ip_network")
744                 self.map:del(section, "ip_url")         -- delete not need parameters
745                 self.map:del(section, "ip_interface")
746         end
747         self.map:del(section, self.option)               -- delete "ipv4_source" helper
748         return self.map:set(section, "ip_source", value) -- and write "ip_source
749 end
750 function src6.parse(self, section, novld)
751         DDNS.value_parse(self, section, novld)
752 end
753
754 -- IPv4 - ip_network (default "wan") -- #######################################
755 ipn4 = ns:taboption("advanced", ListValue, "ipv4_network",
756         translate("Network") .. " [IPv4]",
757         translate("Defines the network to read systems IPv4-Address from") )
758 ipn4:depends("ipv4_source", "network")
759 ipn4.default = "wan"
760 WADM.cbi_add_networks(ipn4)
761 function ipn4.cfgvalue(self, section)
762         return DDNS.read_value(self, section, "ip_network")
763 end
764 function ipn4.validate(self, value)
765         if usev6:formvalue(section) == "1"
766          or src4:formvalue(section) ~= "network" then
767                 -- ignore if IPv6 selected OR
768                 -- ignore everything except "network"
769                 return ""
770         else
771                 return value
772         end
773 end
774 function ipn4.write(self, section, value)
775         if usev6:formvalue(section) == "1"
776          or src4:formvalue(section) ~= "network" then
777                 -- ignore if IPv6 selected OR
778                 -- ignore everything except "network"
779                 return true
780         else
781                 -- set also as "interface" for monitoring events changes/hot-plug
782                 self.map:set(section, "interface", value)
783                 self.map:del(section, self.option)                -- delete "ipv4_network" helper
784                 return self.map:set(section, "ip_network", value) -- and write "ip_network"
785         end
786 end
787 function ipn4.parse(self, section, novld)
788         DDNS.value_parse(self, section, novld)
789 end
790
791 -- IPv6 - ip_network (default "wan6") -- ######################################
792 ipn6 = ns:taboption("advanced", ListValue, "ipv6_network",
793         translate("Network") .. " [IPv6]" )
794 ipn6:depends("ipv6_source", "network")
795 ipn6.default = "wan6"
796 WADM.cbi_add_networks(ipn6)
797 if DDNS.has_ipv6 then
798         ipn6.description = translate("Defines the network to read systems IPv6-Address from")
799 else
800         ipn6.description = err_ipv6_other
801 end
802 function ipn6.cfgvalue(self, section)
803         return DDNS.read_value(self, section, "ip_network")
804 end
805 function ipn6.validate(self, value)
806         if usev6:formvalue(section) ~= "1"
807          or src6:formvalue(section) ~= "network" then
808                 -- ignore if IPv4 selected OR
809                 -- ignore everything except "network"
810                 return ""
811         elseif DDNS.has_ipv6 then
812                 return value
813         else
814                 return nil, err_tab_adv(self) .. err_ipv6_plain
815         end
816 end
817 function ipn6.write(self, section, value)
818         if usev6:formvalue(section) ~= "1"
819          or src6:formvalue(section) ~= "network" then
820                 -- ignore if IPv4 selected OR
821                 -- ignore everything except "network"
822                 return true
823         else
824                 -- set also as "interface" for monitoring events changes/hotplug
825                 self.map:set(section, "interface", value)
826                 self.map:del(section, self.option)                -- delete "ipv6_network" helper
827                 return self.map:set(section, "ip_network", value) -- and write "ip_network"
828         end
829 end
830 function ipn6.parse(self, section, novld)
831         DDNS.value_parse(self, section, novld)
832 end
833
834 -- IPv4 - ip_url (default "checkip.dyndns.com") -- ############################
835 iurl4 = ns:taboption("advanced", Value, "ipv4_url",
836         translate("URL to detect") .. " [IPv4]",
837         translate("Defines the Web page to read systems IPv4-Address from") )
838 iurl4:depends("ipv4_source", "web")
839 iurl4.default = "http://checkip.dyndns.com"
840 function iurl4.cfgvalue(self, section)
841         return DDNS.read_value(self, section, "ip_url")
842 end
843 function iurl4.validate(self, value)
844         if usev6:formvalue(section) == "1"
845          or src4:formvalue(section) ~= "web" then
846                 -- ignore if IPv6 selected OR
847                 -- ignore everything except "web"
848                 return ""
849         elseif not value or #value == 0 then
850                 return nil, err_tab_adv(self) .. translate("missing / required")
851         end
852
853         local url = DDNS.parse_url(value)
854         if not (url.scheme == "http" or url.scheme == "https") then
855                 return nil, err_tab_adv(self) .. translate("must start with 'http://'")
856         elseif not url.host then
857                 return nil, err_tab_adv(self) .. "<HOST> " .. translate("missing / required")
858         elseif SYS.call([[nslookup ]] .. url.host .. [[>/dev/null 2>&1]]) ~= 0 then
859                 return nil, err_tab_adv(self) .. translate("can not resolve host: ") .. url.host
860         else
861                 return value
862         end
863 end
864 function iurl4.write(self, section, value)
865         if usev6:formvalue(section) == "1"
866          or src4:formvalue(section) ~= "web" then
867                 -- ignore if IPv6 selected OR
868                 -- ignore everything except "web"
869                 return true
870         else
871                 self.map:del(section, self.option)              -- delete "ipv4_url" helper
872                 return self.map:set(section, "ip_url", value)   -- and write "ip_url"
873         end
874 end
875 function iurl4.parse(self, section, novld)
876         DDNS.value_parse(self, section, novld)
877 end
878
879 -- IPv6 - ip_url (default "checkipv6.dyndns.com") -- ##########################
880 iurl6 = ns:taboption("advanced", Value, "ipv6_url",
881         translate("URL to detect") .. " [IPv6]" )
882 iurl6:depends("ipv6_source", "web")
883 iurl6.default = "http://checkipv6.dyndns.com"
884 if DDNS.has_ipv6 then
885         iurl6.description = translate("Defines the Web page to read systems IPv6-Address from")
886 else
887         iurl6.description = err_ipv6_other
888 end
889 function iurl6.cfgvalue(self, section)
890         return DDNS.read_value(self, section, "ip_url")
891 end
892 function iurl6.validate(self, value)
893         if usev6:formvalue(section) ~= "1"
894          or src6:formvalue(section) ~= "web" then
895                 -- ignore if IPv4 selected OR
896                 -- ignore everything except "web"
897                 return ""
898         elseif not DDNS.has_ipv6 then
899                 return nil, err_tab_adv(self) .. err_ipv6_plain
900         elseif not value or #value == 0 then
901                 return nil, err_tab_adv(self) .. translate("missing / required")
902         end
903
904         local url = DDNS.parse_url(value)
905         if not (url.scheme == "http" or url.scheme == "https") then
906                 return nil, err_tab_adv(self) .. translate("must start with 'http://'")
907         elseif not url.host then
908                 return nil, err_tab_adv(self) .. "<HOST> " .. translate("missing / required")
909         elseif SYS.call([[nslookup ]] .. url.host .. [[>/dev/null 2>&1]]) ~= 0 then
910                 return nil, err_tab_adv(self) .. translate("can not resolve host: ") .. url.host
911         else
912                 return value
913         end
914 end
915 function iurl6.write(self, section, value)
916         if usev6:formvalue(section) ~= "1"
917          or src6:formvalue(section) ~= "web" then
918                 -- ignore if IPv4 selected OR
919                 -- ignore everything except "web"
920                 return true
921         else
922                 self.map:del(section, self.option)              -- delete "ipv6_url" helper
923                 return self.map:set(section, "ip_url", value)   -- and write "ip_url"
924         end
925 end
926 function iurl6.parse(self, section, novld)
927         DDNS.value_parse(self, section, novld)
928 end
929
930 -- IPv4 + IPv6 - ip_interface -- ##############################################
931 ipi = ns:taboption("advanced", ListValue, "ip_interface",
932         translate("Interface"),
933         translate("Defines the interface to read systems IP-Address from") )
934 ipi:depends("ipv4_source", "interface") -- IPv4
935 ipi:depends("ipv6_source", "interface") -- or IPv6
936 for _, v in pairs(SYS.net.devices()) do
937         -- show only interface set to a network
938         -- and ignore loopback
939         net = WADM.iface_get_network(v)
940         if net and net ~= "loopback" then
941                 ipi:value(v)
942         end
943 end
944 function ipi.validate(self, value)
945         local fusev6 = usev6:formvalue(section)
946         if (fusev6 ~= "1" and src4:formvalue(section) ~= "interface")
947         or (fusev6 == "1" and src6:formvalue(section) ~= "interface") then
948                 return ""
949         else
950                 return value
951         end
952 end
953 function ipi.write(self, section, value)
954         local fusev6 = usev6:formvalue(section)
955         if (fusev6 ~= "1" and src4:formvalue(section) ~= "interface")
956         or (fusev6 == "1" and src6:formvalue(section) ~= "interface") then
957                 return true
958         else
959                 -- get network from device to
960                 -- set also as "interface" for monitoring events changes/hotplug
961                 local net = WADM.iface_get_network(value)
962                 self.map:set(section, "interface", net)
963                 return self.map:set(section, self.option, value)
964         end
965 end
966 function ipi.parse(self, section, novld)
967         DDNS.value_parse(self, section, novld)
968 end
969
970 -- IPv4 + IPv6 - ip_script -- #################################################
971 ips = ns:taboption("advanced", Value, "ip_script",
972         translate("Script"),
973         translate("User defined script to read systems IP-Address") )
974 ips:depends("ipv4_source", "script")    -- IPv4
975 ips:depends("ipv6_source", "script")    -- or IPv6
976 ips.placeholder = "/path/to/script.sh"
977 function ips.validate(self, value)
978         local fusev6 = usev6:formvalue(section)
979         local split
980         if value then split = UTIL.split(value, " ") end
981
982         if (fusev6 ~= "1" and src4:formvalue(section) ~= "script")
983         or (fusev6 == "1" and src6:formvalue(section) ~= "script") then
984                 return ""
985         elseif not value or not (#value > 0) or not NXFS.access(split[1], "x") then
986                 return nil, err_tab_adv(self) ..
987                         translate("not found or not executable - Sample: '/path/to/script.sh'")
988         else
989                 return value
990         end
991 end
992 function ips.write(self, section, value)
993         local fusev6 = usev6:formvalue(section)
994         if (fusev6 ~= "1" and src4:formvalue(section) ~= "script")
995         or (fusev6 == "1" and src6:formvalue(section) ~= "script") then
996                 return true
997         else
998                 return self.map:set(section, self.option, value)
999         end
1000 end
1001 function ips.parse(self, section, novld)
1002         DDNS.value_parse(self, section, novld)
1003 end
1004
1005 -- IPv4 - interface - default "wan" -- ########################################
1006 -- event network to monitor changes/hotplug/dynamic_dns_updater.sh
1007 -- only needs to be set if "ip_source"="web" or "script"
1008 -- if "ip_source"="network" or "interface" we use their network
1009 eif4 = ns:taboption("advanced", ListValue, "ipv4_interface",
1010         translate("Event Network") .. " [IPv4]",
1011         translate("Network on which the ddns-updater scripts will be started") )
1012 eif4:depends("ipv4_source", "web")
1013 eif4:depends("ipv4_source", "script")
1014 eif4.default = "wan"
1015 WADM.cbi_add_networks(eif4)
1016 function eif4.cfgvalue(self, section)
1017         return DDNS.read_value(self, section, "interface")
1018 end
1019 function eif4.validate(self, value)
1020         local fsrc4 = src4:formvalue(section) or ""
1021         if usev6:formvalue(section) == "1"
1022          or fsrc4 == "network"
1023          or fsrc4 == "interface" then
1024                 return ""       -- ignore IPv6, network, interface
1025         else
1026                 return value
1027         end
1028 end
1029 function eif4.write(self, section, value)
1030         local fsrc4 = src4:formvalue(section) or ""
1031         if usev6:formvalue(section) == "1"
1032          or fsrc4 == "network"
1033          or fsrc4 == "interface" then
1034                 return true     -- ignore IPv6, network, interface
1035         else
1036                 self.map:del(section, self.option)               -- delete "ipv4_interface" helper
1037                 return self.map:set(section, "interface", value) -- and write "interface"
1038         end
1039 end
1040 function eif4.parse(self, section, novld)
1041         DDNS.value_parse(self, section, novld)
1042 end
1043
1044 -- IPv6 - interface - default "wan6" -- #######################################
1045 -- event network to monitor changes/hotplug
1046 -- only needs to be set if "ip_source"="web" or "script"
1047 -- if "ip_source"="network" or "interface" we use their network
1048 eif6 = ns:taboption("advanced", ListValue, "ipv6_interface",
1049         translate("Event Network") .. " [IPv6]" )
1050 eif6:depends("ipv6_source", "web")
1051 eif6:depends("ipv6_source", "script")
1052 eif6.default = "wan6"
1053 WADM.cbi_add_networks(eif6)
1054 if not DDNS.has_ipv6 then
1055         eif6.description = err_ipv6_other
1056 else
1057         eif6.description = translate("Network on which the ddns-updater scripts will be started")
1058 end
1059 function eif6.cfgvalue(self, section)
1060         return DDNS.read_value(self, section, "interface")
1061 end
1062 function eif6.validate(self, value)
1063         local fsrc6 = src6:formvalue(section) or ""
1064         if usev6:formvalue(section) ~= "1"
1065          or fsrc6 == "network"
1066          or fsrc6 == "interface" then
1067                 return ""       -- ignore IPv4, network, interface
1068         elseif not DDNS.has_ipv6 then
1069                 return nil, err_tab_adv(self) .. err_ipv6_plain
1070         else
1071                 return value
1072         end
1073 end
1074 function eif6.write(self, section, value)
1075         local fsrc6 = src6:formvalue(section) or ""
1076         if usev6:formvalue(section) ~= "1"
1077          or fsrc6 == "network"
1078          or fsrc6 == "interface" then
1079                 return true     -- ignore IPv4, network, interface
1080         else
1081                 self.map:del(section, self.option)               -- delete "ipv6_interface" helper
1082                 return self.map:set(section, "interface", value) -- and write "interface"
1083         end
1084 end
1085 function eif6.parse(self, section, novld)
1086         DDNS.value_parse(self, section, novld)
1087 end
1088
1089 -- IPv4/IPv6 - bind_network -- ################################################
1090 if DDNS.has_bindnet or ( ( m:get(section, "bind_network") or "" ) ~= "" ) then
1091         bnet = ns:taboption("advanced", ListValue, "bind_network",
1092                 translate("Bind Network") )
1093         bnet:depends("ipv4_source", "web")
1094         bnet:depends("ipv6_source", "web")
1095         bnet.default = ""
1096         bnet:value("", translate("-- default --"))
1097         WADM.cbi_add_networks(bnet)
1098         function bnet.cfgvalue(self, section)
1099                 local value = AbstractValue.cfgvalue(self, section)
1100                 if not DDNS.has_bindnet and value ~= "" then
1101                         self.description = bold_on .. font_red ..
1102                                 translate("Binding to a specific network not supported") .. font_off .. "<br />" ..
1103                                 translate("please set to 'default'") .. " !" .. bold_off
1104                 else
1105                         self.description = translate("OPTIONAL: Network to use for communication") ..
1106                                 "<br />" .. translate("Casual users should not change this setting")
1107                 end
1108                 return value
1109         end
1110         function bnet.validate(self, value)
1111                 if ( (value ~= "") and DDNS.has_bindnet ) or (value == "") then return value end
1112                 return nil, err_tab_adv(self) .. translate("Binding to a specific network not supported") .. " !"
1113         end
1114         function bnet.parse(self, section, novld)
1115                 DDNS.value_parse(self, section, novld)
1116         end
1117 end
1118
1119 -- IPv4 + IPv6 - force_ipversion -- ###########################################
1120 -- optional to force wget/curl and host to use only selected IP version
1121 -- command parameter "-4" or "-6"
1122 if DDNS.has_forceip or ( ( m:get(section, "force_ipversion") or "0" ) ~= "0" ) then
1123         fipv = ns:taboption("advanced", Flag, "force_ipversion",
1124                 translate("Force IP Version") )
1125         fipv.orientation = "horizontal"
1126         function fipv.cfgvalue(self, section)
1127                 local value = AbstractValue.cfgvalue(self, section)
1128                 if not DDNS.has_forceip and value ~= "0" then
1129                         self.description = bold_on .. font_red ..
1130                                 translate("Force IP Version not supported") .. font_off .. "<br />" ..
1131                                 translate("please disable") .. " !" .. bold_off
1132                 else
1133                         self.description = translate("OPTIONAL: Force the usage of pure IPv4/IPv6 only communication.")
1134                 end
1135                 return value
1136         end
1137         function fipv.validate(self, value)
1138                 if (value == "1" and DDNS.has_forceip) or value == "0" then return value end
1139                 return nil, err_tab_adv(self) .. translate("Force IP Version not supported")
1140         end
1141 end
1142
1143 -- IPv4 + IPv6 - dns_server -- ################################################
1144 -- optional DNS Server to use resolving my IP
1145 if DDNS.has_dnsserver or ( ( m:get(section, "dns_server") or "" ) ~= "" ) then
1146         dns = ns:taboption("advanced", Value, "dns_server",
1147                 translate("DNS-Server"),
1148                 translate("OPTIONAL: Use non-default DNS-Server to detect 'Registered IP'.") .. "<br />" ..
1149                 translate("Format: IP or FQDN"))
1150         dns.placeholder = "mydns.lan"
1151         function dns.validate(self, value)
1152                 -- if .datatype is set, then it is checked before calling this function
1153                 if not value or (#value == 0) then
1154                         return ""       -- ignore on empty
1155                 elseif not DDNS.has_dnsserver then
1156                         return nil, err_tab_adv(self) .. translate("Specifying a DNS-Server is not supported")
1157                 elseif not DTYP.host(value) then
1158                         return nil, err_tab_adv(self) .. translate("use hostname, FQDN, IPv4- or IPv6-Address")
1159                 else
1160                         local ipv6  = usev6:formvalue(section) or "0"
1161                         local force = fipv:formvalue(section)  or "0"
1162                         local command = CTRL.luci_helper .. [[ -]]
1163                         if (ipv6 == 1)  then command = command .. [[6]] end
1164                         if (force == 1) then command = command .. [[f]] end
1165                         command = command .. [[d ]] .. value .. [[ -- verify_dns]]
1166
1167                         local ret = SYS.call(command)
1168                         if     ret == 0 then return value       -- everything OK
1169                         elseif ret == 2 then return nil, err_tab_adv(self) .. translate("nslookup can not resolve host")
1170                         elseif ret == 3 then return nil, err_tab_adv(self) .. translate("nc (netcat) can not connect")
1171                         elseif ret == 4 then return nil, err_tab_adv(self) .. translate("Forced IP Version don't matched")
1172                         else                 return nil, err_tab_adv(self) .. translate("unspecific error")
1173                         end
1174                 end
1175         end
1176         function dns.parse(self, section, novld)
1177                 DDNS.value_parse(self, section, novld)
1178         end
1179 end
1180
1181 -- IPv4 + IPv6 - force_dnstcp -- ##############################################
1182 if DDNS.has_bindhost or ( ( m:get(section, "force_dnstcp") or "0" ) ~= "0" ) then
1183         tcp = ns:taboption("advanced", Flag, "force_dnstcp",
1184                 translate("Force TCP on DNS") )
1185         tcp.orientation = "horizontal"
1186         function tcp.cfgvalue(self, section)
1187                 local value = AbstractValue.cfgvalue(self, section)
1188                 if not DDNS.has_bindhost and value ~= "0" then
1189                         self.description = bold_on .. font_red ..
1190                                 translate("DNS requests via TCP not supported") .. font_off .. "<br />" ..
1191                                 translate("please disable") .. " !" .. bold_off
1192                 else
1193                         self.description = translate("OPTIONAL: Force the use of TCP instead of default UDP on DNS requests.")
1194                 end
1195                 return value
1196         end
1197         function tcp.validate(self, value)
1198                 if (value == "1" and DDNS.has_bindhost ) or value == "0" then
1199                         return value
1200                 end
1201                 return nil, err_tab_adv(self) .. translate("DNS requests via TCP not supported")
1202         end
1203 end
1204
1205 -- IPv4 + IPv6 - proxy -- #####################################################
1206 -- optional Proxy to use for http/https requests  [user:password@]proxyhost[:port]
1207 if DDNS.has_proxy or ( ( m:get(section, "proxy") or "" ) ~= "" ) then
1208         pxy = ns:taboption("advanced", Value, "proxy",
1209                 translate("PROXY-Server") )
1210         pxy.placeholder="user:password@myproxy.lan:8080"
1211         function pxy.cfgvalue(self, section)
1212                 local value = AbstractValue.cfgvalue(self, section)
1213                 if not DDNS.has_proxy and value ~= "" then
1214                         self.description = bold_on .. font_red ..
1215                                 translate("PROXY-Server not supported") .. font_off .. "<br />" ..
1216                                 translate("please remove entry") .. "!" .. bold_off
1217                 else
1218                         self.description = translate("OPTIONAL: Proxy-Server for detection and updates.") .. "<br />" ..
1219                                 translate("Format") .. ": " .. bold_on .. "[user:password@]proxyhost:port" .. bold_off .. "<br />" ..
1220                                 translate("IPv6 address must be given in square brackets") .. ": " ..
1221                                 bold_on .. " [2001:db8::1]:8080" .. bold_off
1222                 end
1223                 return value
1224         end
1225         function pxy.validate(self, value)
1226                 -- if .datatype is set, then it is checked before calling this function
1227                 if not value or (#value == 0) then
1228                         return ""       -- ignore on empty
1229                 elseif DDNS.has_proxy then
1230                         local ipv6  = usev6:formvalue(section) or "0"
1231                         local force = fipv:formvalue(section) or "0"
1232                         local command = CRTL.luci_helper .. [[ -]]
1233                         if (ipv6 == 1)  then command = command .. [[6]] end
1234                         if (force == 1) then command = command .. [[f]] end
1235                         command = command .. [[p ]] .. value .. [[ -- verify_proxy]]
1236                         local ret = SYS.call(command)
1237                         if     ret == 0 then return value
1238                         elseif ret == 2 then return nil, err_tab_adv(self) .. translate("nslookup can not resolve host")
1239                         elseif ret == 3 then return nil, err_tab_adv(self) .. translate("nc (netcat) can not connect")
1240                         elseif ret == 4 then return nil, err_tab_adv(self) .. translate("Forced IP Version don't matched")
1241                         elseif ret == 5 then return nil, err_tab_adv(self) .. translate("proxy port missing")
1242                         else                 return nil, err_tab_adv(self) .. translate("unspecific error")
1243                         end
1244                 else
1245                         return nil, err_tab_adv(self) .. translate("PROXY-Server not supported")
1246                 end
1247         end
1248         function pxy.parse(self, section, novld)
1249                 DDNS.value_parse(self, section, novld)
1250         end
1251 end
1252
1253 -- use_syslog -- ##############################################################
1254 slog = ns:taboption("advanced", ListValue, "use_syslog",
1255         translate("Log to syslog"),
1256         translate("Writes log messages to syslog. Critical Errors will always be written to syslog.") )
1257 slog.default = "2"
1258 slog:value("0", translate("No logging"))
1259 slog:value("1", translate("Info"))
1260 slog:value("2", translate("Notice"))
1261 slog:value("3", translate("Warning"))
1262 slog:value("4", translate("Error"))
1263 function slog.parse(self, section, novld)
1264         DDNS.value_parse(self, section, novld)
1265 end
1266
1267 -- use_logfile -- #############################################################
1268 logf = ns:taboption("advanced", Flag, "use_logfile",
1269         translate("Log to file"),
1270         translate("Writes detailed messages to log file. File will be truncated automatically.") .. "<br />" ..
1271         translate("File") .. [[: "]] .. logdir .. [[/]] .. section .. [[.log"]] )
1272 logf.orientation = "horizontal"
1273 logf.default     = "1"          -- if not defined write to log by default
1274
1275 -- TAB: Timer  ####################################################################################
1276 -- check_interval -- ##########################################################
1277 ci = ns:taboption("timer", Value, "check_interval",
1278         translate("Check Interval") )
1279 ci.template = "ddns/detail_value"
1280 ci.default  = "10"
1281 function ci.validate(self, value)
1282         if not DTYP.uinteger(value)
1283         or tonumber(value) < 1 then
1284                 return nil, err_tab_timer(self) .. translate("minimum value 5 minutes == 300 seconds")
1285         end
1286
1287         local secs = DDNS.calc_seconds(value, cu:formvalue(section))
1288         if secs >= 300 then
1289                 return value
1290         else
1291                 return nil, err_tab_timer(self) .. translate("minimum value 5 minutes == 300 seconds")
1292         end
1293 end
1294 function ci.write(self, section, value)
1295         -- remove when default
1296         local secs = DDNS.calc_seconds(value, cu:formvalue(section))
1297         if secs ~= 600 then     --default 10 minutes
1298                 return self.map:set(section, self.option, value)
1299         else
1300                 self.map:del(section, "check_unit")
1301                 return self.map:del(section, self.option)
1302         end
1303 end
1304 function ci.parse(self, section, novld)
1305         DDNS.value_parse(self, section, novld)
1306 end
1307
1308 -- check_unit -- ##############################################################
1309 cu = ns:taboption("timer", ListValue, "check_unit", "not displayed, but needed otherwise error",
1310         translate("Interval to check for changed IP" .. "<br />" ..
1311                 "Values below 5 minutes == 300 seconds are not supported") )
1312 cu.template = "ddns/detail_lvalue"
1313 cu.default  = "minutes"
1314 cu:value("seconds", translate("seconds"))
1315 cu:value("minutes", translate("minutes"))
1316 cu:value("hours", translate("hours"))
1317 --cu:value("days", translate("days"))
1318 function cu.write(self, section, value)
1319         -- remove when default
1320         local secs = DDNS.calc_seconds(ci:formvalue(section), value)
1321         if secs ~= 600 then     --default 10 minutes
1322                 return self.map:set(section, self.option, value)
1323         else
1324                 return true
1325         end
1326 end
1327 function cu.parse(self, section, novld)
1328         DDNS.value_parse(self, section, novld)
1329 end
1330
1331 -- force_interval (modified) -- ###############################################
1332 fi = ns:taboption("timer", Value, "force_interval",
1333         translate("Force Interval") )
1334 fi.template = "ddns/detail_value"
1335 fi.default  = "72"      -- see dynamic_dns_updater.sh script
1336 --fi.rmempty = false    -- validate ourselves for translatable error messages
1337 function fi.validate(self, value)
1338         if not DTYP.uinteger(value)
1339         or tonumber(value) < 0 then
1340                 return nil, err_tab_timer(self) .. translate("minimum value '0'")
1341         end
1342
1343         local force_s = DDNS.calc_seconds(value, fu:formvalue(section))
1344         if force_s == 0 then
1345                 return value
1346         end
1347
1348         local ci_value = ci:formvalue(section)
1349         if not DTYP.uinteger(ci_value) then
1350                 return ""       -- ignore because error in check_interval above
1351         end
1352
1353         local check_s = DDNS.calc_seconds(ci_value, cu:formvalue(section))
1354         if force_s >= check_s then
1355                 return value
1356         end
1357
1358         return nil, err_tab_timer(self) .. translate("must be greater or equal 'Check Interval'")
1359 end
1360 function fi.write(self, section, value)
1361         -- simulate rmempty=true remove default
1362         local secs = DDNS.calc_seconds(value, fu:formvalue(section))
1363         if secs ~= 259200 then  --default 72 hours == 3 days
1364                 return self.map:set(section, self.option, value)
1365         else
1366                 self.map:del(section, "force_unit")
1367                 return self.map:del(section, self.option)
1368         end
1369 end
1370 function fi.parse(self, section, novld)
1371         DDNS.value_parse(self, section, novld)
1372 end
1373
1374 -- force_unit -- ##############################################################
1375 fu = ns:taboption("timer", ListValue, "force_unit", "not displayed, but needed otherwise error",
1376         translate("Interval to force updates send to DDNS Provider" .. "<br />" ..
1377                 "Setting this parameter to 0 will force the script to only run once" .. "<br />" ..
1378                 "Values lower 'Check Interval' except '0' are not supported") )
1379 fu.template = "ddns/detail_lvalue"
1380 fu.default  = "hours"
1381 --fu.rmempty  = false   -- want to control write process
1382 --fu:value("seconds", translate("seconds"))
1383 fu:value("minutes", translate("minutes"))
1384 fu:value("hours", translate("hours"))
1385 fu:value("days", translate("days"))
1386 function fu.write(self, section, value)
1387         -- simulate rmempty=true remove default
1388         local secs = DDNS.calc_seconds(fi:formvalue(section), value)
1389         if secs ~= 259200 and secs ~= 0 then    --default 72 hours == 3 days
1390                 return self.map:set(section, self.option, value)
1391         else
1392                 return true
1393         end
1394 end
1395 function fu.parse(self, section, novld)
1396         DDNS.value_parse(self, section, novld)
1397 end
1398
1399 -- retry_count -- #############################################################
1400 rc = ns:taboption("timer", Value, "retry_count")
1401 rc.title        = translate("Error Retry Counter")
1402 rc.description  = translate("On Error the script will stop execution after given number of retrys")
1403                 .. "<br />"
1404                 .. translate("The default setting of '0' will retry infinite.")
1405 rc.default      = "0"
1406 function rc.validate(self, value)
1407         if not DTYP.uinteger(value) then
1408                 return nil, err_tab_timer(self) .. translate("minimum value '0'")
1409         else
1410                 return value
1411         end
1412 end
1413 function rc.parse(self, section, novld)
1414         DDNS.value_parse(self, section, novld)
1415 end
1416
1417 -- retry_interval -- ##########################################################
1418 ri = ns:taboption("timer", Value, "retry_interval",
1419         translate("Error Retry Interval") )
1420 ri.template = "ddns/detail_value"
1421 ri.default  = "60"
1422 function ri.validate(self, value)
1423         if not DTYP.uinteger(value)
1424         or tonumber(value) < 1 then
1425                 return nil, err_tab_timer(self) .. translate("minimum value '1'")
1426         else
1427                 return value
1428         end
1429 end
1430 function ri.write(self, section, value)
1431         -- simulate rmempty=true remove default
1432         local secs = DDNS.calc_seconds(value, ru:formvalue(section))
1433         if secs ~= 60 then      --default 60seconds
1434                 return self.map:set(section, self.option, value)
1435         else
1436                 self.map:del(section, "retry_unit")
1437                 return self.map:del(section, self.option)
1438         end
1439 end
1440 function ri.parse(self, section, novld)
1441         DDNS.value_parse(self, section, novld)
1442 end
1443
1444 -- retry_unit -- ##############################################################
1445 ru = ns:taboption("timer", ListValue, "retry_unit", "not displayed, but needed otherwise error",
1446         translate("On Error the script will retry the failed action after given time") )
1447 ru.template = "ddns/detail_lvalue"
1448 ru.default  = "seconds"
1449 --ru.rmempty  = false   -- want to control write process
1450 ru:value("seconds", translate("seconds"))
1451 ru:value("minutes", translate("minutes"))
1452 --ru:value("hours", translate("hours"))
1453 --ru:value("days", translate("days"))
1454 function ru.write(self, section, value)
1455         -- simulate rmempty=true remove default
1456         local secs = DDNS.calc_seconds(ri:formvalue(section), value)
1457         if secs ~= 60 then      --default 60seconds
1458                 return self.map:set(section, self.option, value)
1459         else
1460                 return true -- will be deleted by retry_interval
1461         end
1462 end
1463 function ru.parse(self, section, novld)
1464         DDNS.value_parse(self, section, novld)
1465 end
1466
1467 -- TAB: LogView  ##################################################################################
1468 lv = ns:taboption("logview", DummyValue, "_logview")
1469 lv.template = "ddns/detail_logview"
1470 lv.inputtitle = translate("Read / Reread log file")
1471 lv.rows = 50
1472 function lv.cfgvalue(self, section)
1473         local lfile=logdir .. "/" .. section .. ".log"
1474         if NXFS.access(lfile) then
1475                 return lfile .. "\n" .. translate("Please press [Read] button")
1476         end
1477         return lfile .. "\n" .. translate("File not found or empty")
1478 end
1479
1480 return m