luci-base: use default install paths for host utils
[project/luci.git] / modules / luci-base / luasrc / sys.lua
1 -- Copyright 2008 Steven Barth <steven@midlink.org>
2 -- Licensed to the public under the Apache License 2.0.
3
4 local io     = require "io"
5 local os     = require "os"
6 local table  = require "table"
7 local nixio  = require "nixio"
8 local fs     = require "nixio.fs"
9 local uci    = require "luci.model.uci"
10
11 local luci  = {}
12 luci.util   = require "luci.util"
13 luci.ip     = require "luci.ip"
14
15 local tonumber, ipairs, pairs, pcall, type, next, setmetatable, require, select =
16         tonumber, ipairs, pairs, pcall, type, next, setmetatable, require, select
17
18
19 module "luci.sys"
20
21 function call(...)
22         return os.execute(...) / 256
23 end
24
25 exec = luci.util.exec
26
27 function mounts()
28         local data = {}
29         local k = {"fs", "blocks", "used", "available", "percent", "mountpoint"}
30         local ps = luci.util.execi("df")
31
32         if not ps then
33                 return
34         else
35                 ps()
36         end
37
38         for line in ps do
39                 local row = {}
40
41                 local j = 1
42                 for value in line:gmatch("[^%s]+") do
43                         row[k[j]] = value
44                         j = j + 1
45                 end
46
47                 if row[k[1]] then
48
49                         -- this is a rather ugly workaround to cope with wrapped lines in
50                         -- the df output:
51                         --
52                         --      /dev/scsi/host0/bus0/target0/lun0/part3
53                         --                   114382024  93566472  15005244  86% /mnt/usb
54                         --
55
56                         if not row[k[2]] then
57                                 j = 2
58                                 line = ps()
59                                 for value in line:gmatch("[^%s]+") do
60                                         row[k[j]] = value
61                                         j = j + 1
62                                 end
63                         end
64
65                         table.insert(data, row)
66                 end
67         end
68
69         return data
70 end
71
72 -- containing the whole environment is returned otherwise this function returns
73 -- the corresponding string value for the given name or nil if no such variable
74 -- exists.
75 getenv = nixio.getenv
76
77 function hostname(newname)
78         if type(newname) == "string" and #newname > 0 then
79                 fs.writefile( "/proc/sys/kernel/hostname", newname )
80                 return newname
81         else
82                 return nixio.uname().nodename
83         end
84 end
85
86 function httpget(url, stream, target)
87         if not target then
88                 local source = stream and io.popen or luci.util.exec
89                 return source("wget -qO- '"..url:gsub("'", "").."'")
90         else
91                 return os.execute("wget -qO '%s' '%s'" %
92                         {target:gsub("'", ""), url:gsub("'", "")})
93         end
94 end
95
96 function reboot()
97         return os.execute("reboot >/dev/null 2>&1")
98 end
99
100 function syslog()
101         return luci.util.exec("logread")
102 end
103
104 function dmesg()
105         return luci.util.exec("dmesg")
106 end
107
108 function uniqueid(bytes)
109         local rand = fs.readfile("/dev/urandom", bytes)
110         return rand and nixio.bin.hexlify(rand)
111 end
112
113 function uptime()
114         return nixio.sysinfo().uptime
115 end
116
117
118 net = {}
119
120 --                      The following fields are defined for arp entry objects:
121 --                      { "IP address", "HW address", "HW type", "Flags", "Mask", "Device" }
122 function net.arptable(callback)
123         local arp = (not callback) and {} or nil
124         local e, r, v
125         if fs.access("/proc/net/arp") then
126                 for e in io.lines("/proc/net/arp") do
127                         local r = { }, v
128                         for v in e:gmatch("%S+") do
129                                 r[#r+1] = v
130                         end
131
132                         if r[1] ~= "IP" then
133                                 local x = {
134                                         ["IP address"] = r[1],
135                                         ["HW type"]    = r[2],
136                                         ["Flags"]      = r[3],
137                                         ["HW address"] = r[4],
138                                         ["Mask"]       = r[5],
139                                         ["Device"]     = r[6]
140                                 }
141
142                                 if callback then
143                                         callback(x)
144                                 else
145                                         arp = arp or { }
146                                         arp[#arp+1] = x
147                                 end
148                         end
149                 end
150         end
151         return arp
152 end
153
154 local function _nethints(what, callback)
155         local _, k, e, mac, ip, name
156         local cur = uci.cursor()
157         local ifn = { }
158         local hosts = { }
159
160         local function _add(i, ...)
161                 local k = select(i, ...)
162                 if k then
163                         if not hosts[k] then hosts[k] = { } end
164                         hosts[k][1] = select(1, ...) or hosts[k][1]
165                         hosts[k][2] = select(2, ...) or hosts[k][2]
166                         hosts[k][3] = select(3, ...) or hosts[k][3]
167                         hosts[k][4] = select(4, ...) or hosts[k][4]
168                 end
169         end
170
171         luci.ip.neighbors(nil, function(neigh)
172                 if neigh.mac and neigh.family == 4 then
173                         _add(what, neigh.mac:upper(), neigh.dest:string(), nil, nil)
174                 elseif neigh.mac and neigh.family == 6 then
175                         _add(what, neigh.mac:upper(), nil, neigh.dest:string(), nil)
176                 end
177         end)
178
179         if fs.access("/etc/ethers") then
180                 for e in io.lines("/etc/ethers") do
181                         mac, ip = e:match("^([a-f0-9]%S+) (%S+)")
182                         if mac and ip then
183                                 _add(what, mac:upper(), ip, nil, nil)
184                         end
185                 end
186         end
187
188         cur:foreach("dhcp", "dnsmasq",
189                 function(s)
190                         if s.leasefile and fs.access(s.leasefile) then
191                                 for e in io.lines(s.leasefile) do
192                                         mac, ip, name = e:match("^%d+ (%S+) (%S+) (%S+)")
193                                         if mac and ip then
194                                                 _add(what, mac:upper(), ip, nil, name ~= "*" and name)
195                                         end
196                                 end
197                         end
198                 end
199         )
200
201         cur:foreach("dhcp", "host",
202                 function(s)
203                         for mac in luci.util.imatch(s.mac) do
204                                 _add(what, mac:upper(), s.ip, nil, s.name)
205                         end
206                 end)
207
208         for _, e in ipairs(nixio.getifaddrs()) do
209                 if e.name ~= "lo" then
210                         ifn[e.name] = ifn[e.name] or { }
211                         if e.family == "packet" and e.addr and #e.addr == 17 then
212                                 ifn[e.name][1] = e.addr:upper()
213                         elseif e.family == "inet" then
214                                 ifn[e.name][2] = e.addr
215                         elseif e.family == "inet6" then
216                                 ifn[e.name][3] = e.addr
217                         end
218                 end
219         end
220
221         for _, e in pairs(ifn) do
222                 if e[what] and (e[2] or e[3]) then
223                         _add(what, e[1], e[2], e[3], e[4])
224                 end
225         end
226
227         for _, e in luci.util.kspairs(hosts) do
228                 callback(e[1], e[2], e[3], e[4])
229         end
230 end
231
232 --          Each entry contains the values in the following order:
233 --          [ "mac", "name" ]
234 function net.mac_hints(callback)
235         if callback then
236                 _nethints(1, function(mac, v4, v6, name)
237                         name = name or nixio.getnameinfo(v4 or v6, nil, 100) or v4
238                         if name and name ~= mac then
239                                 callback(mac, name or nixio.getnameinfo(v4 or v6, nil, 100) or v4)
240                         end
241                 end)
242         else
243                 local rv = { }
244                 _nethints(1, function(mac, v4, v6, name)
245                         name = name or nixio.getnameinfo(v4 or v6, nil, 100) or v4
246                         if name and name ~= mac then
247                                 rv[#rv+1] = { mac, name or nixio.getnameinfo(v4 or v6, nil, 100) or v4 }
248                         end
249                 end)
250                 return rv
251         end
252 end
253
254 --          Each entry contains the values in the following order:
255 --          [ "ip", "name" ]
256 function net.ipv4_hints(callback)
257         if callback then
258                 _nethints(2, function(mac, v4, v6, name)
259                         name = name or nixio.getnameinfo(v4, nil, 100) or mac
260                         if name and name ~= v4 then
261                                 callback(v4, name)
262                         end
263                 end)
264         else
265                 local rv = { }
266                 _nethints(2, function(mac, v4, v6, name)
267                         name = name or nixio.getnameinfo(v4, nil, 100) or mac
268                         if name and name ~= v4 then
269                                 rv[#rv+1] = { v4, name }
270                         end
271                 end)
272                 return rv
273         end
274 end
275
276 --          Each entry contains the values in the following order:
277 --          [ "ip", "name" ]
278 function net.ipv6_hints(callback)
279         if callback then
280                 _nethints(3, function(mac, v4, v6, name)
281                         name = name or nixio.getnameinfo(v6, nil, 100) or mac
282                         if name and name ~= v6 then
283                                 callback(v6, name)
284                         end
285                 end)
286         else
287                 local rv = { }
288                 _nethints(3, function(mac, v4, v6, name)
289                         name = name or nixio.getnameinfo(v6, nil, 100) or mac
290                         if name and name ~= v6 then
291                                 rv[#rv+1] = { v6, name }
292                         end
293                 end)
294                 return rv
295         end
296 end
297
298 function net.host_hints(callback)
299         if callback then
300                 _nethints(1, function(mac, v4, v6, name)
301                         if mac and mac ~= "00:00:00:00:00:00" and (v4 or v6 or name) then
302                                 callback(mac, v4, v6, name)
303                         end
304                 end)
305         else
306                 local rv = { }
307                 _nethints(1, function(mac, v4, v6, name)
308                         if mac and mac ~= "00:00:00:00:00:00" and (v4 or v6 or name) then
309                                 local e = { }
310                                 if v4   then e.ipv4 = v4   end
311                                 if v6   then e.ipv6 = v6   end
312                                 if name then e.name = name end
313                                 rv[mac] = e
314                         end
315                 end)
316                 return rv
317         end
318 end
319
320 function net.conntrack(callback)
321         local ok, nfct = pcall(io.lines, "/proc/net/nf_conntrack")
322         if not ok or not nfct then
323                 return nil
324         end
325
326         local line, connt = nil, (not callback) and { }
327         for line in nfct do
328                 local fam, l3, l4, timeout, tuples =
329                         line:match("^(ipv[46]) +(%d+) +%S+ +(%d+) +(%d+) +(.+)$")
330
331                 if fam and l3 and l4 and timeout and not tuples:match("^TIME_WAIT ") then
332                         l4 = nixio.getprotobynumber(l4)
333
334                         local entry = {
335                                 bytes = 0,
336                                 packets = 0,
337                                 layer3 = fam,
338                                 layer4 = l4 and l4.name or "unknown",
339                                 timeout = tonumber(timeout, 10)
340                         }
341
342                         local key, val
343                         for key, val in tuples:gmatch("(%w+)=(%S+)") do
344                                 if key == "bytes" or key == "packets" then
345                                         entry[key] = entry[key] + tonumber(val, 10)
346                                 elseif key == "src" or key == "dst" then
347                                         if entry[key] == nil then
348                                                 entry[key] = luci.ip.new(val):string()
349                                         end
350                                 elseif key == "sport" or key == "dport" then
351                                         if entry[key] == nil then
352                                                 entry[key] = val
353                                         end
354                                 elseif val then
355                                         entry[key] = val
356                                 end
357                         end
358
359                         if callback then
360                                 callback(entry)
361                         else
362                                 connt[#connt+1] = entry
363                         end
364                 end
365         end
366
367         return callback and true or connt
368 end
369
370 function net.devices()
371         local devs = {}
372         for k, v in ipairs(nixio.getifaddrs()) do
373                 if v.family == "packet" then
374                         devs[#devs+1] = v.name
375                 end
376         end
377         return devs
378 end
379
380
381 function net.deviceinfo()
382         local devs = {}
383         for k, v in ipairs(nixio.getifaddrs()) do
384                 if v.family == "packet" then
385                         local d = v.data
386                         d[1] = d.rx_bytes
387                         d[2] = d.rx_packets
388                         d[3] = d.rx_errors
389                         d[4] = d.rx_dropped
390                         d[5] = 0
391                         d[6] = 0
392                         d[7] = 0
393                         d[8] = d.multicast
394                         d[9] = d.tx_bytes
395                         d[10] = d.tx_packets
396                         d[11] = d.tx_errors
397                         d[12] = d.tx_dropped
398                         d[13] = 0
399                         d[14] = d.collisions
400                         d[15] = 0
401                         d[16] = 0
402                         devs[v.name] = d
403                 end
404         end
405         return devs
406 end
407
408
409 --                      The following fields are defined for route entry tables:
410 --                      { "dest", "gateway", "metric", "refcount", "usecount", "irtt",
411 --                        "flags", "device" }
412 function net.routes(callback)
413         local routes = { }
414
415         for line in io.lines("/proc/net/route") do
416
417                 local dev, dst_ip, gateway, flags, refcnt, usecnt, metric,
418                           dst_mask, mtu, win, irtt = line:match(
419                         "([^%s]+)\t([A-F0-9]+)\t([A-F0-9]+)\t([A-F0-9]+)\t" ..
420                         "(%d+)\t(%d+)\t(%d+)\t([A-F0-9]+)\t(%d+)\t(%d+)\t(%d+)"
421                 )
422
423                 if dev then
424                         gateway  = luci.ip.Hex( gateway,  32, luci.ip.FAMILY_INET4 )
425                         dst_mask = luci.ip.Hex( dst_mask, 32, luci.ip.FAMILY_INET4 )
426                         dst_ip   = luci.ip.Hex(
427                                 dst_ip, dst_mask:prefix(dst_mask), luci.ip.FAMILY_INET4
428                         )
429
430                         local rt = {
431                                 dest     = dst_ip,
432                                 gateway  = gateway,
433                                 metric   = tonumber(metric),
434                                 refcount = tonumber(refcnt),
435                                 usecount = tonumber(usecnt),
436                                 mtu      = tonumber(mtu),
437                                 window   = tonumber(window),
438                                 irtt     = tonumber(irtt),
439                                 flags    = tonumber(flags, 16),
440                                 device   = dev
441                         }
442
443                         if callback then
444                                 callback(rt)
445                         else
446                                 routes[#routes+1] = rt
447                         end
448                 end
449         end
450
451         return routes
452 end
453
454 --                      The following fields are defined for route entry tables:
455 --                      { "source", "dest", "nexthop", "metric", "refcount", "usecount",
456 --                        "flags", "device" }
457 function net.routes6(callback)
458         if fs.access("/proc/net/ipv6_route", "r") then
459                 local routes = { }
460
461                 for line in io.lines("/proc/net/ipv6_route") do
462
463                         local dst_ip, dst_prefix, src_ip, src_prefix, nexthop,
464                                   metric, refcnt, usecnt, flags, dev = line:match(
465                                 "([a-f0-9]+) ([a-f0-9]+) " ..
466                                 "([a-f0-9]+) ([a-f0-9]+) " ..
467                                 "([a-f0-9]+) ([a-f0-9]+) " ..
468                                 "([a-f0-9]+) ([a-f0-9]+) " ..
469                                 "([a-f0-9]+) +([^%s]+)"
470                         )
471
472                         if dst_ip and dst_prefix and
473                            src_ip and src_prefix and
474                            nexthop and metric and
475                            refcnt and usecnt and
476                            flags and dev
477                         then
478                                 src_ip = luci.ip.Hex(
479                                         src_ip, tonumber(src_prefix, 16), luci.ip.FAMILY_INET6, false
480                                 )
481
482                                 dst_ip = luci.ip.Hex(
483                                         dst_ip, tonumber(dst_prefix, 16), luci.ip.FAMILY_INET6, false
484                                 )
485
486                                 nexthop = luci.ip.Hex( nexthop, 128, luci.ip.FAMILY_INET6, false )
487
488                                 local rt = {
489                                         source   = src_ip,
490                                         dest     = dst_ip,
491                                         nexthop  = nexthop,
492                                         metric   = tonumber(metric, 16),
493                                         refcount = tonumber(refcnt, 16),
494                                         usecount = tonumber(usecnt, 16),
495                                         flags    = tonumber(flags, 16),
496                                         device   = dev,
497
498                                         -- lua number is too small for storing the metric
499                                         -- add a metric_raw field with the original content
500                                         metric_raw = metric
501                                 }
502
503                                 if callback then
504                                         callback(rt)
505                                 else
506                                         routes[#routes+1] = rt
507                                 end
508                         end
509                 end
510
511                 return routes
512         end
513 end
514
515 function net.pingtest(host)
516         return os.execute("ping -c1 '"..host:gsub("'", '').."' >/dev/null 2>&1")
517 end
518
519
520 process = {}
521
522 function process.info(key)
523         local s = {uid = nixio.getuid(), gid = nixio.getgid()}
524         return not key and s or s[key]
525 end
526
527 function process.list()
528         local data = {}
529         local k
530         local ps = luci.util.execi("/bin/busybox top -bn1")
531
532         if not ps then
533                 return
534         end
535
536         for line in ps do
537                 local pid, ppid, user, stat, vsz, mem, cpu, cmd = line:match(
538                         "^ *(%d+) +(%d+) +(%S.-%S) +([RSDZTW][W ][<N ]) +(%d+) +(%d+%%) +(%d+%%) +(.+)"
539                 )
540
541                 local idx = tonumber(pid)
542                 if idx then
543                         data[idx] = {
544                                 ['PID']     = pid,
545                                 ['PPID']    = ppid,
546                                 ['USER']    = user,
547                                 ['STAT']    = stat,
548                                 ['VSZ']     = vsz,
549                                 ['%MEM']    = mem,
550                                 ['%CPU']    = cpu,
551                                 ['COMMAND'] = cmd
552                         }
553                 end
554         end
555
556         return data
557 end
558
559 function process.setgroup(gid)
560         return nixio.setgid(gid)
561 end
562
563 function process.setuser(uid)
564         return nixio.setuid(uid)
565 end
566
567 process.signal = nixio.kill
568
569
570 user = {}
571
572 --                              { "uid", "gid", "name", "passwd", "dir", "shell", "gecos" }
573 user.getuser = nixio.getpw
574
575 function user.getpasswd(username)
576         local pwe = nixio.getsp and nixio.getsp(username) or nixio.getpw(username)
577         local pwh = pwe and (pwe.pwdp or pwe.passwd)
578         if not pwh or #pwh < 1 or pwh == "!" or pwh == "x" then
579                 return nil, pwe
580         else
581                 return pwh, pwe
582         end
583 end
584
585 function user.checkpasswd(username, pass)
586         local pwh, pwe = user.getpasswd(username)
587         if pwe then
588                 return (pwh == nil or nixio.crypt(pass, pwh) == pwh)
589         end
590         return false
591 end
592
593 function user.setpasswd(username, password)
594         if password then
595                 password = password:gsub("'", [['"'"']])
596         end
597
598         if username then
599                 username = username:gsub("'", [['"'"']])
600         end
601
602         return os.execute(
603                 "(echo '" .. password .. "'; sleep 1; echo '" .. password .. "') | " ..
604                 "passwd '" .. username .. "' >/dev/null 2>&1"
605         )
606 end
607
608
609 wifi = {}
610
611 function wifi.getiwinfo(ifname)
612         local stat, iwinfo = pcall(require, "iwinfo")
613
614         if ifname then
615                 local d, n = ifname:match("^(%w+)%.network(%d+)")
616                 local wstate = luci.util.ubus("network.wireless", "status") or { }
617
618                 d = d or ifname
619                 n = n and tonumber(n) or 1
620
621                 if type(wstate[d]) == "table" and
622                    type(wstate[d].interfaces) == "table" and
623                    type(wstate[d].interfaces[n]) == "table" and
624                    type(wstate[d].interfaces[n].ifname) == "string"
625                 then
626                         ifname = wstate[d].interfaces[n].ifname
627                 else
628                         ifname = d
629                 end
630
631                 local t = stat and iwinfo.type(ifname)
632                 local x = t and iwinfo[t] or { }
633                 return setmetatable({}, {
634                         __index = function(t, k)
635                                 if k == "ifname" then
636                                         return ifname
637                                 elseif x[k] then
638                                         return x[k](ifname)
639                                 end
640                         end
641                 })
642         end
643 end
644
645
646 init = {}
647 init.dir = "/etc/init.d/"
648
649 function init.names()
650         local names = { }
651         for name in fs.glob(init.dir.."*") do
652                 names[#names+1] = fs.basename(name)
653         end
654         return names
655 end
656
657 function init.index(name)
658         if fs.access(init.dir..name) then
659                 return call("env -i sh -c 'source %s%s enabled; exit ${START:-255}' >/dev/null"
660                         %{ init.dir, name })
661         end
662 end
663
664 local function init_action(action, name)
665         if fs.access(init.dir..name) then
666                 return call("env -i %s%s %s >/dev/null" %{ init.dir, name, action })
667         end
668 end
669
670 function init.enabled(name)
671         return (init_action("enabled", name) == 0)
672 end
673
674 function init.enable(name)
675         return (init_action("enable", name) == 1)
676 end
677
678 function init.disable(name)
679         return (init_action("disable", name) == 0)
680 end
681
682 function init.start(name)
683         return (init_action("start", name) == 0)
684 end
685
686 function init.stop(name)
687         return (init_action("stop", name) == 0)
688 end