X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fluci.git;a=blobdiff_plain;f=libs%2Fweb%2Fluasrc%2Fdispatcher.lua;h=068f350ce4da22a756a834fe1667a948e7d22559;hp=025ae382d0b78385af6cdea349b5224732416688;hb=3bcab661283d5b9886e46d6bcdab0e756b044997;hpb=d0694fdb1ece991b57b748c29183ccd6563a9c42;ds=sidebyside diff --git a/libs/web/luasrc/dispatcher.lua b/libs/web/luasrc/dispatcher.lua index 025ae382d..068f350ce 100644 --- a/libs/web/luasrc/dispatcher.lua +++ b/libs/web/luasrc/dispatcher.lua @@ -23,129 +23,184 @@ See the License for the specific language governing permissions and limitations under the License. ]]-- + +--- LuCI web dispatcher. module("luci.dispatcher", package.seeall) +require("luci.util") require("luci.init") require("luci.http") require("luci.sys") require("luci.fs") --- Dirty OpenWRT fix -if (os.time() < luci.fs.mtime(luci.sys.libpath() .. "/dispatcher.lua")) 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 +context = luci.util.threadlocal() --- Local dispatch database -local tree = {nodes={}} +authenticator = {} -- Index table -local index = {} - --- Global request object -request = {} - --- Active dispatched node -dispatched = nil - --- Status fields -built_index = false -built_tree = false +local index = nil -- Fastindex local fi --- Builds a URL +--- Build the URL relative to the server webroot from given virtual path. +-- @param ... Virtual path +-- @return Relative 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 + return luci.http.getenv("SCRIPT_NAME") .. "/" .. table.concat(arg, "/") end --- Sends a 404 error code and renders the "error404" template if available +--- Send a 404 error code and render the "error404" template if available. +-- @param message Custom error message (optional) +-- @return false 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 + if not luci.util.copcall(luci.template.render, "error404") then luci.http.prepare_content("text/plain") - print(message) + luci.http.write(message) end return false end --- Sends a 500 error code and renders the "error500" template if available +--- Send a 500 error code and render the "error500" template if available. +-- @param message Custom error message (optional)# +-- @return false function error500(message) luci.http.status(500, "Internal Server Error") require("luci.template") - if not pcall(luci.template.render, "error500", {message=message}) then + if not luci.util.copcall(luci.template.render, "error500", {message=message}) then luci.http.prepare_content("text/plain") - print(message) + luci.http.write(message) end return false end --- Creates a request object for dispatching -function httpdispatch() - local pathinfo = luci.http.env.PATH_INFO or "" - local c = tree +function authenticator.htmlauth(validator, accs, default) + local user = luci.http.formvalue("username") + local pass = luci.http.formvalue("password") + + if user and validator(user, pass) then + return user + end + + require("luci.i18n") + require("luci.template") + context.path = {} + luci.template.render("sysauth", {duser=default, fuser=user}) + return false + +end + +--- Dispatch an HTTP request. +-- @param request LuCI HTTP Request object +function httpdispatch(request) + luci.http.context.request = request + context.request = {} + local pathinfo = request:getenv("PATH_INFO") or "" - for s in pathinfo:gmatch("([%w-]+)") do - table.insert(request, s) + for node in pathinfo:gmatch("[^/]+") do + table.insert(context.request, node) end - dispatch() + dispatch(context.request) + luci.http.close() end --- Dispatches a request -function dispatch() - if not built_tree then +--- Dispatches a LuCI virtual path. +-- @param request Virtual path +function dispatch(request) + context.path = request + + require("luci.i18n") + luci.i18n.setlanguage(require("luci.config").main.lang) + + if not context.tree then createtree() end - - local c = tree + + local c = context.tree local track = {} + local args = {} + context.args = args + local n for i, s in ipairs(request) do c = c.nodes[s] - if not c or c.leaf then + n = i + if not c 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)) + if c.leaf then + break end - - if not luci.http.basic_auth(sysauth) then - error401() - return + end + + if c and c.leaf then + for j=n+1, #request do + table.insert(args, request[j]) end end if track.i18n then require("luci.i18n").loadc(track.i18n) end + + -- Init template engine + local tpl = require("luci.template") + local viewns = {} + tpl.context.viewns = viewns + viewns.write = luci.http.write + viewns.translate = function(...) return require("luci.i18n").translate(...) end + viewns.striptags = luci.util.striptags + viewns.controller = luci.http.getenv("SCRIPT_NAME") + viewns.media = luci.config.main.mediaurlbase + viewns.resource = luci.config.main.resourcebase + viewns.REQUEST_URI = luci.http.getenv("SCRIPT_NAME") .. (luci.http.getenv("PATH_INFO") or "") + + if track.dependent then + local stat, err = pcall(assert, not track.auto) + if not stat then + error500(err) + return + end + end + + if track.sysauth then + require("luci.sauth") + local authen = type(track.sysauth_authenticator) == "function" + and track.sysauth_authenticator + or authenticator[track.sysauth_authenticator] + local def = (type(track.sysauth) == "string") and track.sysauth + local accs = def and {track.sysauth} or track.sysauth + local sess = luci.http.getcookie("sysauth") + sess = sess and sess:match("^[A-F0-9]+$") + local user = luci.sauth.read(sess) + + if not luci.util.contains(accs, user) then + if authen then + local user = authen(luci.sys.user.checkpasswd, accs, def) + if not user or not luci.util.contains(accs, user) then + return + else + local sid = luci.sys.uniqueid(16) + luci.http.header("Set-Cookie", "sysauth=" .. sid.."; path=/") + luci.sauth.write(sid, user) + end + else + luci.http.status(403, "Forbidden") + return + end + end + end if track.setgroup then luci.sys.process.setgroup(track.setgroup) @@ -154,25 +209,15 @@ function dispatch() 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.REQUEST_URI = luci.http.env.SCRIPT_NAME .. luci.http.env.PATH_INFO - if c and type(c.target) == "function" then - dispatched = c - stat, mod = pcall(require, c.module) + context.dispatched = c + stat, mod = luci.util.copcall(require, c.module) if stat then luci.util.updfenv(c.target, mod) end - stat, err = pcall(c.target) + stat, err = luci.util.copcall(c.target, unpack(args)) if not stat then error500(err) end @@ -181,23 +226,24 @@ function dispatch() end end --- Generates the dispatching tree +--- Generate the dispatching index using the best possible strategy. function createindex() - index = {} - local path = luci.sys.libpath() .. "/controller/" + local path = luci.util.libpath() .. "/controller/" local suff = ".lua" - if pcall(require, "luci.fastindex") then + if luci.util.copcall(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) +--- Generate the dispatching index using the fastindex C-indexer. +-- @param path Controller base directory +-- @param suffix Controller file suffix +function createindex_fastindex(path, suffix) + index = {} + if not fi then fi = luci.fastindex.new("index") fi.add(path .. "*" .. suffix) @@ -210,12 +256,11 @@ function createindex_fastindex(path, suffix) 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 +--- Generate the dispatching index using the native file-cache based strategy. +-- @param path Controller base directory +-- @param suffix Controller file suffix function createindex_plain(path, suffix) - if built_index then - return - end + index = {} local cache = nil @@ -247,13 +292,13 @@ function createindex_plain(path, suffix) end if not cache or stime > ctime then - stat, mod = pcall(require, module) + stat, mod = luci.util.copcall(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)) + luci.fs.writefile(cachefile, luci.util.get_bytecode(mod.index)) end end else @@ -262,19 +307,21 @@ function createindex_plain(path, suffix) end end --- Creates the dispatching tree from the index +--- Create the dispatching tree from the index. +-- Build the index before if it does not exist yet. function createtree() - if not built_index then + if not index then createindex() end + context.tree = {nodes={}} require("luci.i18n") -- Load default translation luci.i18n.loadc("default") local scope = luci.util.clone(_G) - for k,v in pairs(_M) do + for k,v in pairs(luci.dispatcher) do if type(v) == "function" then scope[k] = v end @@ -283,34 +330,52 @@ function createtree() for k, v in pairs(index) do scope._NAME = k setfenv(v, scope) - - local stat, err = pcall(v) + + local stat, err = luci.util.copcall(v) if not stat then - error500(err) + error500("createtree failed: " .. k .. ": " .. err) + luci.http.close() os.exit(1) end end - - built_tree = true end --- Reassigns a node to another position +--- Clone a node of the dispatching tree to another position. +-- @param path Virtual path destination +-- @param clone Virtual path source +-- @param title Destination node title (optional) +-- @param order Destination node order value (optional) +-- @return Dispatching tree node function assign(path, clone, title, order) - local obj = node(path) + local obj = node(unpack(path)) obj.nodes = nil obj.module = nil obj.title = title obj.order = order - setmetatable(obj, {__index = clone}) + local c = context.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 +--- Create a new dispatching node and define common parameters. +-- @param path Virtual path +-- @param target Target function to call when dispatched. +-- @param title Destination node title +-- @param order Destination node order value (optional) +-- @return Dispatching tree node function entry(path, target, title, order) - local c = node(path) + local c = node(unpack(path)) c.target = target c.title = title @@ -320,77 +385,126 @@ function entry(path, target, title, order) return c end --- Fetch a dispatching node +--- Fetch or create a new dispatching node. +-- @param ... Virtual path +-- @return Dispatching tree node function node(...) - local c = tree - - if arg[1] and type(arg[1]) == "table" then - arg = arg[1] - end + local c = context.tree + arg.n = nil for k,v in ipairs(arg) do if not c.nodes[v] then - c.nodes[v] = {nodes={}, module=getfenv(2)._NAME} + c.nodes[v] = {nodes={}, auto=true} end c = c.nodes[v] end + c.module = getfenv(2)._NAME + c.path = arg + c.auto = nil + return c end -- Subdispatchers -- + +--- Create a redirect to another dispatching node. +-- @param ... Virtual path destination function alias(...) local req = arg return function() - request = req - dispatch() + dispatch(req) end end +--- Rewrite the first x path values of the request. +-- @param n Number of path values to replace +-- @param ... Virtual path to replace removed path values with function rewrite(n, ...) local req = arg return function() for i=1,n do - table.remove(request, 1) + table.remove(context.path, 1) end for i,r in ipairs(req) do - table.insert(request, i, r) + table.insert(context.path, i, r) end dispatch() end end -function call(name) - return function() getfenv()[name]() end +--- Create a function-call dispatching target. +-- @param name Target function of local controller +-- @param ... Additional parameters passed to the function +function call(name, ...) + local argv = {...} + return function() return getfenv()[name](unpack(argv)) end end +--- Create a template render dispatching target. +-- @param name Template to be rendered function template(name) require("luci.template") return function() luci.template.render(name) end end +--- Create a CBI model dispatching target. +-- @param model CBI model tpo be rendered function cbi(model) require("luci.cbi") require("luci.template") - return function() - local stat, res = pcall(luci.cbi.load, model) + return function(...) + local stat, maps = luci.util.copcall(luci.cbi.load, model, ...) if not stat then - error500(res) + error500(maps) return true end - local stat, err = pcall(res.parse, res) - if not stat then - error500(err) - return true + for i, res in ipairs(maps) do + local stat, err = luci.util.copcall(res.parse, res) + if not stat then + error500(err) + return true + end end luci.template.render("cbi/header") - res:render() + for i, res in ipairs(maps) do + res:render() + end luci.template.render("cbi/footer") end end + +--- Create a CBI form model dispatching target. +-- @param model CBI form model tpo be rendered +function form(model) + require("luci.cbi") + require("luci.template") + + return function(...) + local stat, maps = luci.util.copcall(luci.cbi.load, model, ...) + if not stat then + error500(maps) + return true + end + + for i, res in ipairs(maps) do + local stat, err = luci.util.copcall(res.parse, res) + if not stat then + error500(err) + return true + end + end + + luci.template.render("header") + for i, res in ipairs(maps) do + res:render() + end + luci.template.render("footer") + end +end