1 files changed, 942 insertions, 0 deletions

diff --git a/src/Bindings/ManualBindings_Network.cpp b/src/Bindings/ManualBindings_Network.cpp
new file mode 100644
index 000000000..a628eb9ca
--- /dev/null
+++ b/src/Bindings/ManualBindings_Network.cpp
@@ -0,0 +1,942 @@
+
+// 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"
+#include "LuaUDPEndpoint.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::CreateUDPEndpoint */
+static int tolua_cNetwork_CreateUDPEndpoint(lua_State * L)
+{
+	// Function signature:
+	// cNetwork:CreateUDPEndpoint(Port, Callbacks) -> cUDPEndpoint
+
+	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);
+
+	// Check validity:
+	if ((Port < 0) || (Port > 65535))
+	{
+		LOGWARNING("cNetwork:CreateUDPEndpoint() called with invalid port (%d), failing the request.", Port);
+		S.Push(false);
+		return 1;
+	}
+
+	// Create the LuaUDPEndpoint glue class:
+	auto Endpoint = std::make_shared<cLuaUDPEndpoint>(*Plugin, 3);
+	Endpoint->Open(Port, Endpoint);
+
+	// Register the endpoint to be garbage-collected by Lua:
+	tolua_pushusertype(L, Endpoint.get(), "cUDPEndpoint");
+	tolua_register_gc(L, lua_gettop(L));
+
+	// Return the endpoint object:
+	S.Push(Endpoint.get());
+	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) -> cServerHandle
+
+	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;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// 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;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cTCPLink bindings (routed through cLuaTCPLink):
+
+/** Binds cLuaTCPLink::Close */
+static int tolua_cTCPLink_Close(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:Close()
+
+	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:Close(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// CLose the link:
+	Link->Close();
+	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;
+}
+
+
+
+
+
+/** 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::Shutdown */
+static int tolua_cTCPLink_Shutdown(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:Shutdown()
+
+	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:Shutdown(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Shutdown the link:
+	Link->Shutdown();
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaTCPLink::StartTLSClient */
+static int tolua_cTCPLink_StartTLSClient(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:StartTLSClient(OwnCert, OwnPrivKey, OwnPrivKeyPassword) -> [true] or [nil, ErrMsg]
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamString(2, 4) ||
+		!S.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:StartTLSClient(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Read the params:
+	AString OwnCert, OwnPrivKey, OwnPrivKeyPassword;
+	S.GetStackValues(2, OwnCert, OwnPrivKey, OwnPrivKeyPassword);
+
+	// Start the TLS handshake:
+	AString res = Link->StartTLSClient(OwnCert, OwnPrivKey, OwnPrivKeyPassword);
+	if (!res.empty())
+	{
+		S.PushNil();
+		S.Push(Printf("Cannot start TLS on link to %s:%d: %s", Link->GetRemoteIP().c_str(), Link->GetRemotePort(), res.c_str()));
+		return 2;
+	}
+	return 1;
+}
+
+
+
+
+
+/** Binds cLuaTCPLink::StartTLSServer */
+static int tolua_cTCPLink_StartTLSServer(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:StartTLSServer(OwnCert, OwnPrivKey, OwnPrivKeyPassword, StartTLSData) -> [true] or [nil, ErrMsg]
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cTCPLink") ||
+		!S.CheckParamString(2, 4) ||
+		// Param 5 is optional, don't check
+		!S.CheckParamEnd(6)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	cLuaTCPLink * Link;
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cTCPLink:StartTLSServer(): invalid link object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
+
+	// Read the params:
+	AString OwnCert, OwnPrivKey, OwnPrivKeyPassword, StartTLSData;
+	S.GetStackValues(2, OwnCert, OwnPrivKey, OwnPrivKeyPassword, StartTLSData);
+
+	// Start the TLS handshake:
+	AString res = Link->StartTLSServer(OwnCert, OwnPrivKey, OwnPrivKeyPassword, StartTLSData);
+	if (!res.empty())
+	{
+		S.PushNil();
+		S.Push(Printf("Cannot start TLS on link to %s:%d: %s", Link->GetRemoteIP().c_str(), Link->GetRemotePort(), res.c_str()));
+		return 2;
+	}
+	return 1;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cUDPEndpoint bindings (routed through cLuaUDPEndpoint):
+
+/** Called when Lua destroys the object instance.
+Close the endpoint and let it deallocate on its own (it's in a SharedPtr). */
+static int tolua_collect_cUDPEndpoint(lua_State * L)
+{
+	LOGD("Lua: Collecting cUDPEndpoint");
+	cLuaUDPEndpoint * Endpoint = static_cast<cLuaUDPEndpoint *>(tolua_tousertype(L, 1, nullptr));
+	Endpoint->Release();
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaUDPEndpoint::Close */
+static int tolua_cUDPEndpoint_Close(lua_State * L)
+{
+	// Function signature:
+	// EndpointInstance:Close()
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the endpoint:
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cUDPEndpoint:Close(): invalid endpoint object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	auto Endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
+
+	// Close it:
+	Endpoint->Close();
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaUDPEndpoint::EnableBroadcasts */
+static int tolua_cUDPEndpoint_EnableBroadcasts(lua_State * L)
+{
+	// Function signature:
+	// EndpointInstance:EnableBroadcasts()
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the endpoint:
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cUDPEndpoint:EnableBroadcasts(): invalid endpoint object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	auto Endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
+
+	// Enable the broadcasts:
+	Endpoint->EnableBroadcasts();
+	return 0;
+}
+
+
+
+
+
+/** Binds cLuaUDPEndpoint::GetPort */
+static int tolua_cUDPEndpoint_GetPort(lua_State * L)
+{
+	// Function signature:
+	// Endpoint:GetPort() -> number
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the endpoint:
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cUDPEndpoint:GetPort(): invalid endpoint object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	auto Endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
+
+	// Get the Port:
+	S.Push(Endpoint->GetPort());
+	return 1;
+}
+
+
+
+
+
+/** Binds cLuaUDPEndpoint::IsOpen */
+static int tolua_cUDPEndpoint_IsOpen(lua_State * L)
+{
+	// Function signature:
+	// Endpoint:IsOpen() -> bool
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
+		!S.CheckParamEnd(2)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the endpoint:
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cUDPEndpoint:IsListening(): invalid server handle object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	auto Endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
+
+	// Close it:
+	S.Push(Endpoint->IsOpen());
+	return 1;
+}
+
+
+
+
+
+/** Binds cLuaUDPEndpoint::Send */
+static int tolua_cUDPEndpoint_Send(lua_State * L)
+{
+	// Function signature:
+	// LinkInstance:Send(DataString)
+
+	cLuaState S(L);
+	if (
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
+		!S.CheckParamString(2, 3) ||
+		!S.CheckParamNumber(4) ||
+		!S.CheckParamEnd(5)
+	)
+	{
+		return 0;
+	}
+	
+	// Get the link:
+	if (lua_isnil(L, 1))
+	{
+		LOGWARNING("cUDPEndpoint:Send(): invalid endpoint object. Stack trace:");
+		S.LogStackTrace();
+		return 0;
+	}
+	auto Endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
+
+	// Get the data to send:
+	AString Data, RemotePeer;
+	int RemotePort;
+	S.GetStackValues(2, Data, RemotePeer, RemotePort);
+
+	// Check the port:
+	if ((RemotePort < 0) || (RemotePort > USHRT_MAX))
+	{
+		LOGWARNING("cUDPEndpoint:Send() called with invalid port (%d), failing.", RemotePort);
+		S.LogStackTrace();
+		S.Push(false);
+		return 1;
+	}
+
+	// Send the data:
+	S.Push(Endpoint->Send(Data, RemotePeer, static_cast<UInt16>(RemotePort)));
+	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);
+	tolua_usertype(tolua_S, "cUDPEndpoint");
+	tolua_cclass(tolua_S, "cUDPEndpoint", "cUDPEndpoint", "", tolua_collect_cUDPEndpoint);
+	
+	// Fill in the functions (alpha-sorted):
+	tolua_beginmodule(tolua_S, "cNetwork");
+		tolua_function(tolua_S, "Connect",           tolua_cNetwork_Connect);
+		tolua_function(tolua_S, "CreateUDPEndpoint", tolua_cNetwork_CreateUDPEndpoint);
+		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, "cServerHandle");
+		tolua_function(tolua_S, "Close",       tolua_cServerHandle_Close);
+		tolua_function(tolua_S, "IsListening", tolua_cServerHandle_IsListening);
+	tolua_endmodule(tolua_S);
+
+	tolua_beginmodule(tolua_S, "cTCPLink");
+		tolua_function(tolua_S, "Close",          tolua_cTCPLink_Close);
+		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_function(tolua_S, "Send",           tolua_cTCPLink_Send);
+		tolua_function(tolua_S, "Shutdown",       tolua_cTCPLink_Shutdown);
+		tolua_function(tolua_S, "StartTLSClient", tolua_cTCPLink_StartTLSClient);
+		tolua_function(tolua_S, "StartTLSServer", tolua_cTCPLink_StartTLSServer);
+	tolua_endmodule(tolua_S);
+
+	tolua_beginmodule(tolua_S, "cUDPEndpoint");
+		tolua_function(tolua_S, "Close",            tolua_cUDPEndpoint_Close);
+		tolua_function(tolua_S, "EnableBroadcasts", tolua_cUDPEndpoint_EnableBroadcasts);
+		tolua_function(tolua_S, "GetPort",          tolua_cUDPEndpoint_GetPort);
+		tolua_function(tolua_S, "IsOpen",           tolua_cUDPEndpoint_IsOpen);
+		tolua_function(tolua_S, "Send",             tolua_cUDPEndpoint_Send);
+	tolua_endmodule(tolua_S);
+
+}
+
+
+
+