1 files changed, 297 insertions, 31 deletions

diff --git a/src/Bindings/ManualBindings_Network.cpp b/src/Bindings/ManualBindings_Network.cpp
index 30a34815c..a628eb9ca 100644
--- a/src/Bindings/ManualBindings_Network.cpp
+++ b/src/Bindings/ManualBindings_Network.cpp
@@ -11,6 +11,7 @@
 #include "LuaTCPLink.h"
 #include "LuaNameLookup.h"
 #include "LuaServerHandle.h"
+#include "LuaUDPEndpoint.h"
 
 
 
@@ -73,6 +74,61 @@ static int tolua_cNetwork_Connect(lua_State * L)
 
 
 
+/** 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)
 {
@@ -159,7 +215,7 @@ static int tolua_cNetwork_IPToHostname(lua_State * L)
 static int tolua_cNetwork_Listen(lua_State * L)
 {
 	// Function signature:
-	// cNetwork:Listen(Port, Callbacks) -> bool
+	// cNetwork:Listen(Port, Callbacks) -> cServerHandle
 
 	cLuaState S(L);
 	if (
@@ -212,6 +268,90 @@ static int tolua_cNetwork_Listen(lua_State * L)
 
 
 ////////////////////////////////////////////////////////////////////////////////
+// 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 */
@@ -549,14 +689,15 @@ static int tolua_cTCPLink_StartTLSServer(lua_State * L)
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// cServerHandle bindings (routed through cLuaServerHandle):
+// cUDPEndpoint bindings (routed through cLuaUDPEndpoint):
 
 /** 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)
+Close the endpoint and let it deallocate on its own (it's in a SharedPtr). */
+static int tolua_collect_cUDPEndpoint(lua_State * L)
 {
-	cLuaServerHandle * Srv = static_cast<cLuaServerHandle *>(tolua_tousertype(L, 1, nullptr));
-	Srv->Release();
+	LOGD("Lua: Collecting cUDPEndpoint");
+	cLuaUDPEndpoint * Endpoint = static_cast<cLuaUDPEndpoint *>(tolua_tousertype(L, 1, nullptr));
+	Endpoint->Release();
 	return 0;
 }
 
@@ -564,33 +705,32 @@ static int tolua_collect_cServerHandle(lua_State * L)
 
 
 
-/** Binds cLuaServerHandle::Close */
-static int tolua_cServerHandle_Close(lua_State * L)
+/** Binds cLuaUDPEndpoint::Close */
+static int tolua_cUDPEndpoint_Close(lua_State * L)
 {
 	// Function signature:
-	// ServerInstance:Close()
+	// EndpointInstance:Close()
 
 	cLuaState S(L);
 	if (
-		!S.CheckParamUserType(1, "cServerHandle") ||
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
 		!S.CheckParamEnd(2)
 	)
 	{
 		return 0;
 	}
 	
-	// Get the server handle:
-	cLuaServerHandle * Srv;
+	// Get the endpoint:
 	if (lua_isnil(L, 1))
 	{
-		LOGWARNING("cServerHandle:Close(): invalid server handle object. Stack trace:");
+		LOGWARNING("cUDPEndpoint:Close(): invalid endpoint object. Stack trace:");
 		S.LogStackTrace();
 		return 0;
 	}
-	Srv = *static_cast<cLuaServerHandle **>(lua_touserdata(L, 1));
+	auto Endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
 
 	// Close it:
-	Srv->Close();
+	Endpoint->Close();
 	return 0;
 }
 
@@ -598,33 +738,147 @@ static int tolua_cServerHandle_Close(lua_State * L)
 
 
 
-/** Binds cLuaServerHandle::IsListening */
-static int tolua_cServerHandle_IsListening(lua_State * L)
+/** Binds cLuaUDPEndpoint::EnableBroadcasts */
+static int tolua_cUDPEndpoint_EnableBroadcasts(lua_State * L)
 {
 	// Function signature:
-	// ServerInstance:IsListening() -> bool
+	// EndpointInstance:EnableBroadcasts()
 
 	cLuaState S(L);
 	if (
-		!S.CheckParamUserType(1, "cServerHandle") ||
+		!S.CheckParamUserType(1, "cUDPEndpoint") ||
 		!S.CheckParamEnd(2)
 	)
 	{
 		return 0;
 	}
 	
-	// Get the server handle:
-	cLuaServerHandle * Srv;
+	// Get the endpoint:
 	if (lua_isnil(L, 1))
 	{
-		LOGWARNING("cServerHandle:IsListening(): invalid server handle object. Stack trace:");
+		LOGWARNING("cUDPEndpoint:EnableBroadcasts(): invalid endpoint object. Stack trace:");
 		S.LogStackTrace();
 		return 0;
 	}
-	Srv = *static_cast<cLuaServerHandle **>(lua_touserdata(L, 1));
+	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(Srv->IsListening());
+	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;
 }
 
@@ -644,13 +898,21 @@ void ManualBindings::BindNetwork(lua_State * tolua_S)
 	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, "HostnameToIP", tolua_cNetwork_HostnameToIP);
-		tolua_function(tolua_S, "IPToHostname", tolua_cNetwork_IPToHostname);
-		tolua_function(tolua_S, "Listen",       tolua_cNetwork_Listen);
+		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");
@@ -665,10 +927,14 @@ void ManualBindings::BindNetwork(lua_State * tolua_S)
 		tolua_function(tolua_S, "StartTLSServer", tolua_cTCPLink_StartTLSServer);
 	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_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);
+
 }