--[[

			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

--]]

-- 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          = 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 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, ssl = pcall ( require , "ssl" )

local socket = require "socket"

local levent = require "luaevent.core"

local socket_gettime = socket.gettime

local getaddrinfo = socket.dns.getaddrinfo

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 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) -- 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 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_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[ 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)

	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

interface_mt.clientport = interface_mt.port -- COMPAT server_select

function interface_mt:type()

	return self._type or "client"

end

function interface_mt:connections()

	return self._connections

end

function interface_mt:address()

	return self.addr

end

function interface_mt:set_sslctx(sslctx)

	self._sslctx = sslctx;

	if sslctx then

		self.starttls = nil; -- use starttls() of interface_mt

	else

		self.starttls = false; -- prevent starttls()

	end

end

function interface_mt:set_mode(pattern)

	if pattern then

		self._pattern = pattern;

	end

	return self._pattern;

end

function interface_mt:set_send(new_send) -- luacheck: ignore 212

	-- No-op, we always use the underlying connection's send

end

function interface_mt:starttls(sslctx, call_onconnect)

	debug( "try to start ssl at client id:", self.id )

	local err