--

-- 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 log, table_concat = require ("prosody.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

----------------------------------// 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"

--// lua libs //--

local table = use "table"

local string = use "string"

local coroutine = use "coroutine"

--// lua lib methods //--

local math_min = math.min

local math_huge = math.huge

local table_concat = table.concat

local table_insert = table.insert

local string_sub = string.sub

local coroutine_wrap = coroutine.wrap

local coroutine_yield = coroutine.yield

--// extern libs //--

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

local luasocket_gettime = luasocket.gettime

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

local inet_pton = inet.pton;

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

local has_luasec, tls_impl = pcall(require, "prosody.net.tls_luasec");

--// extern lib methods //--

local socket_bind = luasocket.bind

local socket_select = luasocket.select

--// functions //--

local id

local loop

local stats

local idfalse

local closeall

local addsocket

local addserver

local listen

local addtimer

local getserver

local wrapserver

local getsettings

local closesocket

local removesocket

local removeserver

local wrapconnection

local changesettings

--// tables //--

local _server

local _readlist

local _timerlist

local _sendlist

local _socketlist

local _closelist

local _readtimes

local _writetimes

local _fullservers

--// simple data types //--

local _

local _readlistlen

local _sendlistlen

local _timerlistlen

local _sendtraffic

local _readtraffic

local _selecttimeout

local _tcpbacklog

local _accepretry

local _starttime

local _currenttime

local _maxsendlen

local _maxreadlen

local _checkinterval

local _sendtimeout

local _readtimeout

local _maxselectlen

local _maxfd

local _maxsslhandshake

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

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

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

_sendlist = { } -- array 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

_fullservers = { } -- servers in a paused state while there are too many clients

_readlistlen = 0 -- length of readlist

_sendlistlen = 0 -- length of sendlist

_timerlistlen = 0 -- length of timerlist

_sendtraffic = 0 -- some stats

_readtraffic = 0

_selecttimeout = 1 -- timeout of socket.select

_tcpbacklog = 128 -- some kind of hint to the OS

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

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

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

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

_sendtimeout = 60000 -- allowed send idle time in secs

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

local is_windows = package.config:sub(1,1) == "\\" -- check the directory separator, to determine whether this is Windows

_maxfd = (is_windows and math.huge) or luasocket._SETSIZE or 1024 -- max fd number, limit to 1024 by default to prevent glibc buffer overflow, but not on Windows

_maxselectlen = luasocket._SETSIZE or 1024 -- But this still applies on Windows

_maxsslhandshake = 30 -- max handshake round-trips

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

wrapserver = function( listeners, socket, ip, serverport, pattern, sslctx, ssldirect ) -- this function wraps a server -- FIXME Make sure FD < _maxfd

	if socket:getfd() >= _maxfd then

		out_error("server.lua: Disallowed FD number: "..socket:getfd())

		socket:close()

		return nil, "fd-too-large"

	end

	local connections = 0

	local dispatch, disconnect = listeners.onconnect, 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.hosts = {} -- sni

	handler.remove = function( )

		connections = connections - 1

		if handler then

			handler.resume( )

		end

	end

	handler.close = function()

		socket:close( )

		_sendlistlen = removesocket( _sendlist, socket, _sendlistlen )

		_readlistlen = removesocket( _readlist, socket, _readlistlen )

		_server[ip..":"..serverport] = nil;

		_socketlist[ socket ] = nil

		handler = nil

		socket = nil

		--mem_free( )

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

	end

	handler.pause = function( hard )

		if not handler.paused then

			_readlistlen = removesocket( _readlist, socket, _readlistlen )

			if hard then

				_socketlist[ socket ] = nil

				socket:close( )

				socket = nil;

			end

			handler.paused = true;

			out_put("server.lua: server [", ip, "]:", serverport, " paused")

		end

	end

	handler.resume = function( )

		if handler.paused then

			if not socket then

				socket = socket_bind( ip, serverport, _tcpbacklog );

				socket:settimeout( 0 )

			end

			_readlistlen = addsocket(_readlist, socket, _readlistlen)

			_socketlist[ socket ] = handler

			_fullservers[ handler ] = nil

			handler.paused = false;

			out_put("server.lua: server [", ip, "]:", serverport, " resumed")

		end

	end

	handler.ip = function( )

		return ip

	end

	handler.serverport = function( )

		return serverport

	end

	handler.socket = function( )

		return socket

	end

	handler.readbuffer = function( )

		if _readlistlen >= _maxselectlen or _sendlistlen >= _maxselectlen then

			handler.pause( )

			_fullservers[ handler ] = _currenttime

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

			local handler, client, err = wrapconnection( handler, listeners, client, ip, serverport, clientport, pattern, sslctx, ssldirect ) -- 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))

			if dispatch and not ssldirect then -- SSL connections will notify onconnect when handshake completes

				return dispatch( handler );

			end

			return;

		elseif err then -- maybe timeout or something else

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

			handler.pause( )

			_fullservers[ handler ] = _currenttime

			return false

		end

	end

	return handler

end

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

	if socket:getfd() >= _maxfd then

		out_error("server.lua: Disallowed FD number: "..socket:getfd()) -- PROTIP: Switch to libevent

		socket:close( ) -- Should we send some kind of error here?

		if server then

			_fullservers[ server ] = _currenttime

			server.pause( )

		end

		return nil, nil, "fd-too-large"

	end

	socket:settimeout( 0 )

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

	local send

	local receive

	local shutdown

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

	local ssl

	local pending

	local dispatch = listeners.onincoming

	local status = listeners.onstatus

	local disconnect = listeners.ondisconnect

	local predrain = listeners.onpredrain

	local drain = listeners.ondrain

	local onreadtimeout = listeners.onreadtimeout;

	local detach = listeners.ondetach

	local bufferqueue = { } -- buffer array

	local bufferqueuelen = 0	-- end of buffer array

	local toclose

	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.extra = extra

	if extra then

		handler.servername = extra.servername

	end

	handler.dispatch = function( )

		return dispatch

	end

	handler.disconnect = function( )

		return disconnect

	end

	handler.onreadtimeout = onreadtimeout;

	handler.setlistener = function( self, listeners, data )

		if detach then

			detach(self) -- Notify listener that it is no longer responsible for this connection

		end

		dispatch = listeners.onincoming

		disconnect = listeners.ondisconnect

		status = listeners.onstatus

		predrain = listeners.onpredrain

		drain = listeners.ondrain

		handler.onreadtimeout = listeners.onreadtimeout

		detach = listeners.ondetach

		if listeners.onattach then

			listeners.onattach(self, data)

		end

	end

	handler._setpending = function( )

		pending = true

	end

	handler.getstats = function( )

		return readtraffic, sendtraffic

	end

	handler.ssl = function( )

		return ssl

	end

	handler.sslctx = function ( )

		return sslctx

	end

	handler.ssl_info = function( )

		return socket.info and socket:info()

	end

	handler.ssl_peercertificate = function( )

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

		return socket:getpeercertificate()

	end

	handler.ssl_peerverification = function( )

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

		return socket:getpeerverification();

	end

	handler.ssl_peerfinished = function( )

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

		return socket:getpeerfinished();

	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.force_close = function ( self, err )