Convert spaces->tabs

1 files changed, 476 insertions, 476 deletions

diff --git a/net/server.lua b/net/server.lua
index b7f026d3..8849289c 100644
--- a/net/server.lua
+++ b/net/server.lua
@@ -1,11 +1,11 @@
 --[[

 

-        server.lua by blastbeat of the luadch project

-        

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

+		server.lua by blastbeat of the luadch project

+		

+		re-used here under the MIT/X Consortium License

 

-        - this script contains the server loop of the program

-        - other scripts can reg a server here

+		- this script contains the server loop of the program

+		- other scripts can reg a server here

 

 ]]--

 

@@ -93,509 +93,509 @@ socketlist = { }    -- key = socket, value = wrapped socket
 timelistener = { }

 

 stats = function( )

-    return receivestat, sendstat

+	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 dispatch, disconnect = listener.listener, listener.disconnect    -- dangerous

 

-    local wrapclient, err

+	local wrapclient, err

 

-    if sslctx then

-        if not ssl_newcontext then

-            return nil, "luasec not found"

+	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

+		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

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

-        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

-

-    socketlist[ socket ] = handler

-    readlen = readlen + 1

-    readlist[ readlen ] = socket

-

-    return handler, 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 )

+		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

+

+	socketlist[ socket ] = handler

+	readlen = readlen + 1

+	readlist[ readlen ] = socket

+

+	return handler, socket

 end

 

 addtimer = function( listener )

-    timelistener[ #timelistener + 1 ] = listener

+	timelistener[ #timelistener + 1 ] = listener

 end

 

 firetimer = function( listener )

-    for i, listener in ipairs( timelistener ) do

-        listener( )

-    end

+	for i, listener in ipairs( timelistener ) do

+		listener( )

+	end

 end

 

 addserver = function( listeners, port, addr, mode, sslctx )    -- this function provides a way for other scripts to reg a server

-    local err

-    if type( listeners ) ~= "table" then

-        err = "invalid listener table"

-    else

-        for name, func in pairs( listeners ) do

-            if type( func ) ~= "function" then

-                err = "invalid listener function"

-                break

-            end

-        end

-    end

-    if not type( port ) == "number" or not ( port >= 0 and port <= 65535 ) then

-        err = "invalid port"

-    elseif listener[ port ] then

-        err=  "listeners on port '" .. port .. "' already exist"

-    elseif sslctx and not luasec then

-        err = "luasec not found"

-    end

-    if err then

-        out_error( "server.lua: ", err )

-        return nil, err

-    end

-    addr = addr or "*"

-    local server, err = socket_bind( addr, port )

-    if err then

-        out_error( "server.lua: ", err )

-        return nil, err

-    end

-    local handler, err = wrapserver( listeners, server, addr, port, mode, sslctx )    -- wrap new server socket

-    if not handler then

-        server:close( )

-        return nil, err

-    end

-    server:settimeout( 0 )

-    readlen = readlen + 1

-    readlist[ readlen ] = server

-    listener[ port ] = listeners

-    socketlist[ server ] = handler

-    out_put( "server.lua: new server listener on ", addr, ":", port )

-    return true

+	local err

+	if type( listeners ) ~= "table" then

+		err = "invalid listener table"

+	else

+		for name, func in pairs( listeners ) do

+			if type( func ) ~= "function" then

+				err = "invalid listener function"

+				break

+			end

+		end

+	end

+	if not type( port ) == "number" or not ( port >= 0 and port <= 65535 ) then

+		err = "invalid port"

+	elseif listener[ port ] then

+		err=  "listeners on port '" .. port .. "' already exist"

+	elseif sslctx and not luasec then

+		err = "luasec not found"

+	end

+	if err then

+		out_error( "server.lua: ", err )

+		return nil, err

+	end

+	addr = addr or "*"

+	local server, err = socket_bind( addr, port )

+	if err then

+		out_error( "server.lua: ", err )

+		return nil, err

+	end

+	local handler, err = wrapserver( listeners, server, addr, port, mode, sslctx )    -- wrap new server socket

+	if not handler then

+		server:close( )

+		return nil, err

+	end

+	server:settimeout( 0 )

+	readlen = readlen + 1

+	readlist[ readlen ] = server

+	listener[ port ] = listeners

+	socketlist[ server ] = handler

+	out_put( "server.lua: new server listener on ", addr, ":", port )

+	return true

 end

 

 removesocket = function( tbl, socket, len )    -- this function removes sockets from a list

-    for i, target in ipairs( tbl ) do

-        if target == socket then

-            len = len - 1

-            table_remove( tbl, i )

-            return len

-        end

-    end

-    return len

+	for i, target in ipairs( tbl ) do

+		if target == socket then

+			len = len - 1

+			table_remove( tbl, i )

+			return len

+		end

+	end

+	return len

 end

 

 closeall = function( )

-    for sock, handler in pairs( socketlist ) do

-        handler.shutdown( )

-        handler.close( )

-        socketlist[ sock ] = nil

-    end

-    writelist, readlist, socketlist = { }, { }, { }

+	for sock, handler in pairs( socketlist ) do

+		handler.shutdown( )

+		handler.close( )

+		socketlist[ sock ] = nil

+	end

+	writelist, readlist, socketlist = { }, { }, { }

 end

 

 closesocket = function( socket )

-    writelen = removesocket( writelist, socket, writelen )

-    readlen = removesocket( readlist, socket, readlen )

-    socketlist[ socket ] = nil

-    socket:close( )

+	writelen = removesocket( writelist, socket, writelen )

+	readlen = removesocket( readlist, socket, readlen )

+	socketlist[ socket ] = nil

+	socket:close( )

 end

 

 loop = function( )    -- this is the main loop of the program

-    --signal_set( "hub", "run" )

-    repeat

-        local read, write, err = socket_select( readlist, writelist, 1 )    -- 1 sec timeout, nice for timers

-        for i, socket in ipairs( write ) do    -- send data waiting in writequeues

-            local handler = socketlist[ socket ]

-            if handler then

-                handler.dispatchdata( )

-            else

-                closesocket( socket )

-                out_put "server.lua: found no handler and closed socket (writelist)"    -- this should not happen

-            end

-        end

-        for i, socket in ipairs( read ) do    -- receive data

-            local handler = socketlist[ socket ]

-            if handler then

-                handler.receivedata( )

-            else

-                closesocket( socket )

-                out_put "server.lua: found no handler and closed socket (readlist)"    -- this can happen

-            end

-        end

-        firetimer( )

-        --collectgarbage "collect"

-    until false --signal_get "hub" ~= "run"

-    return --signal_get "hub"

+	--signal_set( "hub", "run" )

+	repeat

+		local read, write, err = socket_select( readlist, writelist, 1 )    -- 1 sec timeout, nice for timers

+		for i, socket in ipairs( write ) do    -- send data waiting in writequeues

+			local handler = socketlist[ socket ]

+			if handler then

+				handler.dispatchdata( )

+			else

+				closesocket( socket )

+				out_put "server.lua: found no handler and closed socket (writelist)"    -- this should not happen

+			end

+		end

+		for i, socket in ipairs( read ) do    -- receive data

+			local handler = socketlist[ socket ]

+			if handler then

+				handler.receivedata( )

+			else

+				closesocket( socket )

+				out_put "server.lua: found no handler and closed socket (readlist)"    -- this can happen

+			end

+		end

+		firetimer( )

+		--collectgarbage "collect"

+	until false --signal_get "hub" ~= "run"

+	return --signal_get "hub"

 end

 

 ----------------------------------// BEGIN //--

@@ -604,10 +604,10 @@ end
 

 return {

 

-    add = addserver,

-    loop = loop,

-    stats = stats,

-    closeall = closeall,

-    addtimer = addtimer,

+	add = addserver,

+	loop = loop,

+	stats = stats,

+	closeall = closeall,

+	addtimer = addtimer,

 

 }