X-Git-Url: http://git.archive.openwrt.org/?a=blobdiff_plain;f=libs%2Fweb%2Fluasrc%2Fdispatcher.lua;h=8e8e19063b8e1149890c3ff608a0ac5f0e44c34f;hb=d61d0795a190dc7f63d6015790809990c9b72bf4;hp=756f3cc7d50f1f4dabf50dcc735666bb6a141518;hpb=3ca2844c9fb46145e5c6023e8767137992e558cb;p=project%2Fluci.git diff --git a/libs/web/luasrc/dispatcher.lua b/libs/web/luasrc/dispatcher.lua index 756f3cc7d..8e8e19063 100644 --- a/libs/web/luasrc/dispatcher.lua +++ b/libs/web/luasrc/dispatcher.lua @@ -23,14 +23,19 @@ 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") +--- LuCI web dispatcher. +local fs = require "luci.fs" +local sys = require "luci.sys" +local init = require "luci.init" +local util = require "luci.util" +local http = require "luci.http" + +module("luci.dispatcher", package.seeall) context = luci.util.threadlocal() +authenticator = {} + -- Index table local index = nil @@ -38,12 +43,16 @@ local index = nil 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.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" @@ -56,7 +65,9 @@ function error404(message) 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") @@ -68,26 +79,24 @@ function error500(message) return false end --- Renders an authorization form -function sysauth(default) +function authenticator.htmlauth(validator, accs, default) local user = luci.http.formvalue("username") local pass = luci.http.formvalue("password") - if user and luci.sys.user.checkpasswd(user, pass) then - local sid = luci.sys.uniqueid(16) - luci.http.header("Set-Cookie", "sysauth=" .. sid.."; path=/") - luci.sauth.write(sid, user) - return true - else - require("luci.i18n") - require("luci.template") - context.path = {} - luci.template.render("sysauth", {duser=default, fuser=user}) - return false + 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 --- Creates a request object for dispatching +--- Dispatch an HTTP request. +-- @param request LuCI HTTP Request object function httpdispatch(request) luci.http.context.request = request context.request = {} @@ -97,32 +106,53 @@ function httpdispatch(request) table.insert(context.request, node) end - dispatch(context.request) + local stat, err = util.copcall(dispatch, context.request) + if not stat then + error500(err) + end + luci.http.close() + + --context._disable_memtrace() end --- Dispatches a request +--- Dispatches a LuCI virtual path. +-- @param request Virtual path function dispatch(request) - context.path = request + --context._disable_memtrace = require "luci.debug".trap_memtrace() + local ctx = context + ctx.path = request - require("luci.i18n") - luci.i18n.setlanguage(require("luci.config").main.lang) + require "luci.i18n".setlanguage(require "luci.config".main.lang) - if not context.tree then - createtree() + local c = ctx.tree + local stat + if not c then + c = createtree() end - 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 + + util.update(track, c) + + if c.leaf then break end + end - for k, v in pairs(c) do - track[k] = v + if c and c.leaf then + for j=n+1, #request do + table.insert(args, request[j]) end end @@ -131,25 +161,51 @@ function dispatch(request) 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.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 not track.notemplate then + local tpl = require("luci.template") + local viewns = setmetatable({}, {__index=_G}) + tpl.context.viewns = viewns + viewns.write = luci.http.write + viewns.include = function(name) tpl.Template(name):render(getfenv(2)) end + viewns.translate = function(...) return require("luci.i18n").translate(...) end + viewns.striptags = 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") or "") .. (luci.http.getenv("PATH_INFO") or "") + end + + track.dependent = (track.dependent ~= false) + assert(not track.dependent or not track.auto, "Access Violation") if track.sysauth then - require("luci.sauth") + local sauth = 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 user = luci.sauth.read(luci.http.getcookie("sysauth")) - + local sess = ctx.authsession or luci.http.getcookie("sysauth") + sess = sess and sess:match("^[A-F0-9]+$") + local user = sauth.read(sess) - if not luci.util.contains(accs, user) then - if not sysauth(def) then + if not util.contains(accs, user) then + if authen then + local user, sess = authen(luci.sys.user.checkpasswd, accs, def) + if not user or not util.contains(accs, user) then + return + else + local sid = sess or luci.sys.uniqueid(16) + luci.http.header("Set-Cookie", "sysauth=" .. sid.."; path=/") + if not sess then + sauth.write(sid, user) + end + ctx.authsession = sid + end + else + luci.http.status(403, "Forbidden") return end end @@ -165,23 +221,28 @@ function dispatch(request) if c and type(c.target) == "function" then context.dispatched = c - stat, mod = luci.util.copcall(require, c.module) - if stat then - luci.util.updfenv(c.target, mod) - end - stat, err = luci.util.copcall(c.target) - if not stat then - error500(err) - end + util.copcall(function() + local oldenv = getfenv(c.target) + local module = require(c.module) + local env = setmetatable({}, {__index= + + function(tbl, key) + return rawget(tbl, key) or module[key] or oldenv[key] + end}) + + setfenv(c.target, env) + end) + + c.target(unpack(args)) else error404() end end --- Generates the dispatching tree +--- Generate the dispatching index using the best possible strategy. function createindex() - local path = luci.sys.libpath() .. "/controller/" + local path = luci.util.libpath() .. "/controller/" local suff = ".lua" if luci.util.copcall(require, "luci.fastindex") then @@ -191,7 +252,9 @@ function createindex() end end --- Uses fastindex to create the dispatching tree +--- 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 = {} @@ -207,89 +270,81 @@ 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 indexcache then + local cachedate = fs.mtime(indexcache) + if cachedate and cachedate > fs.mtime(path) then + + assert( + sys.process.info("uid") == fs.stat(indexcache, "uid") + and fs.stat(indexcache, "mode") == "rw-------", + "Fatal: Indexcache is not sane!" + ) + + index = loadfile(indexcache)() + return index + end + end + index = {} - local cache = nil - - local controllers = luci.util.combine( + local controllers = 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 + local mod = require(module) + local idx = mod.index - if cache then - cachefile = indexcache .. "/" .. module - stime = luci.fs.mtime(c) or 0 - ctime = luci.fs.mtime(cachefile) or 0 + if type(idx) == "function" then + index[module] = idx end - - if not cache or stime > ctime then - stat, mod = luci.util.copcall(require, module) + end - 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 + if indexcache then + fs.writefile(indexcache, util.get_bytecode(index)) + fs.chmod(indexcache, "a-rwx,u+rw") 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 index then createindex() end - context.tree = {nodes={}} - require("luci.i18n") - + local ctx = context + local tree = {nodes={}} + + ctx.treecache = setmetatable({}, {__mode="v"}) + ctx.tree = tree + -- Load default translation - luci.i18n.loadc("default") + require "luci.i18n".loadc("default") - local scope = luci.util.clone(_G) - for k,v in pairs(luci.dispatcher) do - if type(v) == "function" then - scope[k] = v - end - end + local scope = setmetatable({}, {__index = luci.dispatcher}) for k, v in pairs(index) do scope._NAME = k setfenv(v, scope) - - local stat, err = luci.util.copcall(v) - if not stat then - error500("createtree failed: " .. k .. ": " .. err) - luci.http.close() - os.exit(1) - end + v() end + + return tree 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(unpack(path)) obj.nodes = nil @@ -297,22 +352,18 @@ function assign(path, clone, title, order) obj.title = title obj.order = order - - 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}) + setmetatable(obj, {__index = _create_node(clone)}) 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(unpack(path)) @@ -324,40 +375,46 @@ function entry(path, target, title, order) return c end --- Checks whether a node exists -function registered(...) - local c = context.tree - - for k,v in ipairs(arg) do - if not c.nodes[v] then - return false - end - - c = c.nodes[v] - end - return true -end - --- Fetch a dispatching node +--- Fetch or create a new dispatching node. +-- @param ... Virtual path +-- @return Dispatching tree node function node(...) - local c = context.tree - arg.n = nil - - for k,v in ipairs(arg) do - if not c.nodes[v] then - c.nodes[v] = {nodes={}} - end - - c = c.nodes[v] - end + local c = _create_node({...}) c.module = getfenv(2)._NAME c.path = arg + c.auto = nil return c end +function _create_node(path, cache) + if #path == 0 then + return context.tree + end + + cache = cache or context.treecache + local name = table.concat(path, ".") + local c = cache[name] + + if not c then + local last = table.remove(path) + c = _create_node(path, cache) + + local new = {nodes={}, auto=true} + c.nodes[last] = new + cache[name] = new + + return new + else + return c + end +end + -- Subdispatchers -- + +--- Create a redirect to another dispatching node. +-- @param ... Virtual path destination function alias(...) local req = arg return function() @@ -365,6 +422,9 @@ function alias(...) 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() @@ -380,33 +440,34 @@ function rewrite(n, ...) end 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 + return function() + require("luci.template") + 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(...) + 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 + maps = luci.cbi.load(model, ...) 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 + res:parse() end luci.template.render("cbi/header") @@ -416,3 +477,24 @@ function cbi(model) 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) + return function(...) + require("luci.cbi") + require("luci.template") + + maps = luci.cbi.load(model, ...) + + for i, res in ipairs(maps) do + res:parse() + end + + luci.template.render("header") + for i, res in ipairs(maps) do + res:render() + end + luci.template.render("footer") + end +end