core-legacy/sourcehook/sh_memory.h
author Nicholas Hastings <skamonkey@gmail.com>
Wed May 21 17:26:09 2014 -0400 (2014-05-21)
changeset 917 95639ee45d3d
parent 767 fd3ff8d792ce
permissions -rw-r--r--
Trigger build for hl2sdk-l4d changes.
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2008 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 SH_XP == SH_XP_WINAPI
    20 #		include <windows.h>
    21 #		define SH_MEM_READ 1
    22 #		define SH_MEM_WRITE 2
    23 #		define SH_MEM_EXEC 4
    24 # elif SH_XP == SH_XP_POSIX
    25 #		include <sys/mman.h>
    26 #		include <stdio.h>
    27 #		include <signal.h>
    28 #		include <setjmp.h>
    29 #		include <stdint.h>
    30 // http://www.die.net/doc/linux/man/man2/mprotect.2.html
    31 #		include <limits.h>
    32 #		ifndef PAGESIZE
    33 #			define PAGESIZE 4096
    34 #		endif
    35 #		define SH_MEM_READ PROT_READ
    36 #		define SH_MEM_WRITE PROT_WRITE
    37 #		define SH_MEM_EXEC PROT_EXEC
    38 
    39 // We need to align addr down to pagesize on linux
    40 // We assume PAGESIZE is a power of two
    41 #		define SH_LALIGN(x) (void*)((uintptr_t)(x) & ~(PAGESIZE-1))
    42 #		define SH_LALDIF(x) ((uintptr_t)(x) & (PAGESIZE-1))
    43 # else
    44 #		error Unsupported OS/Compiler
    45 # endif
    46 
    47 
    48 namespace SourceHook
    49 {
    50 	static inline bool GetPageBits(void *addr, int *bits)
    51 	{
    52 #if SH_SYS == SH_SYS_LINUX
    53 		// On linux, first check /proc/self/maps
    54 		unsigned long laddr = reinterpret_cast<unsigned long>(addr);
    55 
    56 		FILE *pF = fopen("/proc/self/maps", "r");
    57 		if (pF) {
    58 			// Linux /proc/self/maps -> parse
    59 			// Format:
    60 			// lower    upper    prot     stuff                 path
    61 			// 08048000-0804c000 r-xp 00000000 03:03 1010107    /bin/cat
    62 			unsigned long rlower, rupper;
    63 			char r, w, x;
    64 			while (fscanf(pF, "%lx-%lx %c%c%c", &rlower, &rupper, &r, &w, &x) != EOF) {
    65 				// Check whether we're IN THERE!
    66 				if (laddr >= rlower && laddr < rupper) {
    67 					fclose(pF);
    68 					*bits = 0;
    69 					if (r == 'r')
    70 						*bits |= SH_MEM_READ;
    71 					if (w == 'w')
    72 						*bits |= SH_MEM_WRITE;
    73 					if (x == 'x')
    74 						*bits |= SH_MEM_EXEC;
    75 					return true;
    76 				}
    77 				// Read to end of line
    78 				int c;
    79 				while ((c = fgetc(pF)) != '\n') {
    80 					if (c == EOF)
    81 						break;
    82 				}
    83 				if (c == EOF)
    84 					break;
    85 			}
    86 			fclose(pF);
    87 			return false;
    88 		}
    89 		pF = fopen("/proc/curproc/map", "r");
    90 		if (pF) {
    91 			// FreeBSD /proc/curproc/map -> parse
    92 			// 0x804800 0x805500 13 15 0xc6e18960 r-x 21 0x0 COW NC vnode
    93 			unsigned long rlower, rupper, ignoreLong;
    94 			int ignoreInt;
    95 			char r, w, x;
    96 			while (fscanf(pF, "0x%lx 0x%lx %d %d 0x%lx %c%c%c", &rlower, &rupper, &ignoreInt,
    97 						  &ignoreInt, &ignoreLong, &r, &w, &x) != EOF) {
    98 				// Check whether we're IN THERE!
    99 				if (laddr >= rlower && laddr < rupper) {
   100 					fclose(pF);
   101 					*bits = 0;
   102 					if (r == 'r')
   103 						*bits |= SH_MEM_READ;
   104 					if (r == 'w')
   105 						*bits |= SH_MEM_WRITE;
   106 					if (r == 'x')
   107 						*bits |= SH_MEM_EXEC;
   108 					return true;
   109 				}
   110 				// Read to end of line
   111 				int c;
   112 				while ((c = fgetc(pF)) != '\n') {
   113 					if (c == EOF)
   114 						break;
   115 				}
   116 				if (c == EOF)
   117 					break;
   118 			}
   119 			fclose(pF);
   120 			return false;
   121 		}
   122 		return false;
   123 #elif SH_SYS == SH_SYS_APPLE
   124 #elif SH_XP == SH_XP_WINAPI
   125 		SYSTEM_INFO info;
   126 		GetSystemInfo(&info);
   127 
   128 		MEMORY_BASIC_INFORMATION mem;
   129 		size_t base = size_t(addr) & ~size_t(info.dwPageSize - 1);
   130 		if (!VirtualQuery((void *)base, &mem, sizeof(mem)))
   131 			return false;
   132 		switch (mem.Protect) {
   133 			case PAGE_EXECUTE:
   134 				*bits = SH_MEM_EXEC;
   135 				break;
   136 			case PAGE_EXECUTE_READ:
   137 				*bits = SH_MEM_EXEC | SH_MEM_READ;
   138 				break;
   139 			case PAGE_EXECUTE_READWRITE:
   140 			case PAGE_EXECUTE_WRITECOPY:
   141 				*bits = SH_MEM_EXEC | SH_MEM_READ | SH_MEM_WRITE;
   142 				break;
   143 			case PAGE_NOACCESS:
   144 				*bits = 0;
   145 				break;
   146 			case PAGE_READONLY:
   147 				*bits = SH_MEM_READ;
   148 				break;
   149 			case PAGE_READWRITE:
   150 			case PAGE_WRITECOPY:
   151 				*bits = SH_MEM_READ | SH_MEM_WRITE;
   152 				break;
   153 			default:
   154 				return false;
   155 		}
   156 		return true;
   157 #endif
   158 	}
   159 
   160 	inline bool SetMemAccess(void *addr, size_t len, int access)
   161 	{
   162 # if SH_XP == SH_XP_POSIX
   163 		return mprotect(SH_LALIGN(addr), len + SH_LALDIF(addr), access)==0 ? true : false;
   164 # else
   165 		DWORD tmp;
   166 		DWORD prot;
   167 		switch (access)
   168 		{
   169 		case SH_MEM_READ:
   170 			prot = PAGE_READONLY; break;
   171 		case SH_MEM_READ | SH_MEM_WRITE:
   172 			prot = PAGE_READWRITE; break;
   173 		case SH_MEM_READ | SH_MEM_EXEC:
   174 			prot = PAGE_EXECUTE_READ; break;
   175 		default:
   176 		case SH_MEM_READ | SH_MEM_WRITE | SH_MEM_EXEC:
   177 			prot = PAGE_EXECUTE_READWRITE; break;
   178 		}
   179 		return VirtualProtect(addr, len, prot, &tmp) ? true : false;
   180 # endif
   181 	}
   182 
   183 	inline bool MakePageWritable(void *addr)
   184 	{
   185 		int bits;
   186 		if (GetPageBits(addr, &bits)) {
   187 			if (bits & SH_MEM_WRITE)
   188 				return true;
   189 			bits |= SH_MEM_WRITE;
   190 		} else {
   191 			bits = SH_MEM_READ | SH_MEM_WRITE | SH_MEM_EXEC;
   192 		}
   193 		return SetMemAccess(addr, sizeof(void *), bits);
   194 	}
   195 
   196 #if SH_XP == SH_XP_POSIX
   197 	namespace
   198 	{
   199 		bool g_BadReadCalled;
   200 		jmp_buf g_BadReadJmpBuf;
   201 
   202 # if SH_SYS == SH_SYS_LINUX
   203 		static void BadReadHandler(int sig)
   204 		{
   205 			if (g_BadReadCalled)
   206 				longjmp(g_BadReadJmpBuf, 1);
   207 		}
   208 # elif SH_SYS == SH_SYS_APPLE
   209 		static void BadReadHandler(int signal, siginfo_t* my_siginfo, void* my_context)	
   210 		{
   211 			if (g_BadReadCalled)
   212 				longjmp(g_BadReadJmpBuf, 1);
   213 		}
   214 # endif
   215 	}
   216 #endif
   217 
   218 	/**
   219 	*	@brief Checks whether the specified memory region is (still) accessible
   220 	*
   221 	*	@param addr The lower boundary
   222 	*	@param len Length of the region to be checked
   223 	*/
   224 	namespace
   225 	{
   226 		bool ModuleInMemory(char *addr, size_t len)
   227 		{
   228 #if SH_SYS == SH_SYS_LINUX
   229 			// On linux, first check /proc/self/maps
   230 			long lower = reinterpret_cast<long>(addr);
   231 			long upper = lower + len;
   232 
   233 			FILE *pF = fopen("/proc/self/maps", "r");
   234 			if (pF)
   235 			{
   236 				// Linux /proc/self/maps -> parse
   237 				// Format:
   238 				// lower    upper    prot     stuff                 path
   239 				// 08048000-0804c000 r-xp 00000000 03:03 1010107    /bin/cat
   240 				long rlower, rupper;
   241 				while (fscanf(pF, "%lx-%lx", &rlower, &rupper) != EOF)
   242 				{
   243 					// Check whether we're IN THERE!
   244 					if (lower >= rlower && upper <= rupper)
   245 					{
   246 						fclose(pF);
   247 						return true;
   248 					}
   249 					// Read to end of line
   250 					int c;
   251 					while ((c = fgetc(pF)) != '\n')
   252 					{
   253 						if (c == EOF)
   254 							break;
   255 					}
   256 					if (c == EOF)
   257 						break;
   258 				}
   259 				fclose(pF);
   260 				return false;
   261 			}
   262 			pF = fopen("/proc/curproc/map", "r");
   263 			if (pF)
   264 			{
   265 				// FreeBSD /proc/curproc/map -> parse
   266 				// 0x804800 0x805500 13 15 0xc6e18960 r-x 21 0x0 COW NC vnode
   267 				long rlower, rupper;
   268 				while (fscanf(pF, "0x%lx 0x%lx", &rlower, &rupper) != EOF)
   269 				{
   270 					// Check whether we're IN THERE!
   271 					if (lower >= rlower && upper <= rupper)
   272 					{
   273 						fclose(pF);
   274 						return true;
   275 					}
   276 					// Read to end of line
   277 					int c;
   278 					while ((c = fgetc(pF)) != '\n')
   279 					{
   280 						if (c == EOF)
   281 							break;
   282 					}
   283 					if (c == EOF)
   284 						break;
   285 				}
   286 				fclose(pF);
   287 				return false;
   288 			}
   289 
   290 			// Both of the above failed, try to actually read and trap sigsegv (implemented by Damaged Soul)
   291 			void(*prevHandler)(int sig);
   292 			g_BadReadCalled = true;
   293 
   294 			if (setjmp(g_BadReadJmpBuf))
   295 				return true;
   296 
   297 			prevHandler = signal(SIGSEGV, BadReadHandler);
   298 
   299 			volatile const char *p = reinterpret_cast<const char*>(addr);
   300 			char dummy;
   301 
   302 			for (size_t i = 0; i < len; i++)
   303 				dummy = p[i];
   304 
   305 			g_BadReadCalled = false;
   306 
   307 			signal(SIGSEGV, prevHandler);
   308 
   309 			return false;
   310 #elif SH_SYS == SH_SYS_APPLE
   311 			struct sigaction sa, osa;
   312 			sa.sa_sigaction = BadReadHandler;
   313 			sa.sa_flags = SA_SIGINFO | SA_RESTART;
   314 
   315 			g_BadReadCalled = true;
   316 
   317 			if (setjmp(g_BadReadJmpBuf))
   318 				return false;
   319 
   320 			if (sigaction(SIGBUS, &sa, &osa) == -1)
   321 				return false;
   322 
   323 			volatile const char *p = reinterpret_cast<const char *>(addr);
   324 			char dummy;
   325 
   326 			for (size_t i = 0; i < len; i++)
   327 				dummy = p[i];
   328 
   329 			g_BadReadCalled = false;
   330 
   331 			return true;
   332 #elif SH_XP == SH_XP_WINAPI
   333 			// On Win32, simply use IsBadReadPtr
   334 			return !IsBadReadPtr(addr, len);
   335 #endif
   336 		}
   337 	}
   338 }
   339 
   340 #endif