sourcemod/tools/gdc/gdc.cpp

#include <stdio.h>
#include <unistd.h>
#include <dlfcn.h>
#include <math.h>
#include "gdc.h"
#include "GameConfigs.h"
#include "MemoryUtils.h"

MemoryUtils mu;

char *game = NULL;
char *engine = NULL;
char *binary = NULL;

int main(int argc, char **argv)
{
	char *gamedata = NULL;
	bool debug = false;

	opterr = 0;
	int opt;
	while ((opt = getopt(argc, argv, "b:de:f:g:")) != -1)
		switch (opt)
		{
			case 'd':
				debug = true;
				break;
			case 'g':
				game = optarg;
				break;

			case 'e':
				engine = optarg;
				break;

			case 'f':
				gamedata = optarg;
				break;

			case 'b':
				binary = optarg;
				break;

			case '?':
				printf("Usage: ./gdc -g <game> -e <engine> -f <gamedata file> -b <binary>\n");
				return 0;

			default:
				printf("WHAT\n");
				return 0;
		}

	if (!game || !engine || !gamedata || !binary)
	{
		printf("Usage: ./gdc -g <game> -e <engine> -f <gamedata file> -b <binary>\n");
		return 0;
	}

	printf("Game: %s\nEngine: %s\nGamedata: %s\nBinary: %s\n", game, engine, gamedata, binary);

	void *handle = dlopen(binary, RTLD_LAZY);
	if (!handle)
	{
		printf("Couldn't open %s (%s)\n", binary, dlerror());
		return 0;
	}

	CGameConfig gc;
	char err[512];
	if (!gc.EnterFile(gamedata, err, sizeof(err)))
	{
		printf("%s: %s\n", gamedata, err);
		return 0;
	}

	CGameConfig symbols;
	if (!symbols.EnterFile("symbols.txt", err, sizeof(err)))
	{
		printf("symbols.txt: %s\n", err);
		return 0;
	}

	if (debug)
		for (map<const char*, const char*, cmp_str>::iterator it = symbols.m_Keys.begin(); it != symbols.m_Keys.end(); it++)
			printf("%s - %s\n", it->first, it->second);

	const char *vtsym = symbols.GetKeyValue("vtsym");
	if (!vtsym)
	{
		printf("Couldn't find vtsym\n");
		return 0;
	}

#if 0
	void *lolwhat = (void*)1;
	void *handle = lolwhat;
	handle = dlopen(binary, RTLD_LAZY);
	if (!handle)
	{
		printf("Couldn't open %s\n", binary);
		return 0;
	}
#endif

	void **vt = (void**) mu.ResolveSymbol(handle, vtsym);
	if (!vt)
	{
		printf("Couldn't find vtable %s\n", vtsym);
		dlclose(handle);
		return 0;
	}


	for (list<Offset>::iterator it = gc.m_Offsets.begin(); it != gc.m_Offsets.end(); it++)
	{
		if (debug) printf("DEBUG %s - l: %d w: %d\n", it->name, it->lin, it->win);
//		else
		{
			const char *symbol = symbols.GetKeyValue(it->name);
			if (symbol)
			{
				int offset = findVFunc(handle, vt, symbol);

				if (offset == it->lin) printf("%s - good\n", it->name);
				else printf("%s - l: %d w: %d\n", it->name, offset, offset + it->lin - it->win);
			}
			else printf("%s - no Linux symbol, skipping\n", it->name);
		}
	}

	printf("\nWindows offsets are wild guesses!\n\n");

	for (list<Sig>::iterator it = gc.m_Sigs.begin(); it != gc.m_Sigs.end(); it++)
	{
		if (debug) printf("DEBUG %s - %s - l: %s\n", it->name, it->lib == Server ? "server" : "engine", it->lin);
//		else
		{
			if (it->lib != Server)
			{
				printf("%s - isn't server, skipping\n", it->name);
				continue;
			}

			const char *symbol = it->lin;

			if (!symbol) 
			{
				printf("%s - no Linux symbol, skipping\n", it->name);
				continue;
			}

			if (symbol[0] != '@')
			{
				printf("%s - didn't start with '@', skipping\n", it->name);
				continue;
			}

			void *addr = mu.ResolveSymbol(handle, symbol + 1);

			if (addr) printf("%s - good\n", it->name);
			else printf("%s - %s not found\n", it->name, it->lin);
		}
	}

	return 0;
}

/* 
   takes a mangled member function symbol and returns the position where the function name and parameters start
   01234567890123456789012345678
   _ZN9CTFPlayer12ForceRespawnEv
                ^13            ^28
*/
void findFuncPos(const char *sym, int &func, int &params)
{
	int i = 0;
	while ((sym[i] < '0') || (sym[i] > '9')) i++;
	int classLen = atoi(sym + i);
	func = i + (int)ceil(log10(classLen)) + classLen;
	int funcLen = atoi(sym + func);
	params = func + (int)ceil(log10(funcLen)) + funcLen;
}

int findVFunc(void *handle, void **vt, const char *symbol)
{
	int offset = 1;
	//int overloads = 0;
	int funcPos, paramPos;
	findFuncPos(symbol, funcPos, paramPos);

	for (int i = 0; i < 1000; i++)
	{
		void *pFunc = vt[i];
		const char *s;

//		Dl_info info;
//		if (!mu.ResolveAddr(pFunc, &info)) continue;
		if (!(s = mu.ResolveAddr(handle, pFunc))) continue;

//		if ((i > 1) && (strncmp(info.dli_sname, "_ZTI", 4) == 0)) break;
		if ((i > 1) && (strncmp(s, "_ZTI", 4) == 0)) break;


		int tempFuncPos, tempParamPos;
//		findFuncPos(info.dli_sname, tempFuncPos, tempParamPos);
		findFuncPos(s, tempFuncPos, tempParamPos);

#if 0
		if (strncmp(info.dli_sname[tempFuncPos], symbol[funcPos], paramPos - funcPos) == 0)
		{
			overloads++;
			if (firstOverload == -1) firstOverload = i - 1;
			if (strncmp(info.dli_sname[tempParamPos], symbol[paramPos], strlen(symbol) - paramPos) == 0)
			{
				offset = i;
				matchingOverload = overloads;
			}
		}
#else
//		if (strcmp(info.dli_sname + tempFuncPos, symbol + funcPos) == 0)
		if (strcmp(s + tempFuncPos, symbol + funcPos) == 0)
		{
			offset = i;
			break;
		}
#endif
	}

	return offset - 2;
}

unsigned int strncopy(char *dest, const char *src, size_t count)
{
	if (!count)
	{
		return 0;
	}

	char *start = dest;
	while ((*src) && (--count))
	{
		*dest++ = *src++;
	}
	*dest = '\0';

	return (dest - start);
}

size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	size_t len = vsnprintf(buffer, maxlength, fmt, ap);
	va_end(ap);

	if (len >= maxlength)
	{
		buffer[maxlength - 1] = '\0';
		return (maxlength - 1);
	}
	else
	{
		return len;
	}
}