luci-0.11: merge r9571 - r9622
[project/luci.git] / libs / sys / luasrc / sys.lua
1 --[[
2 LuCI - System library
3
4 Description:
5 Utilities for interaction with the Linux system
6
7 FileId:
8 $Id$
9
10 License:
11 Copyright 2008 Steven Barth <steven@midlink.org>
12
13 Licensed under the Apache License, Version 2.0 (the "License");
14 you may not use this file except in compliance with the License.
15 You may obtain a copy of the License at
16
17 http://www.apache.org/licenses/LICENSE-2.0
18
19 Unless required by applicable law or agreed to in writing, software
20 distributed under the License is distributed on an "AS IS" BASIS,
21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 See the License for the specific language governing permissions and
23 limitations under the License.
24
25 ]]--
26
27
28 local io = require "io"
29 local os = require "os"
30 local table = require "table"
31 local nixio = require "nixio"
32 local fs = require "nixio.fs"
33 local uci = require "luci.model.uci"
34
35 local luci = {}
36 luci.util = require "luci.util"
37 luci.ip = require "luci.ip"
38
39 local tonumber, ipairs, pairs, pcall, type, next, setmetatable, require, select =
40 tonumber, ipairs, pairs, pcall, type, next, setmetatable, require, select
41
42
43 --- LuCI Linux and POSIX system utilities.
44 module "luci.sys"
45
46 --- Execute a given shell command and return the error code
47 -- @class function
48 -- @name call
49 -- @param ... Command to call
50 -- @return Error code of the command
51 function call(...)
52 return os.execute(...) / 256
53 end
54
55 --- Execute a given shell command and capture its standard output
56 -- @class function
57 -- @name exec
58 -- @param command Command to call
59 -- @return String containg the return the output of the command
60 exec = luci.util.exec
61
62 --- Retrieve information about currently mounted file systems.
63 -- @return Table containing mount information
64 function mounts()
65 local data = {}
66 local k = {"fs", "blocks", "used", "available", "percent", "mountpoint"}
67 local ps = luci.util.execi("df")
68
69 if not ps then
70 return
71 else
72 ps()
73 end
74
75 for line in ps do
76 local row = {}
77
78 local j = 1
79 for value in line:gmatch("[^%s]+") do
80 row[k[j]] = value
81 j = j + 1
82 end
83
84 if row[k[1]] then
85
86 -- this is a rather ugly workaround to cope with wrapped lines in
87 -- the df output:
88 --
89 -- /dev/scsi/host0/bus0/target0/lun0/part3
90 -- 114382024 93566472 15005244 86% /mnt/usb
91 --
92
93 if not row[k[2]] then
94 j = 2
95 line = ps()
96 for value in line:gmatch("[^%s]+") do
97 row[k[j]] = value
98 j = j + 1
99 end
100 end
101
102 table.insert(data, row)
103 end
104 end
105
106 return data
107 end
108
109 --- Retrieve environment variables. If no variable is given then a table
110 -- containing the whole environment is returned otherwise this function returns
111 -- the corresponding string value for the given name or nil if no such variable
112 -- exists.
113 -- @class function
114 -- @name getenv
115 -- @param var Name of the environment variable to retrieve (optional)
116 -- @return String containg the value of the specified variable
117 -- @return Table containing all variables if no variable name is given
118 getenv = nixio.getenv
119
120 --- Get or set the current hostname.
121 -- @param String containing a new hostname to set (optional)
122 -- @return String containing the system hostname
123 function hostname(newname)
124 if type(newname) == "string" and #newname > 0 then
125 fs.writefile( "/proc/sys/kernel/hostname", newname )
126 return newname
127 else
128 return nixio.uname().nodename
129 end
130 end
131
132 --- Returns the contents of a documented referred by an URL.
133 -- @param url The URL to retrieve
134 -- @param stream Return a stream instead of a buffer
135 -- @param target Directly write to target file name
136 -- @return String containing the contents of given the URL
137 function httpget(url, stream, target)
138 if not target then
139 local source = stream and io.popen or luci.util.exec
140 return source("wget -qO- '"..url:gsub("'", "").."'")
141 else
142 return os.execute("wget -qO '%s' '%s'" %
143 {target:gsub("'", ""), url:gsub("'", "")})
144 end
145 end
146
147 --- Returns the system load average values.
148 -- @return String containing the average load value 1 minute ago
149 -- @return String containing the average load value 5 minutes ago
150 -- @return String containing the average load value 15 minutes ago
151 function loadavg()
152 local info = nixio.sysinfo()
153 return info.loads[1], info.loads[2], info.loads[3]
154 end
155
156 --- Initiate a system reboot.
157 -- @return Return value of os.execute()
158 function reboot()
159 return os.execute("reboot >/dev/null 2>&1")
160 end
161
162 --- Returns the system type, cpu name and installed physical memory.
163 -- @return String containing the system or platform identifier
164 -- @return String containing hardware model information
165 -- @return String containing the total memory amount in kB
166 -- @return String containing the memory used for caching in kB
167 -- @return String containing the memory used for buffering in kB
168 -- @return String containing the free memory amount in kB
169 -- @return String containing the cpu bogomips (number)
170 function sysinfo()
171 local cpuinfo = fs.readfile("/proc/cpuinfo")
172 local meminfo = fs.readfile("/proc/meminfo")
173
174 local memtotal = tonumber(meminfo:match("MemTotal:%s*(%d+)"))
175 local memcached = tonumber(meminfo:match("\nCached:%s*(%d+)"))
176 local memfree = tonumber(meminfo:match("MemFree:%s*(%d+)"))
177 local membuffers = tonumber(meminfo:match("Buffers:%s*(%d+)"))
178 local bogomips = tonumber(cpuinfo:match("[Bb]ogo[Mm][Ii][Pp][Ss].-: ([^\n]+)")) or 0
179
180 local system =
181 cpuinfo:match("system type\t+: ([^\n]+)") or
182 cpuinfo:match("Processor\t+: ([^\n]+)") or
183 cpuinfo:match("model name\t+: ([^\n]+)")
184
185 local model =
186 luci.util.pcdata(fs.readfile("/tmp/sysinfo/model")) or
187 cpuinfo:match("machine\t+: ([^\n]+)") or
188 cpuinfo:match("Hardware\t+: ([^\n]+)") or
189 luci.util.pcdata(fs.readfile("/proc/diag/model")) or
190 nixio.uname().machine or
191 system
192
193 return system, model, memtotal, memcached, membuffers, memfree, bogomips
194 end
195
196 --- Retrieves the output of the "logread" command.
197 -- @return String containing the current log buffer
198 function syslog()
199 return luci.util.exec("logread")
200 end
201
202 --- Retrieves the output of the "dmesg" command.
203 -- @return String containing the current log buffer
204 function dmesg()
205 return luci.util.exec("dmesg")
206 end
207
208 --- Generates a random id with specified length.
209 -- @param bytes Number of bytes for the unique id
210 -- @return String containing hex encoded id
211 function uniqueid(bytes)
212 local rand = fs.readfile("/dev/urandom", bytes)
213 return rand and nixio.bin.hexlify(rand)
214 end
215
216 --- Returns the current system uptime stats.
217 -- @return String containing total uptime in seconds
218 function uptime()
219 return nixio.sysinfo().uptime
220 end
221
222
223 --- LuCI system utilities / network related functions.
224 -- @class module
225 -- @name luci.sys.net
226 net = {}
227
228 --- Returns the current arp-table entries as two-dimensional table.
229 -- @return Table of table containing the current arp entries.
230 -- The following fields are defined for arp entry objects:
231 -- { "IP address", "HW address", "HW type", "Flags", "Mask", "Device" }
232 function net.arptable(callback)
233 local arp, e, r, v
234 if fs.access("/proc/net/arp") then
235 for e in io.lines("/proc/net/arp") do
236 local r = { }, v
237 for v in e:gmatch("%S+") do
238 r[#r+1] = v
239 end
240
241 if r[1] ~= "IP" then
242 local x = {
243 ["IP address"] = r[1],
244 ["HW type"] = r[2],
245 ["Flags"] = r[3],
246 ["HW address"] = r[4],
247 ["Mask"] = r[5],
248 ["Device"] = r[6]
249 }
250
251 if callback then
252 callback(x)
253 else
254 arp = arp or { }
255 arp[#arp+1] = x
256 end
257 end
258 end
259 end
260 return arp
261 end
262
263 local function _nethints(what, callback)
264 local _, k, e, mac, ip, name
265 local cur = uci.cursor()
266 local ifn = { }
267 local hosts = { }
268
269 local function _add(i, ...)
270 local k = select(i, ...)
271 if k then
272 if not hosts[k] then hosts[k] = { } end
273 hosts[k][1] = select(1, ...) or hosts[k][1]
274 hosts[k][2] = select(2, ...) or hosts[k][2]
275 hosts[k][3] = select(3, ...) or hosts[k][3]
276 hosts[k][4] = select(4, ...) or hosts[k][4]
277 end
278 end
279
280 if fs.access("/proc/net/arp") then
281 for e in io.lines("/proc/net/arp") do
282 ip, mac = e:match("^([%d%.]+)%s+%S+%s+%S+%s+([a-fA-F0-9:]+)%s+")
283 if ip and mac then
284 _add(what, mac:upper(), ip, nil, nil)
285 end
286 end
287 end
288
289 if fs.access("/etc/ethers") then
290 for e in io.lines("/etc/ethers") do
291 mac, ip = e:match("^([a-f0-9]%S+) (%S+)")
292 if mac and ip then
293 _add(what, mac:upper(), ip, nil, nil)
294 end
295 end
296 end
297
298 if fs.access("/var/dhcp.leases") then
299 for e in io.lines("/var/dhcp.leases") do
300 mac, ip, name = e:match("^%d+ (%S+) (%S+) (%S+)")
301 if mac and ip then
302 _add(what, mac:upper(), ip, nil, name ~= "*" and name)
303 end
304 end
305 end
306
307 cur:foreach("dhcp", "host",
308 function(s)
309 for mac in luci.util.imatch(s.mac) do
310 _add(what, mac:upper(), s.ip, nil, s.name)
311 end
312 end)
313
314 for _, e in ipairs(nixio.getifaddrs()) do
315 if e.name ~= "lo" then
316 ifn[e.name] = ifn[e.name] or { }
317 if e.family == "packet" and e.addr and #e.addr == 17 then
318 ifn[e.name][1] = e.addr:upper()
319 elseif e.family == "inet" then
320 ifn[e.name][2] = e.addr
321 elseif e.family == "inet6" then
322 ifn[e.name][3] = e.addr
323 end
324 end
325 end
326
327 for _, e in pairs(ifn) do
328 if e[what] and (e[2] or e[3]) then
329 _add(what, e[1], e[2], e[3], e[4])
330 end
331 end
332
333 for _, e in luci.util.kspairs(hosts) do
334 callback(e[1], e[2], e[3], e[4])
335 end
336 end
337
338 --- Returns a two-dimensional table of mac address hints.
339 -- @return Table of table containing known hosts from various sources.
340 -- Each entry contains the values in the following order:
341 -- [ "mac", "name" ]
342 function net.mac_hints(callback)
343 if callback then
344 _nethints(1, function(mac, v4, v6, name)
345 name = name or nixio.getnameinfo(v4 or v6, nil, 100) or v4
346 if name and name ~= mac then
347 callback(mac, name or nixio.getnameinfo(v4 or v6, nil, 100) or v4)
348 end
349 end)
350 else
351 local rv = { }
352 _nethints(1, function(mac, v4, v6, name)
353 name = name or nixio.getnameinfo(v4 or v6, nil, 100) or v4
354 if name and name ~= mac then
355 rv[#rv+1] = { mac, name or nixio.getnameinfo(v4 or v6, nil, 100) or v4 }
356 end
357 end)
358 return rv
359 end
360 end
361
362 --- Returns a two-dimensional table of IPv4 address hints.
363 -- @return Table of table containing known hosts from various sources.
364 -- Each entry contains the values in the following order:
365 -- [ "ip", "name" ]
366 function net.ipv4_hints(callback)
367 if callback then
368 _nethints(2, function(mac, v4, v6, name)
369 name = name or nixio.getnameinfo(v4, nil, 100) or mac
370 if name and name ~= v4 then
371 callback(v4, name)
372 end
373 end)
374 else
375 local rv = { }
376 _nethints(2, function(mac, v4, v6, name)
377 name = name or nixio.getnameinfo(v4, nil, 100) or mac
378 if name and name ~= v4 then
379 rv[#rv+1] = { v4, name }
380 end
381 end)
382 return rv
383 end
384 end
385
386 --- Returns a two-dimensional table of IPv6 address hints.
387 -- @return Table of table containing known hosts from various sources.
388 -- Each entry contains the values in the following order:
389 -- [ "ip", "name" ]
390 function net.ipv6_hints(callback)
391 if callback then
392 _nethints(3, function(mac, v4, v6, name)
393 name = name or nixio.getnameinfo(v6, nil, 100) or mac
394 if name and name ~= v6 then
395 callback(v6, name)
396 end
397 end)
398 else
399 local rv = { }
400 _nethints(3, function(mac, v4, v6, name)
401 name = name or nixio.getnameinfo(v6, nil, 100) or mac
402 if name and name ~= v6 then
403 rv[#rv+1] = { v6, name }
404 end
405 end)
406 return rv
407 end
408 end
409
410 --- Returns conntrack information
411 -- @return Table with the currently tracked IP connections
412 function net.conntrack(callback)
413 local connt = {}
414 if fs.access("/proc/net/nf_conntrack", "r") then
415 for line in io.lines("/proc/net/nf_conntrack") do
416 line = line:match "^(.-( [^ =]+=).-)%2"
417 local entry, flags = _parse_mixed_record(line, " +")
418 if flags[6] ~= "TIME_WAIT" then
419 entry.layer3 = flags[1]
420 entry.layer4 = flags[3]
421 for i=1, #entry do
422 entry[i] = nil
423 end
424
425 if callback then
426 callback(entry)
427 else
428 connt[#connt+1] = entry
429 end
430 end
431 end
432 elseif fs.access("/proc/net/ip_conntrack", "r") then
433 for line in io.lines("/proc/net/ip_conntrack") do
434 line = line:match "^(.-( [^ =]+=).-)%2"
435 local entry, flags = _parse_mixed_record(line, " +")
436 if flags[4] ~= "TIME_WAIT" then
437 entry.layer3 = "ipv4"
438 entry.layer4 = flags[1]
439 for i=1, #entry do
440 entry[i] = nil
441 end
442
443 if callback then
444 callback(entry)
445 else
446 connt[#connt+1] = entry
447 end
448 end
449 end
450 else
451 return nil
452 end
453 return connt
454 end
455
456 --- Determine the current IPv4 default route. If multiple default routes exist,
457 -- return the one with the lowest metric.
458 -- @return Table with the properties of the current default route.
459 -- The following fields are defined:
460 -- { "dest", "gateway", "metric", "refcount", "usecount", "irtt",
461 -- "flags", "device" }
462 function net.defaultroute()
463 local route
464
465 net.routes(function(rt)
466 if rt.dest:prefix() == 0 and (not route or route.metric > rt.metric) then
467 route = rt
468 end
469 end)
470
471 return route
472 end
473
474 --- Determine the current IPv6 default route. If multiple default routes exist,
475 -- return the one with the lowest metric.
476 -- @return Table with the properties of the current default route.
477 -- The following fields are defined:
478 -- { "source", "dest", "nexthop", "metric", "refcount", "usecount",
479 -- "flags", "device" }
480 function net.defaultroute6()
481 local route
482
483 net.routes6(function(rt)
484 if rt.dest:prefix() == 0 and rt.device ~= "lo" and
485 (not route or route.metric > rt.metric)
486 then
487 route = rt
488 end
489 end)
490
491 if not route then
492 local global_unicast = luci.ip.IPv6("2000::/3")
493 net.routes6(function(rt)
494 if rt.dest:equal(global_unicast) and
495 (not route or route.metric > rt.metric)
496 then
497 route = rt
498 end
499 end)
500 end
501
502 return route
503 end
504
505 --- Determine the names of available network interfaces.
506 -- @return Table containing all current interface names
507 function net.devices()
508 local devs = {}
509 for k, v in ipairs(nixio.getifaddrs()) do
510 if v.family == "packet" then
511 devs[#devs+1] = v.name
512 end
513 end
514 return devs
515 end
516
517
518 --- Return information about available network interfaces.
519 -- @return Table containing all current interface names and their information
520 function net.deviceinfo()
521 local devs = {}
522 for k, v in ipairs(nixio.getifaddrs()) do
523 if v.family == "packet" then
524 local d = v.data
525 d[1] = d.rx_bytes
526 d[2] = d.rx_packets
527 d[3] = d.rx_errors
528 d[4] = d.rx_dropped
529 d[5] = 0
530 d[6] = 0
531 d[7] = 0
532 d[8] = d.multicast
533 d[9] = d.tx_bytes
534 d[10] = d.tx_packets
535 d[11] = d.tx_errors
536 d[12] = d.tx_dropped
537 d[13] = 0
538 d[14] = d.collisions
539 d[15] = 0
540 d[16] = 0
541 devs[v.name] = d
542 end
543 end
544 return devs
545 end
546
547
548 -- Determine the MAC address belonging to the given IP address.
549 -- @param ip IPv4 address
550 -- @return String containing the MAC address or nil if it cannot be found
551 function net.ip4mac(ip)
552 local mac = nil
553 net.arptable(function(e)
554 if e["IP address"] == ip then
555 mac = e["HW address"]
556 end
557 end)
558 return mac
559 end
560
561 --- Returns the current kernel routing table entries.
562 -- @return Table of tables with properties of the corresponding routes.
563 -- The following fields are defined for route entry tables:
564 -- { "dest", "gateway", "metric", "refcount", "usecount", "irtt",
565 -- "flags", "device" }
566 function net.routes(callback)
567 local routes = { }
568
569 for line in io.lines("/proc/net/route") do
570
571 local dev, dst_ip, gateway, flags, refcnt, usecnt, metric,
572 dst_mask, mtu, win, irtt = line:match(
573 "([^%s]+)\t([A-F0-9]+)\t([A-F0-9]+)\t([A-F0-9]+)\t" ..
574 "(%d+)\t(%d+)\t(%d+)\t([A-F0-9]+)\t(%d+)\t(%d+)\t(%d+)"
575 )
576
577 if dev then
578 gateway = luci.ip.Hex( gateway, 32, luci.ip.FAMILY_INET4 )
579 dst_mask = luci.ip.Hex( dst_mask, 32, luci.ip.FAMILY_INET4 )
580 dst_ip = luci.ip.Hex(
581 dst_ip, dst_mask:prefix(dst_mask), luci.ip.FAMILY_INET4
582 )
583
584 local rt = {
585 dest = dst_ip,
586 gateway = gateway,
587 metric = tonumber(metric),
588 refcount = tonumber(refcnt),
589 usecount = tonumber(usecnt),
590 mtu = tonumber(mtu),
591 window = tonumber(window),
592 irtt = tonumber(irtt),
593 flags = tonumber(flags, 16),
594 device = dev
595 }
596
597 if callback then
598 callback(rt)
599 else
600 routes[#routes+1] = rt
601 end
602 end
603 end
604
605 return routes
606 end
607
608 --- Returns the current ipv6 kernel routing table entries.
609 -- @return Table of tables with properties of the corresponding routes.
610 -- The following fields are defined for route entry tables:
611 -- { "source", "dest", "nexthop", "metric", "refcount", "usecount",
612 -- "flags", "device" }
613 function net.routes6(callback)
614 if fs.access("/proc/net/ipv6_route", "r") then
615 local routes = { }
616
617 for line in io.lines("/proc/net/ipv6_route") do
618
619 local dst_ip, dst_prefix, src_ip, src_prefix, nexthop,
620 metric, refcnt, usecnt, flags, dev = line:match(
621 "([a-f0-9]+) ([a-f0-9]+) " ..
622 "([a-f0-9]+) ([a-f0-9]+) " ..
623 "([a-f0-9]+) ([a-f0-9]+) " ..
624 "([a-f0-9]+) ([a-f0-9]+) " ..
625 "([a-f0-9]+) +([^%s]+)"
626 )
627
628 if dst_ip and dst_prefix and
629 src_ip and src_prefix and
630 nexthop and metric and
631 refcnt and usecnt and
632 flags and dev
633 then
634 src_ip = luci.ip.Hex(
635 src_ip, tonumber(src_prefix, 16), luci.ip.FAMILY_INET6, false
636 )
637
638 dst_ip = luci.ip.Hex(
639 dst_ip, tonumber(dst_prefix, 16), luci.ip.FAMILY_INET6, false
640 )
641
642 nexthop = luci.ip.Hex( nexthop, 128, luci.ip.FAMILY_INET6, false )
643
644 local rt = {
645 source = src_ip,
646 dest = dst_ip,
647 nexthop = nexthop,
648 metric = tonumber(metric, 16),
649 refcount = tonumber(refcnt, 16),
650 usecount = tonumber(usecnt, 16),
651 flags = tonumber(flags, 16),
652 device = dev,
653
654 -- lua number is too small for storing the metric
655 -- add a metric_raw field with the original content
656 metric_raw = metric
657 }
658
659 if callback then
660 callback(rt)
661 else
662 routes[#routes+1] = rt
663 end
664 end
665 end
666
667 return routes
668 end
669 end
670
671 --- Tests whether the given host responds to ping probes.
672 -- @param host String containing a hostname or IPv4 address
673 -- @return Number containing 0 on success and >= 1 on error
674 function net.pingtest(host)
675 return os.execute("ping -c1 '"..host:gsub("'", '').."' >/dev/null 2>&1")
676 end
677
678
679 --- LuCI system utilities / process related functions.
680 -- @class module
681 -- @name luci.sys.process
682 process = {}
683
684 --- Get the current process id.
685 -- @class function
686 -- @name process.info
687 -- @return Number containing the current pid
688 function process.info(key)
689 local s = {uid = nixio.getuid(), gid = nixio.getgid()}
690 return not key and s or s[key]
691 end
692
693 --- Retrieve information about currently running processes.
694 -- @return Table containing process information
695 function process.list()
696 local data = {}
697 local k
698 local ps = luci.util.execi("/bin/busybox top -bn1")
699
700 if not ps then
701 return
702 end
703
704 for line in ps do
705 local pid, ppid, user, stat, vsz, mem, cpu, cmd = line:match(
706 "^ *(%d+) +(%d+) +(%S.-%S) +([RSDZTW][W ][<N ]) +(%d+) +(%d+%%) +(%d+%%) +(.+)"
707 )
708
709 local idx = tonumber(pid)
710 if idx then
711 data[idx] = {
712 ['PID'] = pid,
713 ['PPID'] = ppid,
714 ['USER'] = user,
715 ['STAT'] = stat,
716 ['VSZ'] = vsz,
717 ['%MEM'] = mem,
718 ['%CPU'] = cpu,
719 ['COMMAND'] = cmd
720 }
721 end
722 end
723
724 return data
725 end
726
727 --- Set the gid of a process identified by given pid.
728 -- @param gid Number containing the Unix group id
729 -- @return Boolean indicating successful operation
730 -- @return String containing the error message if failed
731 -- @return Number containing the error code if failed
732 function process.setgroup(gid)
733 return nixio.setgid(gid)
734 end
735
736 --- Set the uid of a process identified by given pid.
737 -- @param uid Number containing the Unix user id
738 -- @return Boolean indicating successful operation
739 -- @return String containing the error message if failed
740 -- @return Number containing the error code if failed
741 function process.setuser(uid)
742 return nixio.setuid(uid)
743 end
744
745 --- Send a signal to a process identified by given pid.
746 -- @class function
747 -- @name process.signal
748 -- @param pid Number containing the process id
749 -- @param sig Signal to send (default: 15 [SIGTERM])
750 -- @return Boolean indicating successful operation
751 -- @return Number containing the error code if failed
752 process.signal = nixio.kill
753
754
755 --- LuCI system utilities / user related functions.
756 -- @class module
757 -- @name luci.sys.user
758 user = {}
759
760 --- Retrieve user informations for given uid.
761 -- @class function
762 -- @name getuser
763 -- @param uid Number containing the Unix user id
764 -- @return Table containing the following fields:
765 -- { "uid", "gid", "name", "passwd", "dir", "shell", "gecos" }
766 user.getuser = nixio.getpw
767
768 --- Retrieve the current user password hash.
769 -- @param username String containing the username to retrieve the password for
770 -- @return String containing the hash or nil if no password is set.
771 -- @return Password database entry
772 function user.getpasswd(username)
773 local pwe = nixio.getsp and nixio.getsp(username) or nixio.getpw(username)
774 local pwh = pwe and (pwe.pwdp or pwe.passwd)
775 if not pwh or #pwh < 1 or pwh == "!" or pwh == "x" then
776 return nil, pwe
777 else
778 return pwh, pwe
779 end
780 end
781
782 --- Test whether given string matches the password of a given system user.
783 -- @param username String containing the Unix user name
784 -- @param pass String containing the password to compare
785 -- @return Boolean indicating wheather the passwords are equal
786 function user.checkpasswd(username, pass)
787 local pwh, pwe = user.getpasswd(username)
788 if pwe then
789 return (pwh == nil or nixio.crypt(pass, pwh) == pwh)
790 end
791 return false
792 end
793
794 --- Change the password of given user.
795 -- @param username String containing the Unix user name
796 -- @param password String containing the password to compare
797 -- @return Number containing 0 on success and >= 1 on error
798 function user.setpasswd(username, password)
799 if password then
800 password = password:gsub("'", [['"'"']])
801 end
802
803 if username then
804 username = username:gsub("'", [['"'"']])
805 end
806
807 return os.execute(
808 "(echo '" .. password .. "'; sleep 1; echo '" .. password .. "') | " ..
809 "passwd '" .. username .. "' >/dev/null 2>&1"
810 )
811 end
812
813
814 --- LuCI system utilities / wifi related functions.
815 -- @class module
816 -- @name luci.sys.wifi
817 wifi = {}
818
819 --- Get wireless information for given interface.
820 -- @param ifname String containing the interface name
821 -- @return A wrapped iwinfo object instance
822 function wifi.getiwinfo(ifname)
823 local stat, iwinfo = pcall(require, "iwinfo")
824
825 if ifname then
826 local c = 0
827 local u = uci.cursor_state()
828 local d, n = ifname:match("^(%w+)%.network(%d+)")
829 if d and n then
830 ifname = d
831 n = tonumber(n)
832 u:foreach("wireless", "wifi-iface",
833 function(s)
834 if s.device == d then
835 c = c + 1
836 if c == n then
837 ifname = s.ifname or s.device
838 return false
839 end
840 end
841 end)
842 elseif u:get("wireless", ifname) == "wifi-device" then
843 u:foreach("wireless", "wifi-iface",
844 function(s)
845 if s.device == ifname and s.ifname then
846 ifname = s.ifname
847 return false
848 end
849 end)
850 end
851
852 local t = stat and iwinfo.type(ifname)
853 local x = t and iwinfo[t] or { }
854 return setmetatable({}, {
855 __index = function(t, k)
856 if k == "ifname" then
857 return ifname
858 elseif x[k] then
859 return x[k](ifname)
860 end
861 end
862 })
863 end
864 end
865
866
867 --- LuCI system utilities / init related functions.
868 -- @class module
869 -- @name luci.sys.init
870 init = {}
871 init.dir = "/etc/init.d/"
872
873 --- Get the names of all installed init scripts
874 -- @return Table containing the names of all inistalled init scripts
875 function init.names()
876 local names = { }
877 for name in fs.glob(init.dir.."*") do
878 names[#names+1] = fs.basename(name)
879 end
880 return names
881 end
882
883 --- Get the index of he given init script
884 -- @param name Name of the init script
885 -- @return Numeric index value
886 function init.index(name)
887 if fs.access(init.dir..name) then
888 return call("env -i sh -c 'source %s%s enabled; exit ${START:-255}' >/dev/null"
889 %{ init.dir, name })
890 end
891 end
892
893 local function init_action(action, name)
894 if fs.access(init.dir..name) then
895 return call("env -i %s%s %s >/dev/null" %{ init.dir, name, action })
896 end
897 end
898
899 --- Test whether the given init script is enabled
900 -- @param name Name of the init script
901 -- @return Boolean indicating whether init is enabled
902 function init.enabled(name)
903 return (init_action("enabled", name) == 0)
904 end
905
906 --- Enable the given init script
907 -- @param name Name of the init script
908 -- @return Boolean indicating success
909 function init.enable(name)
910 return (init_action("enable", name) == 1)
911 end
912
913 --- Disable the given init script
914 -- @param name Name of the init script
915 -- @return Boolean indicating success
916 function init.disable(name)
917 return (init_action("disable", name) == 0)
918 end
919
920 --- Start the given init script
921 -- @param name Name of the init script
922 -- @return Boolean indicating success
923 function init.start(name)
924 return (init_action("start", name) == 0)
925 end
926
927 --- Stop the given init script
928 -- @param name Name of the init script
929 -- @return Boolean indicating success
930 function init.stop(name)
931 return (init_action("stop", name) == 0)
932 end
933
934
935 -- Internal functions
936
937 function _parse_mixed_record(cnt, delimiter)
938 delimiter = delimiter or " "
939 local data = {}
940 local flags = {}
941
942 for i, l in pairs(luci.util.split(luci.util.trim(cnt), "\n")) do
943 for j, f in pairs(luci.util.split(luci.util.trim(l), delimiter, nil, true)) do
944 local k, x, v = f:match('([^%s][^:=]*) *([:=]*) *"*([^\n"]*)"*')
945
946 if k then
947 if x == "" then
948 table.insert(flags, k)
949 else
950 data[k] = v
951 end
952 end
953 end
954 end
955
956 return data, flags
957 end