open_sessions = open_sessions + 1;
local w, log = conn.write, logger_init("s2sin"..tostring(conn):match("[a-f0-9]+$"));
session.log = log;
- session.sends2s = function (t) log("debug", "sending: %s", (t.top_tag and t:top_tag()) or t:match("^([^>]*>?)")); w(tostring(t)); end
+ session.sends2s = function (t) log("debug", "sending: %s", (t.top_tag and t:top_tag()) or t:match("^([^>]*>?)"); w(conn, tostring(t)); end
incoming_s2s[session] = true;
add_task(connect_timeout, function ()
if session.conn ~= conn or
cl.register_outgoing(conn, host_session);
local w, log = conn.write, host_session.log;
- host_session.sends2s = function (t) log("debug", "sending: %s", (t.top_tag and t:top_tag()) or t:match("^[^>]*>?")); w(tostring(t)); end
+ host_session.sends2s = function (t) log("debug", "sending: %s", (t.top_tag and t:top_tag()) or t:match("^[^>]*>?")); w(conn, tostring(t)); end
- conn.write(format([[<stream:stream xmlns='jabber:server' xmlns:db='jabber:server:dialback' xmlns:stream='http://etherx.jabber.org/streams' from='%s' to='%s' version='1.0' xml:lang='en'>]], from_host, to_host));
+ conn:write(format([[<stream:stream xmlns='jabber:server' xmlns:db='jabber:server:dialback' xmlns:stream='http://etherx.jabber.org/streams' from='%s' to='%s' version='1.0' xml:lang='en'>]], from_host, to_host));
log("debug", "Connection attempt in progress...");
add_task(connect_timeout, function ()
if host_session.conn ~= conn or
if send_buffer and #send_buffer > 0 then
log("debug", "Sending s2s send_buffer now...");
for i, data in ipairs(send_buffer) do
- session.sends2s(data);
+ session.sends2s(tostring(data));
send_buffer[i] = nil;
end
end
open_sessions = open_sessions + 1;
log("debug", "open sessions now: ".. open_sessions);
local w = conn.write;
- session.send = function (t) w(tostring(t)); end
- session.ip = conn.ip();
+ session.send = function (t) w(conn, tostring(t)); end
+ session.ip = conn:ip();
local conn_name = "c2s"..tostring(conn):match("[a-f0-9]+$");
session.log = logger.init(conn_name);
function new_async_socket(sock, resolver)
local newconn, peername = {}, "<unknown>";
local listener = {};
- function listener.incoming(conn, data)
+ function listener.onincoming(conn, data)
dns.feed(sock, data);
end
- function listener.disconnect(conn, err)
+ function listener.ondisconnect(conn, err)
log("warn", "DNS socket for %s disconnected: %s", peername, err);
local servers = resolver.server;
if resolver.socketset[newconn.handler] == resolver.best_server and resolver.best_server == #servers then
newconn.handler.setsockname = function (_, ...) return sock:setsockname(...); end
newconn.handler.setpeername = function (_, ...) peername = (...); local ret = sock:setpeername(...); _.setsend(sock.send); return ret; end
newconn.handler.connect = function (_, ...) return sock:connect(...) end
- newconn.handler.send = function (_, data) _.write(data); return _.sendbuffer(); end
+ newconn.handler.send = function (_, data) _.write(_, data); return _.sendbuffer(); end
return newconn.handler;
end
end
end
- return server.addserver(h,
- (udata and udata.port) or h.default_port or error("Can't start listener "..name.." because no port was specified, and it has no default port", 0),
- (udata and udata.interface) or h.default_interface or "*", (udata and udata.mode) or h.default_mode or 1, (udata and udata.ssl) or nil, 99999999, udata and udata.type == "ssl");
+ local interface = (udata and udata.interface) or h.default_interface or "*";
+ local port = (udata and udata.port) or h.default_port or error("Can't start listener "..name.." because no port was specified, and it has no default port", 0);
+ local mode = (udata and udata.mode) or h.default_mode or 1;
+ local ssl = (udata and udata.ssl) or nil;
+ local maxclients = 99999999;
+ local autossl = udata and udata.type == "ssl";
+
+ return server.addserver(interface, port, h, mode, ssl, autossl);
end
return _M;
end
req.handler, req.conn = server.wrapclient(socket.tcp(), req.host, req.port or 80, listener, "*a");
- req.write = req.handler.write;
+ req.write = function (...) return req.handler:write(...); end
req.conn:settimeout(0);
local ok, err = req.conn:connect(req.host, req.port or 80);
if not ok and err ~= "timeout" then
function destroy_request(request)
if request.conn then
request.handler.close()
- listener.disconnect(request.conn, "closed");
+ listener.ondisconnect(request.conn, "closed");
end
end
local httpclient = { default_port = 80, default_mode = "*a" };
-function httpclient.listener(conn, data)
+function httpclient.onincoming(conn, data)
local request = requests[conn];
if not request then
end
end
-function httpclient.disconnect(conn, err)
+function httpclient.ondisconnect(conn, err)
local request = requests[conn];
if request then
request:reader(nil);
function new_request(handler)
return { handler = handler, conn = handler.socket,
- write = handler.write, state = "request",
+ write = function (...) return handler:write(...); end, state = "request",
server = http_servers[handler.serverport()],
send = send_response,
destroy = destroy_request,
end
request.handler.close()
if request.conn then
- listener.disconnect(request.handler, "closed");
+ listener.ondisconnect(request.handler, "closed");
end
end
end
local httpserver = { default_port = 80, default_mode = "*a" };
-function httpserver.listener(conn, data)
+function httpserver.onincoming(conn, data)
local request = requests[conn];
if not request then
end
end
-function httpserver.disconnect(conn, err)
+function httpserver.ondisconnect(conn, err)
local request = requests[conn];
if request and not request.destroyed then
request.conn = nil;
-- Backwards compatibility for timers, addtimer
-- called a function roughly every second
- local add_task = require "util.timer";
+ local add_task = require "util.timer".add_task;
function server.addtimer(f)
return add_task(1, function (...) f(...); return 1; end);
end
local function debug(...)\r
return log("debug", ("%s "):rep(select('#', ...)), ...)\r
end\r
+local vdebug = debug;\r
\r
local bitor = ( function( ) -- thx Rici Lake\r
local hasbit = function( x, p )\r
self.fatalerror = "connection timeout"\r
self.listener.ontimeout( self ) -- call timeout listener\r
self:_close()\r
- debug( "new connection failed. id:", self, "error:", self.fatalerror )\r
+ debug( "new connection failed. id:", self.id, "error:", self.fatalerror )\r
else\r
if plainssl then -- start ssl session\r
self:_start_ssl( self.listener.onconnect )\r
else -- normal connection\r
self:_start_session( self.listener.onconnect )\r
end\r
- debug( "new connection established. id:", self )\r
+ debug( "new connection established. id:", self.id )\r
end\r
self.eventconnect = nil\r
return -1\r
if self.type == "client" then\r
local callback = function( )\r
self:_lock( false, false, false )\r
- --vdebug( "start listening on client socket with id:", self ) \r
+ --vdebug( "start listening on client socket with id:", self.id ) \r
self.eventread = addevent( base, self.conn, EV_READ, self.readcallback, cfg.READ_TIMEOUT ) -- register callback\r
- onconnect( self )\r
+ self:onconnect()\r
self.eventsession = nil\r
return -1\r
end\r
self.eventsession = addevent( base, nil, EV_TIMEOUT, callback, 0 )\r
else\r
self:_lock( false )\r
- --vdebug( "start listening on server socket with id:", self )\r
+ --vdebug( "start listening on server socket with id:", self.id )\r
self.eventread = addevent( base, self.conn, EV_READ, self.readcallback ) -- register callback\r
end\r
return true\r
end\r
function interface_mt:_start_ssl(arg) -- old socket will be destroyed, therefore we have to close read/write events first\r
- --vdebug( "starting ssl session with client id:", self )\r
+ --vdebug( "starting ssl session with client id:", self.id )\r
local _\r
_ = self.eventread and self.eventread:close( ) -- close events; this must be called outside of the event callbacks!\r
_ = self.eventwrite and self.eventwrite:close( )\r
self.eventread, self.eventwrite = nil, nil\r
local err\r
- self.conn, err = ssl.wrap( self.conn, self.sslctx )\r
+ self.conn, err = ssl.wrap( self.conn, self._sslctx )\r
if err then\r
self.fatalerror = err\r
self.conn = nil -- cannot be used anymore\r
local maxattempt = cfg.MAX_HANDSHAKE_ATTEMPS\r
while attempt < 1000 do -- no endless loop\r
attempt = attempt + 1\r
- debug( "ssl handshake of client with id:", self, "attemp:", attempt )\r
+ debug( "ssl handshake of client with id:"..tostring(self).."attemp:"..attempt )\r
if attempt > maxattempt then\r
self.fatalerror = "max handshake attemps exceeded"\r
elseif EV_TIMEOUT == event then\r
self.receive = self.conn.receive\r
local onsomething\r
if "onconnect" == arg then -- trigger listener\r
- onsomething = self.listener.onconnect\r
+ onsomething = self.onconnect\r
else\r
- onsomething = self.listener.onsslconnection\r
+ onsomething = self.onsslconnection\r
end\r
self:_start_session( onsomething )\r
debug( "ssl handshake done" )\r
self.eventhandshake = nil\r
return -1\r
end\r
- debug( "error during ssl handshake:", err ) \r
+ debug( "error during ssl handshake:", err ) \r
if err == "wantwrite" then\r
event = EV_WRITE\r
elseif err == "wantread" then\r
return true\r
end\r
function interface_mt:_destroy() -- close this interface + events and call last listener\r
- debug( "closing client with id:", self )\r
+ debug( "closing client with id:", self.id )\r
self:_lock( true, true, true ) -- first of all, lock the interface to avoid further actions\r
local _\r
_ = self.eventread and self.eventread:close( ) -- close events; this must be called outside of the event callbacks!\r
interfacelist( "delete", self )\r
return true\r
end\r
+ \r
function interface_mt:_lock(nointerface, noreading, nowriting) -- lock or unlock this interface or events\r
self.nointerface, self.noreading, self.nowriting = nointerface, noreading, nowriting\r
return nointerface, noreading, nowriting\r
\r
-- Public methods\r
function interface_mt:write(data)\r
- --vdebug( "try to send data to client, id/data:", self, data )\r
+ if self.nowriting then return nil, "locked" end\r
+ --vdebug( "try to send data to client, id/data:", self.id, data )\r
data = tostring( data )\r
local len = string_len( data )\r
local total = len + self.writebufferlen\r
return true\r
end\r
function interface_mt:close(now)\r
- debug( "try to close client connection with id:", self )\r
+ if self.nointerface then return nil, "locked"; end\r
+ debug( "try to close client connection with id:", self.id )\r
if self.type == "client" then\r
self.fatalerror = "client to close"\r
if ( not self.eventwrite ) or now then -- try to close immediately\r
return nil, "writebuffer not empty, waiting"\r
end\r
else\r
- debug( "try to close server with id:", self, "args:", now )\r
+ debug( "try to close server with id:", self.id, "args:", now )\r
self.fatalerror = "server to close"\r
self:_lock( true )\r
local count = 0\r
end\r
\r
function interface_mt:ssl()\r
- return self.usingssl\r
+ return self._usingssl\r
end\r
\r
function interface_mt:type()\r
return self.addr\r
end\r
\r
- \r
+ function interface_mt:set_sslctx(sslctx)\r
+ self._sslctx = sslctx;\r
+ end\r
\r
function interface_mt:starttls()\r
- debug( "try to start ssl at client id:", self )\r
+ debug( "try to start ssl at client id:", self.id )\r
local err\r
- if not self.sslctx then -- no ssl available\r
+ if not self._sslctx then -- no ssl available\r
err = "no ssl context available"\r
- elseif self.usingssl then -- startssl was already called\r
+ elseif self._usingssl then -- startssl was already called\r
err = "ssl already active"\r
end\r
if err then\r
debug( "error:", err )\r
return nil, err \r
end\r
- self.usingssl = true\r
+ self._usingssl = true\r
self.startsslcallback = function( ) -- we have to start the handshake outside of a read/write event\r
+ self.startsslcallback = nil\r
self:_start_ssl();\r
self.eventstarthandshake = nil\r
return -1\r
_sslctx = sslctx; -- parameters\r
_usingssl = false; -- client is using ssl;\r
}\r
+ interface.id = tostring(interface):match("%x+$");\r
interface.writecallback = function( event ) -- called on write events\r
--vdebug( "new client write event, id/ip/port:", interface, ip, port )\r
if interface.nowriting or ( interface.fatalerror and ( "client to close" ~= interface.fatalerror ) ) then -- leave this event\r
interface.eventwrite = false\r
return -1\r
else -- can write :)\r
- if interface.usingssl then -- handle luasec\r
+ if interface._usingssl then -- handle luasec\r
if interface.eventreadtimeout then -- we have to read first\r
local ret = interface.readcallback( ) -- call readcallback\r
--vdebug( "tried to read in writecallback, result:", ret )\r
interface.eventwritetimeout = false\r
end\r
end\r
- local succ, err, byte = interface.send( interface.conn, interface.writebuffer, 1, interface.writebufferlen )\r
+ local succ, err, byte = interface.conn:send( interface.writebuffer, 1, interface.writebufferlen )\r
--vdebug( "write data:", interface.writebuffer, "error:", err, "part:", byte )\r
if succ then -- writing succesful\r
interface.writebuffer = ""\r
end\r
end\r
end\r
- local usingssl, receive = interface._usingssl, interface.receive;\r
+ \r
interface.readcallback = function( event ) -- called on read events\r
--vdebug( "new client read event, id/ip/port:", interface, ip, port )\r
if interface.noreading or interface.fatalerror then -- leave this event\r
interface.eventread = nil\r
return -1\r
else -- can read\r
- if usingssl then -- handle luasec\r
+ if interface._usingssl then -- handle luasec\r
if interface.eventwritetimeout then -- ok, in the past writecallback was regged\r
local ret = interface.writecallback( ) -- call it\r
--vdebug( "tried to write in readcallback, result:", ret )\r
interface.eventreadtimeout = nil\r
end\r
end\r
- local buffer, err, part = receive( client, pattern ) -- receive buffer with "pattern"\r
- --vdebug( "read data:", buffer, "error:", err, "part:", part ) \r
+ local buffer, err, part = interface.conn:receive( pattern ) -- receive buffer with "pattern"\r
+ --vdebug( "read data:", tostring(buffer), "error:", tostring(err), "part:", tostring(part) ) \r
buffer = buffer or part or ""\r
local len = string_len( buffer )\r
if len > cfg.MAX_READ_LENGTH then -- check buffer length\r
interface.eventread = nil\r
return -1\r
end\r
- if err and ( "timeout" ~= err ) then\r
+ if err and ( err ~= "timeout" and err ~= "wantread" ) then\r
if "wantwrite" == err then -- need to read on write event\r
if not interface.eventwrite then -- register new write event if needed\r
interface.eventwrite = addevent( base, interface.conn, EV_WRITE, interface.writecallback, cfg.WRITE_TIMEOUT )\r
fatalerror = false; -- error message\r
nointerface = true; -- lock/unlock parameter\r
}\r
+ interface.id = tostring(interface):match("%x+$");\r
interface.readcallback = function( event ) -- server handler, called on incoming connections\r
--vdebug( "server can accept, id/addr/port:", interface, addr, port )\r
if interface.fatalerror then\r
end\r
\r
local addserver = ( function( )\r
- return function( addr, port, listener, pattern, backlog, sslcfg, startssl ) -- TODO: check arguments\r
+ return function( addr, port, listener, pattern, sslcfg, startssl ) -- TODO: check arguments\r
--vdebug( "creating new tcp server with following parameters:", addr or "nil", port or "nil", sslcfg or "nil", startssl or "nil")\r
- local server, err = socket.bind( addr, port, backlog ) -- create server socket\r
+ local server, err = socket.bind( addr, port, cfg.ACCEPT_QUEUE ) -- create server socket\r
if not server then\r
debug( "creating server socket failed because:", err )\r
return nil, err\r
\r
local connections = 0\r
\r
- local dispatch, disconnect = listeners.incoming or listeners.listener, listeners.disconnect\r
+ local dispatch, disconnect = listeners.onincoming, listeners.ondisconnect\r
\r
local err\r
\r
for _, handler in pairs( _socketlist ) do\r
if handler.serverport == serverport then\r
handler.disconnect( handler, "server closed" )\r
- handler.close( true )\r
+ handler:close( true )\r
end\r
end\r
socket:close( )\r
\r
local ssl\r
\r
- local dispatch = listeners.incoming or listeners.listener\r
+ local dispatch = listeners.onincoming\r
local status = listeners.status\r
- local disconnect = listeners.disconnect\r
+ local disconnect = listeners.ondisconnect\r
\r
local bufferqueue = { } -- buffer array\r
local bufferqueuelen = 0 -- end of buffer array\r
handler.disconnect = function( )\r
return disconnect\r
end\r
- handler.setlistener = function( listeners )\r
- dispatch = listeners.incoming\r
- disconnect = listeners.disconnect\r
+ handler.setlistener = function( self, listeners )\r
+ dispatch = listeners.onincoming\r
+ disconnect = listeners.ondisconnect\r
end\r
handler.getstats = function( )\r
return readtraffic, sendtraffic\r
handler.clientport = function( )\r
return clientport\r
end\r
- local write = function( data )\r
+ local write = function( self, data )\r
bufferlen = bufferlen + string_len( data )\r
if bufferlen > maxsendlen then\r
_closelist[ handler ] = "send buffer exceeded" -- cannot close the client at the moment, have to wait to the end of the cycle\r
return true\r
end\r
handler.write = write\r
- handler.bufferqueue = function( )\r
+ handler.bufferqueue = function( self )\r
return bufferqueue\r
end\r
- handler.socket = function( )\r
+ handler.socket = function( self )\r
return socket\r
end\r
- handler.pattern = function( new )\r
+ handler.pattern = function( self, new )\r
pattern = new or pattern\r
return pattern\r
end\r
- handler.setsend = function ( newsend )\r
+ handler.setsend = function ( self, newsend )\r
send = newsend or send\r
return send\r
end\r
- handler.bufferlen = function( readlen, sendlen )\r
+ handler.bufferlen = function( self, readlen, sendlen )\r
maxsendlen = sendlen or maxsendlen\r
maxreadlen = readlen or maxreadlen\r
return maxreadlen, maxsendlen\r
end\r
- handler.lock = function( switch )\r
+ handler.lock = function( self, switch )\r
if switch == true then\r
handler.write = idfalse\r
local tmp = _sendlistlen\r
bufferqueuelen = 0\r
bufferlen = 0\r
_sendlistlen = removesocket( _sendlist, socket, _sendlistlen ) -- delete socket from writelist\r
- _ = needtls and handler.starttls(true)\r
+ _ = needtls and handler:starttls(true)\r
_writetimes[ handler ] = nil\r
_ = toclose and handler.close( )\r
return true\r
\r
-- Set the sslctx\r
local handshake;\r
- function handler.set_sslctx(new_sslctx)\r
+ function handler.set_sslctx(self, new_sslctx)\r
ssl = true\r
sslctx = new_sslctx;\r
local wrote\r
end\r
end\r
disconnect( handler, "ssl handshake failed" )\r
- _ = handler and handler.close( true ) -- forced disconnect\r
+ _ = handler and handler:close( true ) -- forced disconnect\r
return false -- handshake failed\r
end\r
)\r
end\r
if sslctx then -- ssl?\r
- handler.set_sslctx(sslctx);\r
+ handler:set_sslctx(sslctx);\r
if startssl then -- ssl now?\r
--out_put("server.lua: ", "starting ssl handshake")\r
local err\r
else\r
-- We're not automatically doing SSL, so we're not secure (yet)\r
ssl = false\r
- handler.starttls = function( now )\r
+ handler.starttls = function( self, now )\r
if not now then\r
--out_put "server.lua: we need to do tls, but delaying until later"\r
needtls = true\r
\r
----------------------------------// PUBLIC //--\r
\r
-addserver = function( listeners, port, addr, pattern, sslctx, maxconnections, startssl ) -- this function provides a way for other scripts to reg a server\r
+addserver = function( addr, port, listeners, pattern, sslctx, 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
if type( listeners ) ~= "table" then\r
out_error( "server.lua, port ", port, ": ", err )\r
return nil, err\r
end\r
- local handler, err = wrapserver( listeners, server, addr, port, pattern, sslctx, maxconnections, startssl ) -- wrap new server socket\r
+ local handler, err = wrapserver( listeners, server, addr, port, pattern, sslctx, _maxclientsperserver, startssl ) -- wrap new server socket\r
if not handler then\r
server:close( )\r
return nil, err\r
if not handler then\r
return nil, "no server found on port '" .. tostring( port ) .. "'"\r
end\r
- handler.close( )\r
+ handler:close( )\r
_server[ port ] = nil\r
return true\r
end\r
\r
closeall = function( )\r
for _, handler in pairs( _socketlist ) do\r
- handler.close( )\r
+ handler:close( )\r
_socketlist[ _ ] = nil\r
end\r
_readlistlen = 0\r
end\r
for handler, err in pairs( _closelist ) do\r
handler.disconnect( )( handler, err )\r
- handler.close( true ) -- forced disconnect\r
+ handler:close( true ) -- forced disconnect\r
end\r
clean( _closelist )\r
_currenttime = os_time( )\r
if os_difftime( _currenttime - timestamp ) > _sendtimeout then\r
--_writetimes[ handler ] = nil\r
handler.disconnect( )( handler, "send timeout" )\r
- handler.close( true ) -- forced disconnect\r
+ handler:close( true ) -- forced disconnect\r
end\r
end\r
for handler, timestamp in pairs( _readtimes ) do\r
if os_difftime( _currenttime - timestamp ) > _readtimeout then\r
--_readtimes[ handler ] = nil\r
handler.disconnect( )( handler, "read timeout" )\r
- handler.close( ) -- forced disconnect?\r
+ handler:close( ) -- forced disconnect?\r
end\r
end\r
end\r
end
end
session.send("</stream:stream>");
- session.conn.close();
- xmppclient.disconnect(session.conn, (reason and (reason.text or reason.condition)) or reason or "session closed");
+ session.conn:close();
+ xmppclient.ondisconnect(session.conn, (reason and (reason.text or reason.condition)) or reason or "session closed");
end
end
-- End of session methods --
-function xmppclient.listener(conn, data)
+function xmppclient.onincoming(conn, data)
local session = sessions[conn];
if not session then
session = sm_new_session(conn);
session.log("info", "Client connected");
-- Client is using legacy SSL (otherwise mod_tls sets this flag)
- if conn.ssl() then
+ if conn:ssl() then
session.secure = true;
end
end
end
-function xmppclient.disconnect(conn, err)
+function xmppclient.ondisconnect(conn, err)
local session = sessions[conn];
if session then
(session.log or log)("info", "Client disconnected: %s", err);
end
session.send("</stream:stream>");
session.conn.close();
- component_listener.disconnect(session.conn, "stream error");
+ component_listener.ondisconnect(session.conn, "stream error");
end
end
--- Component connlistener
-function component_listener.listener(conn, data)
+function component_listener.onincoming(conn, data)
local session = sessions[conn];
if not session then
local _send = conn.write;
end
end
-function component_listener.disconnect(conn, err)
+function component_listener.ondisconnect(conn, err)
local session = sessions[conn];
if session then
(session.log or log)("info", "component disconnected: %s (%s)", tostring(session.host), tostring(err));
session.conn.close(true); -- Force FIXME: timer?
end
session.conn.close();
- xmppserver.disconnect(session.conn, "stream error");
+ xmppserver.ondisconnect(session.conn, "stream error");
end
end
-- End of session methods --
-function xmppserver.listener(conn, data)
+function xmppserver.onincoming(conn, data)
local session = sessions[conn];
if not session then
session = s2s_new_incoming(conn);
end
end
-function xmppserver.disconnect(conn, err)
+function xmppserver.ondisconnect(conn, err)
local session = sessions[conn];
if session then
if err and err ~= "closed" and session.srv_hosts then
session.send(st.stanza("proceed", { xmlns = xmlns_starttls }));
session:reset_stream();
if session.host and hosts[session.host].ssl_ctx_in then
- session.conn.set_sslctx(hosts[session.host].ssl_ctx_in);
+ session.conn:set_sslctx(hosts[session.host].ssl_ctx_in);
end
- session.conn.starttls();
+ session.conn:starttls();
session.log("info", "TLS negotiation started...");
session.secure = false;
else
session.sends2s(st.stanza("proceed", { xmlns = xmlns_starttls }));
session:reset_stream();
if session.to_host and hosts[session.to_host].ssl_ctx_in then
- session.conn.set_sslctx(hosts[session.to_host].ssl_ctx_in);
+ session.conn:set_sslctx(hosts[session.to_host].ssl_ctx_in);
end
- session.conn.starttls();
+ session.conn:starttls();
session.log("info", "TLS negotiation started for incoming s2s...");
session.secure = false;
else
module:log("debug", "Proceeding with TLS on s2sout...");
local format, to_host, from_host = string.format, session.to_host, session.from_host;
session:reset_stream();
- session.conn.starttls(true);
+ session.conn:starttls(true);
session.secure = false;
return true;
end);
projects / prosody.git / commitdiff