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

 --

 --	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", tek.class)

 _VERSION = "FastCGI 0.6"

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

 -- local FIFO class:

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

 local FIFO = Class:newClass { _NAME = "_fcgi_fifo" }

 function FIFO.new(class, self)

 	self = self or { }

 	self.buf = self.buf or { }

 	return Class.new(class, 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 = self or { }

 	self.requests = { }

 	self.socket = false

 	self.serving = false

 	return Class.new(class, 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

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

 		else

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

 		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.serving = true

 	while self.serving 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.serving = 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.

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

 function FastCGI:have_params()

 	return true

 end

 function FastCGI:update_stream()

 	return true

 end