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 "nixio.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 local nixio = require "nixio", require "nixio.util"
  34
  35 module("luci.dispatcher", package.seeall)
  36 context = util.threadlocal()
  37 uci = require "luci.model.uci"
  38 i18n = require "luci.i18n"
  39 _M.fs = fs
  40
  41 authenticator = {}
  42
  43 -- Index table
  44 local index = nil
  45
  46 -- Fastindex
  47 local fi
  48
  49
  50 --- Build the URL relative to the server webroot from given virtual path.
  51 -- @param ...   Virtual path
  52 -- @return              Relative URL
  53 function build_url(...)
  54         local path = {...}
  55         local url = { http.getenv("SCRIPT_NAME") or "" }
  56
  57         local k, v
  58         for k, v in pairs(context.urltoken) do
  59                 url[#url+1] = "/;"
  60                 url[#url+1] = http.urlencode(k)
  61                 url[#url+1] = "="
  62                 url[#url+1] = http.urlencode(v)
  63         end
  64
  65         local p
  66         for _, p in ipairs(path) do
  67                 if p:match("^[a-zA-Z0-9_%-%.%%/,;]+$") then
  68                         url[#url+1] = "/"
  69                         url[#url+1] = p
  70                 end
  71         end
  72
  73         return table.concat(url, "")
  74 end
  75
  76 --- Send a 404 error code and render the "error404" template if available.
  77 -- @param message       Custom error message (optional)
  78 -- @return                      false
  79 function error404(message)
  80         luci.http.status(404, "Not Found")
  81         message = message or "Not Found"
  82
  83         require("luci.template")
  84         if not luci.util.copcall(luci.template.render, "error404") then
  85                 luci.http.prepare_content("text/plain")
  86                 luci.http.write(message)
  87         end
  88         return false
  89 end
  90
  91 --- Send a 500 error code and render the "error500" template if available.
  92 -- @param message       Custom error message (optional)#
  93 -- @return                      false
  94 function error500(message)
  95         luci.util.perror(message)
  96         if not context.template_header_sent then
  97                 luci.http.status(500, "Internal Server Error")
  98                 luci.http.prepare_content("text/plain")
  99                 luci.http.write(message)
 100         else
 101                 require("luci.template")
 102                 if not luci.util.copcall(luci.template.render, "error500", {message=message}) then
 103                         luci.http.prepare_content("text/plain")
 104                         luci.http.write(message)
 105                 end
 106         end
 107         return false
 108 end
 109
 110 function authenticator.htmlauth(validator, accs, default)
 111         local user = luci.http.formvalue("username")
 112         local pass = luci.http.formvalue("password")
 113
 114         if user and validator(user, pass) then
 115                 return user
 116         end
 117
 118         require("luci.i18n")
 119         require("luci.template")
 120         context.path = {}
 121         luci.template.render("sysauth", {duser=default, fuser=user})
 122         return false
 123
 124 end
 125
 126 --- Dispatch an HTTP request.
 127 -- @param request       LuCI HTTP Request object
 128 function httpdispatch(request, prefix)
 129         luci.http.context.request = request
 130
 131         local r = {}
 132         context.request = r
 133         context.urltoken = {}
 134
 135         local pathinfo = http.urldecode(request:getenv("PATH_INFO") or "", true)
 136
 137         if prefix then
 138                 for _, node in ipairs(prefix) do
 139                         r[#r+1] = node
 140                 end
 141         end
 142
 143         local tokensok = true
 144         for node in pathinfo:gmatch("[^/]+") do
 145                 local tkey, tval
 146                 if tokensok then
 147                         tkey, tval = node:match(";(%w+)=([a-fA-F0-9]*)")
 148                 end
 149                 if tkey then
 150                         context.urltoken[tkey] = tval
 151                 else
 152                         tokensok = false
 153                         r[#r+1] = node
 154                 end
 155         end
 156
 157         local stat, err = util.coxpcall(function()
 158                 dispatch(context.request)
 159         end, error500)
 160
 161         luci.http.close()
 162
 163         --context._disable_memtrace()
 164 end
 165
 166 --- Dispatches a LuCI virtual path.
 167 -- @param request       Virtual path
 168 function dispatch(request)
 169         --context._disable_memtrace = require "luci.debug".trap_memtrace("l")
 170         local ctx = context
 171         ctx.path = request
 172
 173         local conf = require "luci.config"
 174         assert(conf.main,
 175                 "/etc/config/luci seems to be corrupt, unable to find section 'main'")
 176
 177         local lang = conf.main.lang or "auto"
 178         if lang == "auto" then
 179                 local aclang = http.getenv("HTTP_ACCEPT_LANGUAGE") or ""
 180                 for lpat in aclang:gmatch("[%w-]+") do
 181                         lpat = lpat and lpat:gsub("-", "_")
 182                         if conf.languages[lpat] then
 183                                 lang = lpat
 184                                 break
 185                         end
 186                 end
 187         end
 188         require "luci.i18n".setlanguage(lang)
 189
 190         local c = ctx.tree
 191         local stat
 192         if not c then
 193                 c = createtree()
 194         end
 195
 196         local track = {}
 197         local args = {}
 198         ctx.args = args
 199         ctx.requestargs = ctx.requestargs or args
 200         local n
 201         local token = ctx.urltoken
 202         local preq = {}
 203         local freq = {}
 204
 205         for i, s in ipairs(request) do
 206                 preq[#preq+1] = s
 207                 freq[#freq+1] = s
 208                 c = c.nodes[s]
 209                 n = i
 210                 if not c then
 211                         break
 212                 end
 213
 214                 util.update(track, c)
 215
 216                 if c.leaf then
 217                         break
 218                 end
 219         end
 220
 221         if c and c.leaf then
 222                 for j=n+1, #request do
 223                         args[#args+1] = request[j]
 224                         freq[#freq+1] = request[j]
 225                 end
 226         end
 227
 228         ctx.requestpath = ctx.requestpath or freq
 229         ctx.path = preq
 230
 231         if track.i18n then
 232                 i18n.loadc(track.i18n)
 233         end
 234
 235         -- Init template engine
 236         if (c and c.index) or not track.notemplate then
 237                 local tpl = require("luci.template")
 238                 local media = track.mediaurlbase or luci.config.main.mediaurlbase
 239                 if not pcall(tpl.Template, "themes/%s/header" % fs.basename(media)) then
 240                         media = nil
 241                         for name, theme in pairs(luci.config.themes) do
 242                                 if name:sub(1,1) ~= "." and pcall(tpl.Template,
 243                                  "themes/%s/header" % fs.basename(theme)) then
 244                                         media = theme
 245                                 end
 246                         end
 247                         assert(media, "No valid theme found")
 248                 end
 249
 250                 tpl.context.viewns = setmetatable({
 251                    write       = luci.http.write;
 252                    include     = function(name) tpl.Template(name):render(getfenv(2)) end;
 253                    translate   = i18n.translate;
 254                    export      = function(k, v) if tpl.context.viewns[k] == nil then tpl.context.viewns[k] = v end end;
 255                    striptags   = util.striptags;
 256                    pcdata      = util.pcdata;
 257                    media       = media;
 258                    theme       = fs.basename(media);
 259                    resource    = luci.config.main.resourcebase
 260                 }, {__index=function(table, key)
 261                         if key == "controller" then
 262                                 return build_url()
 263                         elseif key == "REQUEST_URI" then
 264                                 return build_url(unpack(ctx.requestpath))
 265                         else
 266                                 return rawget(table, key) or _G[key]
 267                         end
 268                 end})
 269         end
 270
 271         track.dependent = (track.dependent ~= false)
 272         assert(not track.dependent or not track.auto,
 273                 "Access Violation\nThe page at '" .. table.concat(request, "/") .. "/' " ..
 274                 "has no parent node so the access to this location has been denied.\n" ..
 275                 "This is a software bug, please report this message at " ..
 276                 "http://luci.subsignal.org/trac/newticket"
 277         )
 278
 279         if track.sysauth then
 280                 local sauth = require "luci.sauth"
 281
 282                 local authen = type(track.sysauth_authenticator) == "function"
 283                  and track.sysauth_authenticator
 284                  or authenticator[track.sysauth_authenticator]
 285
 286                 local def  = (type(track.sysauth) == "string") and track.sysauth
 287                 local accs = def and {track.sysauth} or track.sysauth
 288                 local sess = ctx.authsession
 289                 local verifytoken = false
 290                 if not sess then
 291                         sess = luci.http.getcookie("sysauth")
 292                         sess = sess and sess:match("^[a-f0-9]*$")
 293                         verifytoken = true
 294                 end
 295
 296                 local sdat = sauth.read(sess)
 297                 local user
 298
 299                 if sdat then
 300                         sdat = loadstring(sdat)
 301                         setfenv(sdat, {})
 302                         sdat = sdat()
 303                         if not verifytoken or ctx.urltoken.stok == sdat.token then
 304                                 user = sdat.user
 305                         end
 306                 else
 307                         local eu = http.getenv("HTTP_AUTH_USER")
 308                         local ep = http.getenv("HTTP_AUTH_PASS")
 309                         if eu and ep and luci.sys.user.checkpasswd(eu, ep) then
 310                                 authen = function() return eu end
 311                         end
 312                 end
 313
 314                 if not util.contains(accs, user) then
 315                         if authen then
 316                                 ctx.urltoken.stok = nil
 317                                 local user, sess = authen(luci.sys.user.checkpasswd, accs, def)
 318                                 if not user or not util.contains(accs, user) then
 319                                         return
 320                                 else
 321                                         local sid = sess or luci.sys.uniqueid(16)
 322                                         if not sess then
 323                                                 local token = luci.sys.uniqueid(16)
 324                                                 sauth.write(sid, util.get_bytecode({
 325                                                         user=user,
 326                                                         token=token,
 327                                                         secret=luci.sys.uniqueid(16)
 328                                                 }))
 329                                                 ctx.urltoken.stok = token
 330                                         end
 331                                         luci.http.header("Set-Cookie", "sysauth=" .. sid.."; path="..build_url())
 332                                         ctx.authsession = sid
 333                                         ctx.authuser = user
 334                                 end
 335                         else
 336                                 luci.http.status(403, "Forbidden")
 337                                 return
 338                         end
 339                 else
 340                         ctx.authsession = sess
 341                         ctx.authuser = user
 342                 end
 343         end
 344
 345         if track.setgroup then
 346                 luci.sys.process.setgroup(track.setgroup)
 347         end
 348
 349         if track.setuser then
 350                 luci.sys.process.setuser(track.setuser)
 351         end
 352
 353         local target = nil
 354         if c then
 355                 if type(c.target) == "function" then
 356                         target = c.target
 357                 elseif type(c.target) == "table" then
 358                         target = c.target.target
 359                 end
 360         end
 361
 362         if c and (c.index or type(target) == "function") then
 363                 ctx.dispatched = c
 364                 ctx.requested = ctx.requested or ctx.dispatched
 365         end
 366
 367         if c and c.index then
 368                 local tpl = require "luci.template"
 369
 370                 if util.copcall(tpl.render, "indexer", {}) then
 371                         return true
 372                 end
 373         end
 374
 375         if type(target) == "function" then
 376                 util.copcall(function()
 377                         local oldenv = getfenv(target)
 378                         local module = require(c.module)
 379                         local env = setmetatable({}, {__index=
 380
 381                         function(tbl, key)
 382                                 return rawget(tbl, key) or module[key] or oldenv[key]
 383                         end})
 384
 385                         setfenv(target, env)
 386                 end)
 387
 388                 local ok, err
 389                 if type(c.target) == "table" then
 390                         ok, err = util.copcall(target, c.target, unpack(args))
 391                 else
 392                         ok, err = util.copcall(target, unpack(args))
 393                 end
 394                 assert(ok,
 395                        "Failed to execute " .. (type(c.target) == "function" and "function" or c.target.type or "unknown") ..
 396                        " dispatcher target for entry '/" .. table.concat(request, "/") .. "'.\n" ..
 397                        "The called action terminated with an exception:\n" .. tostring(err or "(unknown)"))
 398         else
 399                 local root = node()
 400                 if not root or not root.target then
 401                         error404("No root node was registered, this usually happens if no module was installed.\n" ..
 402                                  "Install luci-mod-admin-full and retry. " ..
 403                                  "If the module is already installed, try removing the /tmp/luci-indexcache file.")
 404                 else
 405                         error404("No page is registered at '/" .. table.concat(request, "/") .. "'.\n" ..
 406                                  "If this url belongs to an extension, make sure it is properly installed.\n" ..
 407                                  "If the extension was recently installed, try removing the /tmp/luci-indexcache file.")
 408                 end
 409         end
 410 end
 411
 412 --- Generate the dispatching index using the best possible strategy.
 413 function createindex()
 414         local path = luci.util.libpath() .. "/controller/"
 415         local suff = { ".lua", ".lua.gz" }
 416
 417         if luci.util.copcall(require, "luci.fastindex") then
 418                 createindex_fastindex(path, suff)
 419         else
 420                 createindex_plain(path, suff)
 421         end
 422 end
 423
 424 --- Generate the dispatching index using the fastindex C-indexer.
 425 -- @param path          Controller base directory
 426 -- @param suffixes      Controller file suffixes
 427 function createindex_fastindex(path, suffixes)
 428         index = {}
 429
 430         if not fi then
 431                 fi = luci.fastindex.new("index")
 432                 for _, suffix in ipairs(suffixes) do
 433                         fi.add(path .. "*" .. suffix)
 434                         fi.add(path .. "*/*" .. suffix)
 435                 end
 436         end
 437         fi.scan()
 438
 439         for k, v in pairs(fi.indexes) do
 440                 index[v[2]] = v[1]
 441         end
 442 end
 443
 444 --- Generate the dispatching index using the native file-cache based strategy.
 445 -- @param path          Controller base directory
 446 -- @param suffixes      Controller file suffixes
 447 function createindex_plain(path, suffixes)
 448         local controllers = { }
 449         for _, suffix in ipairs(suffixes) do
 450                 nixio.util.consume((fs.glob(path .. "*" .. suffix)), controllers)
 451                 nixio.util.consume((fs.glob(path .. "*/*" .. suffix)), controllers)
 452         end
 453
 454         if indexcache then
 455                 local cachedate = fs.stat(indexcache, "mtime")
 456                 if cachedate then
 457                         local realdate = 0
 458                         for _, obj in ipairs(controllers) do
 459                                 local omtime = fs.stat(obj, "mtime")
 460                                 realdate = (omtime and omtime > realdate) and omtime or realdate
 461                         end
 462
 463                         if cachedate > realdate then
 464                                 assert(
 465                                         sys.process.info("uid") == fs.stat(indexcache, "uid")
 466                                         and fs.stat(indexcache, "modestr") == "rw-------",
 467                                         "Fatal: Indexcache is not sane!"
 468                                 )
 469
 470                                 index = loadfile(indexcache)()
 471                                 return index
 472                         end
 473                 end
 474         end
 475
 476         index = {}
 477
 478         for i,c in ipairs(controllers) do
 479                 local modname = "luci.controller." .. c:sub(#path+1, #c):gsub("/", ".")
 480                 for _, suffix in ipairs(suffixes) do
 481                         modname = modname:gsub(suffix.."$", "")
 482                 end
 483
 484                 local mod = require(modname)
 485                 assert(mod ~= true,
 486                        "Invalid controller file found\n" ..
 487                        "The file '" .. c .. "' contains an invalid module line.\n" ..
 488                        "Please verify whether the module name is set to '" .. modname ..
 489                        "' - It must correspond to the file path!")
 490
 491                 local idx = mod.index
 492                 assert(type(idx) == "function",
 493                        "Invalid controller file found\n" ..
 494                        "The file '" .. c .. "' contains no index() function.\n" ..
 495                        "Please make sure that the controller contains a valid " ..
 496                        "index function and verify the spelling!")
 497
 498                 index[modname] = idx
 499         end
 500
 501         if indexcache then
 502                 local f = nixio.open(indexcache, "w", 600)
 503                 f:writeall(util.get_bytecode(index))
 504                 f:close()
 505         end
 506 end
 507
 508 --- Create the dispatching tree from the index.
 509 -- Build the index before if it does not exist yet.
 510 function createtree()
 511         if not index then
 512                 createindex()
 513         end
 514
 515         local ctx  = context
 516         local tree = {nodes={}, inreq=true}
 517         local modi = {}
 518
 519         ctx.treecache = setmetatable({}, {__mode="v"})
 520         ctx.tree = tree
 521         ctx.modifiers = modi
 522
 523         -- Load default translation
 524         require "luci.i18n".loadc("base")
 525
 526         local scope = setmetatable({}, {__index = luci.dispatcher})
 527
 528         for k, v in pairs(index) do
 529                 scope._NAME = k
 530                 setfenv(v, scope)
 531                 v()
 532         end
 533
 534         local function modisort(a,b)
 535                 return modi[a].order < modi[b].order
 536         end
 537
 538         for _, v in util.spairs(modi, modisort) do
 539                 scope._NAME = v.module
 540                 setfenv(v.func, scope)
 541                 v.func()
 542         end
 543
 544         return tree
 545 end
 546
 547 --- Register a tree modifier.
 548 -- @param       func    Modifier function
 549 -- @param       order   Modifier order value (optional)
 550 function modifier(func, order)
 551         context.modifiers[#context.modifiers+1] = {
 552                 func = func,
 553                 order = order or 0,
 554                 module
 555                         = getfenv(2)._NAME
 556         }
 557 end
 558
 559 --- Clone a node of the dispatching tree to another position.
 560 -- @param       path    Virtual path destination
 561 -- @param       clone   Virtual path source
 562 -- @param       title   Destination node title (optional)
 563 -- @param       order   Destination node order value (optional)
 564 -- @return                      Dispatching tree node
 565 function assign(path, clone, title, order)
 566         local obj  = node(unpack(path))
 567         obj.nodes  = nil
 568         obj.module = nil
 569
 570         obj.title = title
 571         obj.order = order
 572
 573         setmetatable(obj, {__index = _create_node(clone)})
 574
 575         return obj
 576 end
 577
 578 --- Create a new dispatching node and define common parameters.
 579 -- @param       path    Virtual path
 580 -- @param       target  Target function to call when dispatched.
 581 -- @param       title   Destination node title
 582 -- @param       order   Destination node order value (optional)
 583 -- @return                      Dispatching tree node
 584 function entry(path, target, title, order)
 585         local c = node(unpack(path))
 586
 587         c.target = target
 588         c.title  = title
 589         c.order  = order
 590         c.module = getfenv(2)._NAME
 591
 592         return c
 593 end
 594
 595 --- Fetch or create a dispatching node without setting the target module or
 596 -- enabling the node.
 597 -- @param       ...             Virtual path
 598 -- @return                      Dispatching tree node
 599 function get(...)
 600         return _create_node({...})
 601 end
 602
 603 --- Fetch or create a new dispatching node.
 604 -- @param       ...             Virtual path
 605 -- @return                      Dispatching tree node
 606 function node(...)
 607         local c = _create_node({...})
 608
 609         c.module = getfenv(2)._NAME
 610         c.auto = nil
 611
 612         return c
 613 end
 614
 615 function _create_node(path)
 616         if #path == 0 then
 617                 return context.tree
 618         end
 619
 620         local name = table.concat(path, ".")
 621         local c = context.treecache[name]
 622
 623         if not c then
 624                 local last = table.remove(path)
 625                 local parent = _create_node(path)
 626
 627                 c = {nodes={}, auto=true}
 628                 -- the node is "in request" if the request path matches
 629                 -- at least up to the length of the node path
 630                 if parent.inreq and context.path[#path+1] == last then
 631                   c.inreq = true
 632                 end
 633                 parent.nodes[last] = c
 634                 context.treecache[name] = c
 635         end
 636         return c
 637 end
 638
 639 -- Subdispatchers --
 640
 641 function _firstchild()
 642    local path = { unpack(context.path) }
 643    local name = table.concat(path, ".")
 644    local node = context.treecache[name]
 645
 646    local lowest
 647    if node and node.nodes and next(node.nodes) then
 648           local k, v
 649           for k, v in pairs(node.nodes) do
 650                  if not lowest or
 651                         (v.order or 100) < (node.nodes[lowest].order or 100)
 652                  then
 653                         lowest = k
 654                  end
 655           end
 656    end
 657
 658    assert(lowest ~= nil,
 659                   "The requested node contains no childs, unable to redispatch")
 660
 661    path[#path+1] = lowest
 662    dispatch(path)
 663 end
 664
 665 --- Alias the first (lowest order) page automatically
 666 function firstchild()
 667    return { type = "firstchild", target = _firstchild }
 668 end
 669
 670 --- Create a redirect to another dispatching node.
 671 -- @param       ...             Virtual path destination
 672 function alias(...)
 673         local req = {...}
 674         return function(...)
 675                 for _, r in ipairs({...}) do
 676                         req[#req+1] = r
 677                 end
 678
 679                 dispatch(req)
 680         end
 681 end
 682
 683 --- Rewrite the first x path values of the request.
 684 -- @param       n               Number of path values to replace
 685 -- @param       ...             Virtual path to replace removed path values with
 686 function rewrite(n, ...)
 687         local req = {...}
 688         return function(...)
 689                 local dispatched = util.clone(context.dispatched)
 690
 691                 for i=1,n do
 692                         table.remove(dispatched, 1)
 693                 end
 694
 695                 for i, r in ipairs(req) do
 696                         table.insert(dispatched, i, r)
 697                 end
 698
 699                 for _, r in ipairs({...}) do
 700                         dispatched[#dispatched+1] = r
 701                 end
 702
 703                 dispatch(dispatched)
 704         end
 705 end
 706
 707
 708 local function _call(self, ...)
 709         if #self.argv > 0 then
 710                 return getfenv()[self.name](unpack(self.argv), ...)
 711         else
 712                 return getfenv()[self.name](...)
 713         end
 714 end
 715
 716 --- Create a function-call dispatching target.
 717 -- @param       name    Target function of local controller
 718 -- @param       ...             Additional parameters passed to the function
 719 function call(name, ...)
 720         return {type = "call", argv = {...}, name = name, target = _call}
 721 end
 722
 723
 724 local _template = function(self, ...)
 725         require "luci.template".render(self.view)
 726 end
 727
 728 --- Create a template render dispatching target.
 729 -- @param       name    Template to be rendered
 730 function template(name)
 731         return {type = "template", view = name, target = _template}
 732 end
 733
 734
 735 local function _cbi(self, ...)
 736         local cbi = require "luci.cbi"
 737         local tpl = require "luci.template"
 738         local http = require "luci.http"
 739
 740         local config = self.config or {}
 741         local maps = cbi.load(self.model, ...)
 742
 743         local state = nil
 744
 745         for i, res in ipairs(maps) do
 746                 res.flow = config
 747                 local cstate = res:parse()
 748                 if cstate and (not state or cstate < state) then
 749                         state = cstate
 750                 end
 751         end
 752
 753         local function _resolve_path(path)
 754                 return type(path) == "table" and build_url(unpack(path)) or path
 755         end
 756
 757         if config.on_valid_to and state and state > 0 and state < 2 then
 758                 http.redirect(_resolve_path(config.on_valid_to))
 759                 return
 760         end
 761
 762         if config.on_changed_to and state and state > 1 then
 763                 http.redirect(_resolve_path(config.on_changed_to))
 764                 return
 765         end
 766
 767         if config.on_success_to and state and state > 0 then
 768                 http.redirect(_resolve_path(config.on_success_to))
 769                 return
 770         end
 771
 772         if config.state_handler then
 773                 if not config.state_handler(state, maps) then
 774                         return
 775                 end
 776         end
 777
 778         http.header("X-CBI-State", state or 0)
 779
 780         if not config.noheader then
 781                 tpl.render("cbi/header", {state = state})
 782         end
 783
 784         local redirect
 785         local messages
 786         local applymap   = false
 787         local pageaction = true
 788         local parsechain = { }
 789
 790         for i, res in ipairs(maps) do
 791                 if res.apply_needed and res.parsechain then
 792                         local c
 793                         for _, c in ipairs(res.parsechain) do
 794                                 parsechain[#parsechain+1] = c
 795                         end
 796                         applymap = true
 797                 end
 798
 799                 if res.redirect then
 800                         redirect = redirect or res.redirect
 801                 end
 802
 803                 if res.pageaction == false then
 804                         pageaction = false
 805                 end
 806
 807                 if res.message then
 808                         messages = messages or { }
 809                         messages[#messages+1] = res.message
 810                 end
 811         end
 812
 813         for i, res in ipairs(maps) do
 814                 res:render({
 815                         firstmap   = (i == 1),
 816                         applymap   = applymap,
 817                         redirect   = redirect,
 818                         messages   = messages,
 819                         pageaction = pageaction,
 820                         parsechain = parsechain
 821                 })
 822         end
 823
 824         if not config.nofooter then
 825                 tpl.render("cbi/footer", {
 826                         flow       = config,
 827                         pageaction = pageaction,
 828                         redirect   = redirect,
 829                         state      = state,
 830                         autoapply  = config.autoapply
 831                 })
 832         end
 833 end
 834
 835 --- Create a CBI model dispatching target.
 836 -- @param       model   CBI model to be rendered
 837 function cbi(model, config)
 838         return {type = "cbi", config = config, model = model, target = _cbi}
 839 end
 840
 841
 842 local function _arcombine(self, ...)
 843         local argv = {...}
 844         local target = #argv > 0 and self.targets[2] or self.targets[1]
 845         setfenv(target.target, self.env)
 846         target:target(unpack(argv))
 847 end
 848
 849 --- Create a combined dispatching target for non argv and argv requests.
 850 -- @param trg1  Overview Target
 851 -- @param trg2  Detail Target
 852 function arcombine(trg1, trg2)
 853         return {type = "arcombine", env = getfenv(), target = _arcombine, targets = {trg1, trg2}}
 854 end
 855
 856
 857 local function _form(self, ...)
 858         local cbi = require "luci.cbi"
 859         local tpl = require "luci.template"
 860         local http = require "luci.http"
 861
 862         local maps = luci.cbi.load(self.model, ...)
 863         local state = nil
 864
 865         for i, res in ipairs(maps) do
 866                 local cstate = res:parse()
 867                 if cstate and (not state or cstate < state) then
 868                         state = cstate
 869                 end
 870         end
 871
 872         http.header("X-CBI-State", state or 0)
 873         tpl.render("header")
 874         for i, res in ipairs(maps) do
 875                 res:render()
 876         end
 877         tpl.render("footer")
 878 end
 879
 880 --- Create a CBI form model dispatching target.
 881 -- @param       model   CBI form model tpo be rendered
 882 function form(model)
 883         return {type = "cbi", model = model, target = _form}
 884 end
 885
 886 --- Access the luci.i18n translate() api.
 887 -- @class  function
 888 -- @name   translate
 889 -- @param  text    Text to translate
 890 translate = i18n.translate
 891
 892 --- No-op function used to mark translation entries for menu labels.
 893 -- This function does not actually translate the given argument but
 894 -- is used by build/i18n-scan.pl to find translatable entries.
 895 function _(text)
 896         return text
 897 end