X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fluci.git;a=blobdiff_plain;f=libs%2Fweb%2Fluasrc%2Fdispatcher.lua;h=735e2a7150c6e6bb28255217882e989ef0d15056;hp=fc551a4bdeb54efa83985742e7c83e3998d1f0c8;hb=d0a622dce8163cb1f9d0a178127b7abda6c4e818;hpb=776f9957d0376670e9d3e43677dbe3ba19ded193 diff --git a/libs/web/luasrc/dispatcher.lua b/libs/web/luasrc/dispatcher.lua index fc551a4bd..735e2a715 100644 --- a/libs/web/luasrc/dispatcher.lua +++ b/libs/web/luasrc/dispatcher.lua @@ -24,30 +24,23 @@ limitations under the License. ]]-- module("luci.dispatcher", package.seeall) +require("luci.init") require("luci.http") require("luci.sys") require("luci.fs") --- Local dispatch database -local tree = {nodes={}} +context = luci.util.threadlocal() -- Index table -local index = {} +local index = nil --- 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, "/") + return luci.http.getenv("SCRIPT_NAME") .. "/" .. table.concat(arg, "/") end -- Sends a 404 error code and renders the "error404" template if available @@ -56,9 +49,9 @@ function error404(message) 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 @@ -68,37 +61,63 @@ 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 +-- Renders an authorization form +function sysauth(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 + end +end + -- Creates a request object for dispatching -function httpdispatch() - local pathinfo = luci.http.env.PATH_INFO or "" - local c = tree +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 +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 = {} for i, s in ipairs(request) do c = c.nodes[s] - if not c then + if not c or c.leaf then break end @@ -107,10 +126,34 @@ function dispatch() 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.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.sysauth then + require("luci.sauth") + 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")) + + + if not luci.util.contains(accs, user) then + if not sysauth(def) then + return + end + end + end if track.setgroup then luci.sys.process.setgroup(track.setgroup) @@ -119,27 +162,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 - - -- Load default translation - require("luci.i18n").loadc("default") - 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) if not stat then error500(err) end @@ -150,24 +181,25 @@ end -- Generates the dispatching tree function createindex() - index = {} local path = luci.sys.libpath() .. "/controller/" local suff = ".lua" - if pcall(require, "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) - local fi = fastindex.new("index") - fi.add(path .. "*" .. suffix) - fi.add(path .. "*/*" .. suffix) +function createindex_fastindex(path, suffix) + index = {} + + 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 @@ -176,8 +208,11 @@ function createindex_fastindex(path, suffix) 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) - local cachetime = nil + index = {} + + local cache = nil local controllers = luci.util.combine( luci.fs.glob(path .. "*" .. suffix) or {}, @@ -185,84 +220,126 @@ function createindex_plain(path, suffix) ) if indexcache then - cachetime = luci.fs.mtime(indexcache) + cache = luci.fs.mtime(indexcache) - if not cachetime then + if not cache then luci.fs.mkdir(indexcache) luci.fs.chmod(indexcache, "a=,u=rwx") + cache = luci.fs.mtime(indexcache) end end - if not cachetime then - for i,c in ipairs(controllers) do - c = "luci.controller." .. c:sub(#path+1, #c-#suffix):gsub("/", ".") - stat, mod = pcall(require, c) + 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 = luci.util.copcall(require, module) if stat and mod and type(mod.index) == "function" then - index[c] = mod.index + index[module] = mod.index - if indexcache then - luci.fs.writefile(indexcache .. "/" .. c, string.dump(mod.index)) + if cache then + luci.fs.writefile(cachefile, luci.util.dump(mod.index)) end end - end - else - for i,c in ipairs(luci.fs.dir(indexcache)) do - if c:sub(1) ~= "." then - index[c] = loadfile(indexcache .. "/" .. c) - end + else + index[module] = loadfile(cachefile) end end end -- Creates the dispatching tree from the index 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(luci.dispatcher) do + if type(v) == "function" then + scope[k] = v + end + end for k, v in pairs(index) do - luci.util.updfenv(v, _M) - luci.util.extfenv(v, "_NAME", k) - pcall(v) + 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 + end +end + +-- Reassigns a node to another position +function assign(path, clone, title, order) + local obj = node(unpack(path)) + obj.nodes = nil + obj.module = nil + + 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 - built_tree = true + setmetatable(obj, {__index = c}) + + return obj end -- Shortcut for creating a dispatching node -function entry(path, target, title, order, add) - add = add or {} - - local c = node(path) +function entry(path, target, title, order) + local c = node(unpack(path)) + c.target = target c.title = title c.order = order c.module = getfenv(2)._NAME - for k,v in pairs(add) do - c[k] = v - end - return c end -- Fetch a dispatching 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={}} end c = c.nodes[v] end + c.module = getfenv(2)._NAME + c.path = arg + return c end @@ -270,13 +347,28 @@ end function alias(...) local req = arg return function() - request = req + dispatch(req) + end +end + +function rewrite(n, ...) + local req = arg + return function() + for i=1,n do + table.remove(context.path, 1) + end + + for i,r in ipairs(req) do + table.insert(context.path, i, r) + end + dispatch() end end -function call(name) - return function() getfenv()[name]() end +function call(name, ...) + local argv = {...} + return function() return getfenv()[name](unpack(argv)) end end function template(name) @@ -289,20 +381,24 @@ function cbi(model) require("luci.template") return function() - local stat, res = pcall(luci.cbi.load, model) + 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