-- Prosody IM

-- Copyright (C) 2008-2009 Matthew Wild

-- Copyright (C) 2008-2009 Waqas Hussain

-- 

-- This project is MIT/X11 licensed. Please see the

-- COPYING file in the source package for more information.

--

--[[

        server.lua by blastbeat

        - this script contains the server loop of the program

        - other scripts can reg a server here

]]--

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

----------------------------------// 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.incoming or listeners.listener, listeners.disconnect

    local err

    local ssl = false

    if sslctx then

        if not ssl_newcontext then

            return nil, "luasec not found"

        end

        if type( sslctx ) ~= "table" then

            out_error "server.lua: wrong server sslctx"

            return nil, "wrong server sslctx"

        end

        sslctx, err = ssl_newcontext( sslctx )

        if not sslctx then

            err = err or "wrong sslctx parameters"

            out_error( "server.lua: ", err )

            return nil, err

        end

        ssl = true

    else

	out_put("server.lua: ", "ssl not enabled on ", serverport);

    end

    local accept = socket.accept

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

    local handler = { }

    handler.shutdown = function( ) end

    handler.ssl = function( )

        return ssl

    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.incoming or listeners.listener

    local disconnect = listeners.disconnect

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

        dispatch = listeners.incoming

        disconnect = listeners.disconnect

    end

    handler.getstats = function( )

        return readtraffic, sendtraffic

    end

    handler.ssl = function( )

        return ssl

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

        _ = shutdown and shutdown( socket )

        socket:close( )

        _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )

        _socketlist[ socket ] = nil

        if handler then

            _writetimes[ handler ] = nil

            _closelist[ handler ] = nil

            handler = nil

        end

        socket = nil

        mem_free( )

	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( 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 = _sendlistlen + 1

            _sendlist[ _sendlistlen ] = socket

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

        return bufferqueue

    end

    handler.socket = function( )

        return socket

    end

    handler.pattern = function( new )

        pattern = new or pattern

        return pattern

    end

    handler.setsend = function ( newsend )

        send = newsend or send

        return send

    end

    handler.bufferlen = function( readlen, sendlen )