path: root/src/Bindings/ManualBindings_Network.cpp

// ManualBindings_Network.cpp

// Implements the cNetwork-related API bindings for Lua
// Also implements the cUrlClient bindings

#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"
#include "../HTTP/UrlClient.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.CheckParamStaticSelf("cNetwork") ||
		!S.CheckParamString(2) ||
		!S.CheckParamNumber(3) ||
		!S.CheckParamTable(4) ||
		!S.CheckParamEnd(5)
	)
	{
		return 0;
	}

	// Read the params:
	AString host;
	int port = 0;
	cLuaState::cTableRefPtr callbacks;
	if (!S.GetStackValues(2, host, port, callbacks))
	{
		return S.ApiParamError("Cannot read parameters.");
	}

	// Check validity:
	if ((port < 0) || (port > 65535))
	{
		return S.ApiParamError("Port number out of range (%d, range 0 - 65535)", port);
	}
	ASSERT(callbacks != nullptr);  // Invalid callbacks would have resulted in GetStackValues() returning false

	// Create the LuaTCPLink glue class:
	auto link = std::make_shared<cLuaTCPLink>(std::move(callbacks));

	// 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.CheckParamStaticSelf("cNetwork") ||
		!S.CheckParamNumber(2) ||
		!S.CheckParamTable(3) ||
		!S.CheckParamEnd(4)
	)
	{
		return 0;
	}

	// Read the params:
	int port;
	cLuaState::cTableRefPtr callbacks;
	if (!S.GetStackValues(2, port, callbacks))
	{
		return S.ApiParamError("Cannot read parameters");
	}

	// Check validity:
	if ((port < 0) || (port > 65535))
	{
		return S.ApiParamError("Port number out of range (%d, range 0 - 65535)", port);
	}
	ASSERT(callbacks != nullptr);  // Invalid callbacks would have resulted in GetStackValues() returning false

	// Create the LuaUDPEndpoint glue class:
	auto endpoint = std::make_shared<cLuaUDPEndpoint>(std::move(callbacks));
	endpoint->Open(static_cast<UInt16>(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::EnumLocalIPAddresses */
static int tolua_cNetwork_EnumLocalIPAddresses(lua_State * L)
{
	// Function signature:
	// cNetwork:EnumLocalIPAddresses() -> {string, ...}

	cLuaState S(L);
	if (
		!S.CheckParamStaticSelf("cNetwork") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Push the enumerated addresses:
	S.Push(cNetwork::EnumLocalIPAddresses());
	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.CheckParamStaticSelf("cNetwork") ||
		!S.CheckParamString(2) ||
		!S.CheckParamTable(3) ||
		!S.CheckParamEnd(4)
	)
	{
		return 0;
	}

	// Read the params:
	AString host;
	cLuaState::cTableRefPtr callbacks;
	if (!S.GetStackValues(2, host, callbacks))
	{
		return S.ApiParamError("Cannot read parameters.");
	}
	ASSERT(callbacks != nullptr);  // Invalid callbacks would have resulted in GetStackValues() returning false

	// Try to look up:
	bool res = cNetwork::HostnameToIP(host, std::make_shared<cLuaNameLookup>(host, std::move(callbacks)));
	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.CheckParamStaticSelf("cNetwork") ||
		!S.CheckParamString(2) ||
		!S.CheckParamTable(3) ||
		!S.CheckParamEnd(4)
	)
	{
		return 0;
	}

	// Read the params:
	AString ip;
	cLuaState::cTableRefPtr callbacks;
	if (!S.GetStackValues(2, ip, callbacks))
	{
		return S.ApiParamError("Cannot read parameters.");
	}
	ASSERT(callbacks != nullptr);  // Invalid callbacks would have resulted in GetStackValues() returning false

	// Try to look up:
	bool res = cNetwork::IPToHostName(ip, std::make_shared<cLuaNameLookup>(ip, std::move(callbacks)));
	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.CheckParamStaticSelf("cNetwork") ||
		!S.CheckParamNumber(2) ||
		!S.CheckParamTable(3) ||
		!S.CheckParamEnd(4)
	)
	{
		return 0;
	}

	// Read the params:
	int port = 0;
	cLuaState::cTableRefPtr callbacks;
	if (!S.GetStackValues(2, port, callbacks))
	{
		return S.ApiParamError("Cannot read parameters");
	}

	// Check the validity:
	if ((port < 0) || (port > 65535))
	{
		return S.ApiParamError("Port number out of range (%d, range 0 - 65535)", port);
	}
	auto port16 = static_cast<UInt16>(port);

	// Create the LuaTCPLink glue class:
	auto srv = std::make_shared<cLuaServerHandle>(port16, std::move(callbacks));

	// 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)
{
	auto Srv = static_cast<cLuaServerHandle *>(tolua_tousertype(L, 1, nullptr));
	ASSERT(Srv != 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.CheckParamSelf("cServerHandle") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the server handle:
	auto Srv = *static_cast<cLuaServerHandle **>(lua_touserdata(L, 1));
	ASSERT(Srv != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cServerHandle") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the server handle:
	auto Srv = *static_cast<cLuaServerHandle **>(lua_touserdata(L, 1));
	ASSERT(Srv != nullptr);  // Checked by CheckParamSelf()

	// Query 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamString(2) ||
		!S.CheckParamEnd(3)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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]

	// Get the link:
	cLuaState S(L);
	if (!S.CheckParamSelf("cTCPLink"))
	{
		return 0;
	}
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// Read the (optional) 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.Push(cLuaState::Nil, 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.CheckParamSelf("cTCPLink") ||
		!S.CheckParamString(2, 4) ||
		// Param 5 is optional, don't check
		!S.CheckParamEnd(6)
	)
	{
		return 0;
	}

	// Get the link:
	auto Link = *static_cast<cLuaTCPLink **>(lua_touserdata(L, 1));
	ASSERT(Link != nullptr);  // Checked by CheckParamSelf()

	// 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.Push(cLuaState::Nil, Printf("Cannot start TLS on link to %s:%d: %s", Link->GetRemoteIP().c_str(), Link->GetRemotePort(), res.c_str()));
		return 2;
	}
	S.Push(true);
	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)
{
	auto endpoint = static_cast<cLuaUDPEndpoint *>(tolua_tousertype(L, 1, nullptr));
	ASSERT(endpoint != 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.CheckParamSelf("cUDPEndpoint") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the endpoint:
	auto endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
	ASSERT(endpoint != nullptr);

	// 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.CheckParamSelf("cUDPEndpoint") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the endpoint:
	auto endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
	ASSERT(endpoint != nullptr);

	// 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.CheckParamSelf("cUDPEndpoint") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the endpoint:
	auto endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
	ASSERT(endpoint != nullptr);

	// 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.CheckParamSelf("cUDPEndpoint") ||
		!S.CheckParamEnd(2)
	)
	{
		return 0;
	}

	// Get the endpoint:
	auto endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
	ASSERT(endpoint != nullptr);

	// Close it:
	S.Push(endpoint->IsOpen());
	return 1;
}





/** Binds cLuaUDPEndpoint::Send */
static int tolua_cUDPEndpoint_Send(lua_State * L)
{
	// Function signature:
	// Endpoint:Send(DataString)

	cLuaState S(L);
	if (
		!S.CheckParamSelf("cUDPEndpoint") ||
		!S.CheckParamString(2, 3) ||
		!S.CheckParamNumber(4) ||
		!S.CheckParamEnd(5)
	)
	{
		return 0;
	}

	// Get the link:
	auto endpoint = *static_cast<cLuaUDPEndpoint **>(lua_touserdata(L, 1));
	ASSERT(endpoint != nullptr);

	// Get the data to send:
	AString data, remotePeer;
	int remotePort = 0;
	S.GetStackValues(2, data, remotePeer, remotePort);

	// Check the port:
	if ((remotePort < 0) || (remotePort > USHRT_MAX))
	{
		return S.ApiParamError("Port number out of range (%d, range 0 - 65535)", remotePort);
	}

	// Send the data:
	S.Push(endpoint->Send(data, remotePeer, static_cast<UInt16>(remotePort)));
	return 1;
}





/** Used when the cUrlClient Lua request wants all the callbacks.
Maps each callback onto a Lua function callback in the callback table. */
class cFullUrlClientCallbacks:
	public cUrlClient::cCallbacks
{
public:
	/** Creates a new instance bound to the specified table of callbacks. */
	cFullUrlClientCallbacks(cLuaState::cTableRefPtr && a_Callbacks):
		m_Callbacks(std::move(a_Callbacks))
	{
	}


	// cUrlClient::cCallbacks overrides:
	virtual void OnConnected(cTCPLink & a_Link) override
	{
		// TODO: Cannot push a cTCPLink to Lua, need to translate via cLuaTCPLink
		m_Callbacks->CallTableFnWithSelf("OnConnected", cLuaState::Nil, a_Link.GetRemoteIP(), a_Link.GetRemotePort());
	}


	virtual bool OnCertificateReceived() override
	{
		// TODO: The received cert needs proper type specification from the underlying cUrlClient framework and in the Lua engine as well
		bool res = true;
		m_Callbacks->CallTableFnWithSelf("OnCertificateReceived", cLuaState::Return, res);
		return res;
	}


	virtual void OnTlsHandshakeCompleted() override
	{
		m_Callbacks->CallTableFnWithSelf("OnTlsHandshakeCompleted");
	}


	virtual void OnRequestSent() override
	{
		m_Callbacks->CallTableFnWithSelf("OnRequestSent");
	}


	virtual void OnStatusLine(const AString & a_HttpVersion, int a_StatusCode, const AString & a_Rest) override
	{
		m_Callbacks->CallTableFnWithSelf("OnStatusLine", a_HttpVersion, a_StatusCode, a_Rest);
	}


	virtual void OnHeader(const AString & a_Key, const AString & a_Value) override
	{
		m_Callbacks->CallTableFnWithSelf("OnHeader", a_Key, a_Value);
		m_Headers[a_Key] = a_Value;
	}


	virtual void OnHeadersFinished() override
	{
		m_Callbacks->CallTableFnWithSelf("OnHeadersFinished", m_Headers);
	}


	virtual void OnBodyData(const void * a_Data, size_t a_Size) override
	{
		m_Callbacks->CallTableFnWithSelf("OnBodyData", AString(reinterpret_cast<const char *>(a_Data), a_Size));
	}


	virtual void OnBodyFinished() override
	{
		m_Callbacks->CallTableFnWithSelf("OnBodyFinished");
	}


	virtual void OnError(const AString & a_ErrorMsg) override
	{
		m_Callbacks->CallTableFnWithSelf("OnError", a_ErrorMsg);
	}


	virtual void OnRedirecting(const AString & a_NewLocation) override
	{
		m_Callbacks->CallTableFnWithSelf("OnRedirecting", a_NewLocation);
	}


protected:
	/** The Lua table containing the callbacks. */
	cLuaState::cTableRefPtr m_Callbacks;

	/** Accumulator for all the headers to be reported in the OnHeadersFinished() callback. */
	AStringMap m_Headers;
};





/** Used when the cUrlClient Lua request has just a single callback.
The callback is used to report the entire body at once, together with the HTTP headers, or to report an error:
callback("BodyContents", {headers})
callback(nil, "ErrorMessage")
Accumulates the body contents into a single string until the body is finished.
Accumulates all HTTP headers into an AStringMap. */
class cSimpleUrlClientCallbacks:
	public cUrlClient::cCallbacks
{
public:
	/** Creates a new instance that uses the specified callback to report when request finishes. */
	cSimpleUrlClientCallbacks(cLuaState::cCallbackPtr && a_Callback):
		m_Callback(std::move(a_Callback))
	{
	}


	virtual void OnHeader(const AString & a_Key, const AString & a_Value) override
	{
		m_Headers[a_Key] = a_Value;
	}


	virtual void OnBodyData(const void * a_Data, size_t a_Size) override
	{
		m_ResponseBody.append(reinterpret_cast<const char *>(a_Data), a_Size);
	}


	virtual void OnBodyFinished() override
	{
		m_Callback->Call(m_ResponseBody, m_Headers);
	}


	virtual void OnError(const AString & a_ErrorMsg) override
	{
		m_Callback->Call(cLuaState::Nil, a_ErrorMsg);
	}


protected:

	/** The callback to call when the request finishes. */
	cLuaState::cCallbackPtr m_Callback;

	/** The accumulator for the partial body data, so that OnBodyFinished() can send the entire thing at once. */
	AString m_ResponseBody;

	/** Accumulator for all the headers to be reported in the combined callback. */
	AStringMap m_Headers;
};





/** Common code shared among the cUrlClient request methods.
a_Method is the method name to be used in the request.
a_UrlStackIdx is the position on the Lua stack of the Url parameter. */
static int tolua_cUrlClient_Request_Common(lua_State * a_LuaState, const AString & a_Method, int a_UrlStackIdx)
{
	// Check params:
	cLuaState L(a_LuaState);
	if (!L.CheckParamString(a_UrlStackIdx))
	{
		return 0;
	}

	// Read params:
	AString url, requestBody;
	AStringMap headers, options;
	cLuaState::cTableRefPtr callbacks;
	cLuaState::cCallbackPtr onCompleteBodyCallback;
	if (!L.GetStackValues(a_UrlStackIdx, url))
	{
		return L.ApiParamError("Cannot read URL parameter at idx %d", a_UrlStackIdx);
	}
	cUrlClient::cCallbacksPtr urlClientCallbacks;
	if (lua_istable(L, a_UrlStackIdx + 1))
	{
		if (!L.GetStackValue(a_UrlStackIdx + 1, callbacks))
		{
			return L.ApiParamError("Cannot read the CallbacksTable parameter at idx %d", a_UrlStackIdx + 1);
		}
		urlClientCallbacks = cpp14::make_unique<cFullUrlClientCallbacks>(std::move(callbacks));
	}
	else if (lua_isfunction(L, a_UrlStackIdx + 1))
	{
		if (!L.GetStackValue(a_UrlStackIdx + 1, onCompleteBodyCallback))
		{
			return L.ApiParamError("Cannot read the CallbackFn parameter at idx %d", a_UrlStackIdx + 1);
		}
		urlClientCallbacks = cpp14::make_unique<cSimpleUrlClientCallbacks>(std::move(onCompleteBodyCallback));
	}
	else
	{
		L.ApiParamError("Invalid Callbacks parameter at %d, expected a table or function, got %s", a_UrlStackIdx + 1, L.GetTypeText(a_UrlStackIdx + 1).c_str());
	}
	if (!L.GetStackValues(a_UrlStackIdx + 2, cLuaState::cOptionalParam<AStringMap>(headers), cLuaState::cOptionalParam<AString>(requestBody), cLuaState::cOptionalParam<AStringMap>(options)))
	{
		L.ApiParamError("Cannot read the Header, Body or Options parameter at idx %d, %d, %d.", a_UrlStackIdx + 2, a_UrlStackIdx + 3, a_UrlStackIdx + 4);
	}

	// Make the request:
	auto res = cUrlClient::Request(a_Method, url, std::move(urlClientCallbacks), std::move(headers), std::move(requestBody), std::move(options));
	if (!res.first)
	{
		L.Push(false);
		L.Push(res.second);
		return 2;
	}
	L.Push(true);
	return 1;
}





/** Implements cUrlClient:Get() using cUrlClient::Request(). */
static int tolua_cUrlClient_Delete(lua_State * a_LuaState)
{
	/* Function signatures:
	cUrlClient:Delete(URL, {CallbacksFnTable}, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	cUrlClient:Delete(URL, OnCompleteBodyCallback, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	*/

	return tolua_cUrlClient_Request_Common(a_LuaState, "DELETE", 2);
}





/** Implements cUrlClient:Get() using cUrlClient::Request(). */
static int tolua_cUrlClient_Get(lua_State * a_LuaState)
{
	/* Function signatures:
	cUrlClient:Get(URL, {CallbacksFnTable}, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	cUrlClient:Get(URL, OnCompleteBodyCallback, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	*/

	return tolua_cUrlClient_Request_Common(a_LuaState, "GET", 2);
}





/** Implements cUrlClient:Post() using cUrlClient::Request(). */
static int tolua_cUrlClient_Post(lua_State * a_LuaState)
{
	/* Function signatures:
	cUrlClient:Post(URL, {CallbacksFnTable}, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	cUrlClient:Post(URL, OnCompleteBodyCallback, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	*/

	return tolua_cUrlClient_Request_Common(a_LuaState, "POST", 2);
}





/** Implements cUrlClient:Put() using cUrlClient::Request(). */
static int tolua_cUrlClient_Put(lua_State * a_LuaState)
{
	/* Function signatures:
	cUrlClient:Put(URL, {CallbacksFnTable}, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	cUrlClient:Put(URL, OnCompleteBodyCallback, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	*/

	return tolua_cUrlClient_Request_Common(a_LuaState, "PUT", 2);
}





/** Binds cUrlClient::Request(). */
static int tolua_cUrlClient_Request(lua_State * a_LuaState)
{
	/* Function signatures:
	cUrlClient:Request(Method, URL, {CallbacksFnTable}, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	cUrlClient:Request(Method, URL, OnCompleteBodyCallback, [{HeadersMapTable}], [RequestBody], [{OptionsMapTable}]) -> true / false + string
	*/

	// Check that the Method param is a string:
	cLuaState L(a_LuaState);
	if (
		!L.CheckParamStaticSelf("cUrlClient") ||
		!L.CheckParamString(2))
	{
		return 0;
	}

	// Redirect the rest to the common code:
	AString method;
	if (!L.GetStackValue(2, method))
	{
		L.ApiParamError("Cannot read the Method parameter");
	}
	return tolua_cUrlClient_Request_Common(a_LuaState, method, 3);
}





////////////////////////////////////////////////////////////////////////////////
// Register the bindings:

void cManualBindings::BindNetwork(lua_State * tolua_S)
{
	// Create the cNetwork API classes:
	tolua_usertype(tolua_S, "cNetwork");
	tolua_usertype(tolua_S, "cServerHandle");
	tolua_usertype(tolua_S, "cTCPLink");
	tolua_usertype(tolua_S, "cUDPEndpoint");
	tolua_usertype(tolua_S, "cUrlClient");
	tolua_cclass(tolua_S, "cNetwork",      "cNetwork",      "", nullptr);
	tolua_cclass(tolua_S, "cServerHandle", "cServerHandle", "", tolua_collect_cServerHandle);
	tolua_cclass(tolua_S, "cTCPLink",      "cTCPLink",      "", nullptr);
	tolua_cclass(tolua_S, "cUDPEndpoint",  "cUDPEndpoint",  "", tolua_collect_cUDPEndpoint);
	tolua_cclass(tolua_S, "cUrlClient",    "cUrlClient",    "", nullptr);

	// 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, "EnumLocalIPAddresses", tolua_cNetwork_EnumLocalIPAddresses);
		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);

	tolua_beginmodule(tolua_S, "cUrlClient");
		tolua_function(tolua_S, "Delete",  tolua_cUrlClient_Delete);
		tolua_function(tolua_S, "Get",     tolua_cUrlClient_Get);
		tolua_function(tolua_S, "Post",    tolua_cUrlClient_Post);
		tolua_function(tolua_S, "Put",     tolua_cUrlClient_Put);
		tolua_function(tolua_S, "Request", tolua_cUrlClient_Request);
	tolua_endmodule(tolua_S);
}