20 files changed, 2453 insertions, 3 deletions

diff --git a/MCServer/Plugins/APIDump/Classes/Network.lua b/MCServer/Plugins/APIDump/Classes/Network.lua
new file mode 100644
index 000000000..065a743d8
--- /dev/null
+++ b/MCServer/Plugins/APIDump/Classes/Network.lua
@@ -0,0 +1,320 @@
+
+-- Network.lua
+
+-- Defines the documentation for the cNetwork-related classes
+
+
+
+
+
+return
+{
+	cNetwork =
+	{
+		Desc =
+		[[
+			This is the namespace for high-level network-related operations. Allows plugins to make TCP
+			connections to the outside world using a callback-based API.</p>
+			<p>
+			All functions in this namespace are static, they should be called on the cNetwork class itself:
+<pre class="prettyprint lang-lua">
+local Server = cNetwork:Listen(1024, ListenCallbacks);
+</pre></p>
+		]],
+		AdditionalInfo =
+		{
+			{
+				Header = "Using callbacks",
+				Contents =
+				[[
+					The entire Networking API is callback-based. Whenever an event happens on the network object, a
+					specific plugin-provided function is called. The callbacks are stored in tables which are passed
+					to the API functions, each table contains multiple callbacks for the various situations.</p>
+					<p>
+					There are three different callback variants used: LinkCallbacks, LookupCallbacks and
+					ListenCallbacks. Each is used in the situation appropriate by its name - LinkCallbacks are used
+					for handling the traffic on a single network link (plus additionally creation of such link when
+					connecting as a client), LookupCallbacks are used when doing DNS and reverse-DNS lookups, and
+					ListenCallbacks are used for handling incoming connections as a server.</p>
+					<p>
+					LinkCallbacks have the following structure:<br/>
+<pre class="prettyprint lang-lua">
+local LinkCallbacks =
+{
+	OnConnected = function ({{cTCPLink|a_TCPLink}})
+		-- The specified {{cTCPLink|link}} has succeeded in connecting to the remote server.
+		-- Only called if the link is being connected as a client (using cNetwork:Connect() )
+		-- Not used for incoming server links
+		-- All returned values are ignored
+	end,
+	
+	OnError = function ({{cTCPLink|a_TCPLink}}, a_ErrorCode, a_ErrorMsg)
+		-- The specified error has occured on the {{cTCPLink|link}}
+		-- No other callback will be called for this link from now on
+		-- For a client link being connected, this reports a connection error (destination unreachable etc.)
+		-- It is an Undefined Behavior to send data to a_TCPLink in or after this callback
+		-- All returned values are ignored
+	end,
+	
+	OnReceivedData = function ({{cTCPLink|a_TCPLink}}, a_Data)
+		-- Data has been received on the {{cTCPLink|link}}
+		-- Will get called whenever there's new data on the {{cTCPLink|link}}
+		-- a_Data contains the raw received data, as a string
+		-- All returned values are ignored
+	end,
+	
+	OnRemoteClosed = function ({{cTCPLink|a_TCPLink}})
+		-- The remote peer has closed the {{cTCPLink|link}}
+		-- The link is already closed, any data sent to it now will be lost
+		-- No other callback will be called for this link from now on
+		-- All returned values are ignored
+	end,
+}
+</pre></p>
+				<p>
+				LookupCallbacks have the following structure:<br/>
+<pre class="prettyprint lang-lua">
+local LookupCallbacks =
+{
+	OnError = function (a_Query, a_ErrorCode, a_ErrorMsg)
+		-- The specified error has occured while doing the lookup
+		-- a_Query is the hostname or IP being looked up
+		-- No other callback will be called for this lookup from now on
+		-- All returned values are ignored
+	end,
+
+	OnFinished = function (a_Query)
+		-- There are no more DNS records for this query
+		-- a_Query is the hostname or IP being looked up
+		-- No other callback will be called for this lookup from now on
+		-- All returned values are ignored
+	end,
+
+	OnNameResolved = function (a_Hostname, a_IP)
+		-- A DNS record has been found, the specified hostname resolves to the IP
+		-- Called for both Hostname -&gt; IP and IP -&gt; Hostname lookups
+		-- May be called multiple times if a hostname resolves to multiple IPs
+		-- All returned values are ignored
+	end,
+}
+</pre></p>
+				<p>
+				ListenCallbacks have the following structure:<br/>
+<pre class="prettyprint lang-lua">
+local ListenCallbacks =
+{
+	OnAccepted = function ({{cTCPLink|a_TCPLink}})
+		-- A new connection has been accepted and a {{cTCPLink|Link}} for it created
+		-- It is safe to send data to the link now
+		-- All returned values are ignored
+	end,
+	
+	OnError = function (a_ErrorCode, a_ErrorMsg)
+		-- The specified error has occured while trying to listen
+		-- No other callback will be called for this lookup from now on
+		-- This callback is called before the cNetwork:Listen() call returns
+		-- All returned values are ignored
+	end,
+
+	OnIncomingConnection = function (a_RemoteIP, a_RemotePort, a_LocalPort)
+		-- A new connection is being accepted, from the specified remote peer
+		-- This function needs to return either nil to drop the connection,
+		-- or valid LinkCallbacks to use for the new connection's {{cTCPLink|TCPLink}} object
+		return SomeLinkCallbacks
+	end,
+}
+</pre></p>
+				]],
+			},
+			
+			{
+				Header = "Example client connection",
+				Contents =
+				[[
+					The following example, adapted from the NetworkTest plugin, shows a simple example of a client
+					connection using the cNetwork API. It connects to www.google.com on port 80 (http) and sends a http
+					request for the front page. It dumps the received data to the console.</p>
+					<p>
+					First, the callbacks are defined in a table. The OnConnected() callback takes care of sending the http
+					request once the socket is connected. The OnReceivedData() callback sends all data to the console. The
+					OnError() callback logs any errors. Then, the connection is initiated using the cNetwork::Connect() API
+					function.</p>
+					<p>
+<pre class="prettyprint lang-lua">
+-- Define the callbacks to use for the client connection:
+local ConnectCallbacks =
+{
+	OnConnected = function (a_Link)
+		-- Connection succeeded, send the http request:
+		a_Link:Send("GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n")
+	end,
+	
+	OnError = function (a_Link, a_ErrorCode, a_ErrorMsg)
+		-- Log the error to console:
+		LOG("An error has occurred while talking to google.com: " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+	end,
+	
+	OnReceivedData = function (a_Link, a_Data)
+		-- Log the received data to console:
+		LOG("Incoming http data:\r\n" .. a_Data)
+	end,
+	
+	OnRemoteClosed = function (a_Link)
+		-- Log the event into the console:
+		LOG("Connection to www.google.com closed")
+	end,
+}
+
+-- Connect:
+if not(cNetwork:Connect("www.google.com", 80, ConnectCallbacks)) then
+	-- Highly unlikely, but better check for errors
+	LOG("Cannot queue connection to www.google.com")
+end
+-- Note that the connection is being made on the background,
+-- there's no guarantee that it's already connected at this point in code
+</pre>
+				]],
+			},
+			
+			{
+				Header = "Example server implementation",
+				Contents =
+				[[
+					The following example, adapted from the NetworkTest plugin, shows a simple example of creating a
+					server listening on a TCP port using the cNetwork API. The server listens on port 9876 and for
+					each incoming connection it sends a welcome message and then echoes back whatever the client has
+					sent ("echo server").</p>
+					<p>
+					First, the callbacks for the listening server are defined. The most important of those is the
+					OnIncomingConnection() callback that must return the LinkCallbacks that will be used for the new
+					connection. In our simple scenario each connection uses the same callbacks, so a predefined
+					callbacks table is returned; it is, however, possible to define different callbacks for each
+					connection. This allows the callbacks to be "personalised", for example by the remote IP or the
+					time of connection. The OnAccepted() and OnError() callbacks only log that they occurred, there's
+					no processing needed for them.</p>
+					<p>
+					Finally, the cNetwork:Listen() API function is used to create the listening server. The status of
+					the server is checked and if it is successfully listening, it is stored in a global variable, so
+					that Lua doesn't garbage-collect it until we actually want the server closed.</p>
+					<p>
+<pre class="prettyprint lang-lua">
+-- Define the callbacks used for the incoming connections:
+local EchoLinkCallbacks =
+{
+	OnConnected = function (a_Link)
+		-- This will not be called for a server connection, ever
+		assert(false, "Unexpected Connect callback call")
+	end,
+	
+	OnError = function (a_Link, a_ErrorCode, a_ErrorMsg)
+		-- Log the error to console:
+		local RemoteName = "'" .. a_Link:GetRemoteIP() .. ":" .. a_Link:GetRemotePort() .. "'"
+		LOG("An error has occurred while talking to " .. RemoteName .. ": " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+	end,
+	
+	OnReceivedData = function (a_Link, a_Data)
+		-- Send the received data back to the remote peer
+		a_Link:Send(Data)
+	end,
+	
+	OnRemoteClosed = function (a_Link)
+		-- Log the event into the console:
+		local RemoteName = "'" .. a_Link:GetRemoteIP() .. ":" .. a_Link:GetRemotePort() .. "'"
+		LOG("Connection to '" .. RemoteName .. "' closed")
+	end,
+}
+
+-- Define the callbacks used by the server:
+local ListenCallbacks =
+{
+	OnAccepted = function (a_Link)
+		-- No processing needed, just log that this happened:
+		LOG("OnAccepted callback called")
+	end,
+	
+	OnError = function (a_ErrorCode, a_ErrorMsg)
+		-- An error has occured while listening for incoming connections, log it:
+		LOG("Cannot listen, error " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")"
+	end,
+
+	OnIncomingConnection = function (a_RemoteIP, a_RemotePort, a_LocalPort)
+		-- A new connection is being accepted, give it the EchoCallbacks
+		return EchoLinkCallbacks
+	end,
+}
+
+-- Start the server:
+local Server = cNetwork:Listen(9876, ListenCallbacks)
+if not(Server:IsListening()) then
+	-- The error has been already printed in the OnError() callbacks
+	-- Just bail out
+	return;
+end
+
+-- Store the server globally, so that it stays open:
+g_Server = Server
+
+...
+
+-- Elsewhere in the code, when terminating:
+-- Close the server and let it be garbage-collected:
+g_Server:Close()
+g_Server = nil
+</pre>
+				]],
+			},
+		},  -- AdditionalInfo
+		
+		Functions =
+		{
+				Connect = { Params = "Host, Port, LinkCallbacks", Return = "bool", Notes = "(STATIC) Begins establishing a (client) TCP connection to the specified host. Uses the LinkCallbacks table to report progress, success, errors and incoming data. Returns false if it fails immediately (bad port value, bad hostname format), true otherwise. Host can be either an IP address or a hostname." },
+				HostnameToIP = { Params = "Host, LookupCallbacks", Return = "bool", Notes = "(STATIC) Begins a DNS lookup to find the IP address(es) for the specified host. Uses the LookupCallbacks table to report progress, success or errors. Returns false if it fails immediately (bad hostname format), true if the lookup started successfully. Host can be either a hostname or an IP address." },
+				IPToHostname = { Params = "Address, LookupCallbacks", Return = "bool", Notes = "(STATIC) Begins a reverse-DNS lookup to find out the hostname for the specified IP address. Uses the LookupCallbacks table to report progress, success or errors. Returns false if it fails immediately (bad address format), true if the lookup started successfully." },
+				Listen = { Params = "Port, ListenCallbacks", Return = "{{cServerHandle|ServerHandle}}", Notes = "(STATIC) Starts listening on the specified port. Uses the ListenCallbacks to report incoming connections or errors. Returns a {{cServerHandle}} object representing the server. If the listen operation failed, the OnError callback is called with the error details and the returned server handle will report IsListening() == false. The plugin needs to store the server handle object for as long as it needs the server running, if the server handle is garbage-collected by Lua, the listening socket will be closed and all current connections dropped." },
+		},
+	},  -- cNetwork
+	
+	cTCPLink =
+	{
+		Desc =
+		[[
+			This class wraps a single TCP connection, that has been established. Plugins can create these by
+			calling {{cNetwork}}:Connect() to connect to a remote server, or by listening using
+			{{cNetwork}}:Listen() and accepting incoming connections. The links are callback-based - when an event
+			such as incoming data or remote disconnect happens on the link, a specific callback is called. See the
+			additional information in {{cNetwork}} documentation for details.
+		]],
+		
+		Functions =
+		{
+			GetLocalIP = { Params = "", Return = "string", Notes = "Returns the IP address of the local endpoint of the TCP connection." },
+			GetLocalPort = { Params = "", Return = "number", Notes = "Returns the port of the local endpoint of the TCP connection." },
+			GetRemoteIP = { Params = "", Return = "string", Notes = "Returns the IP address of the remote endpoint of the TCP connection." },
+			GetRemotePort = { Params = "", Return = "number", Notes = "Returns the port of the remote endpoint of the TCP connection." },
+			Send = { Params = "Data", Return = "", Notes = "Sends the data (raw string) to the remote peer. The data is sent asynchronously and there is no report on the success of the send operation, other than the connection being closed or reset by the underlying OS." },
+		},
+	},  -- cTCPLink
+
+	cServerHandle =
+	{
+		Desc =
+		[[
+			This class provides an interface for TCP sockets listening for a connection. In order to listen, the
+			plugin needs to use the {{cNetwork}}:Listen() function to create the listening socket.</p>
+			<p>
+			Note that when Lua garbage-collects this class, the listening socket is closed. Therefore the plugin
+			should keep it referenced in a global variable for as long as it wants the server running.
+		]],
+		
+		Functions =
+		{
+			Close = { Params = "", Return = "", Notes = "Closes the listening socket. No more connections will be accepted, and all current connections will be closed." },
+			IsListening = { Params = "", Return = "bool", Notes = "Returns true if the socket is listening." },
+		},
+
+	},  -- cServerHandle
+}
+
+
+
+
diff --git a/MCServer/Plugins/NetworkTest/Info.lua b/MCServer/Plugins/NetworkTest/Info.lua
new file mode 100644
index 000000000..f366fd1be
--- /dev/null
+++ b/MCServer/Plugins/NetworkTest/Info.lua
@@ -0,0 +1,94 @@
+
+-- Info.lua
+
+-- Implements the g_PluginInfo standard plugin description
+
+g_PluginInfo =
+{
+	Name = "NetworkTest",
+	Version = "1",
+	Date = "2015-01-28",
+	Description = [[Implements test code (and examples) for the cNetwork API]],
+	
+	Commands =
+	{
+	},
+	
+	ConsoleCommands =
+	{
+		net =
+		{
+			Subcommands =
+			{
+				client =
+				{
+					HelpString = "Connects, as a client, to a specified webpage (google.com by default) and downloads its front page using HTTP",
+					Handler = HandleConsoleNetClient,
+					ParameterCombinations =
+					{
+						{
+							Params = "",
+							Help = "Connects, as a client, to google.com and downloads its front page using HTTP",
+						},
+						{
+							Params = "host [port]",
+							Help = "Connects, as a client, to the specified host and downloads its front page using HTTP",
+						},
+					},  -- ParameterCombinations
+				},  -- client
+				
+				close =
+				{
+					HelpString = "Close a listening socket",
+					Handler = HandleConsoleNetClose,
+					ParameterCombinations =
+					{
+						{
+							Params = "[Port]",
+							Help = "Closes a socket listening on the specified port [1024]",
+						},
+					},  -- ParameterCombinations
+				},  -- close
+				
+				listen =
+				{
+					HelpString = "Creates a new listening socket on the specified port with the specified service attached to it",
+					Handler = HandleConsoleNetListen,
+					ParameterCombinations =
+					{
+						{
+							Params = "[Port] [Service]",
+							Help = "Starts listening on the specified port [1024] providing the specified service [echo]",
+						},
+					},  -- ParameterCombinations
+				},  -- listen
+				
+				lookup =
+				{
+					HelpString = "Looks up the IP addresses corresponding to the given hostname  (google.com by default)",
+					Handler = HandleConsoleNetLookup,
+					ParameterCombinations =
+					{
+						{
+							Params = "",
+							Help = "Looks up the IP addresses of google.com.",
+						},
+						{
+							Params = "Hostname",
+							Help = "Looks up the IP addresses of the specified hostname.",
+						},
+						{
+							Params = "IP",
+							Help = "Looks up the canonical name of the specified IP.",
+						},
+					},
+				},  -- lookup
+				
+			},  -- Subcommands
+		},  -- net
+	},
+}
+
+
+
+
diff --git a/MCServer/Plugins/NetworkTest/NetworkTest.lua b/MCServer/Plugins/NetworkTest/NetworkTest.lua
new file mode 100644
index 000000000..7932f4b88
--- /dev/null
+++ b/MCServer/Plugins/NetworkTest/NetworkTest.lua
@@ -0,0 +1,254 @@
+
+-- NetworkTest.lua
+
+-- Implements a few tests for the cNetwork API
+
+
+
+
+
+--- Map of all servers currently open
+-- g_Servers[PortNum] = cServerHandle
+local g_Servers = {}
+
+--- List of fortune messages for the fortune server
+-- A random message is chosen for each incoming connection
+-- The contents are loaded from the splashes.txt file on plugin startup
+local g_Fortunes =
+{
+	"Empty splashes.txt",
+}
+
+--- Map of all services that can be run as servers
+-- g_Services[ServiceName] = function() -> accept-callbacks
+local g_Services =
+{
+	-- Echo service: each connection echoes back what has been sent to it
+	echo = function (a_Port)
+		return
+		{
+			-- A new connection has come, give it new link-callbacks:
+			OnIncomingConnection = function (a_RemoteIP, a_RemotePort)
+				return
+				{
+					OnError = function (a_Link, a_ErrorCode, a_ErrorMsg)
+						LOG("EchoServer(" .. a_Port .. ": Connection to " .. a_Link:GetRemoteIP() .. ":" .. a_Link:GetRemotePort() .. " failed: " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+					end,
+					
+					OnReceivedData = function (a_Link, a_Data)
+						-- Echo the received data back to the link:
+						a_Link:Send(a_Data)
+					end,
+					
+					OnRemoteClosed = function (a_Link)
+					end
+				}  -- Link callbacks
+			end,  -- OnIncomingConnection()
+			
+			-- Send a welcome message to newly accepted connections:
+			OnAccepted = function (a_Link)
+				a_Link:Send("Hello, " .. a_Link:GetRemoteIP() .. ", welcome to the echo server @ MCServer-Lua\r\n")
+			end,  -- OnAccepted()
+			
+			-- There was an error listening on the port:
+			OnError = function (a_ErrorCode, a_ErrorMsg)
+				LOGINFO("EchoServer(" .. a_Port .. ": Cannot listen: " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+			end,  -- OnError()
+		}  -- Listen callbacks
+	end,  -- echo
+	
+	-- Fortune service: each incoming connection gets a welcome message plus a random fortune text; all communication is ignored afterwards
+	fortune = function (a_Port)
+		return
+		{
+			-- A new connection has come, give it new link-callbacks:
+			OnIncomingConnection = function (a_RemoteIP, a_RemotePort)
+				return
+				{
+					OnError = function (a_Link, a_ErrorCode, a_ErrorMsg)
+						LOG("FortuneServer(" .. a_Port .. ": Connection to " .. a_Link:GetRemoteIP() .. ":" .. a_Link:GetRemotePort() .. " failed: " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+					end,
+					
+					OnReceivedData = function (a_Link, a_Data)
+						-- Ignore any received data
+					end,
+					
+					OnRemoteClosed = function (a_Link)
+					end
+				}  -- Link callbacks
+			end,  -- OnIncomingConnection()
+			
+			-- Send a welcome message and the fortune to newly accepted connections:
+			OnAccepted = function (a_Link)
+				a_Link:Send("Hello, " .. a_Link:GetRemoteIP() .. ", welcome to the fortune server @ MCServer-Lua\r\n\r\nYour fortune:\r\n")
+				a_Link:Send(g_Fortunes[math.random(#g_Fortunes)] .. "\r\n")
+			end,  -- OnAccepted()
+			
+			-- There was an error listening on the port:
+			OnError = function (a_ErrorCode, a_ErrorMsg)
+				LOGINFO("FortuneServer(" .. a_Port .. ": Cannot listen: " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+			end,  -- OnError()
+		}  -- Listen callbacks
+	end,  -- fortune
+	
+	-- TODO: Other services (daytime, ...)
+}
+
+
+
+
+
+function Initialize(a_Plugin)
+	-- Load the splashes.txt file into g_Fortunes, overwriting current content:
+	local idx = 1
+	for line in io.lines(a_Plugin:GetLocalFolder() .. "/splashes.txt") do
+		g_Fortunes[idx] = line
+		idx = idx + 1
+	end
+	
+	-- Use the InfoReg shared library to process the Info.lua file:
+	dofile(cPluginManager:GetPluginsPath() .. "/InfoReg.lua")
+	RegisterPluginInfoCommands()
+	RegisterPluginInfoConsoleCommands()
+
+	-- Seed the random generator:
+	math.randomseed(os.time())
+	
+	return true
+end
+
+
+
+
+
+function HandleConsoleNetClient(a_Split)
+	-- Get the address to connect to:
+	local Host = a_Split[3] or "google.com"
+	local Port = a_Split[4] or 80
+	
+	-- Create the callbacks "personalised" for the address:
+	local Callbacks =
+	{
+		OnConnected = function (a_Link)
+			LOG("Connected to " .. Host .. ":" .. Port .. ".")
+			LOG("Connection stats: Remote address: " .. a_Link:GetRemoteIP() .. ":" .. a_Link:GetRemotePort() .. ", Local address: " .. a_Link:GetLocalIP() .. ":" .. a_Link:GetLocalPort())
+			LOG("Sending HTTP request for front page.")
+			a_Link:Send("GET / HTTP/1.0\r\nHost: " .. Host .. "\r\n\r\n")
+		end,
+		
+		OnError = function (a_Link, a_ErrorCode, a_ErrorMsg)
+			LOG("Connection to " .. Host .. ":" .. Port .. " failed: " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+		end,
+		
+		OnReceivedData = function (a_Link, a_Data)
+			LOG("Received data from " .. Host .. ":" .. Port .. ":\r\n" .. a_Data)
+		end,
+		
+		OnRemoteClosed = function (a_Link)
+			LOG("Connection to " .. Host .. ":" .. Port .. " was closed by the remote peer.")
+		end
+	}
+	
+	-- Queue a connect request:
+	local res = cNetwork:Connect(Host, Port, Callbacks)
+	if not(res) then
+		LOGWARNING("cNetwork:Connect call failed immediately")
+		return true
+	end
+	
+	return true, "Client connection request queued."
+end
+
+
+
+
+
+function HandleConsoleNetClose(a_Split)
+	-- Get the port to close:
+	local Port = tonumber(a_Split[3] or 1024)
+	if not(Port) then
+		return true, "Bad port number: \"" .. Port .. "\"."
+	end
+
+	-- Close the server, if there is one:
+	if not(g_Servers[Port]) then
+		return true, "There is no server currently listening on port " .. Port .. "."
+	end
+	g_Servers[Port]:Close()
+	g_Servers[Port] = nil
+	return true, "Port " .. Port .. " closed."
+end
+
+
+
+
+
+function HandleConsoleNetLookup(a_Split)
+	-- Get the name to look up:
+	local Addr = a_Split[3] or "google.com"
+	
+	-- Create the callbacks "personalised" for the host:
+	local Callbacks =
+	{
+		OnNameResolved = function (a_Hostname, a_IP)
+			LOG(a_Hostname .. " resolves to " .. a_IP)
+		end,
+		
+		OnError = function (a_Query, a_ErrorCode, a_ErrorMsg)
+			LOG("Failed to retrieve information for " .. a_Query .. ": " .. a_ErrorCode .. " (" .. a_ErrorMsg .. ")")
+			assert(a_Query == Addr)
+		end,
+		
+		OnFinished = function (a_Query)
+			LOG("Resolving " .. a_Query .. " has finished.")
+			assert(a_Query == Addr)
+		end,
+	}
+	
+	-- Queue both name and IP DNS queries;
+	-- we don't distinguish between an IP and a hostname in this command so we don't know which one to use:
+	local res = cNetwork:HostnameToIP(Addr, Callbacks)
+	if not(res) then
+		LOGWARNING("cNetwork:HostnameToIP call failed immediately")
+		return true
+	end
+	res = cNetwork:IPToHostname(Addr, Callbacks)
+	if not(res) then
+		LOGWARNING("cNetwork:IPToHostname call failed immediately")
+		return true
+	end
+	
+	return true, "DNS query has been queued."
+end
+
+
+
+
+
+function HandleConsoleNetListen(a_Split)
+	-- Get the params:
+	local Port = tonumber(a_Split[3] or 1024)
+	if not(Port) then
+		return true, "Invalid port: \"" .. Port .. "\"."
+	end
+	local Service = string.lower(a_Split[4] or "echo")
+	
+	-- Create the callbacks specific for the service:
+	if (g_Services[Service] == nil) then
+		return true, "No such service: " .. Service
+	end
+	local Callbacks = g_Services[Service](Port)
+	
+	-- Start the server:
+	local srv = cNetwork:Listen(Port, Callbacks)
+	if not(srv:IsListening()) then
+		-- The error message has already been printed in the Callbacks.OnError()
+		return true
+	end
+	g_Servers[Port] = srv
+	return true, Service .. " server started on port " .. Port
+end
+
+
+
+
diff --git a/MCServer/Plugins/NetworkTest/splashes.txt b/MCServer/Plugins/NetworkTest/splashes.txt
new file mode 100644
index 000000000..50a87bd91
--- /dev/null
+++ b/MCServer/Plugins/NetworkTest/splashes.txt
@@ -0,0 +1,357 @@
+As seen on TV!
+Awesome!
+100% pure!
+May contain nuts!
+Better than Prey!
+More polygons!
+Sexy!
+Limited edition!
+Flashing letters!
+Made by Notch!
+It's here!
+Best in class!
+It's finished!
+Kind of dragon free!
+Excitement!
+More than 500 sold!
+One of a kind!
+Heaps of hits on YouTube!
+Indev!
+Spiders everywhere!
+Check it out!
+Holy cow, man!
+It's a game!
+Made in Sweden!
+Uses LWJGL!
+Reticulating splines!
+Minecraft!
+Yaaay!
+Singleplayer!
+Keyboard compatible!
+Undocumented!
+Ingots!
+Exploding creepers!
+That's no moon!
+l33t!
+Create!
+Survive!
+Dungeon!
+Exclusive!
+The bee's knees!
+Down with O.P.P.!
+Closed source!
+Classy!
+Wow!
+Not on steam!
+Oh man!
+Awesome community!
+Pixels!
+Teetsuuuuoooo!
+Kaaneeeedaaaa!
+Now with difficulty!
+Enhanced!
+90% bug free!
+Pretty!
+12 herbs and spices!
+Fat free!
+Absolutely no memes!
+Free dental!
+Ask your doctor!
+Minors welcome!
+Cloud computing!
+Legal in Finland!
+Hard to label!
+Technically good!
+Bringing home the bacon!
+Indie!
+GOTY!
+Ceci n'est pas une title screen!
+Euclidian!
+Now in 3D!
+Inspirational!
+Herregud!
+Complex cellular automata!
+Yes, sir!
+Played by cowboys!
+OpenGL 2.1 (if supported)!
+Thousands of colors!
+Try it!
+Age of Wonders is better!
+Try the mushroom stew!
+Sensational!
+Hot tamale, hot hot tamale!
+Play him off, keyboard cat!
+Guaranteed!
+Macroscopic!
+Bring it on!
+Random splash!
+Call your mother!
+Monster infighting!
+Loved by millions!
+Ultimate edition!
+Freaky!
+You've got a brand new key!
+Water proof!
+Uninflammable!
+Whoa, dude!
+All inclusive!
+Tell your friends!
+NP is not in P!
+Notch <3 ez!
+Music by C418!
+Livestreamed!
+Haunted!
+Polynomial!
+Terrestrial!
+All is full of love!
+Full of stars!
+Scientific!
+Cooler than Spock!
+Collaborate and listen!
+Never dig down!
+Take frequent breaks!
+Not linear!
+Han shot first!
+Nice to meet you!
+Buckets of lava!
+Ride the pig!
+Larger than Earth!
+sqrt(-1) love you!
+Phobos anomaly!
+Punching wood!
+Falling off cliffs!
+0% sugar!
+150% hyperbole!
+Synecdoche!
+Let's danec!
+Seecret Friday update!
+Reference implementation!
+Lewd with two dudes with food!
+Kiss the sky!
+20 GOTO 10!
+Verlet intregration!
+Peter Griffin!
+Do not distribute!
+Cogito ergo sum!
+4815162342 lines of code!
+A skeleton popped out!
+The Work of Notch!
+The sum of its parts!
+BTAF used to be good!
+I miss ADOM!
+umop-apisdn!
+OICU812!
+Bring me Ray Cokes!
+Finger-licking!
+Thematic!
+Pneumatic!
+Sublime!
+Octagonal!
+Une baguette!
+Gargamel plays it!
+Rita is the new top dog!
+SWM forever!
+Representing Edsbyn!
+Matt Damon!
+Supercalifragilisticexpialidocious!
+Consummate V's!
+Cow Tools!
+Double buffered!
+Fan fiction!
+Flaxkikare!
+Jason! Jason! Jason!
+Hotter than the sun!
+Internet enabled!
+Autonomous!
+Engage!
+Fantasy!
+DRR! DRR! DRR!
+Kick it root down!
+Regional resources!
+Woo, facepunch!
+Woo, somethingawful!
+Woo, /v/!
+Woo, tigsource!
+Woo, minecraftforum!
+Woo, worldofminecraft!
+Woo, reddit!
+Woo, 2pp!
+Google anlyticsed!
+Now supports åäö!
+Give us Gordon!
+Tip your waiter!
+Very fun!
+12345 is a bad password!
+Vote for net neutrality!
+Lives in a pineapple under the sea!
+MAP11 has two names!
+Omnipotent!
+Gasp!
+...!
+Bees, bees, bees, bees!
+Jag känner en bot!
+This text is hard to read if you play the game at the default resolution, but at 1080p it's fine!
+Haha, LOL!
+Hampsterdance!
+Switches and ores!
+Menger sponge!
+idspispopd!
+Eple (original edit)!
+So fresh, so clean!
+Slow acting portals!
+Try the Nether!
+Don't look directly at the bugs!
+Oh, ok, Pigmen!
+Finally with ladders!
+Scary!
+Play Minecraft, Watch Topgear, Get Pig!
+Twittered about!
+Jump up, jump up, and get down!
+Joel is neat!
+A riddle, wrapped in a mystery!
+Huge tracts of land!
+Welcome to your Doom!
+Stay a while, stay forever!
+Stay a while and listen!
+Treatment for your rash!
+"Autological" is!
+Information wants to be free!
+"Almost never" is an interesting concept!
+Lots of truthiness!
+The creeper is a spy!
+Turing complete!
+It's groundbreaking!
+Let our battle's begin!
+The sky is the limit!
+Jeb has amazing hair!
+Ryan also has amazing hair!
+Casual gaming!
+Undefeated!
+Kinda like Lemmings!
+Follow the train, CJ!
+Leveraging synergy!
+This message will never appear on the splash screen, isn't that weird?
+DungeonQuest is unfair!
+110813!
+90210!
+Check out the far lands!
+Tyrion would love it!
+Also try VVVVVV!
+Also try Super Meat Boy!
+Also try Terraria!
+Also try Mount And Blade!
+Also try Project Zomboid!
+Also try World of Goo!
+Also try Limbo!
+Also try Pixeljunk Shooter!
+Also try Braid!
+That's super!
+Bread is pain!
+Read more books!
+Khaaaaaaaaan!
+Less addictive than TV Tropes!
+More addictive than lemonade!
+Bigger than a bread box!
+Millions of peaches!
+Fnord!
+This is my true form!
+Totally forgot about Dre!
+Don't bother with the clones!
+Pumpkinhead!
+Hobo humping slobo babe!
+Made by Jeb!
+Has an ending!
+Finally complete!
+Feature packed!
+Boots with the fur!
+Stop, hammertime!
+Testificates!
+Conventional!
+Homeomorphic to a 3-sphere!
+Doesn't avoid double negatives!
+Place ALL the blocks!
+Does barrel rolls!
+Meeting expectations!
+PC gaming since 1873!
+Ghoughpteighbteau tchoghs!
+Déjà vu!
+Déjà vu!
+Got your nose!
+Haley loves Elan!
+Afraid of the big, black bat!
+Doesn't use the U-word!
+Child's play!
+See you next Friday or so!
+From the streets of Södermalm!
+150 bpm for 400000 minutes!
+Technologic!
+Funk soul brother!
+Pumpa kungen!
+日本ハロー！
+한국 안녕하세요!
+Helo Cymru!
+Cześć Polsko!
+你好中国！
+Привет Россия!
+Γεια σου Ελλάδα!
+My life for Aiur!
+Lennart lennart = new Lennart();
+I see your vocabulary has improved!
+Who put it there?
+You can't explain that!
+if not ok then return end
+§1C§2o§3l§4o§5r§6m§7a§8t§9i§ac
+§kFUNKY LOL
+SOPA means LOSER in Swedish!
+Big Pointy Teeth!
+Bekarton guards the gate!
+Mmmph, mmph!
+Don't feed avocados to parrots!
+Swords for everyone!
+Plz reply to my tweet!
+.party()!
+Take her pillow!
+Put that cookie down!
+Pretty scary!
+I have a suggestion.
+Now with extra hugs!
+Now Java 6!
+Woah.
+HURNERJSGER?
+What's up, Doc?
+Now contains 32 random daily cats!
+That's Numberwang!
+pls rt
+Do you want to join my server?
+Put a little fence around it!
+Throw a blanket over it!
+One day, somewhere in the future, my work will be quoted!
+Now with additional stuff!
+Extra things!
+Yay, puppies for everyone!
+So sweet, like a nice bon bon!
+Popping tags!
+Very influential in its circle!
+Now With Multiplayer!
+Rise from your grave!
+Warning! A huge battleship "STEVE" is approaching fast!
+Blue warrior shot the food!
+Run, coward! I hunger!
+Flavor with no seasoning!
+Strange, but not a stranger!
+Tougher than diamonds, rich like cream!
+Getting ready to show!
+Getting ready to know!
+Getting ready to drop!
+Getting ready to shock!
+Getting ready to freak!
+Getting ready to speak!
+It swings, it jives!
+Cruising streets for gold!
+Take an eggbeater and beat it against a skillet!
+Make me a table, a funky table!
+Take the elevator to the mezzanine!
+Stop being reasonable, this is the Internet!
+/give @a hugs 64
+This is good for Realms.
+Any computer is a laptop if you're brave enough!
\ No newline at end of file
diff --git a/src/Bindings/CMakeLists.txt b/src/Bindings/CMakeLists.txt
index d47579cd6..40b8d4bd9 100644
--- a/src/Bindings/CMakeLists.txt
+++ b/src/Bindings/CMakeLists.txt
@@ -8,9 +8,13 @@ SET (SRCS
 	Bindings.cpp
 	DeprecatedBindings.cpp
 	LuaChunkStay.cpp
+	LuaNameLookup.cpp
+	LuaServerHandle.cpp
 	LuaState.cpp
+	LuaTCPLink.cpp
 	LuaWindow.cpp
 	ManualBindings.cpp
+	ManualBindings_Network.cpp
 	ManualBindings_RankManager.cpp
 	Plugin.cpp
 	PluginLua.cpp
@@ -23,7 +27,10 @@ SET (HDRS
 	DeprecatedBindings.h
 	LuaChunkStay.h
 	LuaFunctions.h
+	LuaNameLookup.h
+	LuaServerHandle.h
 	LuaState.h
+	LuaTCPLink.h
 	LuaWindow.h
 	ManualBindings.h
 	Plugin.h
diff --git a/src/Bindings/LuaNameLookup.cpp b/src/Bindings/LuaNameLookup.cpp
new file mode 100644
index 000000000..e52d8dbdc
--- /dev/null
+++ b/src/Bindings/LuaNameLookup.cpp
@@ -0,0 +1,88 @@
+
+// LuaNameLookup.cpp
+
+// Implements the cLuaNameLookup class used as the cNetwork API callbacks for name and IP lookups from Lua
+
+#include "Globals.h"
+#include "LuaNameLookup.h"
+
+
+
+
+
+cLuaNameLookup::cLuaNameLookup(const AString & a_Query, cPluginLua & a_Plugin, int a_CallbacksTableStackPos):
+	m_Plugin(a_Plugin),
+	m_Callbacks(a_Plugin.GetLuaState(), a_CallbacksTableStackPos),
+	m_Query(a_Query)
+{
+}
+
+
+
+
+
+void cLuaNameLookup::OnNameResolved(const AString & a_Name, const AString & a_IP)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnNameResolved"), a_Name, a_IP))
+	{
+		LOGINFO("cNetwork name lookup OnNameResolved callback failed in plugin %s looking up %s. %s resolves to %s.",
+			m_Plugin.GetName().c_str(), m_Query.c_str(), a_Name.c_str(), a_IP.c_str()
+		);
+	}
+}
+
+
+
+
+
+void cLuaNameLookup::OnError(int a_ErrorCode, const AString & a_ErrorMsg)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnError"), m_Query, a_ErrorCode, a_ErrorMsg))
+	{
+		LOGINFO("cNetwork name lookup OnError callback failed in plugin %s looking up %s. The error is %d (%s)",
+			m_Plugin.GetName().c_str(), m_Query.c_str(), a_ErrorCode, a_ErrorMsg.c_str()
+		);
+	}
+}
+
+
+
+
+
+void cLuaNameLookup::OnFinished(void)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnFinished"), m_Query))
+	{
+		LOGINFO("cNetwork name lookup OnFinished callback failed in plugin %s, looking up %s.",
+			m_Plugin.GetName().c_str(), m_Query.c_str()
+		);
+	}
+}
+
+
+
+
diff --git a/src/Bindings/LuaNameLookup.h b/src/Bindings/LuaNameLookup.h
new file mode 100644
index 000000000..e4cdb9f53
--- /dev/null
+++ b/src/Bindings/LuaNameLookup.h
@@ -0,0 +1,46 @@
+
+// LuaNameLookup.h
+
+// Declares the cLuaNameLookup class used as the cNetwork API callbacks for name and IP lookups from Lua
+
+
+
+
+
+#pragma once
+
+#include "../OSSupport/Network.h"
+#include "PluginLua.h"
+
+
+
+
+
+class cLuaNameLookup:
+	public cNetwork::cResolveNameCallbacks
+{
+public:
+	/** Creates a new instance of the lookup callbacks for the specified query,
+	attached to the specified lua plugin and wrapping the callbacks that are in a table at the specified stack pos. */
+	cLuaNameLookup(const AString & a_Query, cPluginLua & a_Plugin, int a_CallbacksTableStackPos);
+
+protected:
+	/** The plugin for which the query is created. */
+	cPluginLua & m_Plugin;
+
+	/** The Lua table that holds the callbacks to be invoked. */
+	cLuaState::cRef m_Callbacks;
+
+	/** The query used to start the lookup (either hostname or IP). */
+	AString m_Query;
+
+
+	// cNetwork::cResolveNameCallbacks overrides:
+	virtual void OnNameResolved(const AString & a_Name, const AString & a_IP) override;
+	virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) override;
+	virtual void OnFinished(void) override;
+};
+
+
+
+
diff --git a/src/Bindings/LuaServerHandle.cpp b/src/Bindings/LuaServerHandle.cpp
new file mode 100644
index 000000000..a84f894b5
--- /dev/null
+++ b/src/Bindings/LuaServerHandle.cpp
@@ -0,0 +1,209 @@
+
+// LuaServerHandle.cpp
+
+// Implements the cLuaServerHandle class wrapping the cServerHandle functionality for Lua API
+
+#include "Globals.h"
+#include "LuaServerHandle.h"
+#include "LuaTCPLink.h"
+#include "tolua++/include/tolua++.h"
+
+
+
+
+
+cLuaServerHandle::cLuaServerHandle(UInt16 a_Port, cPluginLua & a_Plugin, int a_CallbacksTableStackPos):
+	m_Plugin(a_Plugin),
+	m_Callbacks(a_Plugin.GetLuaState(), a_CallbacksTableStackPos),
+	m_Port(a_Port)
+{
+}
+
+
+
+
+
+
+cLuaServerHandle::~cLuaServerHandle()
+{
+	// If the server handle is still open, close it explicitly:
+	Close();
+}
+
+
+
+
+
+void cLuaServerHandle::SetServerHandle(cServerHandlePtr a_ServerHandle, cLuaServerHandlePtr a_Self)
+{
+	ASSERT(m_ServerHandle == nullptr);  // The handle can be set only once
+
+	m_ServerHandle = a_ServerHandle;
+	m_Self = a_Self;
+}
+
+
+
+
+
+void cLuaServerHandle::Close(void)
+{
+	// Safely grab a copy of the server handle:
+	cServerHandlePtr ServerHandle = m_ServerHandle;
+	if (ServerHandle == nullptr)
+	{
+		return;
+	}
+
+	// Close the underlying server handle:
+	ServerHandle->Close();
+
+	// Close all connections at this server:
+	cLuaTCPLinkPtrs Connections;
+	{
+		cCSLock Lock(m_CSConnections);
+		std::swap(Connections, m_Connections);
+	}
+	for (auto & conn: Connections)
+	{
+		conn->Close();
+	}
+	Connections.clear();
+
+	// Allow the internal server handle to be deallocated:
+	m_ServerHandle.reset();
+}
+
+
+
+
+
+bool cLuaServerHandle::IsListening(void)
+{
+	// Safely grab a copy of the server handle:
+	cServerHandlePtr ServerHandle = m_ServerHandle;
+	if (ServerHandle == nullptr)
+	{
+		return false;
+	}
+
+	// Query the underlying server handle:
+	return ServerHandle->IsListening();
+}
+
+
+
+
+
+void cLuaServerHandle::RemoveLink(cLuaTCPLink * a_Link)
+{
+	cCSLock Lock(m_CSConnections);
+	for (auto itr = m_Connections.begin(), end = m_Connections.end(); itr != end; ++itr)
+	{
+		if (itr->get() == a_Link)
+		{
+			m_Connections.erase(itr);
+			break;
+		}
+	}  // for itr - m_Connections[]
+}
+
+
+
+
+
+void cLuaServerHandle::Release(void)
+{
+	// Close the server, if it isn't closed yet:
+	Close();
+
+	// Allow self to deallocate:
+	m_Self.reset();
+}
+
+
+
+
+
+cTCPLink::cCallbacksPtr cLuaServerHandle::OnIncomingConnection(const AString & a_RemoteIPAddress, UInt16 a_RemotePort)
+{
+	// If not valid anymore, drop the connection:
+	if (!m_Callbacks.IsValid())
+	{
+		return nullptr;
+	}
+
+	// Ask the plugin for link callbacks:
+	cPluginLua::cOperation Op(m_Plugin);
+	cLuaState::cRef LinkCallbacks;
+	if (
+		!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnIncomingConnection"), a_RemoteIPAddress, a_RemotePort, m_Port, cLuaState::Return, LinkCallbacks) ||
+		!LinkCallbacks.IsValid()
+	)
+	{
+		LOGINFO("cNetwork server (port %d) OnIncomingConnection callback failed in plugin %s. Dropping connection.",
+			m_Port, m_Plugin.GetName().c_str()
+		);
+		return nullptr;
+	}
+
+	// Create the link wrapper to use with the callbacks:
+	auto res = std::make_shared<cLuaTCPLink>(m_Plugin, std::move(LinkCallbacks), m_Self);
+
+	// Add the link to the list of our connections:
+	cCSLock Lock(m_CSConnections);
+	m_Connections.push_back(res);
+
+	return res;
+}
+
+
+
+
+
+void cLuaServerHandle::OnAccepted(cTCPLink & a_Link)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Notify the plugin:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnAccepted"), static_cast<cLuaTCPLink *>(a_Link.GetCallbacks().get())))
+	{
+		LOGINFO("cNetwork server (port %d) OnAccepted callback failed in plugin %s, connection to %s:%d.",
+			m_Port, m_Plugin.GetName().c_str(), a_Link.GetRemoteIP().c_str(), a_Link.GetRemotePort()
+		);
+		return;
+	}
+}
+
+
+
+
+
+void cLuaServerHandle::OnError(int a_ErrorCode, const AString & a_ErrorMsg)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Notify the plugin:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnError"), a_ErrorCode, a_ErrorMsg))
+	{
+		LOGINFO("cNetwork server (port %d) OnError callback failed in plugin %s. The error is %d (%s).",
+			m_Port, m_Plugin.GetName().c_str(), a_ErrorCode, a_ErrorMsg.c_str()
+		);
+		return;
+	}
+}
+
+
+
+
+
diff --git a/src/Bindings/LuaServerHandle.h b/src/Bindings/LuaServerHandle.h
new file mode 100644
index 000000000..9325bca3e
--- /dev/null
+++ b/src/Bindings/LuaServerHandle.h
@@ -0,0 +1,89 @@
+
+// LuaServerHandle.h
+
+// Declares the cLuaServerHandle class wrapping the cServerHandle functionality for Lua API
+
+
+
+
+
+#pragma once
+
+#include "../OSSupport/Network.h"
+#include "PluginLua.h"
+
+
+
+
+
+// fwd:
+class cLuaTCPLink;
+typedef SharedPtr<cLuaTCPLink> cLuaTCPLinkPtr;
+typedef std::vector<cLuaTCPLinkPtr> cLuaTCPLinkPtrs;
+class cLuaServerHandle;
+typedef SharedPtr<cLuaServerHandle> cLuaServerHandlePtr;
+
+
+
+
+class cLuaServerHandle:
+	public cNetwork::cListenCallbacks
+{
+public:
+	/** Creates a new instance of the server handle,
+	attached to the specified lua plugin and wrapping the (listen-) callbacks that are in a table at the specified stack pos. */
+	cLuaServerHandle(UInt16 a_Port, cPluginLua & a_Plugin, int a_CallbacksTableStackPos);
+
+	~cLuaServerHandle();
+
+	/** Called by cNetwork::Listen()'s binding.
+	Sets the server handle around which this instance is wrapped, and a self SharedPtr for link management. */
+	void SetServerHandle(cServerHandlePtr a_ServerHandle, cLuaServerHandlePtr a_Self);
+
+	/** Terminates all connections and closes the listening socket. */
+	void Close(void);
+
+	/** Returns true if the server is currently listening. */
+	bool IsListening(void);
+
+	/** Removes the link from the list of links that the server is currently tracking. */
+	void RemoveLink(cLuaTCPLink * a_Link);
+
+	/** Called when Lua garbage-collects the object.
+	Releases the internal SharedPtr to self, so that the instance may be deallocated. */
+	void Release(void);
+
+protected:
+	/** The plugin for which the server is created. */
+	cPluginLua & m_Plugin;
+
+	/** The Lua table that holds the callbacks to be invoked. */
+	cLuaState::cRef m_Callbacks;
+
+	/** The port on which the server is listening.
+	Used mainly for better error reporting. */
+	UInt16 m_Port;
+
+	/** The cServerHandle around which this instance is wrapped. */
+	cServerHandlePtr m_ServerHandle;
+
+	/** Protects m_Connections against multithreaded access. */
+	cCriticalSection m_CSConnections;
+
+	/** All connections that are currently active in this server.
+	Protected by m_CSConnections. */
+	cLuaTCPLinkPtrs m_Connections;
+
+	/** SharedPtr to self, given out to newly created links. */
+	cLuaServerHandlePtr m_Self;
+
+
+	// cNetwork::cListenCallbacks overrides:
+	virtual cTCPLink::cCallbacksPtr OnIncomingConnection(const AString & a_RemoteIPAddress, UInt16 a_RemotePort) override;
+	virtual void OnAccepted(cTCPLink & a_Link) override;
+	virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) override;
+};
+
+
+
+
diff --git a/src/Bindings/LuaState.cpp b/src/Bindings/LuaState.cpp
index 01d3ac687..73b114599 100644
--- a/src/Bindings/LuaState.cpp
+++ b/src/Bindings/LuaState.cpp
@@ -656,6 +656,30 @@ void cLuaState::Push(cItems * a_Items)
 
 
 
+void cLuaState::Push(cLuaServerHandle * a_ServerHandle)
+{
+	ASSERT(IsValid());
+
+	tolua_pushusertype(m_LuaState, a_ServerHandle, "cServerHandle");
+	m_NumCurrentFunctionArgs += 1;
+}
+
+
+
+
+
+void cLuaState::Push(cLuaTCPLink * a_TCPLink)
+{
+	ASSERT(IsValid());
+
+	tolua_pushusertype(m_LuaState, a_TCPLink, "cTCPLink");
+	m_NumCurrentFunctionArgs += 1;
+}
+
+
+
+
+
 void cLuaState::Push(cMonster * a_Monster)
 {
 	ASSERT(IsValid());
@@ -958,6 +982,15 @@ void cLuaState::GetStackValue(int a_StackPos, pWorld & a_ReturnedVal)
 
 
 
+void cLuaState::GetStackValue(int a_StackPos, cRef & a_Ref)
+{
+	a_Ref.RefStack(*this, a_StackPos);
+}
+
+
+
+
+
 bool cLuaState::CallFunction(int a_NumResults)
 {
 	ASSERT (m_NumCurrentFunctionArgs >= 0);  // A function must be pushed to stack first
@@ -1527,6 +1560,18 @@ cLuaState::cRef::cRef(cLuaState & a_LuaState, int a_StackPos) :
 
 
 
+cLuaState::cRef::cRef(cRef && a_FromRef):
+	m_LuaState(a_FromRef.m_LuaState),
+	m_Ref(a_FromRef.m_Ref)
+{
+	a_FromRef.m_LuaState = nullptr;
+	a_FromRef.m_Ref = LUA_REFNIL;
+}
+
+
+
+
+
 cLuaState::cRef::~cRef()
 {
 	if (m_LuaState != nullptr)
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index 97e6b47e1..f68b022ea 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -59,6 +59,8 @@ class cTNTEntity;
 class cHopperEntity;
 class cBlockEntity;
 class cBoundingBox;
+class cLuaTCPLink;
+class cLuaServerHandle;
 
 typedef cBoundingBox * pBoundingBox;
 typedef cWorld *       pWorld;
@@ -83,6 +85,10 @@ public:
 		
 		/** Creates a reference in the specified LuaState for object at the specified StackPos */
 		cRef(cLuaState & a_LuaState, int a_StackPos);
+
+		/** Moves the reference from the specified instance into a newly created instance.
+		The old instance is then "!IsValid()". */
+		cRef(cRef && a_FromRef);
 		
 		~cRef();
 		
@@ -202,6 +208,8 @@ public:
 	void Push(cHopperEntity * a_Hopper);
 	void Push(cItem * a_Item);
 	void Push(cItems * a_Items);
+	void Push(cLuaServerHandle * a_ServerHandle);
+	void Push(cLuaTCPLink * a_TCPLink);
 	void Push(cMonster * a_Monster);
 	void Push(cPickup * a_Pickup);
 	void Push(cPlayer * a_Player);
@@ -240,6 +248,9 @@ public:
 	
 	/** Retrieve value at a_StackPos, if it is a valid cWorld class. If not, a_Value is unchanged */
 	void GetStackValue(int a_StackPos, pWorld & a_Value);
+
+	/** Store the value at a_StackPos as a reference. */
+	void GetStackValue(int a_StackPos, cRef & a_Ref);
 	
 	/** Call the specified Lua function.
 	Returns true if call succeeded, false if there was an error.
diff --git a/src/Bindings/LuaTCPLink.cpp b/src/Bindings/LuaTCPLink.cpp
new file mode 100644
index 000000000..6b8395806
--- /dev/null
+++ b/src/Bindings/LuaTCPLink.cpp
@@ -0,0 +1,304 @@
+
+// LuaTCPLink.cpp
+
+// Implements the cLuaTCPLink class representing a Lua wrapper for the cTCPLink class and the callbacks it needs
+
+#include "Globals.h"
+#include "LuaTCPLink.h"
+#include "LuaServerHandle.h"
+
+
+
+
+
+cLuaTCPLink::cLuaTCPLink(cPluginLua & a_Plugin, int a_CallbacksTableStackPos):
+	m_Plugin(a_Plugin),
+	m_Callbacks(a_Plugin.GetLuaState(), a_CallbacksTableStackPos)
+{
+	// Warn if the callbacks aren't valid:
+	if (!m_Callbacks.IsValid())
+	{
+		LOGWARNING("cTCPLink in plugin %s: callbacks could not be retrieved", m_Plugin.GetName().c_str());
+		cPluginLua::cOperation Op(m_Plugin);
+		Op().LogStackTrace();
+	}
+}
+
+
+
+
+
+cLuaTCPLink::cLuaTCPLink(cPluginLua & a_Plugin, cLuaState::cRef && a_CallbacksTableRef, cLuaServerHandleWPtr a_ServerHandle):
+	m_Plugin(a_Plugin),
+	m_Callbacks(std::move(a_CallbacksTableRef)),
+	m_Server(std::move(a_ServerHandle))
+{
+	// Warn if the callbacks aren't valid:
+	if (!m_Callbacks.IsValid())
+	{
+		LOGWARNING("cTCPLink in plugin %s: callbacks could not be retrieved", m_Plugin.GetName().c_str());
+		cPluginLua::cOperation Op(m_Plugin);
+		Op().LogStackTrace();
+	}
+}
+
+
+
+
+
+cLuaTCPLink::~cLuaTCPLink()
+{
+	// If the link is still open, close it:
+	cTCPLinkPtr Link = m_Link;
+	if (Link != nullptr)
+	{
+		Link->Close();
+	}
+
+	Terminated();
+}
+
+
+
+
+
+bool cLuaTCPLink::Send(const AString & a_Data)
+{
+	// Safely grab a copy of the link:
+	cTCPLinkPtr Link = m_Link;
+	if (Link == nullptr)
+	{
+		return false;
+	}
+
+	// Send the data:
+	return Link->Send(a_Data);
+}
+
+
+
+
+
+AString cLuaTCPLink::GetLocalIP(void) const
+{
+	// Safely grab a copy of the link:
+	cTCPLinkPtr Link = m_Link;
+	if (Link == nullptr)
+	{
+		return "";
+	}
+
+	// Get the IP address:
+	return Link->GetLocalIP();
+}
+
+
+
+
+
+UInt16 cLuaTCPLink::GetLocalPort(void) const
+{
+	// Safely grab a copy of the link:
+	cTCPLinkPtr Link = m_Link;
+	if (Link == nullptr)
+	{
+		return 0;
+	}
+
+	// Get the port:
+	return Link->GetLocalPort();
+}
+
+
+
+
+
+AString cLuaTCPLink::GetRemoteIP(void) const
+{
+	// Safely grab a copy of the link:
+	cTCPLinkPtr Link = m_Link;
+	if (Link == nullptr)
+	{
+		return "";
+	}
+
+	// Get the IP address:
+	return Link->GetRemoteIP();
+}
+
+
+
+
+
+UInt16 cLuaTCPLink::GetRemotePort(void) const
+{
+	// Safely grab a copy of the link:
+	cTCPLinkPtr Link = m_Link;
+	if (Link == nullptr)
+	{
+		return 0;
+	}
+
+	// Get the port:
+	return Link->GetRemotePort();
+}
+
+
+
+
+
+void cLuaTCPLink::Shutdown(void)
+{
+	// Safely grab a copy of the link and shut it down:
+	cTCPLinkPtr Link = m_Link;
+	if (Link != nullptr)
+	{
+		Link->Shutdown();
+	}
+
+	Terminated();
+}
+
+
+
+
+
+void cLuaTCPLink::Close(void)
+{
+	// If the link is still open, close it:
+	cTCPLinkPtr Link = m_Link;
+	if (Link != nullptr)
+	{
+		Link->Close();
+	}
+
+	Terminated();
+}
+
+
+
+
+
+void cLuaTCPLink::Terminated(void)
+{
+	// Disable the callbacks:
+	if (m_Callbacks.IsValid())
+	{
+		m_Callbacks.UnRef();
+	}
+
+	// If the managing server is still alive, let it know we're terminating:
+	auto Server = m_Server.lock();
+	if (Server != nullptr)
+	{
+		Server->RemoveLink(this);
+	}
+
+	// If the link is still open, close it:
+	cTCPLinkPtr Link = m_Link;
+	if (Link != nullptr)
+	{
+		Link->Close();
+		m_Link.reset();
+	}
+}
+
+
+
+
+
+void cLuaTCPLink::OnConnected(cTCPLink & a_Link)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnConnected"), this))
+	{
+		LOGINFO("cTCPLink OnConnected() callback failed in plugin %s.", m_Plugin.GetName().c_str());
+	}
+}
+
+
+
+
+
+void cLuaTCPLink::OnError(int a_ErrorCode, const AString & a_ErrorMsg)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnError"), this, a_ErrorCode, a_ErrorMsg))
+	{
+		LOGINFO("cTCPLink OnError() callback failed in plugin %s; the link error is %d (%s).",
+			m_Plugin.GetName().c_str(), a_ErrorCode, a_ErrorMsg.c_str()
+		);
+	}
+
+	Terminated();
+}
+
+
+
+
+
+void cLuaTCPLink::OnLinkCreated(cTCPLinkPtr a_Link)
+{
+	// Store the cTCPLink for later use:
+	m_Link = a_Link;
+}
+
+
+
+
+
+void cLuaTCPLink::OnReceivedData(const char * a_Data, size_t a_Length)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnReceivedData"), this, AString(a_Data, a_Length)))
+	{
+		LOGINFO("cTCPLink OnReceivedData callback failed in plugin %s.", m_Plugin.GetName().c_str());
+	}
+}
+
+
+
+
+
+void cLuaTCPLink::OnRemoteClosed(void)
+{
+	// Check if we're still valid:
+	if (!m_Callbacks.IsValid())
+	{
+		return;
+	}
+
+	// Call the callback:
+	cPluginLua::cOperation Op(m_Plugin);
+	if (!Op().Call(cLuaState::cTableRef(m_Callbacks, "OnRemoteClosed"), this))
+	{
+		LOGINFO("cTCPLink OnRemoteClosed() callback failed in plugin %s.", m_Plugin.GetName().c_str());
+	}
+
+	Terminated();
+}
+
+
+
+
diff --git a/src/Bindings/LuaTCPLink.h b/src/Bindings/LuaTCPLink.h
new file mode 100644
index 000000000..f2af911ec
--- /dev/null
+++ b/src/Bindings/LuaTCPLink.h
@@ -0,0 +1,97 @@
+
+// LuaTCPLink.h
+
+// Declares the cLuaTCPLink class representing a Lua wrapper for the cTCPLink class and the callbacks it needs
+
+
+
+
+
+#pragma once
+
+#include "../OSSupport/Network.h"
+#include "PluginLua.h"
+
+
+
+
+
+// fwd:
+class cLuaServerHandle;
+typedef WeakPtr<cLuaServerHandle> cLuaServerHandleWPtr;
+
+
+
+
+
+class cLuaTCPLink:
+	public cNetwork::cConnectCallbacks,
+	public cTCPLink::cCallbacks
+{
+public:
+	/** Creates a new instance of the link, attached to the specified plugin and wrapping the callbacks that are in a table at the specified stack pos. */
+	cLuaTCPLink(cPluginLua & a_Plugin, int a_CallbacksTableStackPos);
+
+	/** Creates a new instance of the link, attached to the specified plugin and wrapping the callbacks that are in the specified referenced table. */
+	cLuaTCPLink(cPluginLua & a_Plugin, cLuaState::cRef && a_CallbacksTableRef, cLuaServerHandleWPtr a_Server);
+
+	~cLuaTCPLink();
+
+	/** Sends the data contained in the string to the remote peer.
+	Returns true if successful, false on immediate failure (queueing the data failed or link not available). */
+	bool Send(const AString & a_Data);
+
+	/** Returns the IP address of the local endpoint of the connection. */
+	AString GetLocalIP(void) const;
+
+	/** Returns the port used by the local endpoint of the connection. */
+	UInt16 GetLocalPort(void) const;
+
+	/** Returns the IP address of the remote endpoint of the connection. */
+	AString GetRemoteIP(void) const;
+
+	/** Returns the port used by the remote endpoint of the connection. */
+	UInt16 GetRemotePort(void) const;
+
+	/** Closes the link gracefully.
+	The link will send any queued outgoing data, then it will send the FIN packet.
+	The link will still receive incoming data from remote until the remote closes the connection. */
+	void Shutdown(void);
+
+	/** Drops the connection without any more processing.
+	Sends the RST packet, queued outgoing and incoming data is lost. */
+	void Close(void);
+
+protected:
+	/** The plugin for which the link is created. */
+	cPluginLua & m_Plugin;
+
+	/** The Lua table that holds the callbacks to be invoked. */
+	cLuaState::cRef m_Callbacks;
+
+	/** The underlying link representing the connection.
+	May be nullptr. */
+	cTCPLinkPtr m_Link;
+
+	/** The server that is responsible for this link, if any. */
+	cLuaServerHandleWPtr m_Server;
+
+
+	/** Common code called when the link is considered as terminated.
+	Releases m_Link, m_Callbacks and this from m_Server, each when applicable. */
+	void Terminated(void);
+
+	// cNetwork::cConnectCallbacks overrides:
+	virtual void OnConnected(cTCPLink & a_Link) override;
+	virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) override;
+
+	// cTCPLink::cCallbacks overrides:
+	virtual void OnLinkCreated(cTCPLinkPtr a_Link) override;
+	virtual void OnReceivedData(const char * a_Data, size_t a_Length) override;
+	virtual void OnRemoteClosed(void) override;
+	// The OnError() callback is shared with cNetwork::cConnectCallbacks
+};
+
+
+
+
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index 56f2e73bc..24e3f0052 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -256,7 +256,7 @@ static int tolua_Base64Decode(lua_State * tolua_S)
 
 
 
-static cPluginLua * GetLuaPlugin(lua_State * L)
+cPluginLua * GetLuaPlugin(lua_State * L)
 {
 	// Get the plugin identification out of LuaState:
 	lua_getglobal(L, LUA_PLUGIN_INSTANCE_VAR_NAME);
@@ -3556,6 +3556,7 @@ void ManualBindings::Bind(lua_State * tolua_S)
 		tolua_function(tolua_S, "md5", tolua_md5);
 		
 		BindRankManager(tolua_S);
+		BindNetwork(tolua_S);
 
 	tolua_endmodule(tolua_S);
 }
diff --git a/src/Bindings/ManualBindings.h b/src/Bindings/ManualBindings.h
index 1b6e65654..74d24d5f5 100644
--- a/src/Bindings/ManualBindings.h
+++ b/src/Bindings/ManualBindings.h
@@ -1,6 +1,7 @@
 #pragma once
 
 struct lua_State;
+class cPluginLua;
 
 
 
@@ -17,8 +18,17 @@ protected:
 	/** Binds the manually implemented cRankManager glue code to tolua_S.
 	Implemented in ManualBindings_RankManager.cpp. */
 	static void BindRankManager(lua_State * tolua_S);
+
+	/** Binds the manually implemented cNetwork-related API to tolua_S.
+	Implemented in ManualBindings_Network.cpp. */
+	static void BindNetwork(lua_State * tolua_S);
 };
 
 
 
 
+extern cPluginLua * GetLuaPlugin(lua_State * L);
+
+
+
+
diff --git a/src/Bindings/ManualBindings_Network.cpp b/src/Bindings/ManualBindings_Network.cpp
new file mode 100644
index 000000000..902f687c8
--- /dev/null
+++ b/src/Bindings/ManualBindings_Network.cpp
@@ -0,0 +1,513 @@
+
+// ManualBindings_Network.cpp
+
+// Implements the cNetwork-related API bindings for Lua
+
+#include "Globals.h"
+#include "LuaTCPLink.h"
+#include "ManualBindings.h"
+#include "tolua++/include/tolua++.h"
+#include "LuaState.h"
+#include "LuaTCPLink.h"
+#include "LuaNameLookup.h"
+#include "LuaServerHandle.h"
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cNetwork API functions:
+
+/** Binds cNetwork::Connect */
+static int tolua_cNetwork_Connect(lua_State * L)
+{
+	// Function signature:
+	// cNetwork:Connect(Host, Port, Callbacks) -> bool
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserTable(1, "cNetwork") ||
+		!S.CheckParamString(2) ||
+		!S.CheckParamNumber(3) ||
+		!S.CheckParamTable(4) ||
+		!S.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the plugin instance:
+	cPluginLua * Plugin = GetLuaPlugin(L);
+	if (Plugin == nullptr)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		S.Push(false);
+		return 1;
+	}
+
+	// Read the params:
+	AString Host;
+	int Port;
+	S.GetStackValues(2, Host, Port);
+
+	// Check validity:
+	if ((Port < 0) || (Port > 65535))
+	{
+		LOGWARNING("cNetwork:Connect() called with invalid port (%d), failing the request.", Port);
+		S.Push(false);
+		return 1;
+	}
+
+	// Create the LuaTCPLink glue class:
+	auto Link = std::make_shared<cLuaTCPLink>(*Plugin, 4);
+
+	// Try to connect:
+	bool res = cNetwork::Connect(Host, static_cast<UInt16>(Port), Link, Link);
+	S.Push(res);
+
+	return 1;
+}
+
+
+
+
+
+/** Binds cNetwork::HostnameToIP */
+static int tolua_cNetwork_HostnameToIP(lua_State * L)
+{
+	// Function signature:
+	// cNetwork:HostnameToIP(Host, Callbacks) -> bool
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserTable(1, "cNetwork") ||
+		!S.CheckParamString(2) ||
+		!S.CheckParamTable(3) ||
+		!S.CheckParamEnd(4)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the plugin instance:
+	cPluginLua * Plugin = GetLuaPlugin(L);
+	if (Plugin == nullptr)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		S.Push(false);
+		return 1;
+	}
+
+	// Read the params:
+	AString Host;
+	S.GetStackValue(2, Host);
+
+	// Try to look up:
+	bool res = cNetwork::HostnameToIP(Host, std::make_shared<cLuaNameLookup>(Host, *Plugin, 3));
+	S.Push(res);
+
+	return 1;
+}
+
+
+
+
+
+/** Binds cNetwork::IPToHostname */
+static int tolua_cNetwork_IPToHostname(lua_State * L)
+{
+	// Function signature:
+	// cNetwork:IPToHostname(IP, Callbacks) -> bool
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserTable(1, "cNetwork") ||
+		!S.CheckParamString(2) ||
+		!S.CheckParamTable(3) ||
+		!S.CheckParamEnd(4)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the plugin instance:
+	cPluginLua * Plugin = GetLuaPlugin(L);
+	if (Plugin == nullptr)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		S.Push(false);
+		return 1;
+	}
+
+	// Read the params:
+	AString Host;
+	S.GetStackValue(2, Host);
+
+	// Try to look up:
+	bool res = cNetwork::IPToHostName(Host, std::make_shared<cLuaNameLookup>(Host, *Plugin, 3));
+	S.Push(res);
+
+	return 1;
+}
+
+
+
+
+
+/** Binds cNetwork::Listen */
+static int tolua_cNetwork_Listen(lua_State * L)
+{
+	// Function signature:
+	// cNetwork:Listen(Port, Callbacks) -> bool
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserTable(1, "cNetwork") ||
+		!S.CheckParamNumber(2) ||
+		!S.CheckParamTable(3) ||
+		!S.CheckParamEnd(4)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the plugin instance:
+	cPluginLua * Plugin = GetLuaPlugin(L);
+	if (Plugin == nullptr)
+	{
+		// An error message has been already printed in GetLuaPlugin()
+		S.Push(false);
+		return 1;
+	}
+
+	// Read the params:
+	int Port;
+	S.GetStackValues(2, Port);
+	if ((Port < 0) || (Port > 65535))
+	{
+		LOGWARNING("cNetwork:Listen() called with invalid port (%d), failing the request.", Port);
+		S.Push(false);
+		return 1;
+	}
+	UInt16 Port16 = static_cast<UInt16>(Port);
+
+	// Create the LuaTCPLink glue class:
+	auto Srv = std::make_shared<cLuaServerHandle>(Port16, *Plugin, 3);
+
+	// Listen:
+	Srv->SetServerHandle(cNetwork::Listen(Port16, Srv), Srv);
+
+	// Register the server to be garbage-collected by Lua:
+	tolua_pushusertype(L, Srv.get(), "cServerHandle");
+	tolua_register_gc(L, lua_gettop(L));
+
+	// Return the server handle wrapper:
+	S.Push(Srv.get());
+	return 1;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cTCPLink bindings (routed through cLuaTCPLink):
+
+/** Binds cLuaTCPLink::Send */
+static int tolua_cTCPLink_Send(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:Send(DataString)
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamString(2) ||
+		!S.CheckParamEnd(3)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:Send(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Get the data to send:
+	AString Data;
+	S.GetStackValues(2, Data);
+
+	// Send the data:
+	Link->Send(Data);
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaTCPLink::GetLocalIP */
+static int tolua_cTCPLink_GetLocalIP(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:GetLocalIP() -> string
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:GetLocalIP(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Get the IP:
+	S.Push(Link->GetLocalIP());
+	return 1;
+}
+
+
+
+
+
+/** Binds cLuaTCPLink::GetLocalPort */
+static int tolua_cTCPLink_GetLocalPort(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:GetLocalPort() -> number
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:GetLocalPort(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Get the Port:
+	S.Push(Link->GetLocalPort());
+	return 1;
+}
+
+
+
+
+
+/** Binds cLuaTCPLink::GetRemoteIP */
+static int tolua_cTCPLink_GetRemoteIP(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:GetRemoteIP() -> string
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:GetRemoteIP(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Get the IP:
+	S.Push(Link->GetRemoteIP());
+	return 1;
+}
+
+
+
+
+
+/** Binds cLuaTCPLink::GetRemotePort */
+static int tolua_cTCPLink_GetRemotePort(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:GetRemotePort() -> number
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:GetRemotePort(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Get the Port:
+	S.Push(Link->GetRemotePort());
+	return 1;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cServerHandle bindings (routed through cLuaServerHandle):
+
+/** Called when Lua destroys the object instance.
+Close the server and let it deallocate on its own (it's in a SharedPtr). */
+static int tolua_collect_cServerHandle(lua_State * L)
+{
+	cLuaServerHandle * Srv = static_cast<cLuaServerHandle *>(tolua_tousertype(L, 1, nullptr));
+	Srv->Release();
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaServerHandle::Close */
+static int tolua_cServerHandle_Close(lua_State * L)
+{
+	// Function signature:
+	// ServerInstance:Close()
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cServerHandle") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the server handle:
+	cLuaServerHandle * Srv;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cServerHandle:Close(): invalid server handle object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Srv = *static_cast<cLuaServerHandle **>(lua_touserdata(L, 1));
+
+	// Close it:
+	Srv->Close();
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaServerHandle::IsListening */
+static int tolua_cServerHandle_IsListening(lua_State * L)
+{
+	// Function signature:
+	// ServerInstance:IsListening() -> bool
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cServerHandle") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the server handle:
+	cLuaServerHandle * Srv;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cServerHandle:IsListening(): invalid server handle object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Srv = *static_cast<cLuaServerHandle **>(lua_touserdata(L, 1));
+
+	// Close it:
+	S.Push(Srv->IsListening());
+	return 1;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Register the bindings:
+
+void ManualBindings::BindNetwork(lua_State * tolua_S)
+{
+	// Create the cNetwork API classes:
+	tolua_usertype(tolua_S, "cNetwork");
+	tolua_cclass(tolua_S, "cNetwork", "cNetwork", "", nullptr);
+	tolua_usertype(tolua_S, "cTCPLink");
+	tolua_cclass(tolua_S, "cTCPLink", "cTCPLink", "", nullptr);
+	tolua_usertype(tolua_S, "cServerHandle");
+	tolua_cclass(tolua_S, "cServerHandle", "cServerHandle", "", tolua_collect_cServerHandle);
+	
+	// Fill in the functions (alpha-sorted):
+	tolua_beginmodule(tolua_S, "cNetwork");
+		tolua_function(tolua_S, "Connect",      tolua_cNetwork_Connect);
+		tolua_function(tolua_S, "HostnameToIP", tolua_cNetwork_HostnameToIP);
+		tolua_function(tolua_S, "IPToHostname", tolua_cNetwork_IPToHostname);
+		tolua_function(tolua_S, "Listen",       tolua_cNetwork_Listen);
+	tolua_endmodule(tolua_S);
+
+	tolua_beginmodule(tolua_S, "cTCPLink");
+		tolua_function(tolua_S, "Send",          tolua_cTCPLink_Send);
+		tolua_function(tolua_S, "GetLocalIP",    tolua_cTCPLink_GetLocalIP);
+		tolua_function(tolua_S, "GetLocalPort",  tolua_cTCPLink_GetLocalPort);
+		tolua_function(tolua_S, "GetRemoteIP",   tolua_cTCPLink_GetRemoteIP);
+		tolua_function(tolua_S, "GetRemotePort", tolua_cTCPLink_GetRemotePort);
+	tolua_endmodule(tolua_S);
+
+	tolua_beginmodule(tolua_S, "cServerHandle");
+		tolua_function(tolua_S, "Close",       tolua_cServerHandle_Close);
+		tolua_function(tolua_S, "IsListening", tolua_cServerHandle_IsListening);
+	tolua_endmodule(tolua_S);
+}
+
+
+
+
diff --git a/src/Globals.h b/src/Globals.h
index 654ede95f..29eaac871 100644
--- a/src/Globals.h
+++ b/src/Globals.h
@@ -381,6 +381,7 @@ void inline LOG(const char * a_Format, ...)
 
 // Unified shared ptr from before C++11. Also no silly undercores.
 #define SharedPtr std::shared_ptr
+#define WeakPtr std::weak_ptr
 
 
 
diff --git a/src/OSSupport/Network.h b/src/OSSupport/Network.h
index cdf6ba0e9..e883dfb29 100644
--- a/src/OSSupport/Network.h
+++ b/src/OSSupport/Network.h
@@ -90,6 +90,9 @@ public:
 	Sends the RST packet, queued outgoing and incoming data is lost. */
 	virtual void Close(void) = 0;
 
+	/** Returns the callbacks that are used. */
+	cCallbacksPtr GetCallbacks(void) const { return m_Callbacks; }
+
 protected:
 	/** Callbacks to be used for the various situations. */
 	cCallbacksPtr m_Callbacks;
diff --git a/src/OSSupport/TCPLinkImpl.cpp b/src/OSSupport/TCPLinkImpl.cpp
index f97db7582..88fb57838 100644
--- a/src/OSSupport/TCPLinkImpl.cpp
+++ b/src/OSSupport/TCPLinkImpl.cpp
@@ -221,6 +221,8 @@ void cTCPLinkImpl::EventCallback(bufferevent * a_BufferEvent, short a_What, void
 	// Pending connection succeeded, call the connection callback:
 	if (a_What & BEV_EVENT_CONNECTED)
 	{
+		Self->UpdateLocalAddress();
+		Self->UpdateRemoteAddress();
 		if (Self->m_ConnectCallbacks != nullptr)
 		{
 			Self->m_ConnectCallbacks->OnConnected(*Self);
@@ -228,8 +230,6 @@ void cTCPLinkImpl::EventCallback(bufferevent * a_BufferEvent, short a_What, void
 			Self->m_ConnectCallbacks.reset();
 			return;
 		}
-		Self->UpdateLocalAddress();
-		Self->UpdateRemoteAddress();
 	}
 
 	// If the connection has been closed, call the link callback and remove the connection:
diff --git a/tests/Network/EchoServer.cpp b/tests/Network/EchoServer.cpp
index 5f4b7651d..49fb89122 100644
--- a/tests/Network/EchoServer.cpp
+++ b/tests/Network/EchoServer.cpp
@@ -119,6 +119,7 @@ void DoTest(void)
 	LOG("Server terminating.");
 	Server->Close();
 	ASSERT(!Server->IsListening());
+	Server.reset();
 	LOGD("Server has been closed.");
 }