--[[

			server.lua based on lua/libevent by blastbeat

			notes:

			-- when using luaevent, never register 2 or more EV_READ at one socket, same for EV_WRITE

			-- you can't even register a new EV_READ/EV_WRITE callback inside another one

			-- to do some of the above, use timeout events or something what will called from outside

			-- don't let garbagecollect eventcallbacks, as long they are running

			-- when using luasec, there are 4 cases of timeout errors: wantread or wantwrite during reading or writing

--]]

-- luacheck: ignore 212/self 431/err 211/ret

local SCRIPT_NAME           = "server_event.lua"

local SCRIPT_VERSION        = "0.05"

local SCRIPT_AUTHOR         = "blastbeat"

local LAST_MODIFIED         = "2009/11/20"

local cfg = {

	MAX_CONNECTIONS       = 100000,  -- max per server connections (use "ulimit -n" on *nix)

	MAX_HANDSHAKE_ATTEMPTS= 1000,  -- attempts to finish ssl handshake

	HANDSHAKE_TIMEOUT     = 60,  -- timeout in seconds per handshake attempt

	MAX_READ_LENGTH       = 1024 * 1024 * 1024 * 1024,  -- max bytes allowed to read from sockets

	MAX_SEND_LENGTH       = 1024 * 1024 * 1024 * 1024,  -- max bytes size of write buffer (for writing on sockets)

	ACCEPT_QUEUE          = 128,  -- might influence the length of the pending sockets queue

	ACCEPT_DELAY          = 10,  -- seconds to wait until the next attempt of a full server to accept

	READ_TIMEOUT          = 14 * 60,  -- timeout in seconds for read data from socket

	WRITE_TIMEOUT         = 180,  -- timeout in seconds for write data on socket

	CONNECT_TIMEOUT       = 20,  -- timeout in seconds for connection attempts

	CLEAR_DELAY           = 5,  -- seconds to wait for clearing interface list (and calling ondisconnect listeners)

	READ_RETRY_DELAY      = 1e-06, -- if, after reading, there is still data in buffer, wait this long and continue reading

	DEBUG                 = true,  -- show debug messages

}

local pairs = pairs

local select = select

local require = require

local tostring = tostring

local setmetatable = setmetatable

local t_insert = table.insert

local t_concat = table.concat

local s_sub = string.sub

local coroutine_wrap = coroutine.wrap

local coroutine_yield = coroutine.yield

local has_luasec = pcall ( require , "ssl" )

local socket = require "socket"

local levent = require "luaevent.core"

local inet = require "prosody.util.net";

local inet_pton = inet.pton;

local sslconfig = require "prosody.util.sslconfig";

local tls_impl = require "prosody.net.tls_luasec";

local socket_gettime = socket.gettime

local log = require ("prosody.util.logger").init("socket")

local function debug(...)

	return log("debug", ("%s "):rep(select('#', ...)), ...)

end

-- local vdebug = debug;

local bitor = ( function( ) -- thx Rici Lake

	local hasbit = function( x, p )

		return x % ( p + p ) >= p

	end

	return function( x, y )

		local p = 1

		local z = 0

		local limit = x > y and x or y

		while p <= limit do

			if hasbit( x, p ) or hasbit( y, p ) then

				z = z + p

			end

			p = p + p

		end

		return z

	end

end )( )

local base = levent.new( )

local addevent = base.addevent

local EV_READ = levent.EV_READ

local EV_WRITE = levent.EV_WRITE

local EV_TIMEOUT = levent.EV_TIMEOUT

local EV_SIGNAL = levent.EV_SIGNAL

local EV_READWRITE = bitor( EV_READ, EV_WRITE )

local interfacelist = { }

-- Client interface methods

local interface_mt = {}; interface_mt.__index = interface_mt;

-- Private methods

function interface_mt:_close()

	return self:_destroy();

end

function interface_mt:_start_connection(plainssl) -- called from wrapclient

	local callback = function( event )

		if EV_TIMEOUT == event then  -- timeout during connection

			self.fatalerror = "connection timeout"

			self:ontimeout()  -- call timeout listener

			self:_close()

			debug( "new connection failed. id:", self.id, "error:", self.fatalerror )

		else

			if EV_READWRITE == event then

				if self.readcallback(event) == -1 then

					-- Fatal error occurred

					return -1;

				end

			end

			if plainssl and has_luasec then  -- start ssl session

				self:starttls(self._sslctx, true)

			else  -- normal connection

				self:_start_session(true)

			end

			debug( "new connection established. id:", self.id )

		end

		self.eventconnect = nil

		return -1

	end

	self.eventconnect = addevent( base, self.conn, EV_READWRITE, callback, cfg.CONNECT_TIMEOUT )

	return true

end

function interface_mt:_start_session(call_onconnect) -- new session, for example after startssl

	if self.type == "client" then

		local callback = function( )

			self:_lock( false,  false, false )

			--vdebug( "start listening on client socket with id:", self.id )

			self.eventread = addevent( base, self.conn, EV_READ, self.readcallback, cfg.READ_TIMEOUT );  -- register callback

			if call_onconnect then

				self:onconnect()

			end

			self.eventsession = nil

			return -1

		end

		self.eventsession = addevent( base, nil, EV_TIMEOUT, callback, 0 )

	else

		self:_lock( false )

		--vdebug( "start listening on server socket with id:", self.id )

		self.eventread = addevent( base, self.conn, EV_READ, self.readcallback )  -- register callback

	end

	return true

end

function interface_mt:_start_ssl(call_onconnect) -- old socket will be destroyed, therefore we have to close read/write events first

	--vdebug( "starting ssl session with client id:", self.id )

	local _

	_ = self.eventread and self.eventread:close( )  -- close events; this must be called outside of the event callbacks!

	_ = self.eventwrite and self.eventwrite:close( )

	self.eventread, self.eventwrite = nil, nil

	local err

	self.conn, err = self._sslctx:wrap(self.conn)

	if err then

		self.fatalerror = err

		self.conn = nil  -- cannot be used anymore

		if call_onconnect then

			self.ondisconnect = nil  -- don't call this when client isn't really connected

		end

		self:_close()

		debug( "fatal error while ssl wrapping:", err )

		return false

	end

	if self.conn.sni then

		if self.servername then

			self.conn:sni(self.servername);

		elseif next(self._sslctx._sni_contexts) ~= nil then

			self.conn:sni(self._sslctx._sni_contexts, true);

		end

	end

	self.conn:settimeout( 0 )  -- set non blocking

	local handshakecallback = coroutine_wrap(function( event )

		local _, err

		local attempt = 0

		local maxattempt = cfg.MAX_HANDSHAKE_ATTEMPTS

		while attempt < maxattempt do  -- no endless loop

			attempt = attempt + 1

			debug( "ssl handshake of client with id:"..tostring(self)..", attempt:"..attempt )

			if attempt > maxattempt then

				self.fatalerror = "max handshake attempts exceeded"

			elseif EV_TIMEOUT == event then

				self.fatalerror = "timeout during handshake"

			else

				_, err = self.conn:dohandshake( )

				if not err then

					self:_lock( false, false, false )  -- unlock the interface; sending, closing etc allowed

					self.send = self.conn.send  -- caching table lookups with new client object

					self.receive = self.conn.receive

					if not call_onconnect then  -- trigger listener

						self:onstatus("ssl-handshake-complete");

					end

					self:_start_session( call_onconnect )

					debug( "ssl handshake done" )

					self.eventhandshake = nil

					return -1

				end

				if err == "wantwrite" then

					event = EV_WRITE

				elseif err == "wantread" then

					event = EV_READ

				else

					debug( "ssl handshake error:", err )

					self.fatalerror = err

				end

			end

			if self.fatalerror then

				if call_onconnect then

					self.ondisconnect = nil  -- don't call this when client isn't really connected

				end

				self:_close()

				debug( "handshake failed because:", self.fatalerror )

				self.eventhandshake = nil

				return -1

			end

			event = coroutine_yield( event, cfg.HANDSHAKE_TIMEOUT )  -- yield this monster...

		end

	end

	)

	debug "starting handshake..."

	self:_lock( false, true, true )  -- unlock read/write events, but keep interface locked

	self.eventhandshake = addevent( base, self.conn, EV_READWRITE, handshakecallback, cfg.HANDSHAKE_TIMEOUT )

	return true

end

function interface_mt:_destroy()  -- close this interface + events and call last listener

	debug( "closing client with id:", self.id, self.fatalerror )

	self:_lock( true, true, true )  -- first of all, lock the interface to avoid further actions

	local _

	_ = self.eventread and self.eventread:close( )

	if self.type == "client" then

		_ = self.eventwrite and self.eventwrite:close( )

		_ = self.eventhandshake and self.eventhandshake:close( )

		_ = self.eventstarthandshake and self.eventstarthandshake:close( )

		_ = self.eventconnect and self.eventconnect:close( )

		_ = self.eventsession and self.eventsession:close( )

		_ = self.eventwritetimeout and self.eventwritetimeout:close( )

		_ = self.eventreadtimeout and self.eventreadtimeout:close( )

		-- call ondisconnect listener (won't be the case if handshake failed on connect)

		_ = self.ondisconnect and self:ondisconnect( self.fatalerror ~= "client to close" and self.fatalerror)

		_ = self.conn and self.conn:close( ) -- close connection

		_ = self._server and self._server:counter(-1);

		self.eventread, self.eventwrite = nil, nil

		self.eventstarthandshake, self.eventhandshake, self.eventclose = nil, nil, nil

		self.readcallback, self.writecallback = nil, nil

	else

		self.conn:close( )

		self.eventread, self.eventclose = nil, nil

		self.interface, self.readcallback = nil, nil

	end

	interfacelist[ self ] = nil

	return true

end

function interface_mt:_lock(nointerface, noreading, nowriting)  -- lock or unlock this interface or events

	self.nointerface, self.noreading, self.nowriting = nointerface, noreading, nowriting

	return nointerface, noreading, nowriting

end

--TODO: Deprecate

function interface_mt:lock_read(switch)

	log("warn", ":lock_read is deprecated, use :pause() and :resume()");

	if switch then

		return self:pause();

	else

		return self:resume();

	end

end

function interface_mt:pause()

	return self:_lock(self.nointerface, true, self.nowriting);

end

function interface_mt:sslctx()

	return self._sslctx

end

function interface_mt:ssl_info()

	local sock = self.conn;

	if not sock.info then return nil, "not-implemented"; end

	return sock:info();

end

function interface_mt:ssl_peercertificate()

	local sock = self.conn;

	if not sock.getpeercertificate then return nil, "not-implemented"; end

	return sock:getpeercertificate();

end

function interface_mt:ssl_peerverification()

	local sock = self.conn;

	if not sock.getpeerverification then return nil, { { "Chain verification not supported" } }; end

	return sock:getpeerverification();

end

function interface_mt:ssl_peerfinished()

	local sock = self.conn;

	if not sock.getpeerfinished then return nil, "not-implemented"; end

	return sock:getpeerfinished();

end

function interface_mt:resume()

	self:_lock(self.nointerface, false, self.nowriting);

	if self.readcallback and not self.eventread then

		self.eventread = addevent( base, self.conn, EV_READ, self.readcallback, cfg.READ_TIMEOUT );  -- register callback

		return true;

	end

end

function interface_mt:pause_writes()

	return self:_lock(self.nointerface, self.noreading, true);

end

function interface_mt:resume_writes()

	self:_lock(self.nointerface, self.noreading, false);

	if self.writecallback and not self.eventwrite then

		self.eventwrite = addevent( base, self.conn, EV_WRITE, self.writecallback, cfg.WRITE_TIMEOUT );  -- register callback

		return true;

	end

end

function interface_mt:counter(c)

	if c then

		self._connections = self._connections + c

	end

	return self._connections

end

-- Public methods

function interface_mt:write(data)

	if self.nointerface then return nil, "locked"; end

	--vdebug( "try to send data to client, id/data:", self.id, data )

	data = tostring( data )

	local len = #data

	local total = len + self.writebufferlen

	if total > cfg.MAX_SEND_LENGTH then  -- check buffer length

		local err = "send buffer exceeded"

		debug( "error:", err )  -- to much, check your app

		return nil, err

	end

	t_insert(self.writebuffer, data) -- new buffer

	self.writebufferlen = total

	if not self.eventwrite and not self.nowriting  then  -- register new write event

		--vdebug( "register new write event" )

		self.eventwrite = addevent( base, self.conn, EV_WRITE, self.writecallback, cfg.WRITE_TIMEOUT )

	end

	return true

end

function interface_mt:close()

	if self.nointerface then return nil, "locked"; end

	debug( "try to close client connection with id:", self.id )

	if self.type == "client" then

		self.fatalerror = "client to close"

		if self.eventwrite then -- wait for incomplete write request

			self:_lock( true, true, false )

			debug "closing delayed until writebuffer is empty"

			return nil, "writebuffer not empty, waiting"

		else -- close now

			self:_lock( true, true, true )

			self:_close()

			return true

		end