-- 

-- server.lua by blastbeat of the luadch project

-- Re-used here under the MIT/X Consortium License

-- 

-- Modifications (C) 2008-2010 Matthew Wild, Waqas Hussain

--

-- // wrapping luadch stuff // --

local use = function( what )

	return _G[ what ]

end

local clean = function( tbl )

	for i, k in pairs( tbl ) do

		tbl[ i ] = nil

	end

end

local log, table_concat = require ("util.logger").init("socket"), table.concat;

local out_put = function (...) return log("debug", table_concat{...}); end

local out_error = function (...) return log("warn", table_concat{...}); end

local mem_free = collectgarbage

----------------------------------// DECLARATION //--

--// constants //--

local STAT_UNIT = 1 -- byte

--// lua functions //--

local type = use "type"

local pairs = use "pairs"

local ipairs = use "ipairs"

local tonumber = use "tonumber"

local tostring = use "tostring"

local collectgarbage = use "collectgarbage"

--// lua libs //--

local os = use "os"

local table = use "table"

local string = use "string"

local coroutine = use "coroutine"

--// lua lib methods //--

local os_difftime = os.difftime

local math_min = math.min

local math_huge = math.huge

local table_concat = table.concat

local table_remove = table.remove

local string_len = string.len

local string_sub = string.sub

local coroutine_wrap = coroutine.wrap

local coroutine_yield = coroutine.yield

--// extern libs //--

local luasec = use "ssl"

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

local luasocket_gettime = luasocket.gettime

--// extern lib methods //--

local ssl_wrap = ( luasec and luasec.wrap )

local socket_bind = luasocket.bind

local socket_sleep = luasocket.sleep

local socket_select = luasocket.select

local ssl_newcontext = ( luasec and luasec.newcontext )

--// functions //--

local id

local loop

local stats

local idfalse

local addtimer

local closeall

local addsocket

local addserver

local getserver

local wrapserver

local getsettings

local closesocket

local removesocket

local removeserver

local changetimeout

local wrapconnection

local changesettings

--// tables //--

local _server

local _readlist

local _timerlist

local _sendlist

local _socketlist

local _closelist

local _readtimes

local _writetimes

--// simple data types //--

local _

local _readlistlen

local _sendlistlen

local _timerlistlen

local _sendtraffic

local _readtraffic

local _selecttimeout

local _sleeptime

local _starttime

local _currenttime

local _maxsendlen

local _maxreadlen

local _checkinterval

local _sendtimeout

local _readtimeout

local _cleanqueue

local _timer

local _maxclientsperserver

local _maxsslhandshake

----------------------------------// DEFINITION //--

_server = { } -- key = port, value = table; list of listening servers

_readlist = { } -- array with sockets to read from

_sendlist = { } -- arrary with sockets to write to

_timerlist = { } -- array of timer functions

_socketlist = { } -- key = socket, value = wrapped socket (handlers)

_readtimes = { } -- key = handler, value = timestamp of last data reading

_writetimes = { } -- key = handler, value = timestamp of last data writing/sending

_closelist = { } -- handlers to close

_readlistlen = 0 -- length of readlist

_sendlistlen = 0 -- length of sendlist

_timerlistlen = 0 -- lenght of timerlist

_sendtraffic = 0 -- some stats

_readtraffic = 0

_selecttimeout = 1 -- timeout of socket.select

_sleeptime = 0 -- time to wait at the end of every loop

_maxsendlen = 51000 * 1024 -- max len of send buffer

_maxreadlen = 25000 * 1024 -- max len of read buffer

_checkinterval = 1200000 -- interval in secs to check idle clients

_sendtimeout = 60000 -- allowed send idle time in secs

_readtimeout = 6 * 60 * 60 -- allowed read idle time in secs

_cleanqueue = false -- clean bufferqueue after using

_maxclientsperserver = 1000

_maxsslhandshake = 30 -- max handshake round-trips

----------------------------------// PRIVATE //--

wrapserver = function( listeners, socket, ip, serverport, pattern, sslctx, maxconnections ) -- this function wraps a server

	maxconnections = maxconnections or _maxclientsperserver

	local connections = 0

	local dispatch, disconnect = listeners.onconnect or listeners.onincoming, listeners.ondisconnect

	local accept = socket.accept

	--// public methods of the object //--

	local handler = { }

	handler.shutdown = function( ) end

	handler.ssl = function( )

		return sslctx ~= nil

	end

	handler.sslctx = function( )

		return sslctx

	end

	handler.remove = function( )

		connections = connections - 1

	end

	handler.close = function( )

		for _, handler in pairs( _socketlist ) do

			if handler.serverport == serverport then

				handler.disconnect( handler, "server closed" )

				handler:close( true )

			end

		end

		socket:close( )

		_sendlistlen = removesocket( _sendlist, socket, _sendlistlen )

		_readlistlen = removesocket( _readlist, socket, _readlistlen )

		_socketlist[ socket ] = nil

		handler = nil

		socket = nil

		--mem_free( )

		out_put "server.lua: closed server handler and removed sockets from list"

	end

	handler.ip = function( )

		return ip

	end

	handler.serverport = function( )

		return serverport

	end

	handler.socket = function( )

		return socket

	end

	handler.readbuffer = function( )

		if connections > maxconnections then

			out_put( "server.lua: refused new client connection: server full" )

			return false

		end

		local client, err = accept( socket )	-- try to accept

		if client then

			local ip, clientport = client:getpeername( )

			client:settimeout( 0 )

			local handler, client, err = wrapconnection( handler, listeners, client, ip, serverport, clientport, pattern, sslctx ) -- wrap new client socket

			if err then -- error while wrapping ssl socket

				return false

			end

			connections = connections + 1

			out_put( "server.lua: accepted new client connection from ", tostring(ip), ":", tostring(clientport), " to ", tostring(serverport))

			return dispatch( handler )

		elseif err then -- maybe timeout or something else

			out_put( "server.lua: error with new client connection: ", tostring(err) )

			return false

		end

	end

	return handler

end

wrapconnection = function( server, listeners, socket, ip, serverport, clientport, pattern, sslctx ) -- this function wraps a client to a handler object

	socket:settimeout( 0 )

	--// local import of socket methods //--

	local send

	local receive

	local shutdown

	--// private closures of the object //--

	local ssl

	local dispatch = listeners.onincoming

	local status = listeners.onstatus

	local disconnect = listeners.ondisconnect

	local drain = listeners.ondrain

	local bufferqueue = { } -- buffer array

	local bufferqueuelen = 0	-- end of buffer array

	local toclose

	local fatalerror

	local needtls

	local bufferlen = 0

	local noread = false

	local nosend = false

	local sendtraffic, readtraffic = 0, 0

	local maxsendlen = _maxsendlen

	local maxreadlen = _maxreadlen

	--// public methods of the object //--

	local handler = bufferqueue -- saves a table ^_^

	handler.dispatch = function( )

		return dispatch

	end

	handler.disconnect = function( )

		return disconnect

	end

	handler.setlistener = function( self, listeners )

		dispatch = listeners.onincoming

		disconnect = listeners.ondisconnect

		status = listeners.onstatus

		drain = listeners.ondrain

	end

	handler.getstats = function( )

		return readtraffic, sendtraffic

	end

	handler.ssl = function( )

		return ssl

	end

	handler.sslctx = function ( )

		return sslctx

	end

	handler.send = function( _, data, i, j )

		return send( socket, data, i, j )

	end

	handler.receive = function( pattern, prefix )

		return receive( socket, pattern, prefix )

	end

	handler.shutdown = function( pattern )

		return shutdown( socket, pattern )

	end

	handler.setoption = function (self, option, value)

		if socket.setoption then

			return socket:setoption(option, value);

		end

		return false, "setoption not implemented";

	end

	handler.close = function( self, forced )

		if not handler then return true; end

		_readlistlen = removesocket( _readlist, socket, _readlistlen )

		_readtimes[ handler ] = nil

		if bufferqueuelen ~= 0 then

			if not ( forced or fatalerror ) then

				handler.sendbuffer( )

				if bufferqueuelen ~= 0 then -- try again...

					if handler then

						handler.write = nil -- ... but no further writing allowed

					end

					toclose = true

					return false

				end

			else

				send( socket, table_concat( bufferqueue, "", 1, bufferqueuelen ), 1, bufferlen )	-- forced send

			end

		end

		if socket then

			_ = shutdown and shutdown( socket )

			socket:close( )

			_sendlistlen = removesocket( _sendlist, socket, _sendlistlen )

			_socketlist[ socket ] = nil

			socket = nil

		else

			out_put "server.lua: socket already closed"

		end

		if handler then

			_writetimes[ handler ] = nil

			_closelist[ handler ] = nil

			handler = nil

		end

		if server then

			server.remove( )

		end

		out_put "server.lua: closed client handler and removed socket from list"

		return true

	end

	handler.ip = function( )

		return ip

	end

	handler.serverport = function( )

		return serverport

	end

	handler.clientport = function( )

		return clientport

	end

	local write = function( self, data )

		bufferlen = bufferlen + string_len( data )

		if bufferlen > maxsendlen then

			_closelist[ handler ] = "send buffer exceeded"	 -- cannot close the client at the moment, have to wait to the end of the cycle

			handler.write = idfalse -- dont write anymore

			return false

		elseif socket and not _sendlist[ socket ] then

			_sendlistlen = addsocket(_sendlist, socket, _sendlistlen)

		end

		bufferqueuelen = bufferqueuelen + 1

		bufferqueue[ bufferqueuelen ] = data

		if handler then

			_writetimes[ handler ] = _writetimes[ handler ] or _currenttime

		end

		return true

	end

	handler.write = write

	handler.bufferqueue = function( self )

		return bufferqueue

	end

	handler.socket = function( self )

		return socket

	end

	handler.set_mode = function( self, new )

		pattern = new or pattern

		return pattern

	end

	handler.set_send = function ( self, newsend )

		send = newsend or send

		return send

	end

	handler.bufferlen = function( self, readlen, sendlen )

		maxsendlen = sendlen or maxsendlen

		maxreadlen = readlen or maxreadlen