-------------------------------------------------------------------------------

--

--	tek.class.fastcgi

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

--

--	OVERVIEW::

--	Lua FastCGI protocol implementation - specifically written for

--	the ''external server'' configuration (via IP socket).

--

--	Methods that must be implemented by the user:

--		- FastCGI:have_params() - signals that all arguments have been

--		transferred

--

--	Methods that can be implemented by the user:

--		- FastCGI:update_stream() - stream created/updated (for POST)

--		- FastCGI:have_stream() - stream completed (for POST)

--

--	REQUIREMENTS::

--	LuaSocket and Bit library

--

-------------------------------------------------------------------------------

local Class = require "tek.class"

local socket = require "socket"

local bit = require "bit"

local insert, remove, concat, pairs, ipairs, error, assert =

	table.insert, table.remove, table.concat, pairs, ipairs, error, assert

local tonumber, setmetatable, unpack, type =

	tonumber, setmetatable, unpack, type

local char = string.char

local min = math.min

module("tek.class.fastcgi", Class)

_VERSION = "FastCGI 0.4"

-------------------------------------------------------------------------------

-- local FIFO class:

-------------------------------------------------------------------------------

local FIFO = Class:newClass()

function FIFO.new(class, self)

	self = Class.new(class, self or { })

	self.buf = self.buf or { }

	return self

end

function FIFO:write(s)

	if s and s ~= -1 then

		insert(self.buf, s)

	elseif self.buf[#self.buf] ~= -1 then

		insert(self.buf, -1) -- EOF

	end

end

function FIFO:readn(len)

	local t, p, l = { }

	while len > 0 do

		p = remove(self.buf, 1)

		if not p then

			break -- no more data

		end

		if p == -1 then

			insert(self.buf, -1) -- push back EOF

			break -- end of stream, EOF in next turn

		end

		l = p:len()

		if l > len then -- break buffer fragment in two

			insert(t, p:sub(1, len))

			insert(self.buf, 1, p:sub(len + 1))

			break

		end

		insert(t, p)

		len = len - l

	end

	return concat(t)

end

function FIFO:reada()

	local last = remove(self.buf)

	if last ~= -1 then -- not EOF

		insert(self.buf, last) -- push back

		last = nil

	end

	local s = concat(self.buf)

	self.buf = { last }

	return s

end

function FIFO:read(...)

	if self.buf[1] == -1 then

		return -- EOF

	end

	local t, s = { }

	for _, what in ipairs(arg) do

		if what == "*a" then

			s = self:reada()

		elseif type(what) == "number" then

			s = self:readn(tonumber(what))

		else

			error("unknwon format")

		end

		insert(t, s)

	end

	return unpack(t)

end

--	FCGI encoded lengths and key/value pairs:

function FIFO:readlen()

	local l = self:read(1)

	if not l then return end

	l = l:byte()

	if l < 128 then

		return l

	end

	local t = self:read(3)

	if not t then return end

	return (l % 128) * 16777216 + t:byte(1) * 65536 +

		t:byte(2) * 256 + t:byte(3)

end

function FIFO:readkeyvals()

	local t = { }

	local l1, l2, key, val

	while true do

		l1 = self:readlen()

		if not l1 then break end

		l2 = self:readlen()

		if not l2 then break end

 		key = self:read(l1)

 		val = self:read(l2)

		t[key] = val

	end

	return t

end

-------------------------------------------------------------------------------

-- FCGI class:

-------------------------------------------------------------------------------

FCGI_BEGIN_REQUEST = 1

FCGI_ABORT_REQUEST = 2

FCGI_END_REQUEST = 3

FCGI_PARAMS = 4

FCGI_STDIN = 5

FCGI_STDOUT = 6

FCGI_STDERR = 7

FCGI_DATA = 8

FCGI_GET_VALUES = 9

FCGI_GET_VALUES_RESULT = 10

FCGI_UNKNOWN_TYPE = 11

local FCGI_RESPONDER = 1

local FCGI_REQUEST_COMPLETE = 0

local FCGI_UNKNOWN_ROLE = 3

local function encodelen(buf, l)

	if l > 127 then

		insert(buf, char(bit.rshift(bit.band(l, 0x7f000000), 24) + 128))

		insert(buf, char(bit.rshift(bit.band(l, 0x00ff0000), 16)))

		insert(buf, char(bit.rshift(bit.band(l, 0x0000ff00), 8)))

	end

	insert(buf, char(bit.band(l, 0xff)))

end

local function encodekeyvals(t)

	local buf = { }

	for key, val in pairs(t) do

		encodelen(buf, key:len())

		encodelen(buf, val:len())

		insert(buf, key)

		insert(buf, val)

	end

	return concat(buf)

end

local FastCGI = _M

function FastCGI.new(class, self)

	self = Class.new(class, self)

	self.requests = { }

	return self

end

function FastCGI:readrecord()

	local t, err = self.socket:receive(8)

	if not t then return end

	if err then error(err) end

	local r = {

		ver = t:byte(1),

		type = t:byte(2),

		id = t:byte(3) * 256 + t:byte(4),

		len = t:byte(5) * 256 + t:byte(6)

	}

	if r.len == 0 then

		r.content = ""

	else

		r.content, err = self.socket:receive(r.len)

		if not r.content then return end

		if err then error(err) end

	end

	local pad = t:byte(7)

	if pad > 0 then

		t, err = self.socket:receive(pad)

		if not t then return end

		if err then error(err) end

	end

	return r

end

function FastCGI:write(type, id, s)

	local totlen = s:len()

	local totpos = 1

	while totlen > 0 do

		local len = min(totlen, 65535)

		local buf = concat {

			char(1), -- version

			char(type), -- type

			char(bit.rshift(id, 8)), -- id1

			char(id % 256), -- id0

			char(bit.rshift(len, 8)), -- len1

			char(len % 256), -- len0

			char(0), -- pad = 0

			char(0), -- reserved

			s:sub(totpos, totpos + len - 1) -- content

		}

		totpos = totpos + len

		totlen = totlen - len

		len = buf:len()

		local pos, res, err = 1

		while pos <= len do

			res, err = self.socket:send(buf, pos)

			if not res then

				return nil, err

			end

			pos = res + 1

		end

	end

	return true

end

-------------------------------------------------------------------------------

--	success, msg = write_stdout(req_id, data): Write out data on the FastCGI

--	stdout stream, in reply to a request of the given Id. The result is true,

--	indicating success, or nil followed by an error message.

-------------------------------------------------------------------------------

function FastCGI:write_stdout(id, s)

	return self:write(FCGI_STDOUT, id, s)

end

function FastCGI:collectstream(r)

	local req = self.requests[r.id]

	local s = req.streams[r.type]

	if not s then

		s = FIFO:new()

		req.streams[r.type] = s

	end

	if r.len == 0 then

		s:write() -- append EOF

		return s, true -- finished

	end

	s:write(r.content)

	return s

end

-------------------------------------------------------------------------------

--	success, msg = endrequest(request[, protstatus[, appstatus]]):

--	Confirms the end of a FastCGI request. Optionally, the application can

--	signify a protocol status (by default, FCGI_REQUEST_COMPLETE) and an

--	application status (by default, 0). See

--	[[FastCGI protocol][http://www.fastcgi.com/devkit/doc/fcgi-spec.html]]

--	specification for details.

--	The result will be true, indicating success, or nil followed by an

--	error message.

-------------------------------------------------------------------------------

function FastCGI:endrequest(req, protstatus, appstatus)

	protstatus = protstatus or req.protstatus or FCGI_REQUEST_COMPLETE

	appstatus = appstatus or req.appstatus or 0

	self.requests[req.id] = nil -- delete request

	return self:write(FCGI_END_REQUEST, req.id, concat {

		char(bit.rshift(bit.band(appstatus, 0x7f000000), 24)),

		char(bit.rshift(bit.band(appstatus, 0x00ff0000), 16)),

		char(bit.rshift(bit.band(appstatus, 0x0000ff00), 8)),

		char(bit.band(appstatus, 0xff)),

		char(protstatus),

		char(0), char(0), char(0)

	})

end

function FastCGI:newrequest(id, role, flags)

	assert(not self.requests[id])

	local req = { id = id, role = role, flags = flags, streams = { } }

	self.requests[id] = req

	return req

end

function FastCGI:processrecord(r)

	local c = r.content

	local req = self.requests[r.id]

	if r.type == FCGI_BEGIN_REQUEST then

		assert(not req)

		local role = c:byte(1) * 256 + c:byte(2)

		if role == FCGI_RESPONDER then

			-- new request

			local flags = c:byte(3)

			req = self:newrequest(r.id, role, flags)

			return true -- continue

		end

		-- unknown role

		return self:endrequest(req, FCGI_UNKNOWN_ROLE)

	end

	if not req then -- request already closed

		return true -- continue

	end

	if r.type == FCGI_ABORT_REQUEST then

		return self:abortrequest(req)

	elseif r.type == FCGI_GET_VALUES then

		local s, fin = self:collectstream(r)

		if s and fin then

			local res = { }

			for k in pairs(s:readkeyvals()) do

				if k == "FCGI_MAX_CONNS" then

					res.FCGI_MAX_CONNS = "16"

				elseif k == "FCGI_MAX_REQS" then

					res.FCGI_MAX_CONNS = "32"

				elseif k == "FCGI_MAX_REQS" then

					res.FCGI_MAX_CONNS = "1"

				end

			end

			res = encodekeyvals(res)

			return self:write(FCGI_GET_VALUES_RESULT, 0, res)

		end

	elseif r.type == FCGI_PARAMS then

		local s, fin = self:collectstream(r)

		if s and fin then

			req.params = s:readkeyvals()

			return self:have_params(req, req.params)

		end

	elseif r.type == self.FCGI_STDIN or r.type == self.FCGI_DATA then

		local s, fin = self:collectstream(r)

		if fin then

			if self.have_stream then

				return self:have_stream(req, r.type, s)

			end

		else

			if self.update_stream then

				return self:update_stream(req, r.type, s)

			end

		end

	else

		-- unknown record

		local buf = char(r.type) .. char(0):rep(7)

		return self:write(FCGI_UNKNOWN_TYPE, 0, buf)

	end

	return true -- continue

end

-------------------------------------------------------------------------------

--	serve(socket): Serve the FastCGI protocol on the supplied socket until

--	FastCGI:stop() is called.

-------------------------------------------------------------------------------

function FastCGI:serve(socket)

	assert(socket)

	self.socket = socket

	self.serve = true

	while self.serve do

		local r = self:readrecord()

		if not r then

			break

		end

		if not self:processrecord(r) then

			break

		end

	end

end

-------------------------------------------------------------------------------

--	stop(): Stop acting as a server. This will cause FastCGI:serve() to

--	return.

-------------------------------------------------------------------------------

function FastCGI:stop()

	self.serve = false

end

-------------------------------------------------------------------------------

--	success, msg = abortrequest(req_id): Called when the webserver aborts the

--	request of the given Id. The return value is the result from

--	FastCGI:endrequest().

-------------------------------------------------------------------------------

function FastCGI:abortrequest(req)

	-- request aborted by webserver, confirm:

	return self:endrequest(req)

end

-------------------------------------------------------------------------------

--	continue = have_params(req_id, params):

--	Signals the arrival of all parameters that belong to the request of the

--	given Id; params is a table containing all received parameters as

--	key/value pairs. The return value is a boolean indicating success and,

--	effectively, whether processing of the request should continue.

--	This method must be implemented by the user before anything useful can be

--	done with a FastCGI request.

-------------------------------------------------------------------------------