modules/luci-mod-admin-full/luasrc/controller/admin/system.lua

   1 -- Copyright 2008 Steven Barth <steven@midlink.org>
   2 -- Copyright 2008-2011 Jo-Philipp Wich <jow@openwrt.org>
   3 -- Licensed to the public under the Apache License 2.0.
   4
   5 module("luci.controller.admin.system", package.seeall)
   6
   7 function index()
   8         local fs = require "nixio.fs"
   9
  10         entry({"admin", "system"}, alias("admin", "system", "system"), _("System"), 30).index = true
  11         entry({"admin", "system", "system"}, cbi("admin_system/system"), _("System"), 1)
  12         entry({"admin", "system", "clock_status"}, post_on({ set = true }, "action_clock_status"))
  13
  14         entry({"admin", "system", "admin"}, cbi("admin_system/admin"), _("Administration"), 2)
  15
  16         if fs.access("/bin/opkg") then
  17                 entry({"admin", "system", "packages"}, post_on({ exec = "1" }, "action_packages"), _("Software"), 10)
  18                 entry({"admin", "system", "packages", "ipkg"}, form("admin_system/ipkg"))
  19         end
  20
  21         entry({"admin", "system", "startup"}, form("admin_system/startup"), _("Startup"), 45)
  22         entry({"admin", "system", "crontab"}, form("admin_system/crontab"), _("Scheduled Tasks"), 46)
  23
  24         if fs.access("/sbin/block") and fs.access("/etc/config/fstab") then
  25                 entry({"admin", "system", "fstab"}, cbi("admin_system/fstab"), _("Mount Points"), 50)
  26                 entry({"admin", "system", "fstab", "mount"}, cbi("admin_system/fstab/mount"), nil).leaf = true
  27                 entry({"admin", "system", "fstab", "swap"},  cbi("admin_system/fstab/swap"),  nil).leaf = true
  28         end
  29
  30         if fs.access("/sys/class/leds") then
  31                 entry({"admin", "system", "leds"}, cbi("admin_system/leds"), _("<abbr title=\"Light Emitting Diode\">LED</abbr> Configuration"), 60)
  32         end
  33
  34         entry({"admin", "system", "flashops"}, call("action_flashops"), _("Backup / Flash Firmware"), 70)
  35         entry({"admin", "system", "flashops", "reset"}, post("action_reset"))
  36         entry({"admin", "system", "flashops", "backup"}, post("action_backup"))
  37         entry({"admin", "system", "flashops", "backupfiles"}, form("admin_system/backupfiles"))
  38
  39         -- call() instead of post() due to upload handling!
  40         entry({"admin", "system", "flashops", "restore"}, call("action_restore"))
  41         entry({"admin", "system", "flashops", "sysupgrade"}, call("action_sysupgrade"))
  42
  43         entry({"admin", "system", "reboot"}, template("admin_system/reboot"), _("Reboot"), 90)
  44         entry({"admin", "system", "reboot", "call"}, post("action_reboot"))
  45 end
  46
  47 function action_clock_status()
  48         local set = tonumber(luci.http.formvalue("set"))
  49         if set ~= nil and set > 0 then
  50                 local date = os.date("*t", set)
  51                 if date then
  52                         luci.sys.call("date -s '%04d-%02d-%02d %02d:%02d:%02d'" %{
  53                                 date.year, date.month, date.day, date.hour, date.min, date.sec
  54                         })
  55                 end
  56         end
  57
  58         luci.http.prepare_content("application/json")
  59         luci.http.write_json({ timestring = os.date("%c") })
  60 end
  61
  62 function action_packages()
  63         local fs = require "nixio.fs"
  64         local ipkg = require "luci.model.ipkg"
  65         local submit = (luci.http.formvalue("exec") == "1")
  66         local update, upgrade
  67         local changes = false
  68         local install = { }
  69         local remove  = { }
  70         local stdout  = { "" }
  71         local stderr  = { "" }
  72         local out, err
  73
  74         -- Display
  75         local display = luci.http.formvalue("display") or "installed"
  76
  77         -- Letter
  78         local letter = string.byte(luci.http.formvalue("letter") or "A", 1)
  79         letter = (letter == 35 or (letter >= 65 and letter <= 90)) and letter or 65
  80
  81         -- Search query
  82         local query = luci.http.formvalue("query")
  83         query = (query ~= '') and query or nil
  84
  85
  86         -- Modifying actions
  87         if submit then
  88                 -- Packets to be installed
  89                 local ninst = luci.http.formvalue("install")
  90                 local uinst = nil
  91
  92                 -- Install from URL
  93                 local url = luci.http.formvalue("url")
  94                 if url and url ~= '' then
  95                         uinst = url
  96                 end
  97
  98                 -- Do install
  99                 if ninst then
 100                         install[ninst], out, err = ipkg.install(ninst)
 101                         stdout[#stdout+1] = out
 102                         stderr[#stderr+1] = err
 103                         changes = true
 104                 end
 105
 106                 if uinst then
 107                         local pkg
 108                         for pkg in luci.util.imatch(uinst) do
 109                                 install[uinst], out, err = ipkg.install(pkg)
 110                                 stdout[#stdout+1] = out
 111                                 stderr[#stderr+1] = err
 112                                 changes = true
 113                         end
 114                 end
 115
 116                 -- Remove packets
 117                 local rem = luci.http.formvalue("remove")
 118                 if rem then
 119                         remove[rem], out, err = ipkg.remove(rem)
 120                         stdout[#stdout+1] = out
 121                         stderr[#stderr+1] = err
 122                         changes = true
 123                 end
 124
 125
 126                 -- Update all packets
 127                 update = luci.http.formvalue("update")
 128                 if update then
 129                         update, out, err = ipkg.update()
 130                         stdout[#stdout+1] = out
 131                         stderr[#stderr+1] = err
 132                 end
 133
 134
 135                 -- Upgrade all packets
 136                 upgrade = luci.http.formvalue("upgrade")
 137                 if upgrade then
 138                         upgrade, out, err = ipkg.upgrade()
 139                         stdout[#stdout+1] = out
 140                         stderr[#stderr+1] = err
 141                 end
 142         end
 143
 144
 145         -- List state
 146         local no_lists = true
 147         local old_lists = false
 148         if fs.access("/var/opkg-lists/") then
 149                 local list
 150                 for list in fs.dir("/var/opkg-lists/") do
 151                         no_lists = false
 152                         if (fs.stat("/var/opkg-lists/"..list, "mtime") or 0) < (os.time() - (24 * 60 * 60)) then
 153                                 old_lists = true
 154                                 break
 155                         end
 156                 end
 157         end
 158
 159
 160         luci.template.render("admin_system/packages", {
 161                 display   = display,
 162                 letter    = letter,
 163                 query     = query,
 164                 install   = install,
 165                 remove    = remove,
 166                 update    = update,
 167                 upgrade   = upgrade,
 168                 no_lists  = no_lists,
 169                 old_lists = old_lists,
 170                 stdout    = table.concat(stdout, ""),
 171                 stderr    = table.concat(stderr, "")
 172         })
 173
 174         -- Remove index cache
 175         if changes then
 176                 fs.unlink("/tmp/luci-indexcache")
 177         end
 178 end
 179
 180 local function image_supported(image)
 181         return (os.execute("sysupgrade -T %q >/dev/null" % image) == 0)
 182 end
 183
 184 local function image_checksum(image)
 185         return (luci.sys.exec("md5sum %q" % image):match("^([^%s]+)"))
 186 end
 187
 188 local function supports_sysupgrade()
 189         return nixio.fs.access("/lib/upgrade/platform.sh")
 190 end
 191
 192 local function supports_reset()
 193         return (os.execute([[grep -sqE '"rootfs_data"|"ubi"' /proc/mtd]]) == 0)
 194 end
 195
 196 local function storage_size()
 197         local size = 0
 198         if nixio.fs.access("/proc/mtd") then
 199                 for l in io.lines("/proc/mtd") do
 200                         local d, s, e, n = l:match('^([^%s]+)%s+([^%s]+)%s+([^%s]+)%s+"([^%s]+)"')
 201                         if n == "linux" or n == "firmware" then
 202                                 size = tonumber(s, 16)
 203                                 break
 204                         end
 205                 end
 206         elseif nixio.fs.access("/proc/partitions") then
 207                 for l in io.lines("/proc/partitions") do
 208                         local x, y, b, n = l:match('^%s*(%d+)%s+(%d+)%s+([^%s]+)%s+([^%s]+)')
 209                         if b and n and not n:match('[0-9]') then
 210                                 size = tonumber(b) * 1024
 211                                 break
 212                         end
 213                 end
 214         end
 215         return size
 216 end
 217
 218
 219 function action_flashops()
 220         --
 221         -- Overview
 222         --
 223         luci.template.render("admin_system/flashops", {
 224                 reset_avail   = supports_reset(),
 225                 upgrade_avail = supports_sysupgrade()
 226         })
 227 end
 228
 229 function action_sysupgrade()
 230         local fs = require "nixio.fs"
 231         local http = require "luci.http"
 232         local image_tmp = "/tmp/firmware.img"
 233
 234         local fp
 235         http.setfilehandler(
 236                 function(meta, chunk, eof)
 237                         if not fp and meta and meta.name == "image" then
 238                                 fp = io.open(image_tmp, "w")
 239                         end
 240                         if fp and chunk then
 241                                 fp:write(chunk)
 242                         end
 243                         if fp and eof then
 244                                 fp:close()
 245                         end
 246                 end
 247         )
 248
 249         if not luci.dispatcher.test_post_security() then
 250                 fs.unlink(image_tmp)
 251                 return
 252         end
 253
 254         --
 255         -- Cancel firmware flash
 256         --
 257         if http.formvalue("cancel") then
 258                 fs.unlink(image_tmp)
 259                 http.redirect(luci.dispatcher.build_url('admin/system/flashops'))
 260                 return
 261         end
 262
 263         --
 264         -- Initiate firmware flash
 265         --
 266         local step = tonumber(http.formvalue("step") or 1)
 267         if step == 1 then
 268                 if image_supported(image_tmp) then
 269                         luci.template.render("admin_system/upgrade", {
 270                                 checksum = image_checksum(image_tmp),
 271                                 storage  = storage_size(),
 272                                 size     = (fs.stat(image_tmp, "size") or 0),
 273                                 keep     = (not not http.formvalue("keep"))
 274                         })
 275                 else
 276                         fs.unlink(image_tmp)
 277                         luci.template.render("admin_system/flashops", {
 278                                 reset_avail   = supports_reset(),
 279                                 upgrade_avail = supports_sysupgrade(),
 280                                 image_invalid = true
 281                         })
 282                 end
 283         --
 284         -- Start sysupgrade flash
 285         --
 286         elseif step == 2 then
 287                 local keep = (http.formvalue("keep") == "1") and "" or "-n"
 288                 luci.template.render("admin_system/applyreboot", {
 289                         title = luci.i18n.translate("Flashing..."),
 290                         msg   = luci.i18n.translate("The system is flashing now.<br /> DO NOT POWER OFF THE DEVICE!<br /> Wait a few minutes before you try to reconnect. It might be necessary to renew the address of your computer to reach the device again, depending on your settings."),
 291                         addr  = (#keep > 0) and "192.168.1.1" or nil
 292                 })
 293                 fork_exec("sleep 1; killall dropbear uhttpd; sleep 1; /sbin/sysupgrade %s %q" %{ keep, image_tmp })
 294         end
 295 end
 296
 297 function action_backup()
 298         local reader = ltn12_popen("sysupgrade --create-backup - 2>/dev/null")
 299
 300         luci.http.header(
 301                 'Content-Disposition', 'attachment; filename="backup-%s-%s.tar.gz"' %{
 302                         luci.sys.hostname(),
 303                         os.date("%Y-%m-%d")
 304                 })
 305
 306         luci.http.prepare_content("application/x-targz")
 307         luci.ltn12.pump.all(reader, luci.http.write)
 308 end
 309
 310 function action_restore()
 311         local fs = require "nixio.fs"
 312         local http = require "luci.http"
 313         local archive_tmp = "/tmp/restore.tar.gz"
 314
 315         local fp
 316         http.setfilehandler(
 317                 function(meta, chunk, eof)
 318                         if not fp and meta and meta.name == "archive" then
 319                                 fp = io.open(archive_tmp, "w")
 320                         end
 321                         if fp and chunk then
 322                                 fp:write(chunk)
 323                         end
 324                         if fp and eof then
 325                                 fp:close()
 326                         end
 327                 end
 328         )
 329
 330         if not luci.dispatcher.test_post_security() then
 331                 fs.unlink(archive_tmp)
 332                 return
 333         end
 334
 335         local upload = http.formvalue("archive")
 336         if upload and #upload > 0 then
 337                 luci.template.render("admin_system/applyreboot")
 338                 os.execute("tar -C / -xzf %q >/dev/null 2>&1" % archive_tmp)
 339                 luci.sys.reboot()
 340                 return
 341         end
 342
 343         http.redirect(luci.dispatcher.build_url('admin/system/flashops'))
 344 end
 345
 346 function action_reset()
 347         if supports_reset() then
 348                 luci.template.render("admin_system/applyreboot", {
 349                         title = luci.i18n.translate("Erasing..."),
 350                         msg   = luci.i18n.translate("The system is erasing the configuration partition now and will reboot itself when finished."),
 351                         addr  = "192.168.1.1"
 352                 })
 353
 354                 fork_exec("sleep 1; killall dropbear uhttpd; sleep 1; jffs2reset -y && reboot")
 355                 return
 356         end
 357
 358         http.redirect(luci.dispatcher.build_url('admin/system/flashops'))
 359 end
 360
 361 function action_passwd()
 362         local p1 = luci.http.formvalue("pwd1")
 363         local p2 = luci.http.formvalue("pwd2")
 364         local stat = nil
 365
 366         if p1 or p2 then
 367                 if p1 == p2 then
 368                         stat = luci.sys.user.setpasswd("root", p1)
 369                 else
 370                         stat = 10
 371                 end
 372         end
 373
 374         luci.template.render("admin_system/passwd", {stat=stat})
 375 end
 376
 377 function action_reboot()
 378         luci.sys.reboot()
 379 end
 380
 381 function fork_exec(command)
 382         local pid = nixio.fork()
 383         if pid > 0 then
 384                 return
 385         elseif pid == 0 then
 386                 -- change to root dir
 387                 nixio.chdir("/")
 388
 389                 -- patch stdin, out, err to /dev/null
 390                 local null = nixio.open("/dev/null", "w+")
 391                 if null then
 392                         nixio.dup(null, nixio.stderr)
 393                         nixio.dup(null, nixio.stdout)
 394                         nixio.dup(null, nixio.stdin)
 395                         if null:fileno() > 2 then
 396                                 null:close()
 397                         end
 398                 end
 399
 400                 -- replace with target command
 401                 nixio.exec("/bin/sh", "-c", command)
 402         end
 403 end
 404
 405 function ltn12_popen(command)
 406
 407         local fdi, fdo = nixio.pipe()
 408         local pid = nixio.fork()
 409
 410         if pid > 0 then
 411                 fdo:close()
 412                 local close
 413                 return function()
 414                         local buffer = fdi:read(2048)
 415                         local wpid, stat = nixio.waitpid(pid, "nohang")
 416                         if not close and wpid and stat == "exited" then
 417                                 close = true
 418                         end
 419
 420                         if buffer and #buffer > 0 then
 421                                 return buffer
 422                         elseif close then
 423                                 fdi:close()
 424                                 return nil
 425                         end
 426                 end
 427         elseif pid == 0 then
 428                 nixio.dup(fdo, nixio.stdout)
 429                 fdi:close()
 430                 fdo:close()
 431                 nixio.exec("/bin/sh", "-c", command)
 432         end
 433 end