--[[

			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 cant 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

			-- dont 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

--]]

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_DELAY          = 10,  -- seconds to wait until the next attempt of a full server to accept

	READ_TIMEOUT          = 60 * 60 * 6,  -- 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)

	DEBUG                 = true,  -- show debug messages

}

local function use(x) return rawget(_G, x); end

local ipairs = use "ipairs"

local string = use "string"

local select = use "select"

local require = use "require"

local tostring = use "tostring"

local coroutine = use "coroutine"

local setmetatable = use "setmetatable"

local t_insert = table.insert

local t_concat = table.concat

local ssl = use "ssl"

local socket = use "socket" or require "socket"

local log = require ("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 event = require "luaevent.core"

local base = event.new( )

local EV_READ = event.EV_READ

local EV_WRITE = event.EV_WRITE

local EV_TIMEOUT = event.EV_TIMEOUT

local EV_SIGNAL = event.EV_SIGNAL

local EV_READWRITE = bitor( EV_READ, EV_WRITE )

local interfacelist = ( function( )  -- holds the interfaces for sockets

	local array = { }

	local len = 0

	return function( method, arg )

		if "add" == method then

			len = len + 1

			array[ len ] = arg

			arg:_position( len )

			return len

		elseif "delete" == method then

			if len <= 0 then

				return nil, "array is already empty"

			end

			local position = arg:_position()  -- get position in array

			if position ~= len then

				local interface = array[ len ]  -- get last interface

				array[ position ] = interface  -- copy it into free position

				array[ len ] = nil  -- free last position

				interface:_position( position )  -- set new position in array

			else  -- free last position

				array[ len ] = nil

			end

			len = len - 1

			return len

		else

			return array

		end

	end

end )( )

-- Client interface methods

local interface_mt

do

	interface_mt = {}; interface_mt.__index = interface_mt;

	local addevent = base.addevent

	local coroutine_wrap, coroutine_yield = coroutine.wrap,coroutine.yield

	-- Private methods

	function interface_mt:_position(new_position)

			self.position = new_position or self.position

			return self.position;

	end

	function interface_mt:_close()

		return self:_destroy();

	end

	function interface_mt:_start_connection(plainssl) -- should be called from addclient

			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 plainssl and ssl 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_WRITE, 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 = ssl.wrap( self.conn, self._sslctx )

			if err then

				self.fatalerror = err

				self.conn = nil  -- cannot be used anymore

				if call_onconnect then

					self.ondisconnect = nil  -- dont call this when client isnt really connected

				end

				self:_close()

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

				return false

			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  -- dont call this when client isnt 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( )

				_ = self.ondisconnect and self:ondisconnect( self.fatalerror ~= "client to close" and self.fatalerror)  -- call ondisconnect listener (wont be the case if handshake failed on connect)

				_ = 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( "delete", self )

			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)

		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:resume()

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

		if not self.eventread then

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

		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.nowriting 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 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

		else

			debug( "try to close server with id:", tostring(self.id))

			self.fatalerror = "server to close"

			self:_lock( true )

			self:_close( 0 )

			return true

		end

	end

	function interface_mt:socket()

		return self.conn

	end

	function interface_mt:server()

		return self._server or self;

	end

	function interface_mt:port()

		return self._port

	end

	function interface_mt:serverport()

		return self._serverport

	end

	function interface_mt:ip()

		return self._ip

	end

	function interface_mt:ssl()

		return self._usingssl

	end

	function interface_mt:type()

		return self._type or "client"

	end