NativeProxy.c

#include <Windows.h>
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

typedef int * RakPeer;
typedef UINT64 RAKNET_GUID;

typedef int*(*F_CREATE)();
F_CREATE Create;
typedef int *(*F_LastStartupError)(RakPeer peer);
F_LastStartupError LastStartupError;
typedef INT8(*F_ReadBytes)(RakPeer peer, byte *data, int length);
F_ReadBytes ReadBytes;
typedef void(*F_SetReadPoINT32er)(RakPeer peer, int bitsOffset);
F_SetReadPoINT32er SetReadPoINT32er;
typedef void(*SND_WriteBytes)(RakPeer peer, byte *data, int length);
SND_WriteBytes WriteBytes;
typedef void(*F_WriteCompressedFloat)(RakPeer peer, FLOAT val);
F_WriteCompressedFloat WriteCompressedFloat;
typedef void(*F_WriteCompressedInt32)(RakPeer peer, int val);
F_WriteCompressedInt32 WriteCompressedInt32;
typedef void(*F_WriteCompressedInt64)(RakPeer peer, INT64 val);
F_WriteCompressedInt64 WriteCompressedInt64;
typedef char(*F_Receive)(RakPeer peer);
F_Receive Receive;
typedef FLOAT(*F_ReadCompressedFloat)(RakPeer peer);
F_ReadCompressedFloat ReadCompressedFloat;
typedef UINT64(*F_Broadcast)(RakPeer peer, int priority, int reliability, int channel);
F_Broadcast Broadcast;
typedef int(*F_ReadCompressedInt32)(RakPeer peer);
F_ReadCompressedInt32 ReadCompressedInt32;
typedef UINT32(*F_Send)(RakPeer peer, UINT64 connectionID, int priority, int reliability, int channel);
F_Send Send;
typedef void(*F_CloseConnection)(RakPeer peer, UINT64 connectionID);
F_CloseConnection CloseConnection;
typedef int*(*F_GetAddress)(RakPeer peer, UINT64 connectionID);
F_GetAddress GetAddress;
typedef void(*F_SendMessage)(RakPeer peer, byte *data, int length, UINT32 adr, UINT16 port);
F_SendMessage Send_Message;
typedef int(*F_Start_Client)(RakPeer peer, LPCSTR hostname, int port, int retries, int retryDelay, int timeout);
F_Start_Client StartClient;
typedef int(*F_Start_Server)(RakPeer peer, LPCSTR hostname, int port, int maxConnections);
F_Start_Server StartServer;
typedef UINT32(*F_Address)(RakPeer peer);
F_Address RCV_Address;
typedef UINT64(*F_GUID)(RakPeer peer);
F_GUID RCV_GUID;
typedef int(*F_LengthBits)(RakPeer peer);
F_LengthBits RCV_LengthBits;
typedef UINT32(*F_PORT)(RakPeer peer);
F_PORT RCV_Port;
typedef int(*F_ReadCompressedBytes)(RakPeer peer, int size, byte *data, int expectedSize);
F_ReadCompressedBytes ReadCompressedBytes;
typedef int(*F_UnreadBits)(RakPeer peer);
F_UnreadBits RCV_UnreadBits;
typedef UINT64(*F_ReadCompressedInt64)(RakPeer peer);
F_ReadCompressedInt64 ReadCompressedInt64;
typedef UINT32(*F_Size)(RakPeer peer);
F_Size SND_Size;
typedef void(*F_Start)(RakPeer peer);
F_Start SendStart;
typedef UINT64(*F_WriteCompressedBytes)(RakPeer peer, char *data, int size);
F_WriteCompressedBytes WriteCompressedBytes;
typedef UINT64(*F_Close)(RakPeer peer);
F_Close Close;


void LoadFunctions() {
	HMODULE lib = LoadLibraryA("RakNet");
	DWORD err = GetLastError();
	Create = (F_CREATE)GetProcAddress(lib, "NET_Create");
	LastStartupError = (F_LastStartupError)GetProcAddress(lib, "NET_LastStartupError");
	ReadBytes = (F_ReadBytes)GetProcAddress(lib, "NETRCV_ReadBytes");
	SetReadPoINT32er = (F_SetReadPoINT32er)GetProcAddress(lib, "NETRCV_SetReadPoINT32er");
	WriteBytes = (SND_WriteBytes)GetProcAddress(lib, "NETSND_WriteBytes");
	WriteCompressedFloat = (F_WriteCompressedFloat)GetProcAddress(lib, "NETSND_WriteCompressedFloat");
	WriteCompressedInt32 = (F_WriteCompressedInt32)GetProcAddress(lib, "NETSND_WriteCompressedInt32");
	WriteCompressedInt64 = (F_WriteCompressedInt64)GetProcAddress(lib, "NETSND_WriteCompressedInt64");
	Receive = (F_Receive)GetProcAddress(lib, "NET_Receive");
	ReadCompressedFloat = (F_ReadCompressedFloat)GetProcAddress(lib, "NETSND_ReadCompressedFloat");
	Broadcast = (F_Broadcast)GetProcAddress(lib, "NETSND_Broadcast");
	ReadCompressedInt32 = (F_ReadCompressedInt32)GetProcAddress(lib, "NETSND_ReadCompressedF_INT32");
	Send = (F_Send)GetProcAddress(lib, "NETSND_Send");
	CloseConnection = (F_CloseConnection)GetProcAddress(lib, "NET_CloseConnection");
	GetAddress = (F_GetAddress)GetProcAddress(lib, "NET_GetAddress");
	Send_Message = (F_SendMessage)GetProcAddress(lib, "NET_SendMessage");
	StartClient = (F_Start_Client)GetProcAddress(lib, "NET_StartClient");
	StartServer = (F_Start_Server)GetProcAddress(lib, "NET_StartServer");
	RCV_Address = (F_Address)GetProcAddress(lib, "NETRCV_Address");
	RCV_GUID = (F_GUID)GetProcAddress(lib, "NETRCV_GUID");
	RCV_LengthBits = (F_LengthBits)GetProcAddress(lib, "NETRCV_LengthBits");
	RCV_Port = (F_PORT)GetProcAddress(lib, "NETRCV_Port");
	ReadCompressedBytes = (F_ReadCompressedBytes)GetProcAddress(lib, "NETRCV_ReadCompressedBytes");
	RCV_UnreadBits = (F_UnreadBits)GetProcAddress(lib, "NETRCV_UnreadBits");
	ReadCompressedInt64 = (F_ReadCompressedInt64)GetProcAddress(lib, "NETSND_ReadCompressedlong");
	SND_Size = (F_Size)GetProcAddress(lib, "NETSND_Size");
	SendStart = (F_Start)GetProcAddress(lib, "NETSND_Start");
	WriteCompressedBytes = (F_WriteCompressedBytes)GetProcAddress(lib, "NETSND_WriteCompressedBytes");
	Close = (F_Close)GetProcAddress(lib, "NET_Close");
}

char * getline(void) {
	char * line = malloc(100), *linep = line;
	size_t lenmax = 100, len = lenmax;
	int c;

	if (line == NULL)
		return NULL;

	for (;;) {
		c = fgetc(stdin);
		if (c == EOF)
			break;

		if (--len == 0) {
			len = lenmax;
			char * linen = realloc(linep, lenmax *= 2);

			if (linen == NULL) {
				free(linep);
				return NULL;
			}
			line = linen + (line - linep);
			linep = linen;
		}
		if (c == '\n' || c == '\r')
			break;
		*line++ = c;
	}
	*line = '\0';
	return linep;
}

void handler(int dummy) {
	alive = FALSE;
}

#define incomingSize(peer) (RCV_LengthBits(peer) / 8)
#define unread(peer) (RCV_UnreadBits(peer) / 8)
RAKNET_GUID serverGUID;
RAKNET_GUID clientGUID;
byte *serverBuffer;
byte *clientBuffer;
RakPeer serverPeer;
RakPeer clientPeer;
char alive = TRUE;
char *serverHostname;
int serverPort;

DWORD WINAPI networkThread(void *n) {
	char clientConnected = FALSE;
	while (alive) {
		char serverPacket = Receive(serverPeer);
		char clientPacket = clientConnected ? Receive(clientPeer) : FALSE;
		if (serverPacket) {
			int size = incomingSize(serverPeer);
			ReadBytes(serverPeer, serverBuffer, incomingSize(serverPeer));
			byte packetID = serverBuffer[0];
			if (packetID == 19 /* NEW_INCOMING_CONNECTION */) {
				clientGUID = RCV_GUID(serverPeer);
				clientConnected = TRUE;
				StartClient(clientPeer, serverHostname, serverPort, 32, 100, 1000);
				while (!Receive(clientPeer)) Sleep(10);
				serverGUID = RCV_GUID(clientPeer);
				int size = incomingSize(serverPeer);
				ReadBytes(serverPeer, serverBuffer, size);
				SendStart(clientPeer);
				WriteBytes(clientPeer, serverBuffer, size);
				Send(clientPeer, serverGUID, 2, 0, 0);
			} else {
				SendStart(clientPeer);
				WriteBytes(clientPeer, serverBuffer, size);
				Send(clientPeer, serverGUID, 2, 0, 0);
			}
		}
		if (clientPacket) {
			int size = incomingSize(clientPeer);
			ReadBytes(clientPeer, clientBuffer, size);
			SendStart(serverPeer);
			WriteBytes(serverPeer, clientBuffer, size);
			Send(serverPeer, clientGUID, 2, 0, 0);
		}
	}
}

int main(int argc, char *argv[]) {
	signal(SIGINT, handler);
	if (argc < 2) {
		printf("NativeProxy SERVER_IP_OR_HOSTNAME SERVER_PORT");
		return 1;
	}
	serverHostname = argv[1];
	serverPort = atoi(argv[2]);
	printf("Will connect to %s:%d when client connects to me :D\n", serverHostname, serverPort);
	LoadFunctions();
	serverBuffer = (byte *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 4194304); // 4 Megabytes
	clientBuffer = (byte *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 4194304); // 4 Megabytes
	clientPeer = Create();
	serverPeer = Create();
	StartServer(serverPeer, "0.0.0.0", 5678, 10);
	printf("Server is now listening on :5678\n");
	CreateThread(NULL, 0, networkThread, NULL, 0, NULL);
	while (alive) {
		printf("\n>");
		const char *c = getline();
		if (strcmp(c, "shutdown") == 0) alive = FALSE;
		if (strcmp(c, "exit") == 0) alive = FALSE;
		if (strcmp(c, "quit") == 0) alive = FALSE;
	}
	return 0;
}