-- 

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

    maxconnections = maxconnections or _maxclientsperserver

    local connections = 0

    local dispatch, disconnect = 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.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.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.pattern = 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

        return bufferlen, maxreadlen, maxsendlen

    end

    handler.lock_read  = function (self, switch)

        if switch == true then

            local tmp = _readlistlen

            _readlistlen = removesocket( _readlist, socket, _readlistlen )

            _readtimes[ handler ] = nil

            if _readlistlen ~= tmp then

                noread = true

            end

        elseif switch == false then

            if noread then

                noread = false