M2Loader - One Client for all servers

#pragma once

#include "resource.h"

struct Pointers
{
	Pointers():
		Pointer1(0),
		Pointer2(0),
		Pointer3(0){}

	DWORD Pointer1;
	DWORD Pointer2;
	DWORD Pointer3;
};

namespace ServerInfo
{
	char *LoginServerIP = new char[50];
	USHORT LoginServerPort;
	char *CharacterServerIP = new char[50];
	USHORT CharacterServerPort;
	char *WorldServerIP = new char[50];
	USHORT WorldServerPort;
}

// M2Loader.cpp : Definiert den Einstiegspunkt für die Anwendung.
//

#include "stdafx.h"
#include "M2Loader.h"
#include <iostream>
#include <Winsock2.h>

#pragma comment (lib, "WS2_32.lib")

BOOL CALLBACK Dlgproc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
DWORD ShowDialog(HINSTANCE hInstance);
void ChangeIPAndPort();
void ChangeIPAndPortEnd();
void PatchCode(void *Code, DWORD Offset);
void LoadConfig();
bool RunMetin2(PROCESS_INFORMATION *ProcessInformation);
void LoadConnectionData(HWND hWnd, void *buf);
void WriteBytesToBuffer(HWND hWnd, void *buf, DWORD MyFunctionOffset);
DWORD GetBufferLength();
void SaveConfig();

__declspec(naked) void ChangeIPAndPort()
{
	__asm
	{
		pushad
		mov eax, 0x00000000
		mov edx, eax
		mov ecx, [esp+0x2C]
		cmp [eax], ecx
		je Jump4
		cmp dword ptr ds:[eax], 0x00000000
		jne Jump1
		mov [eax], ecx
		add edx, 0x0C
		jmp Jump3
	Jump1:
		cmp [eax+0x04], ecx
		je Jump4
		cmp dword ptr ds:[eax+0x04], 0x00000000
		jne Jump2
		mov [eax+0x04], ecx
		add edx, 0x1C
		jmp jump3
	Jump2:
		cmp [eax+0x08], ecx
		je Jump4
		cmp dword ptr ds:[eax+0x08], 0x00000000
		jne Jump4
		mov [eax+0x08], ecx
		add edx, 0x2C
	Jump3:		
		mov [esp+0x2C], edx
	Jump4:
		popad

		sub esp, 0x04
		push eax
		mov eax, [esp+0x08]
		mov [esp+0x04], eax
		mov [esp+0x08], ebp
		pop eax
		mov ebp, esp
		add ebp, 0x04
		ret
	}
}

__declspec(naked) void ChangeIPAndPortEnd()
{
}

int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
	LoadLibrary("WS2_32.dll");
	LoadConfig();
	ShowDialog(hInstance);
	return 0;
}


BOOL CALLBACK Dlgproc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	using namespace ServerInfo;

	switch(uMsg)
	{
		case WM_COMMAND:
			PROCESS_INFORMATION *ProcessInformation = new PROCESS_INFORMATION;

			switch(LOWORD(wParam))
			{
				case IDC_MYICON:
					DestroyWindow(hWnd);
					break;

				case IDC_BUTTON1:
					if (!RunMetin2(ProcessInformation))
					{
						DWORD ErrorCode = GetLastError();
						char *buf = new char[1000];
						sprintf_s(buf, 1000, "CreateProcess() failed!\n(Error Code: %d)", ErrorCode);
						if (ErrorCode == 2)
							strcat_s(buf, 1000, "\n\nDid you copy M2Loader into your Metin2 folder?");
						MessageBox(hWnd, buf, "Error!", 0);
					}
					else
					{
						HMODULE ModuleHandle = GetModuleHandle("WS2_32.dll");
						DWORD ConnectOffset = (DWORD)GetProcAddress(ModuleHandle, "connect");
						if (!ConnectOffset)
							MessageBox(hWnd, "Can't find the function \"connect\" in \"WS2_32.dll\"!", "Error!", 0);
						else
						{
							DWORD temp;
							DWORD SizeOfCode = (DWORD)ChangeIPAndPortEnd - (DWORD)ChangeIPAndPort;
							DWORD MyFunctionOffset = (DWORD)VirtualAllocEx(ProcessInformation->hProcess, NULL, (SIZE_T)(sizeof(Pointers) + (sizeof(sockaddr_in) * 3) + SizeOfCode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

							if (!MyFunctionOffset)
							{
								DWORD ErrorCode = GetLastError();
								char *test = new char[1000];
								sprintf_s(test, 1000, "VirtualAllocEx() failed!\n(Error Code: %d)", ErrorCode);
								MessageBox(hWnd, test, "Error!", 0);
							}
							else
							{
								BYTE *buf = new BYTE[GetBufferLength()];
								WriteBytesToBuffer(hWnd, buf, MyFunctionOffset);
								WriteProcessMemory(ProcessInformation->hProcess, (void *)MyFunctionOffset, buf, GetBufferLength(), &temp);

								VirtualProtectEx(ProcessInformation->hProcess, (void *)ConnectOffset, 5, PAGE_EXECUTE_READWRITE, &temp);

								BYTE FunctionCall[5] = {0xE8, 0x00, 0x00, 0x00, 0x00};
								DWORD Address = (MyFunctionOffset - ConnectOffset - 0x05) + sizeof(Pointers) + (sizeof(sockaddr_in) * 3);
								*(DWORD *)(FunctionCall + 1) = Address;

								bool b = true;
								while (b)
								{
									if (!WriteProcessMemory(ProcessInformation->hProcess, (void *)ConnectOffset, FunctionCall, sizeof(FunctionCall), (SIZE_T *)&temp))
									{
										DWORD ErrorCode = GetLastError();
										if (ErrorCode != 487)
										{
											char *buf = new char[1000];
											sprintf_s(buf, 1000, "WriteProcessMemory() failed!\n(Error Code: %d)", ErrorCode);
											MessageBox(hWnd, buf, "Error!", 0);
											b = false;
										}
									}
									else
										b = false;

									Sleep(1);
								}
							}
						}
						DestroyWindow(hWnd);
					}
					break;

				case IDC_BUTTON2:
					HWND LoginServerIPEdit = GetDlgItem(hWnd, IDC_EDIT1);
					HWND LoginServerPortEdit = GetDlgItem(hWnd, IDC_EDIT2);
					HWND CharacterServerIPEdit = GetDlgItem(hWnd, IDC_EDIT3);
					HWND CharacterServerPortEdit = GetDlgItem(hWnd, IDC_EDIT4);
					HWND WorldServerIPEdit = GetDlgItem(hWnd, IDC_EDIT5);
					HWND WorldServerPortEdit = GetDlgItem(hWnd, IDC_EDIT6);
					HWND Button = GetDlgItem(hWnd, IDC_BUTTON2);

					char *ButtonText = new char[20];
					GetWindowText(Button, ButtonText, 20);
					if (!strcmp(ButtonText, "Edit"))
					{
						EnableWindow(LoginServerIPEdit, true);
						EnableWindow(LoginServerPortEdit, true);
						EnableWindow(CharacterServerIPEdit, true);
						EnableWindow(CharacterServerPortEdit, true);
						EnableWindow(WorldServerIPEdit, true);
						EnableWindow(WorldServerPortEdit, true);
						EnableWindow(GetDlgItem(hWnd, IDC_BUTTON1), false);

						SetWindowText(Button, "Save");
					}
					else
					{
						EnableWindow(LoginServerIPEdit, false);
						EnableWindow(LoginServerPortEdit, false);
						EnableWindow(CharacterServerIPEdit, false);
						EnableWindow(CharacterServerPortEdit, false);
						EnableWindow(WorldServerIPEdit, false);
						EnableWindow(WorldServerPortEdit, false);
						EnableWindow(GetDlgItem(hWnd, IDC_BUTTON1), true);

						char Port[20];
						GetWindowText(LoginServerIPEdit, LoginServerIP, 50);
						GetWindowText(LoginServerPortEdit, Port, 20);
						LoginServerPort = atoi(Port);
						GetWindowText(CharacterServerIPEdit, CharacterServerIP, 50);
						GetWindowText(CharacterServerPortEdit, Port, 20);
						CharacterServerPort = atoi(Port);
						GetWindowText(WorldServerIPEdit, WorldServerIP, 50);
						GetWindowText(WorldServerPortEdit, Port, 20);
						WorldServerPort = atoi(Port);

						SaveConfig();

						SetWindowText(Button, "Edit");
					}
			}
	}
	return FALSE;
}


DWORD ShowDialog(HINSTANCE hInstance)
{
	using namespace ServerInfo;
	MSG msg;
	HWND hWnd;

	hWnd = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, (DLGPROC)Dlgproc);

	HWND LoginServerIPEdit = GetDlgItem(hWnd, IDC_EDIT1);
	HWND LoginServerPortEdit = GetDlgItem(hWnd, IDC_EDIT2);
	HWND CharacterServerIPEdit = GetDlgItem(hWnd, IDC_EDIT3);
	HWND CharacterServerPortEdit = GetDlgItem(hWnd, IDC_EDIT4);
	HWND WorldServerIPEdit = GetDlgItem(hWnd, IDC_EDIT5);
	HWND WorldServerPortEdit = GetDlgItem(hWnd, IDC_EDIT6);

	char *buf = new char[20];

	SetWindowText(LoginServerIPEdit, LoginServerIP);
	sprintf_s(buf, 20, "%d", LoginServerPort);
	SetWindowText(LoginServerPortEdit, buf);
	SetWindowText(CharacterServerIPEdit, CharacterServerIP);
	sprintf_s(buf, 20, "%d", CharacterServerPort);
	SetWindowText(CharacterServerPortEdit, buf);
	SetWindowText(WorldServerIPEdit, WorldServerIP);
	sprintf_s(buf, 20, "%d", WorldServerPort);
	SetWindowText(WorldServerPortEdit, buf);

	ShowWindow(hWnd, SW_SHOW);

	while(GetMessage(&msg, hWnd, 0, 0) > 0)
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return true;
}

void PatchCode(void *Code, DWORD Offset)
{
	*(DWORD *)((DWORD)Code + 0x02) = Offset;
}

void LoadConfig()
{
	using namespace ServerInfo;

	char *Directory = new char[1024];
	GetCurrentDirectory(1024, Directory);
	strcat_s(Directory, 1024, "\\M2Loader_config.ini");

	GetPrivateProfileString("LoginServer", "IP", "127.0.0.1", LoginServerIP, 1024, Directory);
	LoginServerPort = GetPrivateProfileInt("LoginServer", "Port", 1000, Directory);
	GetPrivateProfileString("CharacterServer", "IP", "127.0.0.1", CharacterServerIP, 1024, Directory);
	CharacterServerPort = GetPrivateProfileInt("CharacterServer", "Port", 1000, Directory);
	GetPrivateProfileString("WorldServer", "IP", "127.0.0.1", WorldServerIP, 1024, Directory);
	WorldServerPort = GetPrivateProfileInt("WorldServer", "Port", 1000, Directory);
}


bool RunMetin2(PROCESS_INFORMATION *ProcessInformation)
{
	STARTUPINFO myStartupinfo;

	myStartupinfo.cb = 0x00000044;
	myStartupinfo.lpReserved = NULL;
	myStartupinfo.lpDesktop = NULL;
	myStartupinfo.lpTitle = NULL;
	myStartupinfo.dwX = 0x00000000;
	myStartupinfo.dwY = 0x00000000;
	myStartupinfo.dwXSize = 0x00000000;
	myStartupinfo.dwYSize = 0x00000000;
	myStartupinfo.dwXCountChars = 0x00000000;
	myStartupinfo.dwYCountChars = 0x00000000;
	myStartupinfo.dwFillAttribute = 0x00000000;
	myStartupinfo.dwFlags = STARTF_USESHOWWINDOW;
	myStartupinfo.wShowWindow = SW_SHOW;
	myStartupinfo.cbReserved2 = 0x0000;
	myStartupinfo.lpReserved2 = NULL;
	myStartupinfo.hStdInput = NULL;
	myStartupinfo.hStdOutput = NULL;
	myStartupinfo.hStdError = NULL;

	if (!CreateProcess("metin2.bin", "metin2.bin", NULL, NULL, false, 0, NULL, NULL, &myStartupinfo, ProcessInformation))
		return false;
	else
		return true;
}

void LoadConnectionData(HWND hWnd, void *buf)
{
	using namespace ServerInfo;

	sockaddr_in *myConnection = new sockaddr_in[3];
	memset(myConnection, 0, sizeof(sockaddr_in) * 3);

	for (int i = 0; i <= 3; i++)					
		myConnection[i].sin_family = AF_INET;
	
	myConnection[0].sin_addr.s_addr = inet_addr(LoginServerIP);
	myConnection[0].sin_port = htons(LoginServerPort);
	myConnection[1].sin_addr.s_addr = inet_addr(CharacterServerIP);
	myConnection[1].sin_port = htons(CharacterServerPort);
	myConnection[2].sin_addr.s_addr = inet_addr(WorldServerIP);
	myConnection[2].sin_port = htons(WorldServerPort);

	memcpy(buf, myConnection, sizeof(sockaddr_in) * 3);
}

void WriteBytesToBuffer(HWND hWnd, void *buf, DWORD MyFunctionOffset)
{
	Pointers *myPointers = new Pointers;
	memcpy(buf, myPointers, sizeof(Pointers));

	BYTE *ConnectionData = new BYTE[sizeof(sockaddr_in) * 3];
	LoadConnectionData(hWnd, ConnectionData);
	memcpy((void *)((DWORD)buf + sizeof(Pointers)), ConnectionData, sizeof(sockaddr_in) * 3);

	DWORD SizeOfCode = (DWORD)ChangeIPAndPortEnd - (DWORD)ChangeIPAndPort;
	BYTE *myCode = new BYTE[SizeOfCode];
	memcpy(myCode, ChangeIPAndPort, SizeOfCode);
	PatchCode(myCode, MyFunctionOffset);
	memcpy((void *)((DWORD)buf + sizeof(Pointers) + (sizeof(sockaddr_in) * 3)), myCode, SizeOfCode);
}

DWORD GetBufferLength()
{
	return sizeof(Pointers) + sizeof(sockaddr_in) * 3 + (DWORD)ChangeIPAndPortEnd - (DWORD)ChangeIPAndPort;
}

void SaveConfig()
{
	using namespace ServerInfo;

	char *Directory = new char[1024];
	GetCurrentDirectory(1024, Directory);
	strcat_s(Directory, 1024, "\\M2Loader_config.ini");

	char Port[20];
	WritePrivateProfileString("LoginServer", "IP", LoginServerIP, Directory);
	sprintf_s(Port, 20, "%d", LoginServerPort);
	WritePrivateProfileString("LoginServer", "Port", Port, Directory);
	WritePrivateProfileString("CharacterServer", "IP", CharacterServerIP, Directory);
	sprintf_s(Port, 20, "%d", CharacterServerPort);
	WritePrivateProfileString("CharacterServer", "Port", Port, Directory);
	WritePrivateProfileString("WorldServer", "IP", WorldServerIP, Directory);
	sprintf_s(Port, 20, "%d", WorldServerPort);
	WritePrivateProfileString("WorldServer", "Port", Port, Directory);
}