sourcehook/sh_memory.h
author Pavol Marko <pavolmarko@gmail.com>
Sun Nov 11 18:51:56 2007 +0000 (2007-11-11)
branchhookman_autogen
changeset 459 53e363661d53
parent 445 4c2924c393ed
child 475 20898390f369
permissions -rw-r--r--
Added test for big vtable indices
Improved testevents.h
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2007 Metamod:Source Development Team
     3 * No warranties of any kind
     4 *
     5 * License: zlib/libpng
     6 *
     7 * Author(s): Pavol "PM OnoTo" Marko, Scott "Damaged Soul" Ehlert
     8 * Contributors: lancevorgin, XAD, theqizmo
     9 * ============================
    10 */
    11 
    12 #ifndef __SHINT_MEMORY_H__
    13 #define __SHINT_MEMORY_H__
    14 
    15 // Feb 17 / 2005:
    16 //  Unprotect now sets to readwrite
    17 //  The vtable doesn't need to be executable anyway
    18 
    19 # if	/********/ defined _WIN32
    20 #		include <windows.h>
    21 #		define SH_MEM_READ 1
    22 #		define SH_MEM_WRITE 2
    23 #		define SH_MEM_EXEC 4
    24 # elif /******/ defined __linux__
    25 #		include <sys/mman.h>
    26 #		include <stdio.h>
    27 namespace LinuxSignal
    28 {
    29 #		include <signal.h>
    30 }
    31 #		include <setjmp.h>
    32 // http://www.die.net/doc/linux/man/man2/mprotect.2.html
    33 #		include <limits.h>
    34 #		ifndef PAGESIZE
    35 #			define PAGESIZE 4096
    36 #		endif
    37 #		define SH_MEM_READ PROT_READ
    38 #		define SH_MEM_WRITE PROT_WRITE
    39 #		define SH_MEM_EXEC PROT_EXEC
    40 
    41 // We need to align addr down to pagesize on linux
    42 // We assume PAGESIZE is a power of two
    43 #		define SH_LALIGN(x) (void*)((intptr_t)(x) & ~(PAGESIZE-1))
    44 #		define SH_LALDIF(x) ((intptr_t)(x) & (PAGESIZE-1))
    45 # else
    46 #		error Unsupported OS/Compiler
    47 # endif
    48 
    49 #include "sh_list.h"
    50 
    51 namespace SourceHook
    52 {
    53 	inline bool SetMemAccess(void *addr, size_t len, int access)
    54 	{
    55 # ifdef __linux__
    56 		return mprotect(SH_LALIGN(addr), len + SH_LALDIF(addr), access)==0 ? true : false;
    57 # else
    58 		DWORD tmp;
    59 		DWORD prot;
    60 		switch (access)
    61 		{
    62 		case SH_MEM_READ:
    63 			prot = PAGE_READONLY; break;
    64 		case SH_MEM_READ | SH_MEM_WRITE:
    65 			prot = PAGE_READWRITE; break;
    66 		case SH_MEM_READ | SH_MEM_EXEC:
    67 			prot = PAGE_EXECUTE_READ; break;
    68 		default:
    69 		case SH_MEM_READ | SH_MEM_WRITE | SH_MEM_EXEC:
    70 			prot = PAGE_EXECUTE_READWRITE; break;
    71 		}
    72 		return VirtualProtect(addr, len, prot, &tmp) ? true : false;
    73 # endif
    74 	}
    75 
    76 #ifdef __linux__
    77 	namespace
    78 	{
    79 		bool g_BadReadCalled;
    80 		jmp_buf g_BadReadJmpBuf;
    81 
    82 		static void BadReadHandler(int sig)
    83 		{
    84 			if (g_BadReadCalled)
    85 				longjmp(g_BadReadJmpBuf, 1);
    86 		}
    87 	}
    88 #endif
    89 
    90 	/**
    91 	*	@brief Checks whether the specified memory region is (still) accessible
    92 	*
    93 	*	@param addr The lower boundary
    94 	*	@param len Length of the region to be checked
    95 	*/
    96 	namespace
    97 	{
    98 		bool ModuleInMemory(char *addr, size_t len)
    99 		{
   100 #ifdef __linux__
   101 			// On linux, first check /proc/self/maps
   102 			long lower = reinterpret_cast<long>(addr);
   103 			long upper = lower + len;
   104 
   105 			FILE *pF = fopen("/proc/self/maps", "r");
   106 			if (pF)
   107 			{
   108 				// Linux /proc/self/maps -> parse
   109 				// Format:
   110 				// lower    upper    prot     stuff                 path
   111 				// 08048000-0804c000 r-xp 00000000 03:03 1010107    /bin/cat
   112 				long rlower, rupper;
   113 				while (fscanf(pF, "%lx-%lx", &rlower, &rupper) != EOF)
   114 				{
   115 					// Check whether we're IN THERE!
   116 					if (lower >= rlower && upper <= rupper)
   117 					{
   118 						fclose(pF);
   119 						return true;
   120 					}
   121 					// Read to end of line
   122 					int c;
   123 					while ((c = fgetc(pF)) != '\n')
   124 					{
   125 						if (c == EOF)
   126 							break;
   127 					}
   128 					if (c == EOF)
   129 						break;
   130 				}
   131 				fclose(pF);
   132 				return false;
   133 			}
   134 			pF = fopen("/proc/curproc/map", "r");
   135 			if (pF)
   136 			{
   137 				// FreeBSD /proc/curproc/map -> parse
   138 				// 0x804800 0x805500 13 15 0xc6e18960 r-x 21 0x0 COW NC vnode
   139 				long rlower, rupper;
   140 				while (fscanf(pF, "0x%lx 0x%lx", &rlower, &rupper) != EOF)
   141 				{
   142 					// Check whether we're IN THERE!
   143 					if (lower >= rlower && upper <= rupper)
   144 					{
   145 						fclose(pF);
   146 						return true;
   147 					}
   148 					// Read to end of line
   149 					int c;
   150 					while ((c = fgetc(pF)) != '\n')
   151 					{
   152 						if (c == EOF)
   153 							break;
   154 					}
   155 					if (c == EOF)
   156 						break;
   157 				}
   158 				fclose(pF);
   159 				return false;
   160 			}
   161 
   162 			// Both of the above failed, try to actually read and trap sigsegv (implemented by Damaged Soul)
   163 			void(*prevHandler)(int sig);
   164 			g_BadReadCalled = true;
   165 
   166 			if (setjmp(g_BadReadJmpBuf))
   167 				return true;
   168 
   169 			prevHandler = LinuxSignal::signal(SIGSEGV, BadReadHandler);
   170 
   171 			volatile const char *p = reinterpret_cast<const char*>(addr);
   172 			char dummy;
   173 
   174 			for (size_t i = 0; i < len; i++)
   175 				dummy = p[i];
   176 
   177 			g_BadReadCalled = false;
   178 
   179 			LinuxSignal::signal(SIGSEGV, prevHandler);
   180 
   181 			return false;
   182 #else
   183 			// On Win32, simply use IsBadReadPtr
   184 			return !IsBadReadPtr(addr, len);
   185 #endif
   186 		}
   187 	}
   188 }
   189 
   190 #endif