--[[

        server.lua by blastbeat

        - this script contains the server loop of the program

        - other scripts can reg a server here

]]--

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

--// constants //--

local STAT_UNIT = 1 / ( 1024 * 1024 )    -- mb

--// lua functions //--

local function use( what ) return _G[ what ] end

local type = use "type"

local pairs = use "pairs"

local ipairs = use "ipairs"

local tostring = use "tostring"

local collectgarbage = use "collectgarbage"

--// lua libs //--

local table = use "table"

local coroutine = use "coroutine"

--// lua lib methods //--

local table_concat = table.concat

local table_remove = table.remove

local string_sub = use'string'.sub

local coroutine_wrap = coroutine.wrap

local coroutine_yield = coroutine.yield

local print = print;

local out_put = function () end --print;

local out_error = print;

--// extern libs //--

local luasec = require "ssl"

local luasocket = require "socket"

--// extern lib methods //--

local ssl_wrap = ( luasec and luasec.wrap )

local socket_bind = luasocket.bind

local socket_select = luasocket.select

local ssl_newcontext = ( luasec and luasec.newcontext )

--// functions //--

local loop

local stats

local addtimer

local closeall

local addserver

local firetimer

local closesocket

local removesocket

local wrapserver

local wraptcpclient

local wrapsslclient

--// tables //--

local listener

local readlist

local writelist

local socketlist

local timelistener

--// simple data types //--

local _

local readlen = 0    -- length of readlist

local writelen = 0    -- lenght of writelist

local sendstat= 0

local receivestat = 0

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

listener = { }    -- key = port, value = table

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

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

socketlist = { }    -- key = socket, value = wrapped socket

timelistener = { }

stats = function( )

    return receivestat, sendstat

end

wrapserver = function( listener, socket, ip, serverport, mode, sslctx )    -- this function wraps a server

    local dispatch, disconnect = listener.listener, listener.disconnect    -- dangerous

    local wrapclient, err

    if sslctx then

        if not ssl_newcontext then

            return nil, "luasec not found"

--        elseif not cfg_get "use_ssl" then

--            return nil, "ssl is deactivated"

        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

        wrapclient = wrapsslclient

    else

        wrapclient = wraptcpclient

    end

    local accept = socket.accept

    local close = socket.close

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

    local handler = { }

    handler.shutdown = function( ) end

    --[[handler.listener = function( data, err )

        return ondata( handler, data, err )

    end]]

    handler.ssl = function( )

        return sslctx and true or false

    end

    handler.close = function( closed )

        _ = not closed and close( socket )

        writelen = removesocket( writelist, socket, writelen )

        readlen = removesocket( readlist, socket, readlen )

        socketlist[ socket ] = nil

        handler = nil

    end

    handler.ip = function( )

        return ip

    end

    handler.serverport = function( )

        return serverport

    end

    handler.socket = function( )

        return socket

    end

    handler.receivedata = function( )

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

        if client then

            local ip, clientport = client:getpeername( )

            client:settimeout( 0 )

            local handler, client, err = wrapclient( listener, client, ip, serverport, clientport, mode, sslctx )    -- wrap new client socket

            if err then    -- error while wrapping ssl socket

                return false

            end

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

            return dispatch( handler )

        elseif err then    -- maybe timeout or something else

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

            return false

        end

    end

    return handler

end

wrapsslclient = function( listener, socket, ip, serverport, clientport, mode, sslctx )    -- this function wraps a ssl cleint

    local dispatch, disconnect = listener.listener, listener.disconnect

    --// transform socket to ssl object //--

    local err

    socket, err = ssl_wrap( socket, sslctx )    -- wrap socket

    if err then

        out_put( "server.lua: ssl error: ", err )

        return nil, nil, err    -- fatal error

    end

    socket:settimeout( 0 )

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

    local writequeue = { }    -- buffer for messages to send

    local eol   -- end of buffer

    local sstat, rstat = 0, 0

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

    local send = socket.send

    local receive = socket.receive

    local close = socket.close

    --local shutdown = socket.shutdown

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

    local handler = { }

    handler.getstats = function( )

        return rstat, sstat

    end

    handler.listener = function( data, err )

        return listener( handler, data, err )

    end

    handler.ssl = function( )

        return true

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

        close( socket )

        writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen

        readlen = removesocket( readlist, socket, readlen )

        socketlist[ socket ] = nil

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

    end

    handler.ip = function( )

        return ip

    end

    handler.serverport = function( )

        return serverport

    end

    handler.clientport = function( ) 

        return clientport

    end

    handler.write = function( data )

        if not eol then

            writelen = writelen + 1

            writelist[ writelen ] = socket

            eol = 0

        end

        eol = eol + 1

        writequeue[ eol ] = data

    end

    handler.writequeue = function( )

        return writequeue

    end

    handler.socket = function( )

        return socket

    end

    handler.mode = function( )

        return mode

    end

    handler._receivedata = function( )

        local data, err, part = receive( socket, mode )    -- receive data in "mode"

        if not err or ( err == "timeout" or err == "wantread" ) then    -- received something

            local data = data or part or ""

            local count = #data * STAT_UNIT

            rstat = rstat + count

            receivestat = receivestat + count

            out_put( "server.lua: read data '", data, "', error: ", err )

            return dispatch( handler, data, err )

        else    -- connections was closed or fatal error

            out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )

            handler.close( )

            disconnect( handler, err )

            writequeue = nil

            handler = nil

            return false

        end

    end

    handler._dispatchdata = function( )    -- this function writes data to handlers

        local buffer = table_concat( writequeue, "", 1, eol )

        local succ, err, byte = send( socket, buffer )

        local count = ( succ or 0 ) * STAT_UNIT

        sstat = sstat + count

        sendstat = sendstat + count

        out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )

        if succ then    -- sending succesful

            --writequeue = { }

            eol = nil

            writelen = removesocket( writelist, socket, writelen )    -- delete socket from writelist

            return true

        elseif byte and ( err == "timeout" or err == "wantwrite" ) then    -- want write

            buffer = string_sub( buffer, byte + 1, -1 )    -- new buffer

            writequeue[ 1 ] = buffer    -- insert new buffer in queue

            eol = 1

            return true

        else    -- connection was closed during sending or fatal error

            out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )

            handler.close( )

            disconnect( handler, err )

            writequeue = nil

            handler = nil

            return false

        end

    end

    -- // COMPAT // --

    handler.getIp = handler.ip

    handler.getPort = handler.clientport

    --// handshake //--

    local wrote

    handler.handshake = coroutine_wrap( function( client )

            local err

            for i = 1, 10 do    -- 10 handshake attemps

                _, err = client:dohandshake( )

                if not err then

                    out_put( "server.lua: ssl handshake done" )

                    writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen

                    handler.receivedata = handler._receivedata    -- when handshake is done, replace the handshake function with regular functions

                    handler.dispatchdata = handler._dispatchdata

                    return dispatch( handler )

                else

                    out_put( "server.lua: error during ssl handshake: ", err )

                    if err == "wantwrite" then

                        if wrote == nil then

                            writelen = writelen + 1

                            writelist[ writelen ] = client

                            wrote = true

                        end

                    end

                    coroutine_yield( handler, nil, err )    -- handshake not finished

                end

            end

            _ = err ~= "closed" and close( socket )

            handler.close( )

            disconnect( handler, err )

            writequeue = nil

            handler = nil

            return false    -- handshake failed

        end

    )

    handler.receivedata = handler.handshake

    handler.dispatchdata = handler.handshake

    handler.handshake( socket )    -- do handshake

    socketlist[ socket ] = handler

    readlen = readlen + 1

    readlist[ readlen ] = socket

    return handler, socket

end

wraptcpclient = function( listener, socket, ip, serverport, clientport, mode )    -- this function wraps a socket

    local dispatch, disconnect = listener.listener, listener.disconnect

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

    local writequeue = { }    -- list for messages to send

    local eol

    local rstat, sstat = 0, 0

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

    local send = socket.send

    local receive = socket.receive

    local close = socket.close

    local shutdown = socket.shutdown

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

    local handler = { }

    handler.getstats = function( )

        return rstat, sstat

    end

    handler.listener = function( data, err )

        return listener( handler, data, err )

    end

    handler.ssl = function( )

        return false

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

        _ = not closed and shutdown( socket )

        _ = not closed and close( socket )

        writelen = ( eol and removesocket( writelist, socket, writelen ) ) or writelen

        readlen = removesocket( readlist, socket, readlen )

        socketlist[ socket ] = nil

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

    end

    handler.ip = function( )

        return ip

    end

    handler.serverport = function( )

        return serverport

    end

    handler.clientport = function( ) 

        return clientport

    end

    handler.write = function( data )