565e995d191d5fdf38367db732dac746a471baa7
[project/luci.git] / libs / web / luasrc / dispatcher.lua
1 --[[
2 LuCI - Dispatcher
3
4 Description:
5 The request dispatcher and module dispatcher generators
6
7 FileId:
8 $Id$
9
10 License:
11 Copyright 2008 Steven Barth <steven@midlink.org>
12
13 Licensed under the Apache License, Version 2.0 (the "License");
14 you may not use this file except in compliance with the License.
15 You may obtain a copy of the License at
16
17 http://www.apache.org/licenses/LICENSE-2.0
18
19 Unless required by applicable law or agreed to in writing, software
20 distributed under the License is distributed on an "AS IS" BASIS,
21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 See the License for the specific language governing permissions and
23 limitations under the License.
24
25 ]]--
26
27 --- LuCI web dispatcher.
28 local fs = require "luci.fs"
29 local sys = require "luci.sys"
30 local init = require "luci.init"
31 local util = require "luci.util"
32 local http = require "luci.http"
33
34 module("luci.dispatcher", package.seeall)
35 context = util.threadlocal()
36
37 authenticator = {}
38
39 -- Index table
40 local index = nil
41
42 -- Fastindex
43 local fi
44
45
46 --- Build the URL relative to the server webroot from given virtual path.
47 -- @param ... Virtual path
48 -- @return Relative URL
49 function build_url(...)
50 local path = {...}
51 local sn = http.getenv("SCRIPT_NAME") or ""
52 for k, v in pairs(context.urltoken) do
53 sn = sn .. "/;" .. k .. "=" .. http.urlencode(v)
54 end
55 return sn .. ((#path > 0) and "/" .. table.concat(path, "/") or "")
56 end
57
58 --- Send a 404 error code and render the "error404" template if available.
59 -- @param message Custom error message (optional)
60 -- @return false
61 function error404(message)
62 luci.http.status(404, "Not Found")
63 message = message or "Not Found"
64
65 require("luci.template")
66 if not luci.util.copcall(luci.template.render, "error404") then
67 luci.http.prepare_content("text/plain")
68 luci.http.write(message)
69 end
70 return false
71 end
72
73 --- Send a 500 error code and render the "error500" template if available.
74 -- @param message Custom error message (optional)#
75 -- @return false
76 function error500(message)
77 luci.util.perror(message)
78 if not context.template_header_sent then
79 luci.http.status(500, "Internal Server Error")
80 luci.http.prepare_content("text/plain")
81 luci.http.write(message)
82 else
83 require("luci.template")
84 if not luci.util.copcall(luci.template.render, "error500", {message=message}) then
85 luci.http.prepare_content("text/plain")
86 luci.http.write(message)
87 end
88 end
89 return false
90 end
91
92 function authenticator.htmlauth(validator, accs, default)
93 local user = luci.http.formvalue("username")
94 local pass = luci.http.formvalue("password")
95
96 if user and validator(user, pass) then
97 return user
98 end
99
100 require("luci.i18n")
101 require("luci.template")
102 context.path = {}
103 luci.template.render("sysauth", {duser=default, fuser=user})
104 return false
105
106 end
107
108 --- Dispatch an HTTP request.
109 -- @param request LuCI HTTP Request object
110 function httpdispatch(request)
111 luci.http.context.request = request
112 context.request = {}
113 local pathinfo = http.urldecode(request:getenv("PATH_INFO") or "", true)
114
115 for node in pathinfo:gmatch("[^/]+") do
116 table.insert(context.request, node)
117 end
118
119 local stat, err = util.coxpcall(function()
120 dispatch(context.request)
121 end, error500)
122
123 luci.http.close()
124
125 --context._disable_memtrace()
126 end
127
128 --- Dispatches a LuCI virtual path.
129 -- @param request Virtual path
130 function dispatch(request)
131 --context._disable_memtrace = require "luci.debug".trap_memtrace()
132 local ctx = context
133 ctx.path = request
134 ctx.urltoken = ctx.urltoken or {}
135
136 local conf = require "luci.config"
137 assert(conf.main,
138 "/etc/config/luci seems to be corrupt, unable to find section 'main'")
139
140 local lang = conf.main.lang
141 if lang == "auto" then
142 local aclang = http.getenv("HTTP_ACCEPT_LANGUAGE") or ""
143 for lpat in aclang:gmatch("[%w-]+") do
144 lpat = lpat and lpat:gsub("-", "_")
145 if conf.languages[lpat] then
146 lang = lpat
147 break
148 end
149 end
150 end
151 require "luci.i18n".setlanguage(lang)
152
153 local c = ctx.tree
154 local stat
155 if not c then
156 c = createtree()
157 end
158
159 local track = {}
160 local args = {}
161 ctx.args = args
162 ctx.requestargs = ctx.requestargs or args
163 local n
164 local t = true
165 local token = ctx.urltoken
166 local preq = {}
167 local freq = {}
168
169 for i, s in ipairs(request) do
170 local tkey, tval
171 if t then
172 tkey, tval = s:match(";(%w+)=(.*)")
173 end
174
175 if tkey then
176 token[tkey] = tval
177 else
178 t = false
179 preq[#preq+1] = s
180 freq[#freq+1] = s
181 c = c.nodes[s]
182 n = i
183 if not c then
184 break
185 end
186
187 util.update(track, c)
188
189 if c.leaf then
190 break
191 end
192 end
193 end
194
195 if c and c.leaf then
196 for j=n+1, #request do
197 args[#args+1] = request[j]
198 freq[#freq+1] = request[j]
199 end
200 end
201
202 ctx.requestpath = freq
203 ctx.path = preq
204
205 if track.i18n then
206 require("luci.i18n").loadc(track.i18n)
207 end
208
209 -- Init template engine
210 if (c and c.index) or not track.notemplate then
211 local tpl = require("luci.template")
212 local media = track.mediaurlbase or luci.config.main.mediaurlbase
213 if not pcall(tpl.Template, "themes/%s/header" % fs.basename(media)) then
214 media = nil
215 for name, theme in pairs(luci.config.themes) do
216 if name:sub(1,1) ~= "." and pcall(tpl.Template,
217 "themes/%s/header" % fs.basename(theme)) then
218 media = theme
219 end
220 end
221 assert(media, "No valid theme found")
222 end
223
224 local viewns = setmetatable({}, {__index=function(table, key)
225 if key == "controller" then
226 return build_url()
227 elseif key == "REQUEST_URI" then
228 return build_url(unpack(ctx.requestpath))
229 else
230 return rawget(table, key) or _G[key]
231 end
232 end})
233 tpl.context.viewns = viewns
234 viewns.write = luci.http.write
235 viewns.include = function(name) tpl.Template(name):render(getfenv(2)) end
236 viewns.translate = function(...) return require("luci.i18n").translate(...) end
237 viewns.striptags = util.striptags
238 viewns.media = media
239 viewns.theme = fs.basename(media)
240 viewns.resource = luci.config.main.resourcebase
241 end
242
243 track.dependent = (track.dependent ~= false)
244 assert(not track.dependent or not track.auto, "Access Violation")
245
246 if track.sysauth then
247 local sauth = require "luci.sauth"
248
249 local authen = type(track.sysauth_authenticator) == "function"
250 and track.sysauth_authenticator
251 or authenticator[track.sysauth_authenticator]
252
253 local def = (type(track.sysauth) == "string") and track.sysauth
254 local accs = def and {track.sysauth} or track.sysauth
255 local sess = ctx.authsession
256 local verifytoken = false
257 if not sess then
258 sess = luci.http.getcookie("sysauth")
259 sess = sess and sess:match("^[A-F0-9]+$")
260 verifytoken = true
261 end
262
263 local sdat = sauth.read(sess)
264 local user
265
266 if sdat then
267 sdat = loadstring(sdat)()
268 if not verifytoken or ctx.urltoken.stok == sdat.token then
269 user = sdat.user
270 end
271 end
272
273 if not util.contains(accs, user) then
274 if authen then
275 ctx.urltoken.stok = nil
276 local user, sess = authen(luci.sys.user.checkpasswd, accs, def)
277 if not user or not util.contains(accs, user) then
278 return
279 else
280 local sid = sess or luci.sys.uniqueid(16)
281 if not sess then
282 local token = luci.sys.uniqueid(16)
283 sauth.write(sid, util.get_bytecode({
284 user=user,
285 token=token,
286 secret=luci.sys.uniqueid(16)
287 }))
288 ctx.urltoken.stok = token
289 end
290 luci.http.header("Set-Cookie", "sysauth=" .. sid.."; path="..build_url())
291 ctx.authsession = sid
292 end
293 else
294 luci.http.status(403, "Forbidden")
295 return
296 end
297 else
298 ctx.authsession = sess
299 end
300 end
301
302 if track.setgroup then
303 luci.sys.process.setgroup(track.setgroup)
304 end
305
306 if track.setuser then
307 luci.sys.process.setuser(track.setuser)
308 end
309
310 local target = nil
311 if c then
312 if type(c.target) == "function" then
313 target = c.target
314 elseif type(c.target) == "table" then
315 target = c.target.target
316 end
317 end
318
319 if c and (c.index or type(target) == "function") then
320 ctx.dispatched = c
321 ctx.requested = ctx.requested or ctx.dispatched
322 end
323
324 if c and c.index then
325 local tpl = require "luci.template"
326
327 if util.copcall(tpl.render, "indexer", {}) then
328 return true
329 end
330 end
331
332 if type(target) == "function" then
333 util.copcall(function()
334 local oldenv = getfenv(target)
335 local module = require(c.module)
336 local env = setmetatable({}, {__index=
337
338 function(tbl, key)
339 return rawget(tbl, key) or module[key] or oldenv[key]
340 end})
341
342 setfenv(target, env)
343 end)
344
345 if type(c.target) == "table" then
346 target(c.target, unpack(args))
347 else
348 target(unpack(args))
349 end
350 else
351 error404()
352 end
353 end
354
355 --- Generate the dispatching index using the best possible strategy.
356 function createindex()
357 local path = luci.util.libpath() .. "/controller/"
358 local suff = ".lua"
359
360 if luci.util.copcall(require, "luci.fastindex") then
361 createindex_fastindex(path, suff)
362 else
363 createindex_plain(path, suff)
364 end
365 end
366
367 --- Generate the dispatching index using the fastindex C-indexer.
368 -- @param path Controller base directory
369 -- @param suffix Controller file suffix
370 function createindex_fastindex(path, suffix)
371 index = {}
372
373 if not fi then
374 fi = luci.fastindex.new("index")
375 fi.add(path .. "*" .. suffix)
376 fi.add(path .. "*/*" .. suffix)
377 end
378 fi.scan()
379
380 for k, v in pairs(fi.indexes) do
381 index[v[2]] = v[1]
382 end
383 end
384
385 --- Generate the dispatching index using the native file-cache based strategy.
386 -- @param path Controller base directory
387 -- @param suffix Controller file suffix
388 function createindex_plain(path, suffix)
389 local controllers = util.combine(
390 luci.fs.glob(path .. "*" .. suffix) or {},
391 luci.fs.glob(path .. "*/*" .. suffix) or {}
392 )
393
394 if indexcache then
395 local cachedate = fs.mtime(indexcache)
396 if cachedate then
397 local realdate = 0
398 for _, obj in ipairs(controllers) do
399 local omtime = fs.mtime(path .. "/" .. obj)
400 realdate = (omtime and omtime > realdate) and omtime or realdate
401 end
402
403 if cachedate > realdate then
404 assert(
405 sys.process.info("uid") == fs.stat(indexcache, "uid")
406 and fs.stat(indexcache, "mode") == "rw-------",
407 "Fatal: Indexcache is not sane!"
408 )
409
410 index = loadfile(indexcache)()
411 return index
412 end
413 end
414 end
415
416 index = {}
417
418 for i,c in ipairs(controllers) do
419 local module = "luci.controller." .. c:sub(#path+1, #c-#suffix):gsub("/", ".")
420 local mod = require(module)
421 local idx = mod.index
422
423 if type(idx) == "function" then
424 index[module] = idx
425 end
426 end
427
428 if indexcache then
429 fs.writefile(indexcache, util.get_bytecode(index))
430 fs.chmod(indexcache, "a-rwx,u+rw")
431 end
432 end
433
434 --- Create the dispatching tree from the index.
435 -- Build the index before if it does not exist yet.
436 function createtree()
437 if not index then
438 createindex()
439 end
440
441 local ctx = context
442 local tree = {nodes={}}
443 local modi = {}
444
445 ctx.treecache = setmetatable({}, {__mode="v"})
446 ctx.tree = tree
447 ctx.modifiers = modi
448
449 -- Load default translation
450 require "luci.i18n".loadc("default")
451
452 local scope = setmetatable({}, {__index = luci.dispatcher})
453
454 for k, v in pairs(index) do
455 scope._NAME = k
456 setfenv(v, scope)
457 v()
458 end
459
460 local function modisort(a,b)
461 return modi[a].order < modi[b].order
462 end
463
464 for _, v in util.spairs(modi, modisort) do
465 scope._NAME = v.module
466 setfenv(v.func, scope)
467 v.func()
468 end
469
470 return tree
471 end
472
473 --- Register a tree modifier.
474 -- @param func Modifier function
475 -- @param order Modifier order value (optional)
476 function modifier(func, order)
477 context.modifiers[#context.modifiers+1] = {
478 func = func,
479 order = order or 0,
480 module
481 = getfenv(2)._NAME
482 }
483 end
484
485 --- Clone a node of the dispatching tree to another position.
486 -- @param path Virtual path destination
487 -- @param clone Virtual path source
488 -- @param title Destination node title (optional)
489 -- @param order Destination node order value (optional)
490 -- @return Dispatching tree node
491 function assign(path, clone, title, order)
492 local obj = node(unpack(path))
493 obj.nodes = nil
494 obj.module = nil
495
496 obj.title = title
497 obj.order = order
498
499 setmetatable(obj, {__index = _create_node(clone)})
500
501 return obj
502 end
503
504 --- Create a new dispatching node and define common parameters.
505 -- @param path Virtual path
506 -- @param target Target function to call when dispatched.
507 -- @param title Destination node title
508 -- @param order Destination node order value (optional)
509 -- @return Dispatching tree node
510 function entry(path, target, title, order)
511 local c = node(unpack(path))
512
513 c.target = target
514 c.title = title
515 c.order = order
516 c.module = getfenv(2)._NAME
517
518 return c
519 end
520
521 --- Fetch or create a dispatching node without setting the target module or
522 -- enabling the node.
523 -- @param ... Virtual path
524 -- @return Dispatching tree node
525 function get(...)
526 return _create_node({...})
527 end
528
529 --- Fetch or create a new dispatching node.
530 -- @param ... Virtual path
531 -- @return Dispatching tree node
532 function node(...)
533 local c = _create_node({...})
534
535 c.module = getfenv(2)._NAME
536 c.auto = nil
537
538 return c
539 end
540
541 function _create_node(path, cache)
542 if #path == 0 then
543 return context.tree
544 end
545
546 cache = cache or context.treecache
547 local name = table.concat(path, ".")
548 local c = cache[name]
549
550 if not c then
551 local new = {nodes={}, auto=true, path=util.clone(path)}
552 local last = table.remove(path)
553
554 c = _create_node(path, cache)
555
556 c.nodes[last] = new
557 cache[name] = new
558
559 return new
560 else
561 return c
562 end
563 end
564
565 -- Subdispatchers --
566
567 --- Create a redirect to another dispatching node.
568 -- @param ... Virtual path destination
569 function alias(...)
570 local req = {...}
571 return function(...)
572 for _, r in ipairs({...}) do
573 req[#req+1] = r
574 end
575
576 dispatch(req)
577 end
578 end
579
580 --- Rewrite the first x path values of the request.
581 -- @param n Number of path values to replace
582 -- @param ... Virtual path to replace removed path values with
583 function rewrite(n, ...)
584 local req = {...}
585 return function(...)
586 local dispatched = util.clone(context.dispatched)
587
588 for i=1,n do
589 table.remove(dispatched, 1)
590 end
591
592 for i, r in ipairs(req) do
593 table.insert(dispatched, i, r)
594 end
595
596 for _, r in ipairs({...}) do
597 dispatched[#dispatched+1] = r
598 end
599
600 dispatch(dispatched)
601 end
602 end
603
604
605 local function _call(self, ...)
606 if #self.argv > 0 then
607 return getfenv()[self.name](unpack(self.argv), ...)
608 else
609 return getfenv()[self.name](...)
610 end
611 end
612
613 --- Create a function-call dispatching target.
614 -- @param name Target function of local controller
615 -- @param ... Additional parameters passed to the function
616 function call(name, ...)
617 return {type = "call", argv = {...}, name = name, target = _call}
618 end
619
620
621 local _template = function(self, ...)
622 require "luci.template".render(self.view)
623 end
624
625 --- Create a template render dispatching target.
626 -- @param name Template to be rendered
627 function template(name)
628 return {type = "template", view = name, target = _template}
629 end
630
631
632 local function _cbi(self, ...)
633 local cbi = require "luci.cbi"
634 local tpl = require "luci.template"
635 local http = require "luci.http"
636
637 local config = self.config or {}
638 local maps = cbi.load(self.model, ...)
639
640 local state = nil
641
642 for i, res in ipairs(maps) do
643 res.flow = config
644 local cstate = res:parse()
645 if cstate and (not state or cstate < state) then
646 state = cstate
647 end
648 end
649
650 if config.on_valid_to and state and state > 0 and state < 2 then
651 http.redirect(config.on_valid_to)
652 return
653 end
654
655 if config.on_changed_to and state and state > 1 then
656 http.redirect(config.on_changed_to)
657 return
658 end
659
660 if config.on_success_to and state and state > 0 then
661 http.redirect(config.on_success_to)
662 return
663 end
664
665 if config.state_handler then
666 if not config.state_handler(state, maps) then
667 return
668 end
669 end
670
671 local pageaction = true
672 http.header("X-CBI-State", state or 0)
673 if not config.noheader then
674 tpl.render("cbi/header", {state = state})
675 end
676 for i, res in ipairs(maps) do
677 res:render()
678 if res.pageaction == false then
679 pageaction = false
680 end
681 end
682 if not config.nofooter then
683 tpl.render("cbi/footer", {flow = config, pageaction=pageaction, state = state, autoapply = config.autoapply})
684 end
685 end
686
687 --- Create a CBI model dispatching target.
688 -- @param model CBI model to be rendered
689 function cbi(model, config)
690 return {type = "cbi", config = config, model = model, target = _cbi}
691 end
692
693
694 local function _arcombine(self, ...)
695 local argv = {...}
696 local target = #argv > 0 and self.targets[2] or self.targets[1]
697 setfenv(target.target, self.env)
698 target:target(unpack(argv))
699 end
700
701 --- Create a combined dispatching target for non argv and argv requests.
702 -- @param trg1 Overview Target
703 -- @param trg2 Detail Target
704 function arcombine(trg1, trg2)
705 return {type = "arcombine", env = getfenv(), target = _arcombine, targets = {trg1, trg2}}
706 end
707
708
709 local function _form(self, ...)
710 local cbi = require "luci.cbi"
711 local tpl = require "luci.template"
712 local http = require "luci.http"
713
714 local maps = luci.cbi.load(self.model, ...)
715 local state = nil
716
717 for i, res in ipairs(maps) do
718 local cstate = res:parse()
719 if cstate and (not state or cstate < state) then
720 state = cstate
721 end
722 end
723
724 http.header("X-CBI-State", state or 0)
725 tpl.render("header")
726 for i, res in ipairs(maps) do
727 res:render()
728 end
729 tpl.render("footer")
730 end
731
732 --- Create a CBI form model dispatching target.
733 -- @param model CBI form model tpo be rendered
734 function form(model)
735 return {type = "cbi", model = model, target = _form}
736 end