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