diff options
Diffstat (limited to 'applications/luci-ddns/luasrc/model')
4 files changed, 1555 insertions, 0 deletions
diff --git a/applications/luci-ddns/luasrc/model/cbi/ddns/ddns.lua b/applications/luci-ddns/luasrc/model/cbi/ddns/ddns.lua index f318b1be54..1c7e04a96e 100644 --- a/applications/luci-ddns/luasrc/model/cbi/ddns/ddns.lua +++ b/applications/luci-ddns/luasrc/model/cbi/ddns/ddns.lua @@ -26,6 +26,10 @@ s.anonymous = false s:option(Flag, "enabled", translate("Enable")) +interface = s:option(ListValue, "interface", translate("Event interface"), translate("Network on which the ddns-updater scripts will be started")) +luci.tools.webadmin.cbi_add_networks(interface) +interface.default = "wan" + svc = s:option(ListValue, "service_name", translate("Service")) svc.rmempty = false svc.default = "dyndns.org" diff --git a/applications/luci-ddns/luasrc/model/cbi/ddns/detail.lua b/applications/luci-ddns/luasrc/model/cbi/ddns/detail.lua new file mode 100644 index 0000000000..c8d10f29b0 --- /dev/null +++ b/applications/luci-ddns/luasrc/model/cbi/ddns/detail.lua @@ -0,0 +1,1198 @@ +--[[ +LuCI - Lua Configuration Interface + +A lot of code taken from original ddns.lua cbi-model made by +Copyright 2008 Steven Barth <steven@midlink.org> +Copyright 2008 Jo-Philipp Wich <xm@leipzig.freifunk.net> +Copyright 2013 Manuel Munz <freifunk at somakoma dot de> + +modified to use as detail page together with new overview page and +extensions for IPv6, HTTPS settings, syslog and log settings, +optional Proxy-Support, optional DNS-Server, optional use of TCP requests to DNS server, +optional force of IP protocol version usage +Copyright 2014 Christian Schoenebeck <christian dot schoenebeck at gmail dot com> + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +$Id$ +]]-- + +require "luci.dispatcher" +require "nixio.fs" +require "luci.sys" +require "luci.tools.webadmin" +require "luci.cbi.datatypes" +require "luci.tools.ddns" -- ddns multiused functions + +-- takeover arguments +section = arg[1] + +-- check supported options +-- saved to local vars here because doing multiple os calls slow down the system +has_ipv6 = luci.tools.ddns.check_ipv6() -- IPv6 support +has_ssl = luci.tools.ddns.check_ssl() -- HTTPS support +has_proxy = luci.tools.ddns.check_proxy() -- Proxy support +has_dnstcp = luci.tools.ddns.check_bind_host() -- DNS TCP support +has_force = has_ssl and has_dnstcp -- Force IP Protocoll + +-- html constants +font_red = "<font color='red'>" +font_off = "</font>" +bold_on = "<strong>" +bold_off = "</strong>" + +-- error text constants +err_ipv6_plain = translate("IPv6 not supported") .. " - " .. + translate("please select 'IPv4' address version") +err_ipv6_basic = bold_on .. + font_red .. + translate("IPv6 not supported") .. + font_off .. + "<br />" .. translate("please select 'IPv4' address version") .. + bold_off +err_ipv6_other = bold_on .. + font_red .. + translate("IPv6 not supported") .. + font_off .. + "<br />" .. translate("please select 'IPv4' address version in") .. " " .. + [[<a href="]] .. + luci.dispatcher.build_url("admin", "services", "ddns", "detail", section) .. + "?tab.dns." .. section .. "=basic" .. + [[">]] .. + translate("Basic Settings") .. + [[</a>]] .. + bold_off + +function err_tab_basic(self) + return translate("Basic Settings") .. " - " .. self.title .. ": " +end +function err_tab_adv(self) + return translate("Advanced Settings") .. " - " .. self.title .. ": " +end +function err_tab_timer(self) + return translate("Timer Settings") .. " - " .. self.title .. ": " +end + +-- function to verify settings around ip_source +-- will use dynamic_dns_lucihelper to check if +-- local IP can be read +local function _verify_ip_source() + -- section is globally defined here be calling agrument (see above) + local _network = "-" + local _url = "-" + local _interface = "-" + local _script = "-" + local _proxy = "" + + local _ipv6 = usev6:formvalue(section) + local _source = (_ipv6 == "1") + and src6:formvalue(section) + or src4:formvalue(section) + if _source == "network" then + _network = (_ipv6 == "1") + and ipn6:formvalue(section) + or ipn4:formvalue(section) + elseif _source == "web" then + _url = (_ipv6 == "1") + and iurl6:formvalue(section) + or iurl4:formvalue(section) + -- proxy only needed for checking url + _proxy = (pxy) and pxy:formvalue(section) or "" + elseif _source == "interface" then + _interface = ipi:formvalue(section) + elseif _source == "script" then + _script = ips:formvalue(section) + end + + local command = [[/usr/lib/ddns/dynamic_dns_lucihelper.sh get_local_ip ]] .. + _ipv6 .. [[ ]] .. _source .. [[ ]] .. _network .. [[ ]] .. + _url .. [[ ]] .. _interface .. [[ ]] .. _script.. [[ ]] .. _proxy + local ret = luci.sys.call(command) + + if ret == 0 then + return true -- valid + else + return nil -- invalid + end +end + +-- cbi-map definition +m = Map("ddns") + +m.title = [[<a href="]] .. luci.dispatcher.build_url("admin", "services", "ddns") .. [[">]] .. + translate("Dynamic DNS") .. [[</a>]] + +m.description = translate("Dynamic DNS allows that your router can be reached with " .. + "a fixed hostname while having a dynamically changing " .. + "IP address.") + +m.redirect = luci.dispatcher.build_url("admin", "services", "ddns") + +-- read application settings +-- date format; if not set use ISO format +date_format = m.uci:get(m.config, "global", "date_format") or "%F %R" +-- log directory +log_dir = m.uci:get(m.config, "global", "log_dir") or "/var/log/ddns" + +-- cbi-section definition +ns = m:section( NamedSection, section, "service", + translate("Details for") .. ([[: <strong>%s</strong>]] % section), + translate("Configure here the details for selected Dynamic DNS service") ) +ns.instance = section -- arg [1] +ns:tab("basic", translate("Basic Settings"), nil ) +ns:tab("advanced", translate("Advanced Settings"), nil ) +ns:tab("timer", translate("Timer Settings"), nil ) +ns:tab("logview", translate("Log File Viewer"), nil ) + +-- TAB: Basic ################################################################## +-- enabled +en = ns:taboption("basic", Flag, "enabled", + translate("Enabled"), + translate("If this service section is disabled it could not be started." .. "<br />" .. + "Neither from LuCI interface nor from console") ) +en.orientation = "horizontal" + +-- use_ipv6 (NEW) +usev6 = ns:taboption("basic", ListValue, "use_ipv6", + translate("IP address version"), + translate("Defines which IP address 'IPv4/IPv6' is send to the DDNS provider") ) +usev6.widget = "radio" +usev6.default = "0" +usev6:value("0", translate("IPv4-Address") ) +function usev6.cfgvalue(self, section) + local value = AbstractValue.cfgvalue(self, section) + if has_ipv6 or (value == "1" and not has_ipv6) then + self:value("1", translate("IPv6-Address") ) + end + if value == "1" and not has_ipv6 then + self.description = err_ipv6_basic + end + return value +end +function usev6.validate(self, value) + if (value == "1" and has_ipv6) or value == "0" then + return value + end + return nil, err_tab_basic(self) .. err_ipv6_plain +end +function usev6.write(self, section, value) + if value == "0" then -- force rmempty + return self.map:del(section, self.option) + else + return self.map:set(section, self.option, value) + end +end + +-- IPv4 - service_name +svc4 = ns:taboption("basic", ListValue, "ipv4_service_name", + translate("DDNS Service provider") .. " [IPv4]" ) +svc4.default = "-" +svc4:depends("use_ipv6", "0") -- only show on IPv4 + +local services4 = { } +local fd4 = io.open("/usr/lib/ddns/services", "r") + +if fd4 then + local ln + repeat + ln = fd4:read("*l") + local s = ln and ln:match('^%s*"([^"]+)"') + if s then services4[#services4+1] = s end + until not ln + fd4:close() +end + +for _, v in luci.util.vspairs(services4) do svc4:value(v) end +svc4:value("-", translate("-- custom --") ) + +function svc4.cfgvalue(self, section) + local v = luci.tools.ddns.read_value(self, section, "service_name") + if not v or #v == 0 then + return "-" + else + return v + end +end +function svc4.validate(self, value) + if usev6:formvalue(section) == "0" then -- do only on IPv4 + return value + else + return "" -- supress validate error + end +end +function svc4.write(self, section, value) + if usev6:formvalue(section) == "0" then -- do only IPv4 here + self.map:del(section, self.option) -- to be shure + if value ~= "-" then -- and write "service_name + self.map:del(section, "update_url") -- delete update_url + return self.map:set(section, "service_name", value) + else + return self.map:del(section, "service_name") + end + end +end + +-- IPv6 - service_name +svc6 = ns:taboption("basic", ListValue, "ipv6_service_name", + translate("DDNS Service provider") .. " [IPv6]" ) +svc6.default = "-" +svc6:depends("use_ipv6", "1") -- only show on IPv6 +if not has_ipv6 then + svc6.description = err_ipv6_basic +end + +local services6 = { } +local fd6 = io.open("/usr/lib/ddns/services_ipv6", "r") + +if fd6 then + local ln + repeat + ln = fd6:read("*l") + local s = ln and ln:match('^%s*"([^"]+)"') + if s then services6[#services6+1] = s end + until not ln + fd6:close() +end + +for _, v in luci.util.vspairs(services6) do svc6:value(v) end +svc6:value("-", translate("-- custom --") ) + +function svc6.cfgvalue(self, section) + local v = luci.tools.ddns.read_value(self, section, "service_name") + if not v or #v == 0 then + return "-" + else + return v + end +end +function svc6.validate(self, value) + if usev6:formvalue(section) == "1" then -- do only on IPv6 + if has_ipv6 then return value end + return nil, err_tab_basic(self) .. err_ipv6_plain + else + return "" -- supress validate error + end +end +function svc6.write(self, section, value) + if usev6:formvalue(section) == "1" then -- do only when IPv6 + self.map:del(section, self.option) -- delete "ipv6_service_name" helper + if value ~= "-" then -- and write "service_name + self.map:del(section, "update_url") -- delete update_url + return self.map:set(section, "service_name", value) + else + return self.map:del(section, "service_name") + end + end +end + +-- IPv4/IPv6 - update_url +uurl = ns:taboption("basic", Value, "update_url", + translate("Custom update-URL"), + translate("Update URL to be used for updating your DDNS Provider." .. "<br />" .. + "Follow instructions you will find on their WEB page.") ) +uurl:depends("ipv4_service_name", "-") +uurl:depends("ipv6_service_name", "-") +function uurl.validate(self, value) + local script = ush:formvalue(section) + + if (usev6:formvalue(section) == "0" and svc4:formvalue(section) ~= "-") or + (usev6:formvalue(section) == "1" and svc6:formvalue(section) ~= "-") then + return "" -- suppress validate error + elseif not value then + if not script or not (#script > 0) then + return nil, err_tab_basic(self) .. translate("missing / required") + else + return "" -- suppress validate error / update_script is given + end + elseif (#script > 0) then + return nil, err_tab_basic(self) .. translate("either url or script could be set") + end + + local url = luci.tools.ddns.parse_url(value) + if not url.scheme == "http" then + return nil, err_tab_basic(self) .. translate("must start with 'http://'") + elseif not url.query then + return nil, err_tab_basic(self) .. "<QUERY> " .. translate("missing / required") + elseif not url.host then + return nil, err_tab_basic(self) .. "<HOST> " .. translate("missing / required") + elseif luci.sys.call([[nslookup ]] .. url.host .. [[ >/dev/null 2>&1]]) ~= 0 then + return nil, err_tab_basic(self) .. translate("can not resolve host: ") .. url.host + end + + return value +end + +-- IPv4/IPv6 - update_script +ush = ns:taboption("basic", Value, "update_script", + translate("Custom update-script"), + translate("Custom update script to be used for updating your DDNS Provider.") ) +ush:depends("ipv4_service_name", "-") +ush:depends("ipv6_service_name", "-") +function ush.validate(self, value) + local url = uurl:formvalue(section) + + if (usev6:formvalue(section) == "0" and svc4:formvalue(section) ~= "-") or + (usev6:formvalue(section) == "1" and svc6:formvalue(section) ~= "-") then + return "" -- suppress validate error + elseif not value then + if not url or not (#url > 0) then + return nil, err_tab_basic(self) .. translate("missing / required") + else + return "" -- suppress validate error / update_url is given + end + elseif (#url > 0) then + return nil, err_tab_basic(self) .. translate("either url or script could be set") + elseif not nixio.fs.access(value) then + return nil, err_tab_basic(self) .. translate("File not found") + end + return value +end + +-- IPv4/IPv6 - domain +dom = ns:taboption("basic", Value, "domain", + translate("Hostname/Domain"), + translate("Replaces [DOMAIN] in Update-URL") ) +dom.rmempty = false +dom.placeholder = "mypersonaldomain.dyndns.org" +function dom.validate(self, value) + if not value + or not (#value > 0) + or not luci.cbi.datatypes.hostname(value) then + return nil, err_tab_basic(self) .. translate("invalid - Sample") .. ": 'mypersonaldomain.dyndns.org'" + else + return value + end +end + +-- IPv4/IPv6 - username +user = ns:taboption("basic", Value, "username", + translate("Username"), + translate("Replaces [USERNAME] in Update-URL") ) +user.rmempty = false +function user.validate(self, value) + if not value then + return nil, err_tab_basic(self) .. translate("missing / required") + end + return value +end + +-- IPv4/IPv6 - password +pw = ns:taboption("basic", Value, "password", + translate("Password"), + translate("Replaces [PASSWORD] in Update-URL") ) +pw.rmempty = false +pw.password = true +function pw.validate(self, value) + if not value then + return nil, err_tab_basic(self) .. translate("missing / required") + end + return value +end + +-- IPv4/IPv6 - use_https (NEW) +if has_ssl or ( ( m:get(section, "use_https") or "0" ) == "1" ) then + https = ns:taboption("basic", Flag, "use_https", + translate("Use HTTP Secure") ) + https.orientation = "horizontal" + https.rmempty = false -- force validate function + function https.cfgvalue(self, section) + local value = AbstractValue.cfgvalue(self, section) + if not has_ssl and value == "1" then + self.description = bold_on .. font_red .. + translate("HTTPS not supported") .. font_off .. "<br />" .. + translate("please disable") .. " !" .. bold_off + else + self.description = translate("Enable secure communication with DDNS provider") + end + return value + end + function https.validate(self, value) + if (value == "1" and has_ssl ) or value == "0" then return value end + return nil, err_tab_basic(self) .. translate("HTTPS not supported") .. " !" + end + function https.write(self, section, value) + if value == "1" then + return self.map:set(section, self.option, value) + else + self.map:del(section, "cacert") + return self.map:del(section, self.option) + end + end +end + +-- IPv4/IPv6 - cacert (NEW) +if has_ssl then + cert = ns:taboption("basic", Value, "cacert", + translate("Path to CA-Certificate"), + translate("directory or path/file") .. "<br />" .. + translate("or") .. bold_on .. " IGNORE " .. bold_off .. + translate("to run HTTPS without verification of server certificates (insecure)") ) + cert:depends("use_https", "1") + cert.rmempty = false -- force validate function + cert.default = "/etc/ssl/certs" + function cert.validate(self, value) + if https:formvalue(section) == "0" then + return "" -- supress validate error if NOT https + end + if value then -- otherwise errors in datatype check + if luci.cbi.datatypes.directory(value) + or luci.cbi.datatypes.file(value) + or value == "IGNORE" then + return value + end + end + return nil, err_tab_basic(self) .. + translate("file or directory not found or not 'IGNORE'") .. " !" + end +end + +-- use_syslog +slog = ns:taboption("basic", ListValue, "use_syslog", + translate("Log to syslog"), + translate("Writes log messages to syslog. Critical Errors will always be written to syslog.") ) +slog.default = "0" +slog:value("0", translate("No logging")) +slog:value("1", translate("Info")) +slog:value("2", translate("Notice")) +slog:value("3", translate("Warning")) +slog:value("4", translate("Error")) + +-- use_logfile (NEW) +logf = ns:taboption("basic", Flag, "use_logfile", + translate("Log to file"), + translate("Writes detailed messages to log file. File will be truncated automatically.") .. "<br />" .. + translate("File") .. [[: "]] .. log_dir .. [[/]] .. section .. [[.log"]] ) +logf.orientation = "horizontal" +logf.rmempty = false -- we want to save in /etc/config/ddns file on "0" because +logf.default = "1" -- if not defined write to log by default + +-- TAB: Advanced ############################################################## +-- IPv4 - ip_source +src4 = ns:taboption("advanced", ListValue, "ipv4_source", + translate("IP address source") .. " [IPv4]", + translate("Defines the source to read systems IPv4-Address from, that will be send to the DDNS provider") ) +src4:depends("use_ipv6", "0") -- IPv4 selected +src4.default = "network" +src4:value("network", translate("Network")) +src4:value("web", translate("URL")) +src4:value("interface", translate("Interface")) +src4:value("script", translate("Script")) +function src4.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "ip_source") +end +function src4.validate(self, value) + if usev6:formvalue(section) == "1" then + return "" -- ignore on IPv6 selected + elseif not _verify_ip_source() then + return nil, err_tab_adv(self) .. + translate("can not detect local IP. Please select a different Source combination") + else + return value + end +end +function src4.write(self, section, value) + if usev6:formvalue(section) == "1" then + return true -- ignore on IPv6 selected + elseif value == "network" then + self.map:del(section, "ip_url") -- delete not need parameters + self.map:del(section, "ip_interface") + self.map:del(section, "ip_script") + elseif value == "web" then + self.map:del(section, "ip_network") -- delete not need parameters + self.map:del(section, "ip_interface") + self.map:del(section, "ip_script") + elseif value == "interface" then + self.map:del(section, "ip_network") -- delete not need parameters + self.map:del(section, "ip_url") + self.map:del(section, "ip_script") + elseif value == "script" then + self.map:del(section, "ip_network") + self.map:del(section, "ip_url") -- delete not need parameters + self.map:del(section, "ip_interface") + end + self.map:del(section, self.option) -- delete "ipv4_source" helper + return self.map:set(section, "ip_source", value) -- and write "ip_source +end + +-- IPv6 - ip_source +src6 = ns:taboption("advanced", ListValue, "ipv6_source", + translate("IP address source") .. " [IPv6]", + translate("Defines the source to read systems IPv6-Address from, that will be send to the DDNS provider") ) +src6:depends("use_ipv6", 1) -- IPv6 selected +src6.default = "network" +src6:value("network", translate("Network")) +src6:value("web", translate("URL")) +src6:value("interface", translate("Interface")) +src6:value("script", translate("Script")) +if not has_ipv6 then + src6.description = err_ipv6_other +end +function src6.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "ip_source") +end +function src6.validate(self, value) + if usev6:formvalue(section) == "0" then + return "" -- ignore on IPv4 selected + elseif not has_ipv6 then + return nil, err_tab_adv(self) .. err_ipv6_plain + elseif not _verify_ip_source() then + return nil, err_tab_adv(self) .. + translate("can not detect local IP. Please select a different Source combination") + else + return value + end +end +function src6.write(self, section, value) + if usev6:formvalue(section) == "0" then + return true -- ignore on IPv4 selected + elseif value == "network" then + self.map:del(section, "ip_url") -- delete not need parameters + self.map:del(section, "ip_interface") + self.map:del(section, "ip_script") + elseif value == "web" then + self.map:del(section, "ip_network") -- delete not need parameters + self.map:del(section, "ip_interface") + self.map:del(section, "ip_script") + elseif value == "interface" then + self.map:del(section, "ip_network") -- delete not need parameters + self.map:del(section, "ip_url") + self.map:del(section, "ip_script") + elseif value == "script" then + self.map:del(section, "ip_network") + self.map:del(section, "ip_url") -- delete not need parameters + self.map:del(section, "ip_interface") + end + self.map:del(section, self.option) -- delete "ipv4_source" helper + return self.map:set(section, "ip_source", value) -- and write "ip_source +end + +-- IPv4 - ip_network (default "wan") +ipn4 = ns:taboption("advanced", ListValue, "ipv4_network", + translate("Network") .. " [IPv4]", + translate("Defines the network to read systems IPv4-Address from") ) +ipn4:depends("ipv4_source", "network") +ipn4.default = "wan" +luci.tools.webadmin.cbi_add_networks(ipn4) +function ipn4.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "ip_network") +end +function ipn4.validate(self, value) + if usev6:formvalue(section) == "1" + or src4:formvalue(section) ~= "network" then + -- ignore if IPv6 selected OR + -- ignore everything except "network" + return "" + else + return value + end +end +function ipn4.write(self, section, value) + if usev6:formvalue(section) == "1" + or src4:formvalue(section) ~= "network" then + -- ignore if IPv6 selected OR + -- ignore everything except "network" + return true + else + -- set also as "interface" for monitoring events changes/hot-plug + self.map:set(section, "interface", value) + self.map:del(section, self.option) -- delete "ipv4_network" helper + return self.map:set(section, "ip_network", value) -- and write "ip_network" + end +end + +-- IPv6 - ip_network (default "wan6") +ipn6 = ns:taboption("advanced", ListValue, "ipv6_network", + translate("Network") .. " [IPv6]" ) +ipn6:depends("ipv6_source", "network") +ipn6.default = "wan6" +luci.tools.webadmin.cbi_add_networks(ipn6) +if has_ipv6 then + ipn6.description = translate("Defines the network to read systems IPv6-Address from") +else + ipn6.description = err_ipv6_other +end +function ipn6.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "ip_network") +end +function ipn6.validate(self, value) + if usev6:formvalue(section) == "0" + or src6:formvalue(section) ~= "network" then + -- ignore if IPv4 selected OR + -- ignore everything except "network" + return "" + elseif has_ipv6 then + return value + else + return nil, err_tab_adv(self) .. err_ipv6_plain + end +end +function ipn6.write(self, section, value) + if usev6:formvalue(section) == "0" + or src6:formvalue(section) ~= "network" then + -- ignore if IPv4 selected OR + -- ignore everything except "network" + return true + else + -- set also as "interface" for monitoring events changes/hotplug + self.map:set(section, "interface", value) + self.map:del(section, self.option) -- delete "ipv6_network" helper + return self.map:set(section, "ip_network", value) -- and write "ip_network" + end +end + +-- IPv4 - ip_url (default "checkip.dyndns.com") +iurl4 = ns:taboption("advanced", Value, "ipv4_url", + translate("URL to detect") .. " [IPv4]", + translate("Defines the Web page to read systems IPv4-Address from") ) +iurl4:depends("ipv4_source", "web") +iurl4.default = "http://checkip.dyndns.com" +function iurl4.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "ip_url") +end +function iurl4.validate(self, value) + if usev6:formvalue(section) == "1" + or src4:formvalue(section) ~= "web" then + -- ignore if IPv6 selected OR + -- ignore everything except "web" + return "" + elseif not value or #value == 0 then + return nil, err_tab_adv(self) .. translate("missing / required") + end + + local url = luci.tools.ddns.parse_url(value) + if not (url.scheme == "http" or url.scheme == "https") then + return nil, err_tab_adv(self) .. translate("must start with 'http://'") + elseif not url.host then + return nil, err_tab_adv(self) .. "<HOST> " .. translate("missing / required") + elseif luci.sys.call([[nslookup ]] .. + url.host .. + [[>/dev/null 2>&1]]) ~= 0 then + return nil, err_tab_adv(self) .. translate("can not resolve host: ") .. url.host + else + return value + end +end +function iurl4.write(self, section, value) + if usev6:formvalue(section) == "1" + or src4:formvalue(section) ~= "web" then + -- ignore if IPv6 selected OR + -- ignore everything except "web" + return true + else + self.map:del(section, self.option) -- delete "ipv4_url" helper + return self.map:set(section, "ip_url", value) -- and write "ip_url" + end +end + +-- IPv6 - ip_url (default "checkipv6.dyndns.com") +iurl6 = ns:taboption("advanced", Value, "ipv6_url", + translate("URL to detect") .. " [IPv6]" ) +iurl6:depends("ipv6_source", "web") +iurl6.default = "http://checkipv6.dyndns.com" +if has_ipv6 then + iurl6.description = translate("Defines the Web page to read systems IPv6-Address from") +else + iurl6.description = err_ipv6_other +end +function iurl6.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "ip_url") +end +function iurl6.validate(self, value) + if usev6:formvalue(section) == "0" + or src6:formvalue(section) ~= "web" then + -- ignore if IPv4 selected OR + -- ignore everything except "web" + return "" + elseif not has_ipv6 then + return nil, err_tab_adv(self) .. err_ipv6_plain + elseif not value or #value == 0 then + return nil, err_tab_adv(self) .. translate("missing / required") + end + + local url = luci.tools.ddns.parse_url(value) + if not (url.scheme == "http" or url.scheme == "https") then + return nil, err_tab_adv(self) .. translate("must start with 'http://'") + elseif not url.host then + return nil, err_tab_adv(self) .. "<HOST> " .. translate("missing / required") + elseif luci.sys.call([[nslookup ]] .. + url.host .. + [[>/dev/null 2>&1]]) ~= 0 then + return nil, err_tab_adv(self) .. translate("can not resolve host: ") .. url.host + else + return value + end +end +function iurl6.write(self, section, value) + if usev6:formvalue(section) == "0" + or src6:formvalue(section) ~= "web" then + -- ignore if IPv4 selected OR + -- ignore everything except "web" + return true + else + self.map:del(section, self.option) -- delete "ipv6_url" helper + return self.map:set(section, "ip_url", value) -- and write "ip_url" + end +end + +-- IPv4 + IPv6 - ip_interface +ipi = ns:taboption("advanced", ListValue, "ip_interface", + translate("Interface"), + translate("Defines the interface to read systems IP-Address from") ) +ipi:depends("ipv4_source", "interface") -- IPv4 +ipi:depends("ipv6_source", "interface") -- or IPv6 +for _, v in pairs(luci.sys.net.devices()) do + -- show only interface set to a network + -- and ignore loopback + net = luci.tools.webadmin.iface_get_network(v) + if net and net ~= "loopback" then + ipi:value(v) + end +end +function ipi.validate(self, value) + if (usev6:formvalue(section) == "0" and src4:formvalue(section) ~= "interface") + or (usev6:formvalue(section) == "1" and src6:formvalue(section) ~= "interface") then + return "" + else + return value + end +end +function ipi.write(self, section, value) + if (usev6:formvalue(section) == "0" and src4:formvalue(section) ~= "interface") + or (usev6:formvalue(section) == "1" and src6:formvalue(section) ~= "interface") then + return true + else + -- get network from device to + -- set also as "interface" for monitoring events changes/hotplug + local net = luci.tools.webadmin.iface_get_network(value) + self.map:set(section, "interface", net) + return self.map:set(section, self.option, value) + end +end + +-- IPv4 + IPv6 - ip_script (NEW) +ips = ns:taboption("advanced", Value, "ip_script", + translate("Script"), + translate("User defined script to read systems IP-Address") ) +ips:depends("ipv4_source", "script") -- IPv4 +ips:depends("ipv6_source", "script") -- or IPv6 +ips.placeholder = "/path/to/script.sh" +function ips.validate(self, value) + if (usev6:formvalue(section) == "0" and src4:formvalue(section) ~= "script") + or (usev6:formvalue(section) == "1" and src6:formvalue(section) ~= "script") then + return "" + elseif not value or not nixio.fs.access(value, "x") then + return nil, err_tab_adv(self) .. + translate("not found or not executable - Sample: '/path/to/script.sh'") + else + return value + end +end +function ips.write(self, section, value) + if (usev6:formvalue(section) == "0" and src4:formvalue(section) ~= "script") + or (usev6:formvalue(section) == "1" and src6:formvalue(section) ~= "script") then + return true + else + return self.map:set(section, self.option, value) + end +end + +-- IPv4 - interface - default "wan" +-- event network to monitor changes/hotplug/dynamic_dns_updater.sh +-- only needs to be set if "ip_source"="web" or "script" +-- if "ip_source"="network" or "interface" we use their network +eif4 = ns:taboption("advanced", ListValue, "ipv4_interface", + translate("Event Network") .. " [IPv4]", + translate("Network on which the ddns-updater scripts will be started") ) +eif4:depends("ipv4_source", "web") +eif4:depends("ipv4_source", "script") +eif4.default = "wan" +luci.tools.webadmin.cbi_add_networks(eif4) +function eif4.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "interface") +end +function eif4.validate(self, value) + if usev6:formvalue(section) == "1" + or src4:formvalue(section) == "network" + or src4:formvalue(section) == "interface" then + return "" -- ignore IPv6, network, interface + else + return value + end +end +function eif4.write(self, section, value) + if usev6:formvalue(section) == "1" + or src4:formvalue(section) == "network" + or src4:formvalue(section) == "interface" then + return true -- ignore IPv6, network, interface + else + self.map:del(section, self.option) -- delete "ipv4_interface" helper + return self.map:set(section, "interface", value) -- and write "interface" + end +end + +-- IPv6 - interface (NEW) - default "wan6" +-- event network to monitor changes/hotplug (NEW) +-- only needs to be set if "ip_source"="web" or "script" +-- if "ip_source"="network" or "interface" we use their network +eif6 = ns:taboption("advanced", ListValue, "ipv6_interface", + translate("Event Network") .. " [IPv6]" ) +eif6:depends("ipv6_source", "web") +eif6:depends("ipv6_source", "script") +eif6.default = "wan6" +luci.tools.webadmin.cbi_add_networks(eif6) +if not has_ipv6 then + eif6.description = err_ipv6_other +else + eif6.description = translate("Network on which the ddns-updater scripts will be started") +end +function eif6.cfgvalue(self, section) + return luci.tools.ddns.read_value(self, section, "interface") +end +function eif6.validate(self, value) + if usev6:formvalue(section) == "0" + or src4:formvalue(section) == "network" + or src4:formvalue(section) == "interface" then + return "" -- ignore IPv4, network, interface + elseif not has_ipv6 then + return nil, err_tab_adv(self) .. err_ipv6_plain + else + return value + end +end +function eif6.write(self, section, value) + if usev6:formvalue(section) == "0" + or src4:formvalue(section) == "network" + or src4:formvalue(section) == "interface" then + return true -- ignore IPv4, network, interface + else + self.map:del(section, self.option) -- delete "ipv6_interface" helper + return self.map:set(section, "interface", value) -- and write "interface" + end +end + +-- IPv4 + IPv6 - force_ipversion (NEW) +-- optional to force wget/curl and host to use only selected IP version +-- command parameter "-4" or "-6" +if has_force or ( ( m:get(section, "force_ipversion") or "0" ) ~= "0" ) then + fipv = ns:taboption("advanced", Flag, "force_ipversion", + translate("Force IP Version") ) + fipv.orientation = "horizontal" + function fipv.cfgvalue(self, section) + local value = AbstractValue.cfgvalue(self, section) + if not has_force and value ~= "0" then + self.description = bold_on .. font_red .. + translate("Force IP Version not supported") .. font_off .. "<br />" .. + translate("please disable") .. " !" .. bold_off + else + self.description = translate("OPTIONAL: Force the usage of pure IPv4/IPv6 only communication.") + end + return value + end + function fipv.validate(self, value) + if (value == "1" and has_force) or value == "0" then return value end + return nil, err_tab_adv(self) .. translate("Force IP Version not supported") + end + function fipv.write(self, section, value) + if value == "1" then + return self.map:set(section, self.option, value) + else + return self.map:del(section, self.option) + end + end +end + +-- IPv4 + IPv6 - dns_server (NEW) +-- optional DNS Server to use resolving my IP if "ip_source"="web" +dns = ns:taboption("advanced", Value, "dns_server", + translate("DNS-Server"), + translate("OPTIONAL: Use non-default DNS-Server to detect 'Registered IP'.") .. "<br />" .. + translate("Format: IP or FQDN")) +dns.placeholder = "mydns.lan" +function dns.validate(self, value) + -- if .datatype is set, then it is checked before calling this function + if not value then + return "" -- ignore on empty + elseif not luci.cbi.datatypes.hostname(value) then + return nil, err .. translate("use hostname, FQDN, IPv4- or IPv6-Address") + else + local ipv6 = usev6:formvalue(section) + local force = (fipv) and fipv:formvalue(section) or "0" + local command = [[/usr/lib/ddns/dynamic_dns_lucihelper.sh verify_dns ]] .. + value .. [[ ]] .. ipv6 .. [[ ]] .. force + local ret = luci.sys.call(command) + if ret == 0 then return value -- everything OK + elseif ret == 2 then return nil, err_tab_adv(self) .. translate("nslookup can not resolve host") + elseif ret == 3 then return nil, err_tab_adv(self) .. translate("nc (netcat) can not connect") + elseif ret == 4 then return nil, err_tab_adv(self) .. translate("Forced IP Version don't matched") + else return nil, err_tab_adv(self) .. translate("unspecific error") + end + end +end + +-- IPv4 + IPv6 - force_dnstcp (NEW) +if has_dnstcp or ( ( m:get(section, "force_dnstcp") or "0" ) ~= "0" ) then + tcp = ns:taboption("advanced", Flag, "force_dnstcp", + translate("Force TCP on DNS") ) + tcp.orientation = "horizontal" + function tcp.cfgvalue(self, section) + local value = AbstractValue.cfgvalue(self, section) + if not has_dnstcp and value ~= "0" then + self.description = bold_on .. font_red .. + translate("DNS requests via TCP not supported") .. font_off .. "<br />" .. + translate("please disable") .. " !" .. bold_off + else + self.description = translate("OPTIONAL: Force the use of TCP instead of default UDP on DNS requests.") + end + return value + end + function tcp.validate(self, value) + if (value == "1" and has_dnstcp ) or value == "0" then + return value + end + return nil, err_tab_adv(self) .. translate("DNS requests via TCP not supported") + end +end + +-- IPv4 + IPv6 - proxy (NEW) +-- optional Proxy to use for http/https requests [user:password@]proxyhost[:port] +if has_proxy or ( ( m:get(section, "proxy") or "" ) ~= "" ) then + pxy = ns:taboption("advanced", Value, "proxy", + translate("PROXY-Server") ) + pxy.placeholder="user:password@myproxy.lan:8080" + function pxy.cfgvalue(self, section) + local value = AbstractValue.cfgvalue(self, section) + if not has_proxy and value ~= "" then + self.description = bold_on .. font_red .. + translate("PROXY-Server not supported") .. font_off .. "<br />" .. + translate("please remove entry") .. "!" .. bold_off + else + self.description = translate("OPTIONAL: Proxy-Server for detection and updates.") .. "<br />" .. + translate("Format") .. ": " .. bold_on .. "[user:password@]proxyhost:port" .. bold_off .. "<br />" .. + translate("IPv6 address must be given in square brackets") .. ": " .. + bold_on .. " [2001:db8::1]:8080" .. bold_off + end + return value + end + function pxy.validate(self, value) + -- if .datatype is set, then it is checked before calling this function + if not value then + return "" -- ignore on empty + elseif has_proxy then + local ipv6 = usev6:formvalue(section) or "0" + local force = (fipv) and fipv:formvalue(section) or "0" + local command = [[/usr/lib/ddns/dynamic_dns_lucihelper.sh verify_proxy ]] .. + value .. [[ ]] .. ipv6 .. [[ ]] .. force + local ret = luci.sys.call(command) + if ret == 0 then return value + elseif ret == 2 then return nil, err_tab_adv(self) .. translate("nslookup can not resolve host") + elseif ret == 3 then return nil, err_tab_adv(self) .. translate("nc (netcat) can not connect") + elseif ret == 4 then return nil, err_tab_adv(self) .. translate("Forced IP Version don't matched") + elseif ret == 5 then return nil, err_tab_adv(self) .. translate("proxy port missing") + else return nil, err_tab_adv(self) .. translate("unspecific error") + end + else + return nil, err .. translate("PROXY-Server not supported") + end + end +end + +-- TAB: Timer ################################################################# +-- check_interval +ci = ns:taboption("timer", Value, "check_interval", + translate("Check Interval") ) +ci.template = "ddns/detail_value" +ci.default = 10 +ci.rmempty = false -- validate ourselves for translatable error messages +function ci.validate(self, value) + if not luci.cbi.datatypes.uinteger(value) + or tonumber(value) < 1 then + return nil, err_tab_timer(self) .. translate("minimum value 5 minutes == 300 seconds") + end + + local secs = luci.tools.ddns.calc_seconds(value, cu:formvalue(section)) + if secs >= 300 then + return value + else + return nil, err_tab_timer(self) .. translate("minimum value 5 minutes == 300 seconds") + end +end +function ci.write(self, section, value) + -- simulate rmempty=true remove default + local secs = luci.tools.ddns.calc_seconds(value, cu:formvalue(section)) + if secs ~= 600 then --default 10 minutes + return self.map:set(section, self.option, value) + else + self.map:del(section, "check_unit") + return self.map:del(section, self.option) + end +end + +-- check_unit +cu = ns:taboption("timer", ListValue, "check_unit", "not displayed, but needed otherwise error", + translate("Interval to check for changed IP" .. "<br />" .. + "Values below 5 minutes == 300 seconds are not supported") ) +cu.template = "ddns/detail_lvalue" +cu.default = "minutes" +cu.rmempty = false -- want to control write process +cu:value("seconds", translate("seconds")) +cu:value("minutes", translate("minutes")) +cu:value("hours", translate("hours")) +--cu:value("days", translate("days")) +function cu.write(self, section, value) + -- simulate rmempty=true remove default + local secs = luci.tools.ddns.calc_seconds(ci:formvalue(section), value) + if secs ~= 600 then --default 10 minutes + return self.map:set(section, self.option, value) + else + return true + end +end + +-- force_interval (modified) +fi = ns:taboption("timer", Value, "force_interval", + translate("Force Interval") ) +fi.template = "ddns/detail_value" +fi.default = 72 -- see dynamic_dns_updater.sh script +fi.rmempty = false -- validate ourselves for translatable error messages +function fi.validate(self, value) + if not luci.cbi.datatypes.uinteger(value) + or tonumber(value) < 0 then + return nil, err_tab_timer(self) .. translate("minimum value '0'") + end + + local force_s = luci.tools.ddns.calc_seconds(value, fu:formvalue(section)) + if force_s == 0 then + return value + end + + local ci_value = ci:formvalue(section) + if not luci.cbi.datatypes.uinteger(ci_value) then + return "" -- ignore because error in check_interval above + end + + local check_s = luci.tools.ddns.calc_seconds(ci_value, cu:formvalue(section)) + if force_s >= check_s then + return value + end + + return nil, err_tab_timer(self) .. translate("must be greater or equal 'Check Interval'") +end +function fi.write(self, section, value) + -- simulate rmempty=true remove default + local secs = luci.tools.ddns.calc_seconds(value, fu:formvalue(section)) + if secs ~= 259200 then --default 72 hours == 3 days + return self.map:set(section, self.option, value) + else + self.map:del(section, "force_unit") + return self.map:del(section, self.option) + end +end + +-- force_unit +fu = ns:taboption("timer", ListValue, "force_unit", "not displayed, but needed otherwise error", + translate("Interval to force updates send to DDNS Provider" .. "<br />" .. + "Setting this parameter to 0 will force the script to only run once" .. "<br />" .. + "Values lower 'Check Interval' except '0' are not supported") ) +fu.template = "ddns/detail_lvalue" +fu.default = "hours" +fu.rmempty = false -- want to control write process +--fu:value("seconds", translate("seconds")) +fu:value("minutes", translate("minutes")) +fu:value("hours", translate("hours")) +fu:value("days", translate("days")) +function fu.write(self, section, value) + -- simulate rmempty=true remove default + local secs = luci.tools.ddns.calc_seconds(fi:formvalue(section), value) + if secs ~= 259200 and secs ~= 0 then --default 72 hours == 3 days + return self.map:set(section, self.option, value) + else + return true + end +end + +-- retry_count (NEW) +rc = ns:taboption("timer", Value, "retry_count", + translate("Error Retry Counter"), + translate("On Error the script will stop execution after given number of retrys") ) +rc.default = 5 +rc.rmempty = false -- validate ourselves for translatable error messages +function rc.validate(self, value) + if not luci.cbi.datatypes.uinteger(value) + or tonumber(value) < 1 then + return nil, err_tab_timer(self) .. translate("minimum value '1'") + else + return value + end +end +function rc.write(self, section, value) + -- simulate rmempty=true remove default + if tonumber(value) ~= self.default then + return self.map:set(section, self.option, value) + else + return self.map:del(section, self.option) + end +end + +-- retry_interval +ri = ns:taboption("timer", Value, "retry_interval", + translate("Error Retry Interval") ) +ri.template = "ddns/detail_value" +ri.default = 60 +ri.rmempty = false -- validate ourselves for translatable error messages +function ri.validate(self, value) + if not luci.cbi.datatypes.uinteger(value) + or tonumber(value) < 1 then + return nil, err_tab_timer(self) .. translate("minimum value '1'") + else + return value + end +end +function ri.write(self, section, value) + -- simulate rmempty=true remove default + local secs = luci.tools.ddns.calc_seconds(value, ru:formvalue(section)) + if secs ~= 60 then --default 60seconds + return self.map:set(section, self.option, value) + else + self.map:del(section, "retry_unit") + return self.map:del(section, self.option) + end +end + +-- retry_unit +ru = ns:taboption("timer", ListValue, "retry_unit", "not displayed, but needed otherwise error", + translate("On Error the script will retry the failed action after given time") ) +ru.template = "ddns/detail_lvalue" +ru.default = "seconds" +ru.rmempty = false -- want to control write process +ru:value("seconds", translate("seconds")) +ru:value("minutes", translate("minutes")) +--ru:value("hours", translate("hours")) +--ru:value("days", translate("days")) +function ru.write(self, section, value) + -- simulate rmempty=true remove default + local secs = luci.tools.ddns.calc_seconds(ri:formvalue(section), value) + if secs ~= 60 then --default 60seconds + return self.map:set(section, self.option, value) + else + return true -- will be deleted by retry_interval + end +end + +-- TAB: LogView (NEW) ############################################################################# +lv = ns:taboption("logview", DummyValue, "_logview") +lv.template = "ddns/detail_logview" +lv.inputtitle = translate("Read / Reread log file") +lv.rows = 50 +function lv.cfgvalue(self, section) + local lfile=log_dir .. "/" .. section .. ".log" + if nixio.fs.access(lfile) then + return lfile .. "\n" .. translate("Please press [Read] button") + end + return lfile .. "\n" .. translate("File not found or empty") +end + +return m diff --git a/applications/luci-ddns/luasrc/model/cbi/ddns/hints.lua b/applications/luci-ddns/luasrc/model/cbi/ddns/hints.lua new file mode 100644 index 0000000000..d0d323c03e --- /dev/null +++ b/applications/luci-ddns/luasrc/model/cbi/ddns/hints.lua @@ -0,0 +1,129 @@ +--[[ +LuCI - Lua Configuration Interface + +Copyright 2014 Christian Schoenebeck <christian dot schoenebeck at gmail dot com> + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +$Id$ +]]-- + +require "luci.sys" +require "luci.dispatcher" +require "luci.tools.ddns" + +-- check supported options +-- saved to local vars here because doing multiple os calls slow down the system +has_ssl = luci.tools.ddns.check_ssl() -- HTTPS support +has_proxy = luci.tools.ddns.check_proxy() -- Proxy support +has_dnstcp = luci.tools.ddns.check_bind_host() -- DNS TCP support + +-- html constants +bold_on = [[<strong>]] +bold_off = [[</strong>]] + +-- cbi-map definition +m = Map("ddns") + +m.title = [[<a href="]] .. luci.dispatcher.build_url("admin", "services", "ddns") .. [[">]] .. + translate("Dynamic DNS") .. [[</a>]] + +m.description = translate("Dynamic DNS allows that your router can be reached with " .. + "a fixed hostname while having a dynamically changing " .. + "IP address.") + +m.redirect = luci.dispatcher.build_url("admin", "services", "ddns") + +-- SimpleSection definition +-- show Hints to optimize installation and script usage +s = m:section( SimpleSection, + translate("Hints"), + translate("Below a list of configuration tips for your system to run Dynamic DNS updates without limitations") ) +-- DDNS Service disabled +if not luci.sys.init.enabled("ddns") then + local dv = s:option(DummyValue, "_not_enabled") + dv.titleref = luci.dispatcher.build_url("admin", "system", "startup") + dv.rawhtml = true + dv.title = bold_on .. + translate("DDNS Autostart disabled") .. bold_off + dv.value = translate("Currently DDNS updates are not started at boot or on interface events." .. "<br />" .. + "This is the default if you run DDNS scripts by yourself (i.e. via cron with force_interval set to '0')" ) +end + +-- No IPv6 support +if not luci.tools.ddns.check_ipv6() then + local dv = s:option(DummyValue, "_no_ipv6") + dv.titleref = 'http://www.openwrt.org" target="_blank' + dv.rawhtml = true + dv.title = bold_on .. + translate("IPv6 not supported") .. bold_off + dv.value = translate("IPv6 is currently not (fully) supported by this system" .. "<br />" .. + "Please follow the instructions on OpenWrt's homepage to enable IPv6 support" .. "<br />" .. + "or update your system to the latest OpenWrt Release") +end + +-- No HTTPS support +if not has_ssl then + local dv = s:option(DummyValue, "_no_https") + dv.titleref = luci.dispatcher.build_url("admin", "system", "packages") + dv.rawhtml = true + dv.title = bold_on .. + translate("HTTPS not supported") .. bold_off + dv.value = translate("Neither GNU Wget with SSL nor cURL installed to support updates via HTTPS protocol.") .. + "<br />- " .. + translate("You should install GNU Wget with SSL (prefered) or cURL package.") .. + "<br />- " .. + translate("In some versions cURL/libcurl in OpenWrt is compiled without proxy support.") +end + +-- cURL without proxy support +if has_ssl and not has_proxy then + local dv = s:option(DummyValue, "_no_proxy") + dv.titleref = luci.dispatcher.build_url("admin", "system", "packages") + dv.rawhtml = true + dv.title = bold_on .. + translate("cURL without Proxy Support") .. bold_off + dv.value = translate("cURL is installed, but libcurl was compiled without proxy support.") .. + "<br />- " .. + translate("You should install GNU Wget with SSL or replace libcurl.") .. + "<br />- " .. + translate("In some versions cURL/libcurl in OpenWrt is compiled without proxy support.") +end + +-- "Force IP Version not supported" +if not (has_ssl and has_dnstcp) then + local dv = s:option(DummyValue, "_no_force_ip") + dv.titleref = luci.dispatcher.build_url("admin", "system", "packages") + dv.rawhtml = true + dv.title = bold_on .. + translate("Force IP Version not supported") .. bold_off + local value = translate("BusyBox's nslookup and Wget do not support to specify " .. + "the IP version to use for communication with DDNS Provider.") + if not has_ssl then + value = value .. "<br />- " .. + translate("You should install GNU Wget with SSL (prefered) or cURL package.") + end + if not has_dnstcp then + value = value .. "<br />- " .. + translate("You should install BIND host package for DNS requests.") + end + dv.value = value +end + +-- "DNS requests via TCP not supported" +if not has_dnstcp then + local dv = s:option(DummyValue, "_no_dnstcp") + dv.titleref = luci.dispatcher.build_url("admin", "system", "packages") + dv.rawhtml = true + dv.title = bold_on .. + translate("DNS requests via TCP not supported") .. bold_off + dv.value = translate("BusyBox's nslookup does not support to specify to use TCP instead of default UDP when requesting DNS server") .. + "<br />- " .. + translate("You should install BIND host package for DNS requests.") +end + +return m diff --git a/applications/luci-ddns/luasrc/model/cbi/ddns/overview.lua b/applications/luci-ddns/luasrc/model/cbi/ddns/overview.lua new file mode 100644 index 0000000000..a1ce9c3aef --- /dev/null +++ b/applications/luci-ddns/luasrc/model/cbi/ddns/overview.lua @@ -0,0 +1,224 @@ +--[[ +LuCI - Lua Configuration Interface + +Copyright 2014 Christian Schoenebeck <christian dot schoenebeck at gmail dot com> + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +$Id$ +]]-- + +require "nixio.fs" +require "luci.sys" +require "luci.dispatcher" +require "luci.tools.ddns" + +-- show hints ? +show_hints = not (luci.tools.ddns.check_ipv6() -- IPv6 support + and luci.tools.ddns.check_ssl() -- HTTPS support + and luci.tools.ddns.check_proxy() -- Proxy support + and luci.tools.ddns.check_bind_host() -- DNS TCP support + ) + +-- html constants +font_red = [[<font color="red">]] +font_off = [[</font>]] +bold_on = [[<strong>]] +bold_off = [[</strong>]] + +-- cbi-map definition +m = Map("ddns", + translate("Dynamic DNS"), + translate("Dynamic DNS allows that your router can be reached with " .. + "a fixed hostname while having a dynamically changing " .. + "IP address.")) + +-- read application settings +date_format = m.uci:get(m.config, "global", "date_format") or "%F %R" +run_dir = m.uci:get(m.config, "global", "run_dir") or "/var/run/ddns" + +-- SimpleSection definition +-- show Hints to optimize installation and script usage +-- only show if service not enabled +-- or no IPv6 support +-- or not GNU Wget and not cURL (for https support) +-- or not GNU Wget but cURL without proxy support +-- or not BIND's host +if show_hints or not luci.sys.init.enabled("ddns") then + s = m:section( SimpleSection, translate("Hints") ) + -- DDNS Service disabled + if not luci.sys.init.enabled("ddns") then + local dv = s:option(DummyValue, "_not_enabled") + dv.titleref = luci.dispatcher.build_url("admin", "system", "startup") + dv.rawhtml = true + dv.title = bold_on .. + translate("DDNS Autostart disabled") .. bold_off + dv.value = translate("Currently DDNS updates are not started at boot or on interface events." .. "<br />" .. + "You can start/stop each configuration here. It will run until next reboot.") + end + + -- Show more hints on a separate page + if show_hints then + local dv = s:option(DummyValue, "_separate") + dv.titleref = luci.dispatcher.build_url("admin", "services", "ddns", "hints") + dv.rawhtml = true + dv.title = bold_on .. + translate("Show more") .. bold_off + dv.value = translate("Follow this link" .. "<br />" .. + "You will find more hints to optimize your system to run DDNS scripts with all options") + end +end + +-- SimpleSection definiton +-- with all the JavaScripts we need for "a good Show" +a = m:section( SimpleSection ) +a.template = "ddns/overview_status" + +-- TableSection definition +ts = m:section( TypedSection, "service", + translate("Overview"), + translate("Below is a list of configured DDNS configurations and their current state." .. "<br />" .. + "If you want to send updates for IPv4 and IPv6 you need to define two separate Configurations " .. + "i.e. 'myddns_ipv4' and 'myddns_ipv6'") ) +ts.sectionhead = translate("Configuration") +ts.template = "cbi/tblsection" +ts.addremove = true +ts.extedit = luci.dispatcher.build_url("admin", "services", "ddns", "detail", "%s") +function ts.create(self, name) + AbstractSection.create(self, name) + luci.http.redirect( self.extedit:format(name) ) +end + +-- Domain and registered IP +dom = ts:option(DummyValue, "_domainIP", + translate("Hostname/Domain") .. "<br />" .. translate("Registered IP") ) +dom.template = "ddns/overview_doubleline" +function dom.set_one(self, section) + local domain = self.map:get(section, "domain") or "" + if domain ~= "" then + return domain + else + return [[<em>]] .. translate("config error") .. [[</em>]] + end +end +function dom.set_two(self, section) + local domain = self.map:get(section, "domain") or "" + if domain == "" then return "" end + local dnsserver = self.map:get(section, "dnsserver") or "" + local use_ipv6 = tonumber(self.map:get(section, "use_ipv6") or 0) + local force_ipversion = tonumber(self.map:get(section, "force_ipversion") or 0) + local force_dnstcp = tonumber(self.map:get(section, "force_dnstcp") or 0) + local command = [[/usr/lib/ddns/dynamic_dns_lucihelper.sh]] + if not nixio.fs.access(command, "rwx", "rx", "rx") then + nixio.fs.chmod(command, 755) + end + command = command .. [[ get_registered_ip ]] .. domain .. [[ ]] .. use_ipv6 .. + [[ ]] .. force_ipversion .. [[ ]] .. force_dnstcp .. [[ ]] .. dnsserver + local ip = luci.sys.exec(command) + if ip == "" then ip = translate("no data") end + return ip +end + +-- enabled +ena = ts:option( Flag, "enabled", + translate("Enabled")) +ena.template = "ddns/overview_enabled" +ena.rmempty = false + +-- show PID and next update +upd = ts:option( DummyValue, "_update", + translate("Last Update") .. "<br />" .. translate("Next Update")) +upd.template = "ddns/overview_doubleline" +function upd.set_one(self, section) -- fill Last Update + -- get/validate last update + local uptime = luci.sys.uptime() + local lasttime = tonumber(nixio.fs.readfile("%s/%s.update" % { run_dir, section } ) or 0 ) + if lasttime > uptime then -- /var might not be linked to /tmp and cleared on reboot + lasttime = 0 + end + + -- no last update happen + if lasttime == 0 then + return translate("never") + + -- we read last update + else + -- calc last update + -- os.epoch - sys.uptime + lastupdate(uptime) + local epoch = os.time() - uptime + lasttime + -- use linux date to convert epoch + return luci.sys.exec([[/bin/date -d @]] .. epoch .. [[ +']] .. date_format .. [[']]) + end +end +function upd.set_two(self, section) -- fill Next Update + -- get enabled state + local enabled = tonumber(self.map:get(section, "enabled") or 0) + local datenext = translate("unknown error") -- formatted date of next update + + -- get force seconds + local force_interval = tonumber(self.map:get(section, "force_interval") or 72) + local force_unit = self.map:get(section, "force_unit") or "hours" + local force_seconds = luci.tools.ddns.calc_seconds(force_interval, force_unit) + + -- get last update and get/validate PID + local uptime = luci.sys.uptime() + local lasttime = tonumber(nixio.fs.readfile("%s/%s.update" % { run_dir, section } ) or 0 ) + if lasttime > uptime then -- /var might not be linked to /tmp and cleared on reboot + lasttime = 0 + end + local pid = luci.tools.ddns.get_pid(section, run_dir) + + -- calc next update + if lasttime > 0 then + local epoch = os.time() - uptime + lasttime + force_seconds + -- use linux date to convert epoch + datelast = luci.sys.exec([[/bin/date -d @]] .. epoch .. [[ +']] .. date_format .. [[']]) + end + + -- process running but update needs to happen + if pid > 0 and ( lasttime + force_seconds - uptime ) < 0 then + datenext = translate("Verify") + + -- run once + elseif force_seconds == 0 then + datenext = translate("Run once") + + -- no process running and NOT enabled + elseif pid == 0 and enabled == 0 then + datenext = translate("Disabled") + + -- no process running and NOT + elseif pid == 0 and enabled ~= 0 then + datenext = translate("Stopped") + end + + return datenext +end + +-- start/stop button +btn = ts:option( Button, "_startstop", + translate("Process ID") .. "<br />" .. translate("Start / Stop") ) +btn.template = "ddns/overview_startstop" +function btn.cfgvalue(self, section) + local pid = luci.tools.ddns.get_pid(section, run_dir) + if pid > 0 then + btn.inputtitle = "PID: " .. pid + btn.inputstyle = "reset" + btn.disabled = false + elseif (self.map:get(section, "enabled") or "0") ~= "0" then + btn.inputtitle = translate("Start") + btn.inputstyle = "apply" + btn.disabled = false + else + btn.inputtitle = "----------" + btn.inputstyle = "button" + btn.disabled = true + end + return true +end + +return m |