-- 

-- server.lua by blastbeat of the luadch project

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

-- 

-- Modifications (C) 2008-2009 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 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_time = os.time

local os_difftime = os.difftime

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

local luasocket = require "socket"

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

----------------------------------// 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, startssl )    -- this function wraps a server

    maxconnections = maxconnections or _maxclientsperserver

    local connections = 0

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

    local err

    local ssl = false

    if sslctx then

        ssl = true

        if not ssl_newcontext then

            out_error "luasec not found"

            ssl = false

        end

        if type( sslctx ) ~= "table" then

            out_error "server.lua: wrong server sslctx"

            ssl = false

        end

        local ctx;

        ctx, err = ssl_newcontext( sslctx )

        if not ctx then

            err = err or "wrong sslctx parameters"

            local file;

            file = err:match("^error loading (.-) %(");

            if file then

            	if file == "private key" then

            		file = sslctx.key or "your private key";

            	elseif file == "certificate" then

            		file = sslctx.certificate or "your certificate file";

            	end

	        local reason = err:match("%((.+)%)$") or "some reason";

	        if reason == "Permission denied" then

	        	reason = "Check that the permissions allow Prosody to read this file.";

	        elseif reason == "No such file or directory" then

	        	reason = "Check that the path is correct, and the file exists.";

	        elseif reason == "system lib" then

	        	reason = "Previous error (see logs), or other system error.";

	        else

	        	reason = "Reason: "..tostring(reason or "unknown"):lower();

	        end

	        log("error", "SSL/TLS: Failed to load %s: %s", file, reason);

	    else

                log("error", "SSL/TLS: Error initialising for port %d: %s", serverport, err );

            end

            ssl = false

        end

        sslctx = ctx;

    end

    if not ssl then

      sslctx = false;

      if startssl then

         log("error", "Failed to listen on port %d due to SSL/TLS to SSL/TLS initialisation errors (see logs)", serverport )

         return nil, "Cannot start ssl,  see log for details"

       end

    end

    local accept = socket.accept

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

    local handler = { }

    handler.shutdown = function( ) end

    handler.ssl = function( )

        return ssl

    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, startssl )    -- 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, startssl )    -- 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.status

    local disconnect = listeners.ondisconnect

    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

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