411 lines
8 KiB
Lua
411 lines
8 KiB
Lua
--[[
|
|
LuCI - Dispatcher
|
|
|
|
Description:
|
|
The request dispatcher and module dispatcher generators
|
|
|
|
FileId:
|
|
$Id$
|
|
|
|
License:
|
|
Copyright 2008 Steven Barth <steven@midlink.org>
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
|
|
]]--
|
|
module("luci.dispatcher", package.seeall)
|
|
require("luci.init")
|
|
require("luci.http")
|
|
require("luci.sys")
|
|
require("luci.fs")
|
|
|
|
-- Dirty OpenWRT fix
|
|
if (os.time() < 1000000000) then
|
|
os.execute('date -s '..os.date('%m%d%H%M%Y', luci.fs.mtime(luci.sys.libpath() .. "/dispatcher.lua"))..' > /dev/null 2>&1')
|
|
end
|
|
|
|
-- Local dispatch database
|
|
local tree = {nodes={}}
|
|
|
|
-- Index table
|
|
local index = {}
|
|
|
|
-- Global request object
|
|
request = {}
|
|
|
|
-- Active dispatched node
|
|
dispatched = nil
|
|
|
|
-- Status fields
|
|
built_index = false
|
|
built_tree = false
|
|
|
|
-- Fastindex
|
|
local fi
|
|
|
|
|
|
-- Builds a URL
|
|
function build_url(...)
|
|
return luci.http.dispatcher() .. "/" .. table.concat(arg, "/")
|
|
end
|
|
|
|
-- Prints an error message or renders the "error401" template if available
|
|
function error401(message)
|
|
message = message or "Unauthorized"
|
|
|
|
require("luci.template")
|
|
if not pcall(luci.template.render, "error401") then
|
|
luci.http.prepare_content("text/plain")
|
|
print(message)
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Sends a 404 error code and renders the "error404" template if available
|
|
function error404(message)
|
|
luci.http.status(404, "Not Found")
|
|
message = message or "Not Found"
|
|
|
|
require("luci.template")
|
|
if not pcall(luci.template.render, "error404") then
|
|
luci.http.prepare_content("text/plain")
|
|
print(message)
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Sends a 500 error code and renders the "error500" template if available
|
|
function error500(message)
|
|
luci.http.status(500, "Internal Server Error")
|
|
|
|
require("luci.template")
|
|
if not pcall(luci.template.render, "error500", {message=message}) then
|
|
luci.http.prepare_content("text/plain")
|
|
print(message)
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Creates a request object for dispatching
|
|
function httpdispatch()
|
|
local pathinfo = luci.http.env.PATH_INFO or ""
|
|
|
|
for node in pathinfo:gmatch("[^/]+") do
|
|
table.insert(request, node)
|
|
end
|
|
|
|
dispatch()
|
|
end
|
|
|
|
-- Dispatches a request
|
|
function dispatch()
|
|
if not built_tree then
|
|
createtree()
|
|
end
|
|
|
|
local c = tree
|
|
local track = {}
|
|
|
|
for i, s in ipairs(request) do
|
|
c = c.nodes[s]
|
|
if not c or c.leaf then
|
|
break
|
|
end
|
|
|
|
for k, v in pairs(c) do
|
|
track[k] = v
|
|
end
|
|
end
|
|
|
|
if track.sysauth then
|
|
local accs = track.sysauth
|
|
accs = (type(accs) == "string") and {accs} or accs
|
|
|
|
local function sysauth(user, password)
|
|
return (luci.util.contains(accs, user)
|
|
and luci.sys.user.checkpasswd(user, password))
|
|
end
|
|
|
|
if not luci.http.basic_auth(sysauth) then
|
|
error401()
|
|
return
|
|
end
|
|
end
|
|
|
|
if track.i18n then
|
|
require("luci.i18n").loadc(track.i18n)
|
|
end
|
|
|
|
if track.setgroup then
|
|
luci.sys.process.setgroup(track.setgroup)
|
|
end
|
|
|
|
if track.setuser then
|
|
luci.sys.process.setuser(track.setuser)
|
|
end
|
|
|
|
-- Init template engine
|
|
local tpl = require("luci.template")
|
|
tpl.viewns.translate = function(...) return require("luci.i18n").translate(...) end
|
|
tpl.viewns.controller = luci.http.dispatcher()
|
|
tpl.viewns.uploadctrl = luci.http.dispatcher_upload()
|
|
tpl.viewns.media = luci.config.main.mediaurlbase
|
|
tpl.viewns.resource = luci.config.main.resourcebase
|
|
tpl.viewns.uci = require("luci.model.uci").config
|
|
tpl.viewns.REQUEST_URI = luci.http.env.SCRIPT_NAME .. (luci.http.env.PATH_INFO or "")
|
|
|
|
|
|
if c and type(c.target) == "function" then
|
|
dispatched = c
|
|
stat, mod = pcall(require, c.module)
|
|
if stat then
|
|
luci.util.updfenv(c.target, mod)
|
|
end
|
|
|
|
stat, err = pcall(c.target)
|
|
if not stat then
|
|
error500(err)
|
|
end
|
|
else
|
|
error404()
|
|
end
|
|
end
|
|
|
|
-- Generates the dispatching tree
|
|
function createindex()
|
|
index = {}
|
|
local path = luci.sys.libpath() .. "/controller/"
|
|
local suff = ".lua"
|
|
|
|
if pcall(require, "luci.fastindex") then
|
|
createindex_fastindex(path, suff)
|
|
else
|
|
createindex_plain(path, suff)
|
|
end
|
|
|
|
built_index = true
|
|
end
|
|
|
|
-- Uses fastindex to create the dispatching tree
|
|
function createindex_fastindex(path, suffix)
|
|
if not fi then
|
|
fi = luci.fastindex.new("index")
|
|
fi.add(path .. "*" .. suffix)
|
|
fi.add(path .. "*/*" .. suffix)
|
|
end
|
|
fi.scan()
|
|
|
|
for k, v in pairs(fi.indexes) do
|
|
index[v[2]] = v[1]
|
|
end
|
|
end
|
|
|
|
-- Calls the index function of all available controllers
|
|
-- Fallback for transition purposes / Leave it in as long as it works otherwise throw it away
|
|
function createindex_plain(path, suffix)
|
|
if built_index then
|
|
return
|
|
end
|
|
|
|
local cache = nil
|
|
|
|
local controllers = luci.util.combine(
|
|
luci.fs.glob(path .. "*" .. suffix) or {},
|
|
luci.fs.glob(path .. "*/*" .. suffix) or {}
|
|
)
|
|
|
|
if indexcache then
|
|
cache = luci.fs.mtime(indexcache)
|
|
|
|
if not cache then
|
|
luci.fs.mkdir(indexcache)
|
|
luci.fs.chmod(indexcache, "a=,u=rwx")
|
|
cache = luci.fs.mtime(indexcache)
|
|
end
|
|
end
|
|
|
|
for i,c in ipairs(controllers) do
|
|
local module = "luci.controller." .. c:sub(#path+1, #c-#suffix):gsub("/", ".")
|
|
local cachefile
|
|
local stime
|
|
local ctime
|
|
|
|
if cache then
|
|
cachefile = indexcache .. "/" .. module
|
|
stime = luci.fs.mtime(c) or 0
|
|
ctime = luci.fs.mtime(cachefile) or 0
|
|
end
|
|
|
|
if not cache or stime > ctime then
|
|
stat, mod = pcall(require, module)
|
|
|
|
if stat and mod and type(mod.index) == "function" then
|
|
index[module] = mod.index
|
|
|
|
if cache then
|
|
luci.fs.writefile(cachefile, luci.util.dump(mod.index))
|
|
end
|
|
end
|
|
else
|
|
index[module] = loadfile(cachefile)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Creates the dispatching tree from the index
|
|
function createtree()
|
|
if not built_index then
|
|
createindex()
|
|
end
|
|
|
|
require("luci.i18n")
|
|
|
|
-- Load default translation
|
|
luci.i18n.loadc("default")
|
|
|
|
local scope = luci.util.clone(_G)
|
|
for k,v in pairs(_M) do
|
|
if type(v) == "function" then
|
|
scope[k] = v
|
|
end
|
|
end
|
|
|
|
for k, v in pairs(index) do
|
|
scope._NAME = k
|
|
setfenv(v, scope)
|
|
|
|
local stat, err = pcall(v)
|
|
if not stat then
|
|
error500(err)
|
|
os.exit(1)
|
|
end
|
|
end
|
|
|
|
built_tree = true
|
|
end
|
|
|
|
-- Reassigns a node to another position
|
|
function assign(path, clone, title, order)
|
|
local obj = node(path)
|
|
obj.nodes = nil
|
|
obj.module = nil
|
|
|
|
obj.title = title
|
|
obj.order = order
|
|
|
|
local c = tree
|
|
for k, v in ipairs(clone) do
|
|
if not c.nodes[v] then
|
|
c.nodes[v] = {nodes={}}
|
|
end
|
|
|
|
c = c.nodes[v]
|
|
end
|
|
|
|
setmetatable(obj, {__index = c})
|
|
|
|
return obj
|
|
end
|
|
|
|
-- Shortcut for creating a dispatching node
|
|
function entry(path, target, title, order)
|
|
local c = node(path)
|
|
|
|
c.target = target
|
|
c.title = title
|
|
c.order = order
|
|
c.module = getfenv(2)._NAME
|
|
|
|
return c
|
|
end
|
|
|
|
-- Fetch a dispatching node
|
|
function node(...)
|
|
local c = tree
|
|
|
|
arg.n = nil
|
|
if arg[1] then
|
|
if type(arg[1]) == "table" then
|
|
arg = arg[1]
|
|
end
|
|
end
|
|
|
|
for k,v in ipairs(arg) do
|
|
if not c.nodes[v] then
|
|
c.nodes[v] = {nodes={}}
|
|
end
|
|
|
|
c = c.nodes[v]
|
|
end
|
|
|
|
c.module = getfenv(2)._NAME
|
|
c.path = arg
|
|
|
|
return c
|
|
end
|
|
|
|
-- Subdispatchers --
|
|
function alias(...)
|
|
local req = arg
|
|
return function()
|
|
request = req
|
|
dispatch()
|
|
end
|
|
end
|
|
|
|
function rewrite(n, ...)
|
|
local req = arg
|
|
return function()
|
|
for i=1,n do
|
|
table.remove(request, 1)
|
|
end
|
|
|
|
for i,r in ipairs(req) do
|
|
table.insert(request, i, r)
|
|
end
|
|
|
|
dispatch()
|
|
end
|
|
end
|
|
|
|
function call(name)
|
|
return function() getfenv()[name]() end
|
|
end
|
|
|
|
function template(name)
|
|
require("luci.template")
|
|
return function() luci.template.render(name) end
|
|
end
|
|
|
|
function cbi(model)
|
|
require("luci.cbi")
|
|
require("luci.template")
|
|
|
|
return function()
|
|
local stat, res = pcall(luci.cbi.load, model)
|
|
if not stat then
|
|
error500(res)
|
|
return true
|
|
end
|
|
|
|
local stat, err = pcall(res.parse, res)
|
|
if not stat then
|
|
error500(err)
|
|
return true
|
|
end
|
|
|
|
luci.template.render("cbi/header")
|
|
res:render()
|
|
luci.template.render("cbi/footer")
|
|
end
|
|
end
|