_ = 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
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
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.id, 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
+ 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
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.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
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
projects / prosody.git / blobdiff