lxmppd-hg-xmllex: comparison net/server.lua

-:9c471840acb9
+:018705d57f09
 		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 )
+			--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 = { }
 			eol = nil
 			writelen = removesocket( writelist, socket, writelen )    -- delete socket from writelist
 			if handler.need_tls then
 				out_put("server.lua: connection is ready for tls handshake");
-				handler.need_tls = not handler.starttls(true);
+				handler.starttls(true);
+				if handler.need_tls then
+					out_put("server.lua: uh-oh... we still want tls, something must be wrong");
+				end
 			end
 			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
 	--// handshake //--
 	local wrote, read
 	handler.starttls = function (now)
-		if not now then handler.need_tls = true; return; end
+		if not now then out_put("server.lua: we need to do tls, but delaying until later"); handler.need_tls = true; return; end
 		out_put( "server.lua: attempting to start tls on "..tostring(socket) )
 		socket, err = ssl_wrap( socket, sslctx )    -- wrap socket
 		out_put("sslwrapped socket is "..tostring(socket));
 		if err then
 			out_put( "server.lua: ssl error: ", err )
 		end
 		socket:settimeout( 1 )
 		send = socket.send
 		receive = socket.receive
 		close = socket.close
-		print(readlen, writelen)
-		for _, s in ipairs(readlist) do print("R:", tostring(s)) end
-		for _, s in ipairs(writelist) do print("W:", tostring(s)) 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.handshake = function (conn)
+			handler.handshake = coroutine_wrap( function( client )
-							local succ, msg
+					local err
-							out_put("ssl handshaking on socket "..tostring(conn))
+					for i = 1, 10 do    -- 10 handshake attemps
-							conn:settimeout()
+						_, err = client:dohandshake( )
-							while not succ do
+						if not err then
-								succ, msg = conn:dohandshake()
+							out_put( "server.lua: ssl handshake done" )
-								out_put("msg: "..tostring(msg))
+							writelen = ( wrote and removesocket( writelist, socket, writelen ) ) or writelen
-								if msg == 'wantread' then
+							handler.receivedata = handler._receivedata    -- when handshake is done, replace the handshake function with regular functions
-									socket_select({conn}, nil)
+							handler.dispatchdata = handler._dispatchdata
-								elseif msg == 'wantwrite' then
+							handler.need_tls = nil
-									socket_select(nil, {conn})
+							socketlist[ client ] = handler
-								elseif not succ then
+							readlen = readlen + 1
-									-- other error
+							readlist[ readlen ] = client
-									_ = err ~= "closed" and close( socket )
+							return true;
-									handler.close( )
+						else
-									disconnect( handler, err )
+							out_put( "server.lua: error during ssl handshake: ", err )
-									writequeue = nil
+							if err == "wantwrite" then
-									handler = nil
+								if wrote == nil then
-									out_error("server.lua: ssl handshake failed");
+									writelen = writelen + 1
-									return false    -- handshake failed
+									writelist[ writelen ] = client
+									wrote = true
 								end
 							end
-							out_put("server.lua: ssl handshake succeeded!");
+							coroutine_yield( handler, nil, err )    -- handshake not finished
-							handler.receivedata = handler._receivedata;
-							handler.dispatchdata = handler._dispatchdata;
-							return true;
 						end
+					end
-		handler.receivedata = handler.handshake
+					_ = err ~= "closed" and close( socket )
-		handler.dispatchdata = handler.handshake
+					handler.close( )
+					disconnect( handler, err )
-		return handler.handshake( socket )    -- do handshake
+					writequeue = nil
-	end
+					handler = nil
+					return false    -- handshake failed
+				end
+			)
+			handler.receivedata = handler.handshake
+			handler.dispatchdata = handler.handshake
+			handler.handshake( socket )    -- do handshake
+		end
 	socketlist[ socket ] = handler
 	readlen = readlen + 1
 	readlist[ readlen ] = socket
 	return handler, socket
 end
 loop = function( )    -- this is the main loop of the program
 	--signal_set( "hub", "run" )
 	repeat
-		out_put("select()")
+		--[[print(readlen, writelen)
+		for _, s in ipairs(readlist) do print("R:", tostring(s)) end
+		for _, s in ipairs(writelist) do print("W:", tostring(s)) end
+		out_put("select()"..os.time())]]
 		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( )

Mercurial > lxmppd-hg-xmllex / file comparison

comparison: net/server.lua

net/server.lua