tbl[ i ] = nil\r
end\r
end\r
-local out_put = print\r
-local out_error = print\r
+\r
+local log, table_concat = require ("util.logger").init("socket"), table.concat;\r
+local out_put = function (...) return log("debug", table_concat{...}); end\r
+local out_error = function (...) return log("warn", table_concat{...}); end\r
local mem_free = collectgarbage\r
\r
----------------------------------// DECLARATION //--\r
local addtimer\r
local closeall\r
local addserver\r
+local getserver\r
local wrapserver\r
local getsettings\r
local closesocket\r
return false\r
end\r
connections = connections + 1\r
- out_put( "server.lua: accepted new client connection from ", ip, ":", clientport, " to ", serverport)\r
+ out_put( "server.lua: accepted new client connection from ", tostring(ip), ":", tostring(clientport), " to ", tostring(serverport))\r
return dispatch( handler )\r
elseif err then -- maybe timeout or something else\r
- out_put( "server.lua: error with new client connection: ", err )\r
+ out_put( "server.lua: error with new client connection: ", tostring(err) )\r
return false\r
end\r
end\r
return shutdown( socket, pattern )\r
end\r
handler.close = function( forced )\r
+ if not handler then return true; end\r
_readlistlen = removesocket( _readlist, socket, _readlistlen )\r
_readtimes[ handler ] = nil\r
if bufferqueuelen ~= 0 then\r
if not ( forced or fatalerror ) then\r
handler.sendbuffer( )\r
if bufferqueuelen ~= 0 then -- try again...\r
- handler.write = nil -- ... but no further writing allowed\r
+ if handler then\r
+ handler.write = nil -- ... but no further writing allowed\r
+ end\r
toclose = true\r
return false\r
end\r
send( socket, table_concat( bufferqueue, "", 1, bufferqueuelen ), 1, bufferlen ) -- forced send\r
end\r
end\r
- shutdown( socket )\r
+ _ = shutdown and shutdown( socket )\r
socket:close( )\r
_sendlistlen = removesocket( _sendlist, socket, _sendlistlen )\r
_socketlist[ socket ] = nil\r
- _writetimes[ handler ] = nil\r
- _closelist[ handler ] = nil\r
- handler = nil\r
+ if handler then\r
+ _writetimes[ handler ] = nil\r
+ _closelist[ handler ] = nil\r
+ handler = nil\r
+ end\r
socket = nil\r
mem_free( )\r
if server then\r
_closelist[ handler ] = "send buffer exceeded" -- cannot close the client at the moment, have to wait to the end of the cycle\r
handler.write = idfalse -- dont write anymore\r
return false\r
- elseif not _sendlist[ socket ] then\r
+ elseif socket and not _sendlist[ socket ] then\r
_sendlistlen = _sendlistlen + 1\r
_sendlist[ _sendlistlen ] = socket\r
_sendlist[ socket ] = _sendlistlen\r
end\r
bufferqueuelen = bufferqueuelen + 1\r
bufferqueue[ bufferqueuelen ] = data\r
- _writetimes[ handler ] = _writetimes[ handler ] or _currenttime\r
+ if handler then\r
+ _writetimes[ handler ] = _writetimes[ handler ] or _currenttime\r
+ end\r
return true\r
end\r
handler.write = write\r
pattern = new or pattern\r
return pattern\r
end\r
+ handler.setsend = function ( newsend )\r
+ send = newsend or send\r
+ return send\r
+ end\r
handler.bufferlen = function( readlen, sendlen )\r
maxsendlen = sendlen or maxsendlen\r
maxreadlen = readlen or maxreadlen\r
readtraffic = readtraffic + count\r
_readtraffic = _readtraffic + count\r
_readtimes[ handler ] = _currenttime\r
- out_put( "server.lua: read data '", buffer, "', error: ", err )\r
+ --out_put( "server.lua: read data '", buffer, "', error: ", err )\r
return dispatch( handler, buffer, err )\r
else -- connections was closed or fatal error\r
- out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )\r
+ out_put( "server.lua: client ", tostring(ip), ":", tostring(clientport), " error: ", tostring(err) )\r
fatalerror = true\r
disconnect( handler, err )\r
- handler.close( )\r
+ _ = handler and handler.close( )\r
return false\r
end\r
end\r
sendtraffic = sendtraffic + count\r
_sendtraffic = _sendtraffic + count\r
_ = _cleanqueue and clean( bufferqueue )\r
- out_put( "server.lua: sended '", buffer, "', bytes: ", succ, ", error: ", err, ", part: ", byte, ", to: ", ip, ":", clientport )\r
+ --out_put( "server.lua: sended '", buffer, "', bytes: ", tostring(succ), ", error: ", tostring(err), ", part: ", tostring(byte), ", to: ", tostring(ip), ":", tostring(clientport) )\r
if succ then -- sending succesful\r
bufferqueuelen = 0\r
bufferlen = 0\r
_sendlistlen = removesocket( _sendlist, socket, _sendlistlen ) -- delete socket from writelist\r
_ = needtls and handler.starttls(true)\r
- _ = toclose and handler.close( )\r
_writetimes[ handler ] = nil\r
+ _ = toclose and handler.close( )\r
return true\r
elseif byte and ( err == "timeout" or err == "wantwrite" ) then -- want write\r
buffer = string_sub( buffer, byte + 1, bufferlen ) -- new buffer\r
_writetimes[ handler ] = _currenttime\r
return true\r
else -- connection was closed during sending or fatal error\r
- out_put( "server.lua: client ", ip, ":", clientport, " error: ", err )\r
+ out_put( "server.lua: client ", tostring(ip), ":", tostring(clientport), " error: ", tostring(err) )\r
fatalerror = true\r
disconnect( handler, err )\r
- handler.close( )\r
+ _ = handler and handler.close( )\r
return false\r
end\r
end\r
if sslctx then -- ssl?\r
ssl = true\r
local wrote\r
+ local read\r
local handshake = coroutine_wrap( function( client ) -- create handshake coroutine\r
local err\r
for i = 1, 10 do -- 10 handshake attemps\r
+ _sendlistlen = ( wrote and removesocket( _sendlist, socket, _sendlistlen ) ) or _sendlistlen\r
+ _readlistlen = ( read and removesocket( _readlist, socket, _readlistlen ) ) or _readlistlen\r
+ read, wrote = nil, nil\r
_, err = client:dohandshake( )\r
if not err then\r
out_put( "server.lua: ssl handshake done" )\r
- _sendlistlen = ( wrote and removesocket( _sendlist, socket, _sendlistlen ) ) or _sendlistlen\r
handler.readbuffer = _readbuffer -- when handshake is done, replace the handshake function with regular functions\r
handler.sendbuffer = _sendbuffer\r
- --return dispatch( handler )\r
+ -- return dispatch( handler )\r
return true\r
else\r
- out_put( "server.lua: error during ssl handshake: ", err )\r
+ out_put( "server.lua: error during ssl handshake: ", tostring(err) )\r
if err == "wantwrite" and not wrote then\r
_sendlistlen = _sendlistlen + 1\r
_sendlist[ _sendlistlen ] = client\r
wrote = true\r
+ elseif err == "wantread" and not read then\r
+ _readlistlen = _readlistlen + 1\r
+ _readlist [ _readlistlen ] = client\r
+ read = true\r
+ else\r
+ break;\r
end\r
--coroutine_yield( handler, nil, err ) -- handshake not finished\r
coroutine_yield( )\r
end\r
end\r
- disconnect( handler, "max handshake attemps exceeded" )\r
+ disconnect( handler, "ssl handshake failed" )\r
handler.close( true ) -- forced disconnect\r
return false -- handshake failed\r
end\r
)\r
if startssl then -- ssl now?\r
- out_put("server.lua: ", "starting ssl handshake")\r
+ --out_put("server.lua: ", "starting ssl handshake")\r
local err\r
socket, err = ssl_wrap( socket, sslctx ) -- wrap socket\r
if err then\r
- out_put( "server.lua: ssl error: ", err )\r
+ out_put( "server.lua: ssl error: ", tostring(err) )\r
mem_free( )\r
return nil, nil, err -- fatal error\r
end\r
else\r
handler.starttls = function( now )\r
if not now then\r
- out_put "server.lua: we need to do tls, but delaying until later"\r
+ --out_put "server.lua: we need to do tls, but delaying until later"\r
needtls = true\r
return\r
end\r
- out_put( "server.lua: attempting to start tls on " .. tostring( socket ) )\r
+ --out_put( "server.lua: attempting to start tls on " .. tostring( socket ) )\r
local oldsocket, err = socket\r
socket, err = ssl_wrap( socket, sslctx ) -- wrap socket\r
- out_put( "server.lua: sslwrapped socket is " .. tostring( socket ) )\r
+ --out_put( "server.lua: sslwrapped socket is " .. tostring( socket ) )\r
if err then\r
- out_put( "server.lua: error while starting tls on client: ", err )\r
+ out_put( "server.lua: error while starting tls on client: ", tostring(err) )\r
return nil, err -- fatal error\r
end\r
\r
handler.starttls = nil\r
needtls = nil\r
\r
- handler.receivedata = handler.handshake\r
- handler.dispatchdata = handler.handshake\r
+ handler.readbuffer = handshake\r
+ handler.sendbuffer = handshake\r
handshake( socket ) -- do handshake\r
end\r
handler.readbuffer = _readbuffer\r
\r
addserver = function( listeners, port, addr, pattern, sslctx, maxconnections, startssl ) -- this function provides a way for other scripts to reg a server\r
local err\r
- out_put("server.lua: autossl on ", port, " is ", startssl)\r
+ --out_put("server.lua: autossl on ", port, " is ", startssl)\r
if type( listeners ) ~= "table" then\r
err = "invalid listener table"\r
end\r
return handler\r
end\r
\r
+getserver = function ( port )\r
+ return _server[ port ];\r
+end\r
+\r
removeserver = function( port )\r
local handler = _server[ port ]\r
if not handler then\r
return _readtraffic, _sendtraffic, _readlistlen, _sendlistlen, _timerlistlen\r
end\r
\r
+local dontstop = true; -- thinking about tomorrow, ...\r
+\r
+setquitting = function (quit)\r
+ dontstop = not quit;\r
+ return;\r
+end\r
+\r
loop = function( ) -- this is the main loop of the program\r
- while true do\r
+ while dontstop do\r
local read, write, err = socket_select( _readlist, _sendlist, _selecttimeout )\r
for i, socket in ipairs( write ) do -- send data waiting in writequeues\r
local handler = _socketlist[ socket ]\r
socket_sleep( _sleeptime ) -- wait some time\r
--collectgarbage( )\r
end\r
+ return "quitting"\r
end\r
\r
--// EXPERIMENTAL //--\r
end\r
\r
local addclient = function( address, port, listeners, pattern, sslctx, startssl )\r
- local client, err = socket.tcp( )\r
+ local client, err = luasocket.tcp( )\r
if err then\r
return nil, err\r
end\r
if err then -- try again\r
local handler = wrapclient( client, address, port, listeners )\r
else\r
- wrapconnection( server, listeners, socket, address, port, "clientport", pattern, sslctx, startssl )\r
+ wrapconnection( nil, listeners, client, address, port, "clientport", pattern, sslctx, startssl )\r
end\r
end\r
\r
closeall = closeall,\r
addtimer = addtimer,\r
addserver = addserver,\r
+ getserver = getserver,\r
getsettings = getsettings,\r
+ setquitting = setquitting,\r
removeserver = removeserver,\r
changesettings = changesettings,\r
-\r
}\r
projects / prosody.git / blobdiff