/**

  * vim: set ts=4 :

  * ===============================================================

  * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.

  * ===============================================================

  *

  * This file is not open source and may not be copied without explicit

  * written permission of AlliedModders LLC.  This file may not be redistributed 

  * in whole or significant part.

  * For information, see LICENSE.txt or http://www.sourcemod.net/license.php

  *

  * Version: $Id$

  */

 #include "MemoryUtils.h"

 #include "ShareSys.h"

 #ifdef PLATFORM_LINUX

 #include <string.h>

 #include <elf.h>

 #endif

 MemoryUtils g_MemUtils;

 #if 0

 MemoryUtils::MemoryUtils()

 {

 #ifdef PLATFORM_WINDOWS

 	SYSTEM_INFO info;

 	GetSystemInfo(&info);

 	m_PageSize = info.dwPageSize;

 #elif defined PLATFORM_POSIX

 	m_PageSize = sysconf(_SC_PAGE_SIZE);

 #endif

 }

 #endif

 void MemoryUtils::OnSourceModAllInitialized()

 {

 	g_ShareSys.AddInterface(NULL, this);

 }

 void *MemoryUtils::FindPattern(const void *libPtr, const char *pattern, size_t len)

 {

 	DynLibInfo lib;

 	bool found;

 	char *ptr, *end;

 	memset(&lib, 0, sizeof(DynLibInfo));

 	if (!GetLibraryInfo(libPtr, lib))

 	{

 		return NULL;

 	}

 	ptr = reinterpret_cast<char *>(lib.baseAddress);

 	end = ptr + lib.memorySize;

 	while (ptr < end)

 	{

 		found = true;

 		for (register size_t i = 0; i < len; i++)

 		{

 			if (pattern[i] != '\x2A' && pattern[i] != ptr[i])

 			{

 				found = false;

 				break;

 			}

 		}

 		if (found)

 			return ptr;

 		ptr++;

 	}

 	return NULL;

 }

 bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)

 {

 	unsigned long baseAddr;

 	if (libPtr == NULL)

 	{

 		return false;

 	}

 #ifdef PLATFORM_WINDOWS

 	MEMORY_BASIC_INFORMATION info;

 	IMAGE_DOS_HEADER *dos;

 	IMAGE_NT_HEADERS *pe;

 	IMAGE_FILE_HEADER *file;

 	IMAGE_OPTIONAL_HEADER *opt;

 	if (!VirtualQuery(libPtr, &info, sizeof(MEMORY_BASIC_INFORMATION)))

 	{

 		return false;

 	}

 	baseAddr = reinterpret_cast<unsigned long>(info.AllocationBase);

 	/* All this is for our insane sanity checks :o */

 	dos = reinterpret_cast<IMAGE_DOS_HEADER *>(baseAddr);

 	pe = reinterpret_cast<IMAGE_NT_HEADERS *>(baseAddr + dos->e_lfanew);

 	file = &pe->FileHeader;

 	opt = &pe->OptionalHeader;

 	/* Check PE magic and signature */

 	if (dos->e_magic != IMAGE_DOS_SIGNATURE || pe->Signature != IMAGE_NT_SIGNATURE || opt->Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)

 	{

 		return false;

 	}

 	/* Check architecture, which is 32-bit/x86 right now

 	 * Should change this for 64-bit if Valve gets their act together

 	 */

 	if (file->Machine != IMAGE_FILE_MACHINE_I386)

 	{

 		return false;

 	}

 	/* For our purposes, this must be a dynamic library */

 	if ((file->Characteristics & IMAGE_FILE_DLL) == 0)

 	{

 		return false;

 	}

 	/* Finally, we can do this */

 	lib.memorySize = opt->SizeOfImage;

 #elif defined PLATFORM_LINUX

 	Dl_info info;

 	Elf32_Ehdr *file;

 	Elf32_Phdr *phdr;

 	uint16_t phdrCount;

 	if (!dladdr(libPtr, &info))

 	{

 		return false;

 	}

 	if (!info.dli_fbase || !info.dli_fname)

 	{

 		return false;

 	}

 	/* This is for our insane sanity checks :o */

 	baseAddr = reinterpret_cast<unsigned long>(info.dli_fbase);

 	file = reinterpret_cast<Elf32_Ehdr *>(baseAddr);

 	/* Check ELF magic */

 	if (memcmp(ELFMAG, file->e_ident, SELFMAG) != 0)

 	{

 		return false;

 	}

 	/* Check ELF version */

 	if (file->e_ident[EI_VERSION] != EV_CURRENT)

 	{

 		return false;

 	}

 	/* Check ELF architecture, which is 32-bit/x86 right now

 	 * Should change this for 64-bit if Valve gets their act together

 	 */

 	if (file->e_ident[EI_CLASS] != ELFCLASS32 || file->e_machine != EM_386 || file->e_ident[EI_DATA] != ELFDATA2LSB)

 	{

 		return false;

 	}

 	/* For our purposes, this must be a dynamic library/shared object */

 	if (file->e_type != ET_DYN)

 	{

 		return false;

 	}

 	phdrCount = file->e_phnum;

 	phdr = reinterpret_cast<Elf32_Phdr *>(baseAddr + file->e_phoff);

 	/* Add up the memory sizes of segments marked as PT_LOAD as those are the only ones that should be in memory */

 	for (uint16_t i = 0; i < phdrCount; i++)

 	{

 		Elf32_Phdr &hdr = phdr[i];

 		if (hdr.p_type == PT_LOAD)

 		{

 			lib.memorySize += hdr.p_memsz;

 		}

 	}

 #endif

 	lib.baseAddress = reinterpret_cast<void *>(baseAddr);

 	return true;

 }