applications/luci-ddns/luasrc/model/cbi/ddns/detail.lua

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