Merge pull request #278 from nmav/ocserv
[project/luci.git] / applications / luci-ddns / luasrc / tools / ddns.lua
1 --[[
2 LuCI - Lua Configuration Interface
3
4 shared module for luci-app-ddns
5 Copyright 2014 Christian Schoenebeck <christian dot schoenebeck at gmail dot com>
6
7 function parse_url copied from https://svn.nmap.org/nmap/nselib/url.lua
8 Parses a URL and returns a table with all its parts according to RFC 2396.
9 @author Diego Nehab     @author Eddie Bell <ejlbell@gmail.com>
10
11 Licensed under the Apache License, Version 2.0 (the "License");
12 you may not use this file except in compliance with the License.
13 You may obtain a copy of the License at
14
15         http://www.apache.org/licenses/LICENSE-2.0
16
17 ]]--
18
19 module("luci.tools.ddns", package.seeall)
20
21 local NX   = require "nixio"
22 local NXFS = require "nixio.fs"
23 local OPKG = require "luci.model.ipkg"
24 local UCI  = require "luci.model.uci"
25 local SYS  = require "luci.sys"
26 local UTIL = require "luci.util"
27
28 -- function to calculate seconds from given interval and unit
29 function calc_seconds(interval, unit)
30         if not tonumber(interval) then
31                 return nil
32         elseif unit == "days" then
33                 return (tonumber(interval) * 86400)     -- 60 sec * 60 min * 24 h
34         elseif unit == "hours" then
35                 return (tonumber(interval) * 3600)      -- 60 sec * 60 min
36         elseif unit == "minutes" then
37                 return (tonumber(interval) * 60)        -- 60 sec
38         elseif unit == "seconds" then
39                 return tonumber(interval)
40         else
41                 return nil
42         end
43 end
44
45 -- check if IPv6 supported by OpenWrt
46 function check_ipv6()
47         return NXFS.access("/proc/net/ipv6_route")
48            and NXFS.access("/usr/sbin/ip6tables")
49 end
50
51 -- check if Wget with SSL support or cURL installed
52 function check_ssl()
53         if (SYS.call([[ grep -iq "\+ssl" /usr/bin/wget 2>/dev/null ]]) == 0) then
54                 return true
55         else
56                 return NXFS.access("/usr/bin/curl")
57         end
58 end
59
60 -- check if Wget with SSL or cURL with proxy support installed
61 function check_proxy()
62         -- we prefere GNU Wget for communication
63         if (SYS.call([[ grep -iq "\+ssl" /usr/bin/wget 2>/dev/null ]]) == 0) then
64                 return true
65
66         -- if not installed cURL must support proxy
67         elseif NXFS.access("/usr/bin/curl") then
68                 return (SYS.call([[ grep -iq all_proxy /usr/lib/libcurl.so* 2>/dev/null ]]) == 0)
69
70         -- only BusyBox Wget is installed
71         else
72                 return NXFS.access("/usr/bin/wget")
73         end
74 end
75
76 -- check if BIND host installed
77 function check_bind_host()
78         return NXFS.access("/usr/bin/host")
79 end
80
81 -- convert epoch date to given format
82 function epoch2date(epoch, format)
83         if not format or #format < 2 then
84                 local uci = UCI.cursor()
85                 format    = uci:get("ddns", "global", "date_format") or "%F %R"
86                 uci:unload("ddns")
87         end
88         format = format:gsub("%%n", "<br />")   -- replace newline
89         format = format:gsub("%%t", "    ")     -- replace tab
90         return os.date(format, epoch)
91 end
92
93 -- read lastupdate from [section].update file
94 function get_lastupd(section)
95         local uci     = UCI.cursor()
96         local run_dir = uci:get("ddns", "global", "run_dir") or "/var/run/ddns"
97         local etime   = tonumber(NXFS.readfile("%s/%s.update" % { run_dir, section } ) or 0 )
98         uci:unload("ddns")
99         return etime
100 end
101
102 -- read PID from run file and verify if still running
103 function get_pid(section)
104         local uci     = UCI.cursor()
105         local run_dir = uci:get("ddns", "global", "run_dir") or "/var/run/ddns"
106         local pid     = tonumber(NXFS.readfile("%s/%s.pid" % { run_dir, section } ) or 0 )
107         if pid > 0 and not NX.kill(pid, 0) then
108                 pid = 0
109         end
110         uci:unload("ddns")
111         return pid
112 end
113
114 -- read version information for given package if installed
115 function ipkg_version(package)
116         if not package then
117                 return nil
118         end
119         local info = OPKG.info(package)
120         local data = {}
121         local version = ""
122         local i = 0
123         for k, v in pairs(info) do
124                 if v.Package == package and v.Status.installed then
125                         version = v.Version
126                         i = i + 1
127                 end
128         end
129         if i > 1 then   -- more then one valid record
130                 return data
131         end
132         local sver = UTIL.split(version, "[%.%-]", nil, true)
133         data = {
134                 version = version,
135                 major   = tonumber(sver[1]) or 0,
136                 minor   = tonumber(sver[2]) or 0,
137                 patch   = tonumber(sver[3]) or 0,
138                 build   = tonumber(sver[4]) or 0
139         }
140         return data
141 end
142
143 -- replacement of build-in read of UCI option
144 -- modified AbstractValue.cfgvalue(self, section) from cbi.lua
145 -- needed to read from other option then current value definition
146 function read_value(self, section, option)
147         local value
148         if self.tag_error[section] then
149                 value = self:formvalue(section)
150         else
151                 value = self.map:get(section, option)
152         end
153
154         if not value then
155                 return nil
156         elseif not self.cast or self.cast == type(value) then
157                 return value
158         elseif self.cast == "string" then
159                 if type(value) == "table" then
160                         return value[1]
161                 end
162         elseif self.cast == "table" then
163                 return { value }
164         end
165 end
166
167 -- replacement of build-in Flag.parse of cbi.lua
168 -- modified to mark section as changed if value changes
169 -- current parse did not do this, but it is done AbstaractValue.parse()
170 function flag_parse(self, section)
171         local fexists = self.map:formvalue(
172                 luci.cbi.FEXIST_PREFIX .. self.config .. "." .. section .. "." .. self.option)
173
174         if fexists then
175                 local fvalue = self:formvalue(section) and self.enabled or self.disabled
176                 local cvalue = self:cfgvalue(section)
177                 if fvalue ~= self.default or (not self.optional and not self.rmempty) then
178                         self:write(section, fvalue)
179                 else
180                         self:remove(section)
181                 end
182                 if (fvalue ~= cvalue) then self.section.changed = true end
183         else
184                 self:remove(section)
185                 self.section.changed = true
186         end
187 end
188
189 -----------------------------------------------------------------------------
190 -- copied from https://svn.nmap.org/nmap/nselib/url.lua
191 -- @author Diego Nehab
192 -- @author Eddie Bell <ejlbell@gmail.com>
193 --[[
194     URI parsing, composition and relative URL resolution
195     LuaSocket toolkit.
196     Author: Diego Nehab
197     RCS ID: $Id: url.lua,v 1.37 2005/11/22 08:33:29 diego Exp $
198     parse_query and build_query added For nmap (Eddie Bell <ejlbell@gmail.com>)
199 ]]--
200 ---
201 -- Parses a URL and returns a table with all its parts according to RFC 2396.
202 --
203 -- The following grammar describes the names given to the URL parts.
204 -- <code>
205 -- <url> ::= <scheme>://<authority>/<path>;<params>?<query>#<fragment>
206 -- <authority> ::= <userinfo>@<host>:<port>
207 -- <userinfo> ::= <user>[:<password>]
208 -- <path> :: = {<segment>/}<segment>
209 -- </code>
210 --
211 -- The leading <code>/</code> in <code>/<path></code> is considered part of
212 -- <code><path></code>.
213 -- @param url URL of request.
214 -- @param default Table with default values for each field.
215 -- @return A table with the following fields, where RFC naming conventions have
216 --   been preserved:
217 --     <code>scheme</code>, <code>authority</code>, <code>userinfo</code>,
218 --     <code>user</code>, <code>password</code>, <code>host</code>,
219 --     <code>port</code>, <code>path</code>, <code>params</code>,
220 --     <code>query</code>, and <code>fragment</code>.
221 -----------------------------------------------------------------------------
222 function parse_url(url) --, default)
223         -- initialize default parameters
224         local parsed = {}
225 --      for i,v in base.pairs(default or parsed) do
226 --              parsed[i] = v
227 --      end
228
229         -- remove whitespace
230 --      url = string.gsub(url, "%s", "")
231         -- get fragment
232         url = string.gsub(url, "#(.*)$",
233                 function(f)
234                         parsed.fragment = f
235                         return ""
236                 end)
237         -- get scheme. Lower-case according to RFC 3986 section 3.1.
238         url = string.gsub(url, "^([%w][%w%+%-%.]*)%:",
239                 function(s)
240                         parsed.scheme = string.lower(s);
241                         return ""
242                 end)
243         -- get authority
244         url = string.gsub(url, "^//([^/]*)",
245                 function(n)
246                         parsed.authority = n
247                         return ""
248                 end)
249         -- get query stringing
250         url = string.gsub(url, "%?(.*)",
251                 function(q)
252                         parsed.query = q
253                         return ""
254                 end)
255         -- get params
256         url = string.gsub(url, "%;(.*)",
257                 function(p)
258                         parsed.params = p
259                         return ""
260                 end)
261         -- path is whatever was left
262         parsed.path = url
263
264         local authority = parsed.authority
265         if not authority then
266                 return parsed
267         end
268         authority = string.gsub(authority,"^([^@]*)@",
269                 function(u)
270                         parsed.userinfo = u;
271                         return ""
272                 end)
273         authority = string.gsub(authority, ":([0-9]*)$",
274                 function(p)
275                         if p ~= "" then
276                                 parsed.port = p
277                         end;
278                         return ""
279                 end)
280         if authority ~= "" then
281                 parsed.host = authority
282         end
283
284         local userinfo = parsed.userinfo
285         if not userinfo then
286                 return parsed
287         end
288         userinfo = string.gsub(userinfo, ":([^:]*)$",
289                 function(p)
290                         parsed.password = p;
291                         return ""
292                 end)
293         parsed.user = userinfo
294         return parsed
295 end