--

--	loona - tiny CMS

--	Written by Timm S. Mueller <tmueller at neoscientists.org>

--	See copyright notice in COPYRIGHT

--

local tek = require "tek"

local cgi = require "tek.cgi"

local posix = require "tek.posix"

require "tek.cgi.request"

require "tek.cgi.request.args"

require "tek.cgi.session"

require "tek.web"

require "tek.web.markup"

require "tek.util"

-- 	local io = require "io"

local boxed_G = { 

	string = string, table = table,

	assert = assert, collectgarbage = collectgarbage, dofile = dofile,

	error = error, getfenv = getfenv, getmetatable = getmetatable,

	ipairs = ipairs, load = load, loadfile = loadfile, loadstring = loadstring,

	next = next, pairs = pairs, pcall = pcall, print = print,

	rawequal = rawequal, rawget = rawget, rawset = rawset, require = require,

	select = select, setfenv = setfenv, setmetatable = setmetatable,

	tonumber = tonumber, tostring = tostring, type = type, unpack = unpack,

	xpcall = xpcall

}

local table, string, assert, unpack, ipairs, pairs, type, require =

	table, string, assert, unpack, ipairs, pairs, type, require

local setmetatable, setfenv, getfenv = setmetatable, setfenv, getfenv

local open, remove, rename, getenv, time =

	io.open, os.remove, os.rename, os.getenv, os.time

module "loona"

_VERSION = 3

_REVISION = 0

local function lookupname(tab, val)

	if tab then

		for i, v in ipairs(tab) do

			if v.name == val then

				return i

			end

		end

	end

end

local atom = { }

function atom:new(o)

	o = o or { }

	setmetatable(o, self)

	self.__index = self

	return o

end

local loona = atom:new(getfenv())

function loona:dbmsg(msg, detail)

 	return (msg and detail and self.authuser) and

 		("%s : %s"):format(msg, detail) or msg

end

function loona:checkprofilename(n)

	assert(n:match("^%w+$") and n ~= "current",

		self:dbmsg("Invalid profile name", n))

	return n

end

function loona:checkbodyname(s)

	s = s or "main"

	assert(s:match("^[%w_]*%w+[%w_]*$"), self:dbmsg("Invalid body name", s))

	return s

end

function loona:deleteprofile(p, lang)

	p = self.config.contentdir .. "/" .. p .. "_" .. (lang or self.lang)

	for e in tek.util.readdir(p) do

 		local success, msg = remove(p .. "/" .. e)

		assert(success, self:dbmsg("Error removing entry in profile", msg))

	end

	return remove(p)

end

function loona:copyprofile(newprofile, srcprofile, lang)

	srcprofile = srcprofile or self.profile

	lang = lang or self.lang

	local contentdir = self.config.contentdir

	local src = ("%s/%s_%s"):format(contentdir, srcprofile or self.profile, lang)

	assert(posix.stat(src, "mode") == "directory",

		self:dbmsg("Not a directory", src))

	local dst = ("%s/%s_%s"):format(contentdir, newprofile, lang)

	local success, msg = posix.mkdir(dst)

	assert(success, self:dbmsg("Error creating profile directory", msg))

	for e in tek.util.readdir(src) do

		local ext = e:match("^[^.].*%.([^.]*)$")

		if ext ~= "LOCK" then

			local f = src .. "/" .. e

			if posix.stat(f, "mode") == "file" then

				success, msg = tek.copyfile(f, dst .. "/" .. e)

				assert(success, self:dbmsg("Error copying file", msg))

			end

		end

	end

end

function loona:publishprofile(profile, lang)

	lang = lang or self.lang

	local contentdir = self.config.contentdir

	local newpath = ("%s/current_%s"):format(contentdir, lang)

	local tmppath = newpath .. "." .. self.session.name

	local success, msg = posix.symlink(profile .. "_" .. lang, tmppath)

	assert(success, self:dbmsg("Cannot create symlink", msg))

	success, msg = rename(tmppath, newpath)

	assert(success, self:dbmsg("Cannot put symlink in place", msg))

	-- Unroll site to static HTML

	self:recursesections(self.sections, function(self, s, e, path)

		path = path and path .. "/" .. e.name or e.name

 		loona:dumphtml { requestpath = path }

		return path

	end)

	-- Update file cache

	local htdocs = self.config.htdocsdir

	local cache = self.config.htmlcachedir

	for e in tek.util.readdir(cache) do

		if e:match("^.*%.html$") then

			local success, msg = remove(htdocs .. "/" .. e)

			success, msg = remove(cache .. "/" .. e)

 			assert(success, self:dbmsg("Could not purge cached HTML file", msg))

		end

	end

	for e in tek.util.readdir(cache) do

		local f = e:match("^(.*%.html)%.tmp$")

		if f then

			local success, msg = rename(cache .. "/" .. e, cache .. "/" .. f)

			assert(success, self:dbmsg("Could not update cached HTML file", msg))

			success, msg = rename(htdocs .. "/" .. e, htdocs .. "/" .. f)

			assert(success, self:dbmsg("Could not update cached HTML file", msg))

		end

	end

end

function loona:recursesections(s, func, ...)

	for _, e in ipairs(s) do

		local udata = { func(self, s, e, unpack(arg)) }

		if e.subs then

			self:recursesections(e.subs, func, unpack(udata))

		end

	end

end

function loona:indexsections()

	self:recursesections(self.sections, function(self, s, e)

		e.notvalid = (not self.secure and e.secure) or 

			(not self.authuser and e.secret) or nil

		e.notvisible = e.notvalid or not self.authuser and e.hidden or nil

		s[e.name] = e

	end)

end

--	Decompose section path into a stack of sections, returning only up to

--	the last valid element in the path. additionally returns the table of

--	the last section path element (or the default section)

function loona:getsection(path)

	local default = not self.authuser and self.config.defname

	local tab = { { entries = self.sections, name = default } }

	local ss = self.sections

	local sectionpath

	(path or ""):gsub("(%w+)/?", function(a)

		if ss then

			local s = ss[a]

			if s and not s.notvalid then

				sectionpath = s

				tab[#tab].name = a

				ss = s.subs

				if ss then

					table.insert(tab, { entries = ss })

				end

			else

				ss = nil -- stop.

			end

		end

	end)

	if not self.section and not sectionpath then

		sectionpath = self.sections[default]

		if sectionpath then

			table.insert(tab, { entries = sectionpath.subs })

		end

	end

	return tab, sectionpath

end

function loona:getpath(delimiter)

	local t = { }

	for _, menu in ipairs(self.submenus) do

		if menu.name then

			table.insert(t, menu.name)

		end

	end

	return table.concat(t, delimiter or "/")

end

function loona:deletesection(fname, all_bodies)

	local fullname = self.contentdir .. "/" .. fname

	local success, msg = remove(fullname)

	if all_bodies then

		local pat = "^" .. 

			fname:gsub("%^%$%(%)%%%.%[%]%*%+%-%?", "%%%1") .. "%..*$"

		for e in tek.util.readdir(self.contentdir) do

			if e:match(pat) then

				remove(self.contentdir .. "/" .. e)

			end

		end

	end

	return success, msg

end

function loona:addpath(path, e)

	local tab = self.sections

	path:gsub("(%w+)/?", function(a)

		if tab then

			local s = tab[a]

			if s then

				if not s.subs then

					s.subs = { }

				end

				tab = s.subs

			else

				table.insert(tab, e)

				tab[a] = e

 				tab = nil -- stop

			end

		end

	end)

	return e

end

function loona:rmpath(path)

	local parent

	local tab = self.sections

	path:gsub("(%w+)/?", function(a)

		if tab then

			local idx = lookupname(tab, a)

			if idx then

				if tab[idx].subs then

					parent = tab[idx]

					tab = tab[idx].subs

				else

					table.remove(tab, idx)

					tab[a] = nil

					if #tab == 0 and parent then

						parent.subs = nil

					end

					tab = nil

				end

			end

		end

	end)

end

function loona:checkpath(path)

	if path ~= "index" then -- "index" is reserved

		local res, idx

		local tab = self.sections

		path:gsub("(%w+)/?", function(a)

			if tab then

				local i = lookupname(tab, a)

				if i then

					res, idx = tab, i

					tab = tab[i].subs

				else

					res, idx = nil, nil

				end

			end

		end)

		return res, idx

	end

end

function loona:title()

	return self.section and (self.section.title or self.section.label or

		self.section.name) or ""

end

--	Run a site function snippet, with full error recovery

--	(also recovers from errors in error handling function)

function loona:dosnippet(func, errfunc)

	local ret = { tek.catch(func) }

	if ret[1] == 0 or (errfunc and tek.catch(errfunc) == 0) then

		return unpack(ret)

	end

	self:out("<h2>Error</h2>")

	self:out("<h3>" .. self:encodeform(ret[2] or "") .. "</h3>")

	if self.authuser then

		if type(ret[3]) == "string" then

			self:out("<p>" .. self:encodeform(ret[3]) .. "</p>")

		end

		if ret[4] then

			self:out("<pre>" .. self:encodeform(ret[4]) .. "</pre>")

		end

	end

end	

function loona:lockfile(file)

	return not self.session and true or 

		posix.symlink(self.session.filename, file .. ".LOCK")

end

function loona:unlockfile(file)

	return not self.session and true or remove(file .. ".LOCK")

end

function loona:saveindex()

	local tempname = self.indexfname .. "." .. self.session.name

	local f, msg = open(tempname, "wb")

	assert(f, self:dbmsg("Error opening section file for writing", msg))

	tek.dump(self.sections, function(...)

		f:write(unpack(arg))

	end)

	f:close()

	local success, msg = rename(tempname, self.indexfname)

	assert(success, self:dbmsg("Error renaming section file", msg))

end

function loona:savebody(fname, content)

	fname = self.contentdir .. "/" .. fname

	local f, msg = open(fname, "wb")

	assert(f, self:dbmsg("Could not open file for writing", msg))

	f:write(content or "")

	f:close()

end

function loona:runboxed(func, envitems, ...)

	local fenv = {

 		arg = arg,

 		loona = self

 	}

 	if envitems then

	 	for k, v in pairs(envitems) do

 			fenv[k] = v

 		end

 	end

 	setmetatable(fenv, { __index = boxed_G }) -- boxed global environment

	setfenv(func, fenv)

	return func()

end

function loona:include(fname, ...)

	assert(not fname:match("%W"), self:dbmsg("Invalid include name", fname))

	local fname2 = ("%s/%s.lua"):format(self.config.extdir, fname)

	local f, msg = open(fname2)

	assert(f, self:dbmsg("Cannot open file", msg))

	local parsed, msg = self:loadhtml(f, "loona:out", fname2)

	assert(parsed, self:dbmsg("Syntax error", msg))

	return self:runboxed(parsed)

end

--	produce link target, propagate lang, profile, session

function loona:href(section, ...)

	local target = self:getdocname(section)

-- 	if self.session or self.profile ~= self.pubprofile then

	if self.session then

		return tek.web.gethref(target, { "profile", "session", "lang", 

			unpack(arg) })

	end

	return tek.web.gethref(target, { "lang", unpack(arg) })

end

function loona:ilink(target, text, extra)

	return ('<a href="%s"%s>%s</a>'):format(target, extra or "", text)

end

--	internal link, propagation of lang, profile, session

function loona:link(section, text, ...)

	return self:ilink(self:href(section, unpack(arg)), text or section)

end

--	external link (opens in a new window), no argument propagation

function loona:elink(target, text)

	return self:ilink(target, text or target, not self.config.extlinksamewindow and

		' class="extlink" onclick="void(window.open(this.href, \'\', \'\')); return false;"')

end

--	plain link, no argument propagation

function loona:plink(section, text, ...)

	return self:ilink(tek.web.gethref(section, arg), text or section)

end

--	user interface link, propagation of lang, profile, session

function loona:uilink(section, text, ...)

	return self:ilink(self:href(section, unpack(arg)), text or section)

end

--	produce a hidden input value in forms

function loona:hidden(name, value)

	return not value and "" or

		('<input type="hidden" name="%s" value="%s" />'):format(name, value)

end

function loona:getprofiles(lang)

	lang = lang or self.lang

	local dir = self.config.contentdir

	local t = { }

	for f in tek.util.readdir(dir) do

		if posix.lstat(dir .. "/" .. f, "mode") == "directory" then

			local e = f:match("^(%w+)_" .. lang .. "$")

 			if e then

	 			t[e] = e

 	 		end

		end

	end

	return t

end

--	Functions to produce a hierarchical navigation menu

local newent = { name = "new", label = "[+]", action="actionnew=true" }

function loona:rmenu(level, linkf, path)

	local sub = (self.authuser and level == #self.submenus + 1) and

		{ name = "new", entries = { }} or self.submenus[level]

 	if sub and sub.entries then

		local visible = { }

		for _, e in ipairs(sub.entries) do

			if not e.notvisible then

				table.insert(visible, e)

			end

		end

		if self.authuser then

			table.insert(visible, newent)

		end

		if #visible > 0 then

			self:out('<ul id="menulevel' .. level .. '">\n')

			for _, e in ipairs(visible) do

				local label = self:encodeform(e.label or e.name)

				local newpath = path and path .. "/" .. e.name or e.name

				local active = (e.name == sub.name)

				self:out('<li>\n')

				linkf(self, newpath, label, active, e.action)

				if active then

					self:rmenu(level + 1, linkf, newpath)

				end

				self:out('</li>\n')

			end

			self:out('</ul>\n')

		end

	end

end

function loona:menulink(path, label, active, ...)

	self:out(('<a %shref="%s">%s</a>\n'):format(active and 'class="active" ' or "",

		self:href(path, unpack(arg)), label))

end

function loona:menu(level, linkf)

	self:rmenu(level or 1, linkf or menulink)

end

function loona:init()

	-- get list of languages, in order of preference

	self.langs = { self.args.lang and self.args.lang:match("^%w+$") }

	if self.config.browserlang then

		local s = getenv("HTTP_ACCEPT_LANGUAGE")

		while s do

			local l, r = s:match("^([%w.=]+)[,;](.*)$")

			l = l or s

			s = r

			if l:match("^%w+$") then

				table.insert(self.langs, l)

			end

		end

	end

	table.insert(self.langs, self.config.deflang)

	-- get list of possible profiles

	local profiles = { }

	for e in tek.util.readdir(self.config.contentdir) do

		profiles[e] = e

	end

	-- get pubprofile

	for _, lang in ipairs(self.langs) do

		local p = posix.readlink(self.config.contentdir .. "/current_" .. lang)

		p = p and p:match("^(%w+)_" .. lang .. "$")

		if p then

			self.pubprofile = p

			break

		end

	end

	-- get profile

	local checkprofile = self.authuser and self.args.profile or self.pubprofile or "default"

	for _, lang in ipairs(self.langs) do

		if profiles[checkprofile .. "_" .. lang] then

			self.profile = checkprofile

			self.lang = lang

			break

		end

	end

	assert(self.profile and self.lang, "Invalid profile or language")

	-- write back language and profile

	self.args.lang = self.lang ~= self.config.deflang and self.lang or nil

	self.args.profile = self.profile

	-- determine content directory pathname and section filename

	self.contentdir = ("%s/%s_%s"):format(self.config.contentdir, self.profile, self.lang)

 	self.indexfname = self.contentdir .. "/.sections"

	-- load sections

 	self.sections = tek.source(self.indexfname)

	-- index sections, determine visibility in menu

	self:indexsections()

	-- decompose request path, produce a stack of sections

	self.submenus, self.section = self:getsection(self.requestpath)

	-- handle redirects if not logged on

	if not self.authuser and self.section and self.section.redirect then

		self.submenus, self.section = self:getsection(self.section.redirect)

	end

	-- section path and document name (refined)

	self.sectionpath = self:getpath()

	self.sectionname = self:getpath("_")

end

function loona:handlechanges()

	local save

	if self.args.editkey == "main" then

		-- In main editable section:

		if self.args.actioncreate then

			-- Create new section

			local editname = self.args.editname:lower()

			assert(not editname:match("%W"),

				dbmsg("Invalid section name", editname))

			if not (section and (section.subs or section)[editname]) then

				local newpath = 

					(self.sectionpath and (self.sectionpath .. "/")) .. editname

				local s = self:addpath(newpath, { name = editname,

					label = self.args.editlabel ~= "" and self.args.editlabel or nil,

					title = self.args.edittitle ~= "" and self.args.edittitle or nil,

					redirect = self.args.editredirect ~= "" and self.args.editredirect or nil,

					hidden = self.args.editvisibility and true,

					secret = self.args.editsecrecy and true,

					secure = self.args.editsecure and true,

					creator = self.authuser,

					creationdate = time() })

				save = true

			end

		elseif self.args.actionsave then

			-- Save section

			self.section.revisiondate = time()

			self.section.revisioner = self.authuser

			save = true

		elseif self.args.actionsaveprops then

			-- Save properties

			self.section.hidden = self.args.editvisibility and true

			self.section.secret = self.args.editsecrecy and true

			self.section.secure = self.args.editsecure and true

			self.section.label = self.args.editlabel ~= "" and self.args.editlabel or nil

			self.section.title = self.args.edittitle ~= "" and self.args.edittitle or nil

			self.section.redirect =

				self.args.editredirect ~= "" and self.args.editredirect or nil

			save = true

		elseif self.args.actionup then

			-- Move section up

			local t, i = self:checkpath(self.sectionpath)

			if t and i > 1 then

				if self.profile == self.pubprofile and not self.args.actionconfirm then

					useralert = {

						text = self.locale.ALERT_MOVE_SECTION_IN_PUBLISHED_PROFILE,

						confirm =

							'<input type="submit" name="actionup" value="' .. 

							self.locale.MOVE .. '" /> ' ..

							self:hidden("actionconfirm", "true")

					}

				else

					local item = table.remove(t, i)

					table.insert(t, i - 1, item)

					save = true

				end

			end

		elseif self.args.actiondown then

			-- Move section down

			local t, i = self:checkpath(self.sectionpath)

			if t and i < #t then

				if self.profile == self.pubprofile and not self.args.actionconfirm then

					useralert = {

						text = self.locale.ALERT_MOVE_SECTION_IN_PUBLISHED_PROFILE,

						confirm =

							'<input type="submit" name="actiondown" value="' .. 

							self.locale.MOVE .. '" /> ' ..

							self:hidden("actionconfirm", "true")

					}

				else

					local item = table.remove(t, i)

					table.insert(t, i + 1, item)

					save = true

				end

			end

		elseif self.args.actioncreateprofile and self.args.createprofile then

			-- Create profile

			local c = self:checkprofilename(self.args.createprofile:lower())

			if c == profile then

				useralert = { text = self.locale.ALERT_CANNOT_COPY_PROFILE_TO_SELF }

			else

				local profiles = self:getprofiles()

				if profiles[c] and not self.args.actionconfirm then

					useralert = {

						text = c == self.pubprofile and 

							self.locale.ALERT_OVERWRITE_PUBLISHED_PROFILE or

							self.locale.ALERT_OVERWRITE_EXISTING_PROFILE,

						confirm =

							'<input type="submit" name="actioncreateprofile" value="' .. 

							self.locale.OVERWRITE .. '" /> ' ..

							self:hidden("actionconfirm", "true") .. 

							self:hidden("createprofile", c)

					}

				else

					if profiles[c] then

						self:deleteprofile(c)

					end

					self:copyprofile(c)

				end

			end

		elseif self.args.actiondeleteprofile and self.args.deleteprofile then

			-- Delete profile

			local c = self:checkprofilename(self.args.deleteprofile:lower())

			assert(c ~= self.pubprofile, self:dbmsg("Cannot delete published profile", c))

			if self.args.actionconfirm then

				self:deleteprofile(c)

				self.profile = nil

				self.args.profile = nil

				self:init()

				save = true

			else

				useralert = { 

					text = self.locale.ALERT_DELETE_PROFILE,

					confirm = 

						'<input type="submit" name="actiondeleteprofile" value="' .. 

						self.locale.DELETE .. '" /> ' ..

						self:hidden("actionconfirm", "true") ..

						self:hidden("deleteprofile", c)

				}

			end

		elseif self.args.actionchangeprofile and self.args.changeprofile then

			-- Change profile

			local c = self:checkprofilename(self.args.changeprofile:lower())

			self.profile = c

			self.args.profile = c

			save = true

		elseif self.args.actionpublishprofile and self.args.publishprofile then

			-- Publish profile

			local c = self:checkprofilename(self.args.publishprofile:lower())

			if c ~= self.publicprofile then

				if self.args.actionconfirm then

					self:publishprofile(c)

					save = true

				else

					useralert = {

						text = self.locale.ALERT_PUBLISH_PROFILE,

						confirm =

							'<input type="submit" name="actionpublishprofile" value="' ..

							self.locale.PUBLISH .. '" /> ' ..

							self:hidden("actionconfirm", "true") ..

							self:hidden("publishprofile", c)

					}

				end

			end

		end

	end

	if self.args.actiondelete then

		-- Delete section

		if not self.args.actionconfirm then

			useralert = {

				text = self.profile == self.pubprofile and

					self.locale.ALERT_DELETE_SECTION_IN_PUBLISHED_PROFILE or

					self.locale.ALERT_DELETE_SECTION,

				confirm =

					'<input type="submit" name="actiondelete" value="' .. 

					self.locale.DELETE .. '" /> ' ..

					self:hidden("actionconfirm", "true")

			}

		else

			local key = self.args.editkey

			if key == "main" and not self.section.subs then

				self:deletesection(self.sectionname, true) -- all bodies

				self:rmpath(self.sectionpath) -- and node

			else

				local ext = (key == "main" and "") or "." .. key

				self:deletesection(self.sectionname .. ext) -- only text

				if self.section.dynamic then

					self.section.dynamic[key] = nil

					local n = 0

					for _ in pairs(self.section.dynamic) do

						n = n + 1

					end

					if n == 0 then

						self.section.dynamic = nil

					end

				end

			end

			save = true

		end

	end

	if save then

		self:saveindex()

		self:init()

	end

end

function loona:encodeform(s)

	return cgi.encodeform(s)

end

function loona:loadhtml(src, outfunc, chunkname)

	return tek.web.include.load(src, outfunc, chunkname)

end

function loona:domarkup(s)

	return tek.web.markup.main(s)

end

function loona:expire(dir, pat, maxage)

	return tek.util.expire(dir, pat, maxage)

end

--

--	Get pathname of an existing content file that

--	the current path is determined by or defaults to

--

function loona:getsectionpath(bodyname, requestpath)

	local ext = (not bodyname or bodyname == "main") and "" or "." .. bodyname

	local t, path, section = { }

	for _, menu in ipairs(self.submenus) do

		if menu.entries and menu.entries[menu.name] then

			table.insert(t, menu.name)

			local fn = table.concat(t, "_")

			if posix.stat(self.contentdir .. "/" .. fn .. ext, "mode") == "file" then

				path, section = fn, menu

			end

		end

	end

	return path, ext, section

end

function loona:body(name)

	name = self:checkbodyname(name)

	local path, ext = self:getsectionpath(name)

	self:dosnippet(self.editable(name, path and path .. ext, self.sectionname .. ext))

end

function loona:new(o)

	local parsed, msg

	o = o or { }

	o = atom.new(self, o)

	o.out = o.out or function(self, s) tek.web.out(s) end

	o.setheader = o.setheader or function(self, s) tek.web.setheader(s) end

	-- Get configuration

	o.config = o.config or tek.source(o.conffile or "../etc/config.lua") or { }

	o.config.defname = o.config.defname or "home"

	o.config.deflang = o.config.deflang or "en"

	o.config.sessionmaxage = o.config.sessionmaxage or 600

	o.config.secureport = o.config.secureport or 443

	o.config.passwdfile = posix.abspath(o.config.passwdfile or "../etc/passwd.lua")

	o.config.sessiondir = posix.abspath(o.config.sessiondir or "../var/sessions")

	o.config.extdir = posix.abspath(o.config.extdir or "../extensions")

	o.config.contentdir = posix.abspath(o.config.contentdir or "../content")

	o.config.localedir = posix.abspath(o.config.localedir or "../locale")

	o.config.htdocsdir = posix.abspath(o.config.htdocsdir or "../htdocs")

	o.config.htmlcachedir = posix.abspath(o.config.htmlcachedir or "../var/htmlcache")

	-- Create proxy for on-demand loading of locales

	o.locale = { }

	local locmt = { }

	locmt.__index = function(_, key)

		for _, l in ipairs(o.langs) do

			locmt.__locale = tek.source(o.config.localedir .. "/" .. l)

			if locmt.__locale then

				break

			end

		end

		locmt.__index = function(tab, key)

			return locmt.__locale[key] or key

		end

		return locmt.__locale[key] or key

	end

	setmetatable(o.locale, locmt)

	-- Get request, args, document, script name, request path

	o.request = o.request or cgi.request

	o.args = o.args or cgi.request.args

	o.session = o.session or cgi.session

 	o.scriptpath = o.scriptpath or cgi.document.Path

	o.requesthandler = o.requesthandler or cgi.document.Handler

 	o.requestdocument = o.requestdocument or cgi.document.Name

	o.requestpath = o.requestpath or cgi.document.VirtualPath

	-- Manage login and establish session

	o.session.init(o.config.sessiondir, o.args.session, o.config.sessionmaxage)

	if o.args.login then

		if o.args.login == "false" then

			o.session.delete()

			o.session = nil

		elseif o.args.password then

			o.loginfailed = true

			local pwddb = tek.source(o.config.passwdfile)

			local pwdentry = pwddb[o.args.login]

			if pwdentry and pwdentry.password == o.args.password then

				o.session.data.authuser = pwdentry.username

				o.session.data.id = o.session.id

				o.loginfailed = nil

			end

		end

	end

	o.secure = o.request.Port == o.config.secureport

	o.authuser = o.session and o.session.data.authuser

	if o.nologin or not o.authuser then

		o.authuser = nil

		o.session = nil

-- 		o.args.session = nil -- TODO?

	end

	-- Get lang, locale, profile, section

	o:init()

	if o.authuser then

		o:handlechanges()

	end

	-- Current document

	o.document = o.requestdocument .. "/" .. o.sectionpath

	if o.authuser then

		o.getdocname = function(self, path)

			return path and self.requestdocument .. "/" .. path or self.requestdocument

		end

	else

		o.getdocname = function(self, path)

			path = path or self.config.defname

			if self:isdynamic(path) then

				return self.requestdocument .. "/" .. path

			end

			path = path == self.config.defname and "index" or path

			return "/" .. path:gsub("/", "_") .. ".html"

		end

	end

	-- Create "editable section" function

	local func, msg = o:loadhtml(open("loona/editable.lua"),

		"loona:out", "loona/editable.lua")

 	assert(func, o:dbmsg("Syntax error", msg))

	o.editable = o:runboxed(func)

	-- Save session state

	if o.session then

		o.session.save()

	end

	return o

end

function loona:execute(fname)

	self:indexdynamic() -- TODO: this a solution?

	fname = fname or self.requesthandler