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