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 =
  40         tonumber, ipairs, pairs, pcall, type, next, setmetatable, require
  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         return _parse_delimited_table(io.lines("/proc/net/arp"), "%s%s+", callback)
 234 end
 235
 236 --- Returns conntrack information
 237 -- @return      Table with the currently tracked IP connections
 238 function net.conntrack(callback)
 239         local connt = {}
 240         if fs.access("/proc/net/nf_conntrack", "r") then
 241                 for line in io.lines("/proc/net/nf_conntrack") do
 242                         line = line:match "^(.-( [^ =]+=).-)%2"
 243                         local entry, flags = _parse_mixed_record(line, " +")
 244                         if flags[6] ~= "TIME_WAIT" then
 245                                 entry.layer3 = flags[1]
 246                                 entry.layer4 = flags[3]
 247                                 for i=1, #entry do
 248                                         entry[i] = nil
 249                                 end
 250
 251                                 if callback then
 252                                         callback(entry)
 253                                 else
 254                                         connt[#connt+1] = entry
 255                                 end
 256                         end
 257                 end
 258         elseif fs.access("/proc/net/ip_conntrack", "r") then
 259                 for line in io.lines("/proc/net/ip_conntrack") do
 260                         line = line:match "^(.-( [^ =]+=).-)%2"
 261                         local entry, flags = _parse_mixed_record(line, " +")
 262                         if flags[4] ~= "TIME_WAIT" then
 263                                 entry.layer3 = "ipv4"
 264                                 entry.layer4 = flags[1]
 265                                 for i=1, #entry do
 266                                         entry[i] = nil
 267                                 end
 268
 269                                 if callback then
 270                                         callback(entry)
 271                                 else
 272                                         connt[#connt+1] = entry
 273                                 end
 274                         end
 275                 end
 276         else
 277                 return nil
 278         end
 279         return connt
 280 end
 281
 282 --- Determine the current IPv4 default route. If multiple default routes exist,
 283 -- return the one with the lowest metric.
 284 -- @return      Table with the properties of the current default route.
 285 --                      The following fields are defined:
 286 --                      { "dest", "gateway", "metric", "refcount", "usecount", "irtt",
 287 --                        "flags", "device" }
 288 function net.defaultroute()
 289         local route
 290
 291         net.routes(function(rt)
 292                 if rt.dest:prefix() == 0 and (not route or route.metric > rt.metric) then
 293                         route = rt
 294                 end
 295         end)
 296
 297         return route
 298 end
 299
 300 --- Determine the current IPv6 default route. If multiple default routes exist,
 301 -- return the one with the lowest metric.
 302 -- @return      Table with the properties of the current default route.
 303 --                      The following fields are defined:
 304 --                      { "source", "dest", "nexthop", "metric", "refcount", "usecount",
 305 --                        "flags", "device" }
 306 function net.defaultroute6()
 307         local route
 308
 309         net.routes6(function(rt)
 310                 if rt.dest:prefix() == 0 and rt.device ~= "lo" and
 311                    (not route or route.metric > rt.metric)
 312                 then
 313                         route = rt
 314                 end
 315         end)
 316
 317         if not route then
 318                 local global_unicast = luci.ip.IPv6("2000::/3")
 319                 net.routes6(function(rt)
 320                         if rt.dest:equal(global_unicast) and
 321                            (not route or route.metric > rt.metric)
 322                         then
 323                                 route = rt
 324                         end
 325                 end)
 326         end
 327
 328         return route
 329 end
 330
 331 --- Determine the names of available network interfaces.
 332 -- @return      Table containing all current interface names
 333 function net.devices()
 334         local devs = {}
 335         for k, v in ipairs(nixio.getifaddrs()) do
 336                 if v.family == "packet" then
 337                         devs[#devs+1] = v.name
 338                 end
 339         end
 340         return devs
 341 end
 342
 343
 344 --- Return information about available network interfaces.
 345 -- @return      Table containing all current interface names and their information
 346 function net.deviceinfo()
 347         local devs = {}
 348         for k, v in ipairs(nixio.getifaddrs()) do
 349                 if v.family == "packet" then
 350                         local d = v.data
 351                         d[1] = d.rx_bytes
 352                         d[2] = d.rx_packets
 353                         d[3] = d.rx_errors
 354                         d[4] = d.rx_dropped
 355                         d[5] = 0
 356                         d[6] = 0
 357                         d[7] = 0
 358                         d[8] = d.multicast
 359                         d[9] = d.tx_bytes
 360                         d[10] = d.tx_packets
 361                         d[11] = d.tx_errors
 362                         d[12] = d.tx_dropped
 363                         d[13] = 0
 364                         d[14] = d.collisions
 365                         d[15] = 0
 366                         d[16] = 0
 367                         devs[v.name] = d
 368                 end
 369         end
 370         return devs
 371 end
 372
 373
 374 -- Determine the MAC address belonging to the given IP address.
 375 -- @param ip    IPv4 address
 376 -- @return              String containing the MAC address or nil if it cannot be found
 377 function net.ip4mac(ip)
 378         local mac = nil
 379         net.arptable(function(e)
 380                 if e["IP address"] == ip then
 381                         mac = e["HW address"]
 382                 end
 383         end)
 384         return mac
 385 end
 386
 387 --- Returns the current kernel routing table entries.
 388 -- @return      Table of tables with properties of the corresponding routes.
 389 --                      The following fields are defined for route entry tables:
 390 --                      { "dest", "gateway", "metric", "refcount", "usecount", "irtt",
 391 --                        "flags", "device" }
 392 function net.routes(callback)
 393         local routes = { }
 394
 395         for line in io.lines("/proc/net/route") do
 396
 397                 local dev, dst_ip, gateway, flags, refcnt, usecnt, metric,
 398                           dst_mask, mtu, win, irtt = line:match(
 399                         "([^%s]+)\t([A-F0-9]+)\t([A-F0-9]+)\t([A-F0-9]+)\t" ..
 400                         "(%d+)\t(%d+)\t(%d+)\t([A-F0-9]+)\t(%d+)\t(%d+)\t(%d+)"
 401                 )
 402
 403                 if dev then
 404                         gateway  = luci.ip.Hex( gateway,  32, luci.ip.FAMILY_INET4 )
 405                         dst_mask = luci.ip.Hex( dst_mask, 32, luci.ip.FAMILY_INET4 )
 406                         dst_ip   = luci.ip.Hex(
 407                                 dst_ip, dst_mask:prefix(dst_mask), luci.ip.FAMILY_INET4
 408                         )
 409
 410                         local rt = {
 411                                 dest     = dst_ip,
 412                                 gateway  = gateway,
 413                                 metric   = tonumber(metric),
 414                                 refcount = tonumber(refcnt),
 415                                 usecount = tonumber(usecnt),
 416                                 mtu      = tonumber(mtu),
 417                                 window   = tonumber(window),
 418                                 irtt     = tonumber(irtt),
 419                                 flags    = tonumber(flags, 16),
 420                                 device   = dev
 421                         }
 422
 423                         if callback then
 424                                 callback(rt)
 425                         else
 426                                 routes[#routes+1] = rt
 427                         end
 428                 end
 429         end
 430
 431         return routes
 432 end
 433
 434 --- Returns the current ipv6 kernel routing table entries.
 435 -- @return      Table of tables with properties of the corresponding routes.
 436 --                      The following fields are defined for route entry tables:
 437 --                      { "source", "dest", "nexthop", "metric", "refcount", "usecount",
 438 --                        "flags", "device" }
 439 function net.routes6(callback)
 440         if fs.access("/proc/net/ipv6_route", "r") then
 441                 local routes = { }
 442
 443                 for line in io.lines("/proc/net/ipv6_route") do
 444
 445                         local dst_ip, dst_prefix, src_ip, src_prefix, nexthop,
 446                                   metric, refcnt, usecnt, flags, dev = line:match(
 447                                 "([a-f0-9]+) ([a-f0-9]+) " ..
 448                                 "([a-f0-9]+) ([a-f0-9]+) " ..
 449                                 "([a-f0-9]+) ([a-f0-9]+) " ..
 450                                 "([a-f0-9]+) ([a-f0-9]+) " ..
 451                                 "([a-f0-9]+) +([^%s]+)"
 452                         )
 453
 454                         src_ip = luci.ip.Hex(
 455                                 src_ip, tonumber(src_prefix, 16), luci.ip.FAMILY_INET6, false
 456                         )
 457
 458                         dst_ip = luci.ip.Hex(
 459                                 dst_ip, tonumber(dst_prefix, 16), luci.ip.FAMILY_INET6, false
 460                         )
 461
 462                         nexthop = luci.ip.Hex( nexthop, 128, luci.ip.FAMILY_INET6, false )
 463
 464                         local rt = {
 465                                 source   = src_ip,
 466                                 dest     = dst_ip,
 467                                 nexthop  = nexthop,
 468                                 metric   = tonumber(metric, 16),
 469                                 refcount = tonumber(refcnt, 16),
 470                                 usecount = tonumber(usecnt, 16),
 471                                 flags    = tonumber(flags, 16),
 472                                 device   = dev,
 473
 474                                 -- lua number is too small for storing the metric
 475                                 -- add a metric_raw field with the original content
 476                                 metric_raw = metric
 477                         }
 478
 479                         if callback then
 480                                 callback(rt)
 481                         else
 482                                 routes[#routes+1] = rt
 483                         end
 484                 end
 485
 486                 return routes
 487         end
 488 end
 489
 490 --- Tests whether the given host responds to ping probes.
 491 -- @param host  String containing a hostname or IPv4 address
 492 -- @return              Number containing 0 on success and >= 1 on error
 493 function net.pingtest(host)
 494         return os.execute("ping -c1 '"..host:gsub("'", '').."' >/dev/null 2>&1")
 495 end
 496
 497
 498 --- LuCI system utilities / process related functions.
 499 -- @class       module
 500 -- @name        luci.sys.process
 501 process = {}
 502
 503 --- Get the current process id.
 504 -- @class function
 505 -- @name  process.info
 506 -- @return      Number containing the current pid
 507 function process.info(key)
 508         local s = {uid = nixio.getuid(), gid = nixio.getgid()}
 509         return not key and s or s[key]
 510 end
 511
 512 --- Retrieve information about currently running processes.
 513 -- @return      Table containing process information
 514 function process.list()
 515         local data = {}
 516         local k
 517         local ps = luci.util.execi("top -bn1")
 518
 519         if not ps then
 520                 return
 521         end
 522
 523         while true do
 524                 local line = ps()
 525                 if not line then
 526                         return
 527                 end
 528
 529                 k = luci.util.split(luci.util.trim(line), "%s+", nil, true)
 530                 if k[6] == "%VSZ" then
 531                         k[6] = "%MEM"
 532                 end
 533                 if k[1] == "PID" then
 534                         break
 535                 end
 536         end
 537
 538         for line in ps do
 539                 local row = {}
 540
 541                 line = luci.util.trim(line)
 542                 for i, value in ipairs(luci.util.split(line, "%s+", #k-1, true)) do
 543                         row[k[i]] = value
 544                 end
 545
 546                 local pid = tonumber(row[k[1]])
 547                 if pid then
 548                         data[pid] = row
 549                 end
 550         end
 551
 552         return data
 553 end
 554
 555 --- Set the gid of a process identified by given pid.
 556 -- @param gid   Number containing the Unix group id
 557 -- @return              Boolean indicating successful operation
 558 -- @return              String containing the error message if failed
 559 -- @return              Number containing the error code if failed
 560 function process.setgroup(gid)
 561         return nixio.setgid(gid)
 562 end
 563
 564 --- Set the uid of a process identified by given pid.
 565 -- @param uid   Number containing the Unix user id
 566 -- @return              Boolean indicating successful operation
 567 -- @return              String containing the error message if failed
 568 -- @return              Number containing the error code if failed
 569 function process.setuser(uid)
 570         return nixio.setuid(uid)
 571 end
 572
 573 --- Send a signal to a process identified by given pid.
 574 -- @class function
 575 -- @name  process.signal
 576 -- @param pid   Number containing the process id
 577 -- @param sig   Signal to send (default: 15 [SIGTERM])
 578 -- @return              Boolean indicating successful operation
 579 -- @return              Number containing the error code if failed
 580 process.signal = nixio.kill
 581
 582
 583 --- LuCI system utilities / user related functions.
 584 -- @class       module
 585 -- @name        luci.sys.user
 586 user = {}
 587
 588 --- Retrieve user informations for given uid.
 589 -- @class               function
 590 -- @name                getuser
 591 -- @param uid   Number containing the Unix user id
 592 -- @return              Table containing the following fields:
 593 --                              { "uid", "gid", "name", "passwd", "dir", "shell", "gecos" }
 594 user.getuser = nixio.getpw
 595
 596 --- Retrieve the current user password hash.
 597 -- @param username      String containing the username to retrieve the password for
 598 -- @return                      String containing the hash or nil if no password is set.
 599 function user.getpasswd(username)
 600         local pwe = nixio.getsp and nixio.getsp(username) or nixio.getpw(username)
 601         local pwh = pwe and (pwe.pwdp or pwe.passwd)
 602         if not pwh or #pwh < 1 or pwh == "!" or pwh == "x" then
 603                 return nil
 604         else
 605                 return pwh
 606         end
 607 end
 608
 609 --- Test whether given string matches the password of a given system user.
 610 -- @param username      String containing the Unix user name
 611 -- @param pass          String containing the password to compare
 612 -- @return                      Boolean indicating wheather the passwords are equal
 613 function user.checkpasswd(username, pass)
 614         local pwh = user.getpasswd(username)
 615         if pwh then
 616                 return (nixio.crypt(pass, pwh) == pwh)
 617         end
 618         return false
 619 end
 620
 621 --- Change the password of given user.
 622 -- @param username      String containing the Unix user name
 623 -- @param password      String containing the password to compare
 624 -- @return                      Number containing 0 on success and >= 1 on error
 625 function user.setpasswd(username, password)
 626         if password then
 627                 password = password:gsub("'", [['"'"']])
 628         end
 629
 630         if username then
 631                 username = username:gsub("'", [['"'"']])
 632         end
 633
 634         return os.execute(
 635                 "(echo '" .. password .. "'; sleep 1; echo '" .. password .. "') | " ..
 636                 "passwd '" .. username .. "' >/dev/null 2>&1"
 637         )
 638 end
 639
 640
 641 --- LuCI system utilities / wifi related functions.
 642 -- @class       module
 643 -- @name        luci.sys.wifi
 644 wifi = {}
 645
 646 --- Get wireless information for given interface.
 647 -- @param ifname        String containing the interface name
 648 -- @return              A wrapped iwinfo object instance
 649 function wifi.getiwinfo(ifname)
 650         local stat, iwinfo = pcall(require, "iwinfo")
 651
 652         if ifname then
 653                 local c = 0
 654                 local u = uci.cursor_state()
 655                 local d, n = ifname:match("^(%w+)%.network(%d+)")
 656                 if d and n then
 657                         n = tonumber(n)
 658                         u:foreach("wireless", "wifi-iface",
 659                                 function(s)
 660                                         if s.device == d then
 661                                                 c = c + 1
 662                                                 if c == n then
 663                                                         ifname = s.ifname or s.device
 664                                                         return false
 665                                                 end
 666                                         end
 667                                 end)
 668                 elseif u:get("wireless", ifname) == "wifi-device" then
 669                         u:foreach("wireless", "wifi-iface",
 670                                 function(s)
 671                                         if s.device == ifname and s.ifname then
 672                                                 ifname = s.ifname
 673                                                 return false
 674                                         end
 675                                 end)
 676                 end
 677
 678                 local t = stat and iwinfo.type(ifname)
 679                 local x = t and iwinfo[t] or { }
 680                 return setmetatable({}, {
 681                         __index = function(t, k)
 682                                 if k == "ifname" then
 683                                         return ifname
 684                                 elseif x[k] then
 685                                         return x[k](ifname)
 686                                 end
 687                         end
 688                 })
 689         end
 690 end
 691
 692 --- Get iwconfig output for all wireless devices.
 693 -- @return      Table of tables containing the iwconfing output for each wifi device
 694 function wifi.getiwconfig()
 695         local cnt = luci.util.exec("PATH=/sbin:/usr/sbin iwconfig 2>/dev/null")
 696         local iwc = {}
 697
 698         for i, l in pairs(luci.util.split(luci.util.trim(cnt), "\n\n")) do
 699                 local k = l:match("^(.-) ")
 700                 l = l:gsub("^(.-) +", "", 1)
 701                 if k then
 702                         local entry, flags = _parse_mixed_record(l)
 703                         if entry then
 704                                 entry.flags = flags
 705                         end
 706                         iwc[k] = entry
 707                 end
 708         end
 709
 710         return iwc
 711 end
 712
 713 --- Get iwlist scan output from all wireless devices.
 714 -- @return      Table of tables contaiing all scan results
 715 function wifi.iwscan(iface)
 716         local siface = iface or ""
 717         local cnt = luci.util.exec("iwlist "..siface.." scan 2>/dev/null")
 718         local iws = {}
 719
 720         for i, l in pairs(luci.util.split(luci.util.trim(cnt), "\n\n")) do
 721                 local k = l:match("^(.-) ")
 722                 l = l:gsub("^[^\n]+", "", 1)
 723                 l = luci.util.trim(l)
 724                 if k then
 725                         iws[k] = {}
 726                         for j, c in pairs(luci.util.split(l, "\n          Cell")) do
 727                                 c = c:gsub("^(.-)- ", "", 1)
 728                                 c = luci.util.split(c, "\n", 7)
 729                                 c = table.concat(c, "\n", 1)
 730                                 local entry, flags = _parse_mixed_record(c)
 731                                 if entry then
 732                                         entry.flags = flags
 733                                 end
 734                                 table.insert(iws[k], entry)
 735                         end
 736                 end
 737         end
 738
 739         return iface and (iws[iface] or {}) or iws
 740 end
 741
 742 --- Get available channels from given wireless iface.
 743 -- @param iface Wireless interface (optional)
 744 -- @return              Table of available channels
 745 function wifi.channels(iface)
 746         local stat, iwinfo = pcall(require, "iwinfo")
 747         local cns
 748
 749         if stat then
 750                 local t = iwinfo.type(iface or "")
 751                 if iface and t and iwinfo[t] then
 752                         cns = iwinfo[t].freqlist(iface)
 753                 end
 754         end
 755
 756         if not cns or #cns == 0 then
 757                 cns = {
 758                         {channel =  1, mhz = 2412},
 759                         {channel =  2, mhz = 2417},
 760                         {channel =  3, mhz = 2422},
 761                         {channel =  4, mhz = 2427},
 762                         {channel =  5, mhz = 2432},
 763                         {channel =  6, mhz = 2437},
 764                         {channel =  7, mhz = 2442},
 765                         {channel =  8, mhz = 2447},
 766                         {channel =  9, mhz = 2452},
 767                         {channel = 10, mhz = 2457},
 768                         {channel = 11, mhz = 2462}
 769                 }
 770         end
 771
 772         return cns
 773 end
 774
 775
 776 --- LuCI system utilities / init related functions.
 777 -- @class       module
 778 -- @name        luci.sys.init
 779 init = {}
 780 init.dir = "/etc/init.d/"
 781
 782 --- Get the names of all installed init scripts
 783 -- @return      Table containing the names of all inistalled init scripts
 784 function init.names()
 785         local names = { }
 786         for name in fs.glob(init.dir.."*") do
 787                 names[#names+1] = fs.basename(name)
 788         end
 789         return names
 790 end
 791
 792 --- Get the index of he given init script
 793 -- @param name  Name of the init script
 794 -- @return              Numeric index value
 795 function init.index(name)
 796         if fs.access(init.dir..name) then
 797                 return call("env -i sh -c 'source %s%s enabled; exit ${START:-255}' >/dev/null"
 798                         %{ init.dir, name })
 799         end
 800 end
 801
 802 local function init_action(action, name)
 803         if fs.access(init.dir..name) then
 804                 return call("env -i %s%s %s >/dev/null" %{ init.dir, name, action })
 805         end
 806 end
 807
 808 --- Test whether the given init script is enabled
 809 -- @param name  Name of the init script
 810 -- @return              Boolean indicating whether init is enabled
 811 function init.enabled(name)
 812         return (init_action("enabled", name) == 0)
 813 end
 814
 815 --- Enable the given init script
 816 -- @param name  Name of the init script
 817 -- @return              Boolean indicating success
 818 function init.enable(name)
 819         return (init_action("enable", name) == 1)
 820 end
 821
 822 --- Disable the given init script
 823 -- @param name  Name of the init script
 824 -- @return              Boolean indicating success
 825 function init.disable(name)
 826         return (init_action("disable", name) == 0)
 827 end
 828
 829 --- Start the given init script
 830 -- @param name  Name of the init script
 831 -- @return              Boolean indicating success
 832 function init.start(name)
 833         return (init_action("start", name) == 0)
 834 end
 835
 836 --- Stop the given init script
 837 -- @param name  Name of the init script
 838 -- @return              Boolean indicating success
 839 function init.stop(name)
 840         return (init_action("stop", name) == 0)
 841 end
 842
 843
 844 -- Internal functions
 845
 846 function _parse_delimited_table(iter, delimiter, callback)
 847         delimiter = delimiter or "%s+"
 848
 849         local data  = {}
 850         local trim  = luci.util.trim
 851         local split = luci.util.split
 852
 853         local keys = split(trim(iter()), delimiter, nil, true)
 854         for i, j in pairs(keys) do
 855                 keys[i] = trim(keys[i])
 856         end
 857
 858         for line in iter do
 859                 local row = {}
 860                 line = trim(line)
 861                 if #line > 0 then
 862                         for i, j in pairs(split(line, delimiter, nil, true)) do
 863                                 if keys[i] then
 864                                         row[keys[i]] = j
 865                                 end
 866                         end
 867                 end
 868
 869                 if callback then
 870                         callback(row)
 871                 else
 872                         data[#data+1] = row
 873                 end
 874         end
 875
 876         return data
 877 end
 878
 879 function _parse_mixed_record(cnt, delimiter)
 880         delimiter = delimiter or "  "
 881         local data = {}
 882         local flags = {}
 883
 884         for i, l in pairs(luci.util.split(luci.util.trim(cnt), "\n")) do
 885                 for j, f in pairs(luci.util.split(luci.util.trim(l), delimiter, nil, true)) do
 886                         local k, x, v = f:match('([^%s][^:=]*) *([:=]*) *"*([^\n"]*)"*')
 887
 888                         if k then
 889                                 if x == "" then
 890                                         table.insert(flags, k)
 891                                 else
 892                                         data[k] = v
 893                                 end
 894                         end
 895                 end
 896         end
 897
 898         return data, flags
 899 end