X-Git-Url: https://git.archive.openwrt.org/?p=project%2Fluci.git;a=blobdiff_plain;f=libs%2Fweb%2Fluasrc%2Fdispatcher.lua;h=5110209aacb21e0ab6781d61b49b016ebe7bce1e;hp=0666060ed515d1476772519bb9b40e926e17c974;hb=ab18c3ba1006db94df57c310da97b5ddb07991ad;hpb=90a6f45d33a3b5590e315f267713d526583ace19

diff --git a/libs/web/luasrc/dispatcher.lua b/libs/web/luasrc/dispatcher.lua
index 0666060ed..5110209aa 100644
--- a/libs/web/luasrc/dispatcher.lua
+++ b/libs/web/luasrc/dispatcher.lua
@@ -25,13 +25,14 @@ limitations under the License.
 ]]--
 
 --- LuCI web dispatcher.
-module("luci.dispatcher", package.seeall)
-require("luci.init")
-require("luci.http")
-require("luci.sys")
-require("luci.fs")
+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"
 
-context = luci.util.threadlocal()
+module("luci.dispatcher", package.seeall)
+context = util.threadlocal()
 
 authenticator = {}
 
@@ -46,7 +47,12 @@ local fi
 -- @param ...	Virtual path
 -- @return 		Relative URL
 function build_url(...)
-	return luci.http.getenv("SCRIPT_NAME") .. "/" .. table.concat(arg, "/")
+	local path = {...}
+	local sn = http.getenv("SCRIPT_NAME") or ""
+	for k, v in pairs(context.urltoken) do
+		sn = sn .. "/;" .. k .. "=" .. http.urlencode(v)
+	end
+	return sn .. ((#path > 0) and "/" .. table.concat(path, "/") or "")
 end
 
 --- Send a 404 error code and render the "error404" template if available.
@@ -78,20 +84,20 @@ function error500(message)
 	return false
 end
 
-function authenticator.htmlauth(validator, default)
+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.
@@ -99,98 +105,191 @@ end
 function httpdispatch(request)
 	luci.http.context.request = request
 	context.request = {}
-	local pathinfo = request:getenv("PATH_INFO") or ""
+	local pathinfo = http.urldecode(request:getenv("PATH_INFO") or "", true)
 
 	for node in pathinfo:gmatch("[^/]+") do
 		table.insert(context.request, node)
 	end
 
-	dispatch(context.request)
+	local stat, err = util.copcall(dispatch, context.request)
+	if not stat then
+		luci.util.perror(err)
+		error500(err)
+	end
+
 	luci.http.close()
+
+	--context._disable_memtrace()
 end
 
 --- 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()
+	--context._disable_memtrace = require "luci.debug".trap_memtrace()
+	local ctx = context
+	ctx.path = request
+	ctx.urltoken   = ctx.urltoken or {}
+
+	local conf = require "luci.config"
+	local lang = conf.main.lang
+	if lang == "auto" then
+		local aclang = http.getenv("HTTP_ACCEPT_LANGUAGE") or ""
+		for lpat in aclang:gmatch("[%w-]+") do
+			lpat = lpat and lpat:gsub("-", "_")
+			if conf.languages[lpat] then
+				lang = lpat
+				break
+			end
+		end
+        end
+	require "luci.i18n".setlanguage(lang)
+
+	local c = ctx.tree
+	local stat
+	if not c then
+		c = createtree()
 	end
-	
-	local c = context.tree
+
 	local track = {}
 	local args = {}
+	ctx.args = args
+	ctx.requestargs = ctx.requestargs or args
 	local n
+	local t = true
+	local token = ctx.urltoken
+	local preq = {}
+	local freq = {}
 
 	for i, s in ipairs(request) do
-		c = c.nodes[s]
-		n = i
-		if not c or c.leaf then
-			break
+		local tkey, tval
+		if t then
+			tkey, tval = s:match(";(%w+)=(.*)")
 		end
 
-		for k, v in pairs(c) do
-			track[k] = v
+		if tkey then
+			token[tkey] = tval
+		else
+			t = false
+			preq[#preq+1] = s
+			freq[#freq+1] = s
+			c = c.nodes[s]
+			n = i
+			if not c then
+				break
+			end
+
+			util.update(track, c)
+
+			if c.leaf then
+				break
+			end
 		end
 	end
 
 	if c and c.leaf then
 		for j=n+1, #request do
-			table.insert(args, request[j])
+			args[#args+1] = request[j]
+			freq[#freq+1] = request[j]
 		end
 	end
 
+	ctx.requestpath = freq
+	ctx.path = preq
+
 	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.dependent then
-		local stat, err = pcall(assert, not track.auto)
-		if not stat then
-			error500(err)
-			return
+	if (c and c.index) or not track.notemplate then
+		local tpl = require("luci.template")
+		local media = track.mediaurlbase or luci.config.main.mediaurlbase
+		if not pcall(tpl.Template, "themes/%s/header" % fs.basename(media)) then
+			media = nil
+			for name, theme in pairs(luci.config.themes) do
+				if name:sub(1,1) ~= "." and pcall(tpl.Template,
+				 "themes/%s/header" % fs.basename(theme)) then
+					media = theme
+				end
+			end
+			assert(media, "No valid theme found")
 		end
+
+		local viewns = setmetatable({}, {__index=function(table, key)
+			if key == "controller" then
+				return build_url()
+			elseif key == "REQUEST_URI" then
+				return build_url(unpack(ctx.requestpath))
+			else
+				return rawget(table, key) or _G[key]
+			end
+		end})
+		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.media       = media
+		viewns.theme       = fs.basename(media)
+		viewns.resource    = luci.config.main.resourcebase
 	end
-	
+
+	track.dependent = (track.dependent ~= false)
+	assert(not track.dependent or not track.auto, "Access Violation")
+
 	if track.sysauth then
-		require("luci.sauth")
-		local authen = authenticator[track.sysauth_authenticator]
+		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"))
-		
-		if not luci.util.contains(accs, user) then
+		local sess = ctx.authsession
+		local verifytoken = false
+		if not sess then
+			sess = luci.http.getcookie("sysauth")
+			sess = sess and sess:match("^[A-F0-9]+$")
+			verifytoken = true
+		end
+
+		local sdat = sauth.read(sess)
+		local user
+
+		if sdat then
+			sdat = loadstring(sdat)()
+			if not verifytoken or ctx.urltoken.stok == sdat.token then
+				user = sdat.user
+			end
+		end
+
+		if not util.contains(accs, user) then
 			if authen then
-				local user = authen(luci.sys.user.checkpasswd, def)
-				if not user or not luci.util.contains(accs, user) then
+				ctx.urltoken.stok = nil
+				local user, sess = authen(luci.sys.user.checkpasswd, accs, def)
+				if not user or not 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)
+					local sid = sess or luci.sys.uniqueid(16)
+					if not sess then
+						local token = luci.sys.uniqueid(16)
+						sauth.write(sid, util.get_bytecode({
+							user=user,
+							token=token,
+							secret=luci.sys.uniqueid(16)
+						}))
+						ctx.urltoken.stok = token
+					end
+					luci.http.header("Set-Cookie", "sysauth=" .. sid.."; path="..build_url())
+					ctx.authsession = sid
 				end
 			else
 				luci.http.status(403, "Forbidden")
 				return
 			end
 		else
-			luci.http.status(403, "Forbidden")
-			return
+			ctx.authsession = sess
 		end
 	end
 
@@ -202,16 +301,45 @@ function dispatch(request)
 		luci.sys.process.setuser(track.setuser)
 	end
 
-	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)
+	local target = nil
+	if c then
+		if type(c.target) == "function" then
+			target = c.target
+		elseif type(c.target) == "table" then
+			target = c.target.target
 		end
-		
-		stat, err = luci.util.copcall(c.target, unpack(args))
-		if not stat then
-			error500(err)
+	end
+
+	if c and (c.index or type(target) == "function") then
+		ctx.dispatched = c
+		ctx.requested = ctx.requested or ctx.dispatched
+	end
+
+	if c and c.index then
+		local tpl = require "luci.template"
+
+		if util.copcall(tpl.render, "indexer", {}) then
+			return true
+		end
+	end
+
+	if type(target) == "function" then
+		util.copcall(function()
+			local oldenv = getfenv(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(target, env)
+		end)
+
+		if type(c.target) == "table" then
+			target(c.target, unpack(args))
+		else
+			target(unpack(args))
 		end
 	else
 		error404()
@@ -222,7 +350,7 @@ end
 function createindex()
 	local path = luci.util.libpath() .. "/controller/"
 	local suff = ".lua"
-	
+
 	if luci.util.copcall(require, "luci.fastindex") then
 		createindex_fastindex(path, suff)
 	else
@@ -235,14 +363,14 @@ end
 -- @param suffix	Controller file 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
 		index[v[2]] = v[1]
 	end
@@ -252,51 +380,49 @@ end
 -- @param path		Controller base directory
 -- @param suffix	Controller file suffix
 function createindex_plain(path, suffix)
-	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)
+		local cachedate = fs.mtime(indexcache)
+		if cachedate then
+			local realdate = 0
+			for _, obj in ipairs(controllers) do
+				local omtime = fs.mtime(path .. "/" .. obj)
+				realdate = (omtime and omtime > realdate) and omtime or realdate
+			end
+
+			if cachedate > realdate 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
 	end
 
+	index = {}
+
 	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[module] = mod.index
-				
-				if cache then
-					luci.fs.writefile(cachefile, luci.util.get_bytecode(mod.index))
-				end
-			end
-		else
-			index[module] = loadfile(cachefile)
+		local mod = require(module)
+		local idx = mod.index
+
+		if type(idx) == "function" then
+			index[module] = idx
 		end
 	end
+
+	if indexcache then
+		fs.writefile(indexcache, util.get_bytecode(index))
+		fs.chmod(indexcache, "a-rwx,u+rw")
+	end
 end
 
 --- Create the dispatching tree from the index.
@@ -305,31 +431,49 @@ function createtree()
 	if not index then
 		createindex()
 	end
-	
-	context.tree = {nodes={}}
-	require("luci.i18n")
-		
+
+	local ctx  = context
+	local tree = {nodes={}}
+	local modi = {}
+
+	ctx.treecache = setmetatable({}, {__mode="v"})
+	ctx.tree = tree
+	ctx.modifiers = modi
+
 	-- 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
+	require "luci.i18n".loadc("default")
+
+	local scope = setmetatable({}, {__index = luci.dispatcher})
 
 	for k, v in pairs(index) do
 		scope._NAME = k
 		setfenv(v, scope)
+		v()
+	end
 
-		local stat, err = luci.util.copcall(v)
-		if not stat then
-			error500("createtree failed: " .. k .. ": " .. err)
-			luci.http.close()
-			os.exit(1)
-		end
+	local function modisort(a,b)
+		return modi[a].order < modi[b].order
 	end
+
+	for _, v in util.spairs(modi, modisort) do
+		scope._NAME = v.module
+		setfenv(v.func, scope)
+		v.func()
+	end
+
+	return tree
+end
+
+--- Register a tree modifier.
+-- @param	func	Modifier function
+-- @param	order	Modifier order value (optional)
+function modifier(func, order)
+	context.modifiers[#context.modifiers+1] = {
+		func = func,
+		order = order or 0,
+		module
+			= getfenv(2)._NAME
+	}
 end
 
 --- Clone a node of the dispatching tree to another position.
@@ -342,33 +486,24 @@ 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
-	
-	setmetatable(obj, {__index = c})
-	
+	setmetatable(obj, {__index = _create_node(clone)})
+
 	return obj
 end
 
 --- Create a new dispatching node and define common parameters.
 -- @param	path	Virtual path
--- @param	target	Target function to call when dispatched. 
+-- @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))
-	
+
 	c.target = target
 	c.title  = title
 	c.order  = order
@@ -381,31 +516,49 @@ end
 -- @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={}, auto=true}
-		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 new = {nodes={}, auto=true, path=util.clone(path)}
+		local last = table.remove(path)
+
+		c = _create_node(path, cache)
+
+		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()
+	local req = {...}
+	return function(...)
+		for _, r in ipairs({...}) do
+			req[#req+1] = r
+		end
+
 		dispatch(req)
 	end
 end
@@ -414,89 +567,154 @@ end
 -- @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(context.path, 1)
+	local req = {...}
+	return function(...)
+		local dispatched = util.clone(context.dispatched)
+
+		for i=1,n do
+			table.remove(dispatched, 1)
 		end
-		
-		for i,r in ipairs(req) do
-			table.insert(context.path, i, r)
+
+		for i, r in ipairs(req) do
+			table.insert(dispatched, i, r)
 		end
-		
-		dispatch()
+
+		for _, r in ipairs({...}) do
+			dispatched[#dispatched+1] = r
+		end
+
+		dispatch(dispatched)
+	end
+end
+
+
+local function _call(self, ...)
+	if #self.argv > 0 then 
+		return getfenv()[self.name](unpack(self.argv), ...)
+	else
+		return getfenv()[self.name](...)
 	end
 end
 
 --- Create a function-call dispatching target.
--- @param	name	Target function of local controller 
+-- @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
+	return {type = "call", argv = {...}, name = name, target = _call}
+end
+
+
+local _template = function(self, ...)
+	require "luci.template".render(self.view)
 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 {type = "template", view = name, target = _template}
 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, maps = luci.util.copcall(luci.cbi.load, model, ...)
-		if not stat then
-			error500(maps)
-			return true
+local function _cbi(self, ...)
+	local cbi = require "luci.cbi"
+	local tpl = require "luci.template"
+	local http = require "luci.http"
+
+	local config = self.config or {}
+	local maps = cbi.load(self.model, ...)
+
+	local state = nil
+
+	for i, res in ipairs(maps) do
+		if config.autoapply then
+			res.autoapply = config.autoapply
+		end
+		local cstate = res:parse()
+		if not state or cstate < state then
+			state = cstate
 		end
+	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
+	if config.on_valid_to and state and state > 0 and state < 2 then
+		http.redirect(config.on_valid_to)
+		return
+	end
+
+	if config.on_changed_to and state and state > 1 then
+		http.redirect(config.on_changed_to)
+		return
+	end
+
+	if config.on_success_to and state and state > 0 then
+		http.redirect(config.on_success_to)
+		return
+	end
+
+	if config.state_handler then
+		if not config.state_handler(state, maps) then
+			return
 		end
+	end
 
-		luci.template.render("cbi/header")
-		for i, res in ipairs(maps) do
-			res:render()
+	local pageaction = true
+	http.header("X-CBI-State", state or 0)
+	tpl.render("cbi/header", {state = state})
+	for i, res in ipairs(maps) do
+		res:render()
+		if res.pageaction == false then
+			pageaction = false
 		end
-		luci.template.render("cbi/footer")
 	end
+	tpl.render("cbi/footer", {pageaction=pageaction, state = state, autoapply = config.autoapply})
 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")
+--- Create a CBI model dispatching target.
+-- @param	model	CBI model to be rendered
+function cbi(model, config)
+	return {type = "cbi", config = config, model = model, target = _cbi}
+end
 
-	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
+local function _arcombine(self, ...)
+	local argv = {...}
+	local target = #argv > 0 and self.targets[2] or self.targets[1]
+	setfenv(target.target, self.env)
+	target:target(unpack(argv))
+end
+
+--- Create a combined dispatching target for non argv and argv requests.
+-- @param trg1	Overview Target
+-- @param trg2	Detail Target
+function arcombine(trg1, trg2)
+	return {type = "arcombine", env = getfenv(), target = _arcombine, targets = {trg1, trg2}}
+end
 
-		luci.template.render("header")
-		for i, res in ipairs(maps) do
-			res:render()
+
+local function _form(self, ...)
+	local cbi = require "luci.cbi"
+	local tpl = require "luci.template"
+	local http = require "luci.http"
+
+	local maps = luci.cbi.load(self.model, ...)
+	local state = nil
+
+	for i, res in ipairs(maps) do
+		local cstate = res:parse()
+		if not state or cstate < state then
+			state = cstate
 		end
-		luci.template.render("footer")
 	end
+
+	http.header("X-CBI-State", state or 0)
+	tpl.render("header")
+	for i, res in ipairs(maps) do
+		res:render()
+	end
+	tpl.render("footer")
+end
+
+--- Create a CBI form model dispatching target.
+-- @param	model	CBI form model tpo be rendered
+function form(model)
+	return {type = "cbi", model = model, target = _form}
 end