libs/web/luasrc/dispatcher.lua

   1 --[[
   2 LuCI - Dispatcher
   3
   4 Description:
   5 The request dispatcher and module dispatcher generators
   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 module("luci.dispatcher", package.seeall)
  27 require("luci.init")
  28 require("luci.http")
  29 require("luci.sys")
  30 require("luci.fs")
  31
  32 context = luci.util.threadlocal()
  33
  34 -- Index table
  35 local index = nil
  36
  37 -- Fastindex
  38 local fi
  39
  40
  41 -- Builds a URL
  42 function build_url(...)
  43         return luci.http.getenv("SCRIPT_NAME") .. "/" .. table.concat(arg, "/")
  44 end
  45
  46 -- Sends a 404 error code and renders the "error404" template if available
  47 function error404(message)
  48         luci.http.status(404, "Not Found")
  49         message = message or "Not Found"
  50
  51         require("luci.template")
  52         if not luci.util.copcall(luci.template.render, "error404") then
  53                 luci.http.prepare_content("text/plain")
  54                 luci.http.write(message)
  55         end
  56         return false
  57 end
  58
  59 -- Sends a 500 error code and renders the "error500" template if available
  60 function error500(message)
  61         luci.http.status(500, "Internal Server Error")
  62
  63         require("luci.template")
  64         if not luci.util.copcall(luci.template.render, "error500", {message=message}) then
  65                 luci.http.prepare_content("text/plain")
  66                 luci.http.write(message)
  67         end
  68         return false
  69 end
  70
  71 -- Renders an authorization form
  72 function sysauth(default)
  73         local user = luci.http.formvalue("username")
  74         local pass = luci.http.formvalue("password")
  75
  76         if user and luci.sys.user.checkpasswd(user, pass) then
  77                 local sid = luci.sys.uniqueid(16)
  78                 luci.http.header("Set-Cookie", "sysauth=" .. sid)
  79                 luci.sauth.write(sid, user)
  80                 return true
  81         else
  82                 require("luci.i18n")
  83                 require("luci.template")
  84                 context.path = {}
  85                 luci.template.render("sysauth", {duser=default, fuser=user})
  86                 return false
  87         end
  88 end
  89
  90 -- Creates a request object for dispatching
  91 function httpdispatch(request)
  92         luci.http.context.request = request
  93         context.request = {}
  94         local pathinfo = request:getenv("PATH_INFO") or ""
  95
  96         for node in pathinfo:gmatch("[^/]+") do
  97                 table.insert(context.request, node)
  98         end
  99
 100         dispatch(context.request)
 101         luci.http.close()
 102 end
 103
 104 -- Dispatches a request
 105 function dispatch(request)
 106         context.path = request
 107
 108         require("luci.i18n")
 109         luci.i18n.setlanguage(require("luci.config").main.lang)
 110
 111         if not context.tree then
 112                 createtree()
 113         end
 114
 115         local c = context.tree
 116         local track = {}
 117
 118         for i, s in ipairs(request) do
 119                 c = c.nodes[s]
 120                 if not c or c.leaf then
 121                         break
 122                 end
 123
 124                 for k, v in pairs(c) do
 125                         track[k] = v
 126                 end
 127         end
 128
 129         if track.i18n then
 130                 require("luci.i18n").loadc(track.i18n)
 131         end
 132
 133         -- Init template engine
 134         local tpl = require("luci.template")
 135         local viewns = {}
 136         tpl.context.viewns = viewns
 137         viewns.write       = luci.http.write
 138         viewns.translate   = function(...) return require("luci.i18n").translate(...) end
 139         viewns.controller  = luci.http.getenv("SCRIPT_NAME")
 140         viewns.media       = luci.config.main.mediaurlbase
 141         viewns.resource    = luci.config.main.resourcebase
 142         viewns.REQUEST_URI = luci.http.getenv("SCRIPT_NAME") .. (luci.http.getenv("PATH_INFO") or "")
 143
 144         if track.sysauth then
 145                 require("luci.sauth")
 146                 local def  = (type(track.sysauth) == "string") and track.sysauth
 147                 local accs = def and {track.sysauth} or track.sysauth
 148                 local user = luci.sauth.read(luci.http.getcookie("sysauth"))
 149
 150
 151                 if not luci.util.contains(accs, user) then
 152                         if not sysauth(def) then
 153                                 return
 154                         end
 155                 end
 156         end
 157
 158         if track.setgroup then
 159                 luci.sys.process.setgroup(track.setgroup)
 160         end
 161
 162         if track.setuser then
 163                 luci.sys.process.setuser(track.setuser)
 164         end
 165
 166         if c and type(c.target) == "function" then
 167                 context.dispatched = c
 168                 stat, mod = luci.util.copcall(require, c.module)
 169                 if stat then
 170                         luci.util.updfenv(c.target, mod)
 171                 end
 172
 173                 stat, err = luci.util.copcall(c.target)
 174                 if not stat then
 175                         error500(err)
 176                 end
 177         else
 178                 error404()
 179         end
 180 end
 181
 182 -- Generates the dispatching tree
 183 function createindex()
 184         local path = luci.sys.libpath() .. "/controller/"
 185         local suff = ".lua"
 186
 187         if luci.util.copcall(require, "luci.fastindex") then
 188                 createindex_fastindex(path, suff)
 189         else
 190                 createindex_plain(path, suff)
 191         end
 192 end
 193
 194 -- Uses fastindex to create the dispatching tree
 195 function createindex_fastindex(path, suffix)
 196         index = {}
 197
 198         if not fi then
 199                 fi = luci.fastindex.new("index")
 200                 fi.add(path .. "*" .. suffix)
 201                 fi.add(path .. "*/*" .. suffix)
 202         end
 203         fi.scan()
 204
 205         for k, v in pairs(fi.indexes) do
 206                 index[v[2]] = v[1]
 207         end
 208 end
 209
 210 -- Calls the index function of all available controllers
 211 -- Fallback for transition purposes / Leave it in as long as it works otherwise throw it away
 212 function createindex_plain(path, suffix)
 213         index = {}
 214
 215         local cache = nil
 216
 217         local controllers = luci.util.combine(
 218                 luci.fs.glob(path .. "*" .. suffix) or {},
 219                 luci.fs.glob(path .. "*/*" .. suffix) or {}
 220         )
 221
 222         if indexcache then
 223                 cache = luci.fs.mtime(indexcache)
 224
 225                 if not cache then
 226                         luci.fs.mkdir(indexcache)
 227                         luci.fs.chmod(indexcache, "a=,u=rwx")
 228                         cache = luci.fs.mtime(indexcache)
 229                 end
 230         end
 231
 232         for i,c in ipairs(controllers) do
 233                 local module = "luci.controller." .. c:sub(#path+1, #c-#suffix):gsub("/", ".")
 234                 local cachefile
 235                 local stime
 236                 local ctime
 237
 238                 if cache then
 239                         cachefile = indexcache .. "/" .. module
 240                         stime = luci.fs.mtime(c) or 0
 241                         ctime = luci.fs.mtime(cachefile) or 0
 242                 end
 243
 244                 if not cache or stime > ctime then
 245                         stat, mod = luci.util.copcall(require, module)
 246
 247                         if stat and mod and type(mod.index) == "function" then
 248                                 index[module] = mod.index
 249
 250                                 if cache then
 251                                         luci.fs.writefile(cachefile, luci.util.dump(mod.index))
 252                                 end
 253                         end
 254                 else
 255                         index[module] = loadfile(cachefile)
 256                 end
 257         end
 258 end
 259
 260 -- Creates the dispatching tree from the index
 261 function createtree()
 262         if not index then
 263                 createindex()
 264         end
 265
 266         context.tree = {nodes={}}
 267         require("luci.i18n")
 268
 269         -- Load default translation
 270         luci.i18n.loadc("default")
 271
 272         local scope = luci.util.clone(_G)
 273         for k,v in pairs(luci.dispatcher) do
 274                 if type(v) == "function" then
 275                         scope[k] = v
 276                 end
 277         end
 278
 279         for k, v in pairs(index) do
 280                 scope._NAME = k
 281                 setfenv(v, scope)
 282
 283                 local stat, err = luci.util.copcall(v)
 284                 if not stat then
 285                         error500("createtree failed: " .. k .. ": " .. err)
 286                         luci.http.close()
 287                         os.exit(1)
 288                 end
 289         end
 290 end
 291
 292 -- Reassigns a node to another position
 293 function assign(path, clone, title, order)
 294         local obj  = node(path)
 295         obj.nodes  = nil
 296         obj.module = nil
 297
 298         obj.title = title
 299         obj.order = order
 300
 301         local c = context.tree
 302         for k, v in ipairs(clone) do
 303                 if not c.nodes[v] then
 304                         c.nodes[v] = {nodes={}}
 305                 end
 306
 307                 c = c.nodes[v]
 308         end
 309
 310         setmetatable(obj, {__index = c})
 311
 312         return obj
 313 end
 314
 315 -- Shortcut for creating a dispatching node
 316 function entry(path, target, title, order)
 317         local c = node(path)
 318
 319         c.target = target
 320         c.title  = title
 321         c.order  = order
 322         c.module = getfenv(2)._NAME
 323
 324         return c
 325 end
 326
 327 -- Fetch a dispatching node
 328 function node(...)
 329         local c = context.tree
 330         arg.n = nil
 331         if arg[1] then
 332                 if type(arg[1]) == "table" then
 333                         arg = arg[1]
 334                 end
 335         end
 336
 337         for k,v in ipairs(arg) do
 338                 if not c.nodes[v] then
 339                         c.nodes[v] = {nodes={}}
 340                 end
 341
 342                 c = c.nodes[v]
 343         end
 344
 345         c.module = getfenv(2)._NAME
 346         c.path = arg
 347
 348         return c
 349 end
 350
 351 -- Subdispatchers --
 352 function alias(...)
 353         local req = arg
 354         return function()
 355                 dispatch(req)
 356         end
 357 end
 358
 359 function rewrite(n, ...)
 360         local req = arg
 361         return function()
 362                 for i=1,n do
 363                         table.remove(context.path, 1)
 364                 end
 365
 366                 for i,r in ipairs(req) do
 367                         table.insert(context.path, i, r)
 368                 end
 369
 370                 dispatch()
 371         end
 372 end
 373
 374 function call(name, ...)
 375         local argv = {...}
 376         return function() return getfenv()[name](unpack(argv)) end
 377 end
 378
 379 function template(name)
 380         require("luci.template")
 381         return function() luci.template.render(name) end
 382 end
 383
 384 function cbi(model)
 385         require("luci.cbi")
 386         require("luci.template")
 387
 388         return function()
 389                 local stat, res = luci.util.copcall(luci.cbi.load, model)
 390                 if not stat then
 391                         error500(res)
 392                         return true
 393                 end
 394
 395                 local stat, err = luci.util.copcall(res.parse, res)
 396                 if not stat then
 397                         error500(err)
 398                         return true
 399                 end
 400
 401                 luci.template.render("cbi/header")
 402                 res:render()
 403                 luci.template.render("cbi/footer")
 404         end
 405 end