prosody: comparison net/server

equal deleted inserted replaced

-:7674cb520557
+:cccea9136b2d
 	handshake_timeout = 60;
 	max_wait = 86400;
 };
 local fds = createtable(10, 0); -- FD -> conn
+-- Timer and scheduling --
 local timers = {};
 local function noop() end
 local function closetimer(t)
 	t[1] = 0;
 			end
 			break;
 		end
 		local new_timeout = f(now);
 		if new_timeout then
-			-- Schedlue for 'delay' from the time actually sheduled,
+			-- Schedule for 'delay' from the time actually scheduled,
 			-- not from now, in order to prevent timer drift.
 			timer[1] = t + new_timeout;
 			resort_timers = true;
 		else
 			t_remove(timers, i);
 		next_delay = 1e-6;
 	end
 	return next_delay;
 end
+-- Socket handler interface
 local interface = {};
 local interface_mt = { __index = interface };
 function interface_mt:__tostring()
 	if self.sockname and self.peername then
 		return ("FD %d (%s, %d)"):format(self:getfd(), self.sockname or self.peername, self.sockport or self.peerport);
 	end
 	return ("%s FD %d"):format(tostring(self.conn), self:getfd());
 end
+-- Replace the listener and tell the old one
 function interface:setlistener(listeners)
 	self:on("detach");
 	self.listeners = listeners;
 end
--- Call callback
+-- Call a listener callback
 function interface:on(what, ...)
 	local listener = self.listeners["on"..what];
 	if not listener then
 		-- log("debug", "Missing listener 'on%s'", what); -- uncomment for development and debugging
 		return;
 		log("error", "Error calling on%s: %s", what, err);
 	end
 	return err;
 end
+-- Return the file descriptor number
 function interface:getfd()
 	if self.conn then
 		return self.conn:getfd();
 	end
 	return -1;
 end
+-- Get IP address
 function interface:ip()
 	return self.peername or self.sockname;
 end
+-- Get a port number, doesn't matter which
 function interface:port()
 	return self.sockport or self.peerport;
 end
+-- Get local port number
 function interface:clientport()
 	return self.sockport;
 end
+-- Get remote port
 function interface:serverport()
 	if self.sockport then
 		return self.sockport;
 	elseif self.server then
 		self.server:port();
 	end
 end
+-- Return underlying socket
 function interface:socket()
 	return self.conn;
 end
 function interface:setoption(k, v)
 	if self.conn.setoption then
 		self.conn:setoption(k, v);
 	end
 end
+-- Timeout for detecting dead or idle sockets
 function interface:setreadtimeout(t)
 	if t == false then
 		if self._readtimeout then
 			self._readtimeout:close();
 			self._readtimeout = nil;
 			end
 		end);
 	end
 end
+-- Timeout for detecting dead sockets
 function interface:setwritetimeout(t)
 	if t == false then
 		if self._writetimeout then
 			self._writetimeout:close();
 			self._writetimeout = nil;
 			self:destroy();
 		end);
 	end
 end
+-- lua-epoll flag for currently requested poll state
 function interface:flags()
 	if self._wantread then
 		if self._wantwrite then
 			return "rw";
 		end
 	elseif self._wantwrite then
 		return "w";
 	end
 end
+-- Add or remove sockets or modify epoll flags
 function interface:setflags(r, w)
 	if r ~= nil then self._wantread = r; end
 	if w ~= nil then self._wantwrite = w; end
 	local flags = self:flags();
 	local currentflags = self._flags;
 		self:on("disconnect", err);
 		self:destroy();
 	end
 end
+-- The write buffer has been successfully emptied
 function interface:ondrain()
 	if self._toclose then
 		return self:close();
 	elseif self._starttls then
 		return self:starttls();
 	else
 		return self:on("drain");
 	end
 end
+-- Add data to write buffer and set flag for wanting to write
 function interface:write(data)
 	local buffer = self.writebuffer;
 	if buffer then
 		t_insert(buffer, data);
 	else
 	self:setflags(nil, true);
 	return #data;
 end
 interface.send = interface.write;
+-- Close, possibly after writing is done
 function interface:close()
 	if self._wantwrite then
 		self:setflags(false, true); -- Flush final buffer contents
 		self.write, self.send = noop, noop; -- No more writing
 		log("debug", "Close %s after writing", tostring(self));
 		conn.sockname, conn.sockport = client:getsockname();
 	end
 	return conn;
 end
+-- A server interface has new incoming connections waiting
+-- This replaces the onreadable callback
 function interface:onacceptable()
 	local conn, err = self.conn:accept();
 	if not conn then
 		log("debug", "Error accepting new client: %s, server will be paused for %ds", err, cfg.accept_retry_interval);
 		self:pausefor(cfg.accept_retry_interval);
 	local client = wrapsocket(conn, self, nil, self.listeners, self.tls);
 	log("debug", "New connection %s", tostring(client));
 	client:init();
 end
+-- Initialization
 function interface:init()
 	if self.tls and not self._tls then
 		self._tls = false; -- This means we should call onconnect when TLS is up
 		return self:starttls();
 	else
 		end
 		self:setflags(true);
 	end);
 end
+-- Connected!
 function interface:onconnect()
 	self.onwriteable = nil;
 	self:on("connect");
 	self:setflags(true);
 	return self:onwriteable();
 	self.send = new_send;
 end
 local quitting = nil;
+-- Signal main loop about shutdown via above upvalue
 local function setquitting()
 	quitting = "quitting";
 end
+-- Main loop
 local function loop()
 	repeat
 		local t = runtimers(cfg.max_wait);
 		local fd, r, w = epoll.wait(t);
 		if fd then

changeset 7640	cccea9136b2d
parent 7633	abe2697b5e92
child 7660	252823632401