reactos/lib/kernel32/mem/isbad.c

   1 /* $Id$
   2  *
   3  * lib/kernel32/mem/isbad.c
   4  *
   5  * ReactOS Operating System
   6  *
   7  */
   8 #include <k32.h>
   9
  10 #define NDEBUG
  11 #include "../include/debug.h"
  12
  13 /* FIXME: Stubs. What is it for? */
  14 /*
  15  * @implemented
  16  */
  17 UINT
  18 wcsnlen (
  19         LPCWSTR lpsz,
  20         UINT    ucchMax
  21         )
  22 {
  23   UINT i = 0;
  24   while( lpsz[i] && i < ucchMax ) i++;
  25   return i;
  26 }
  27
  28
  29 /* FIXME: Stubs. What is it for? */
  30 /*
  31  * @implemented
  32  */
  33 UINT
  34 strnlen (
  35         LPCSTR  lpsz,
  36         UINT    uiMax
  37         )
  38 {
  39   UINT i = 0;
  40   while( lpsz[i] && i < uiMax ) i++;
  41   return i;
  42 }
  43
  44 /* --- --- --- */
  45
  46 /*
  47  * @implemented
  48  */
  49 BOOL
  50 STDCALL
  51 IsBadReadPtr (
  52         CONST VOID      * lp,
  53         UINT            ucb
  54         )
  55 {
  56         MEMORY_BASIC_INFORMATION MemoryInformation;
  57
  58         if ( ucb == 0 )
  59         {
  60                 return TRUE;
  61         }
  62
  63         VirtualQuery (
  64                 lp,
  65                 & MemoryInformation,
  66                 sizeof (MEMORY_BASIC_INFORMATION)
  67                 );
  68
  69         if ( MemoryInformation.State != MEM_COMMIT )
  70         {
  71                 return TRUE;
  72         }
  73
  74         if ( MemoryInformation.RegionSize < ucb )
  75         {
  76                 return TRUE;
  77         }
  78
  79         if ( MemoryInformation.Protect == PAGE_EXECUTE )
  80         {
  81                 return TRUE;
  82         }
  83
  84         if ( MemoryInformation.Protect == PAGE_NOACCESS )
  85         {
  86                 return TRUE;
  87         }
  88
  89         return FALSE;
  90
  91 }
  92
  93
  94 /*
  95  * @implemented
  96  */
  97 BOOL
  98 STDCALL
  99 IsBadHugeReadPtr (
 100         CONST VOID      * lp,
 101         UINT            ucb
 102         )
 103 {
 104         return IsBadReadPtr (lp, ucb);
 105 }
 106
 107
 108 /*
 109  * @implemented
 110  */
 111 BOOL
 112 STDCALL
 113 IsBadCodePtr (
 114         FARPROC lpfn
 115         )
 116 {
 117         MEMORY_BASIC_INFORMATION MemoryInformation;
 118
 119
 120         VirtualQuery (
 121                 lpfn,
 122                 & MemoryInformation,
 123                 sizeof (MEMORY_BASIC_INFORMATION)
 124                 );
 125
 126         if ( MemoryInformation.State != MEM_COMMIT )
 127         {
 128                 return TRUE;
 129         }
 130
 131         if (    (MemoryInformation.Protect == PAGE_EXECUTE)
 132                 || (MemoryInformation.Protect == PAGE_EXECUTE_READ)
 133                 )
 134         {
 135                 return FALSE;
 136         }
 137
 138         return TRUE;
 139 }
 140
 141
 142 /*
 143  * @implemented
 144  */
 145 BOOL
 146 STDCALL
 147 IsBadWritePtr (
 148         LPVOID  lp,
 149         UINT    ucb
 150         )
 151 {
 152         MEMORY_BASIC_INFORMATION MemoryInformation;
 153
 154         if ( ucb == 0 )
 155         {
 156                 return TRUE;
 157         }
 158
 159         VirtualQuery (
 160                 lp,
 161                 & MemoryInformation,
 162                 sizeof (MEMORY_BASIC_INFORMATION)
 163                 );
 164
 165         if ( MemoryInformation.State != MEM_COMMIT )
 166         {
 167                 return TRUE;
 168         }
 169
 170         if ( MemoryInformation.RegionSize < ucb )
 171         {
 172                 return TRUE;
 173         }
 174
 175
 176         if ( MemoryInformation.Protect == PAGE_READONLY)
 177         {
 178                 return TRUE;
 179         }
 180
 181         if (    (MemoryInformation.Protect == PAGE_EXECUTE)
 182                 || (MemoryInformation.Protect == PAGE_EXECUTE_READ)
 183                 )
 184         {
 185                 return TRUE;
 186         }
 187
 188         if ( MemoryInformation.Protect == PAGE_NOACCESS )
 189         {
 190                 return TRUE;
 191         }
 192
 193         return FALSE;
 194 }
 195
 196
 197 /*
 198  * @implemented
 199  */
 200 BOOL
 201 STDCALL
 202 IsBadHugeWritePtr (
 203         LPVOID  lp,
 204         UINT    ucb
 205         )
 206 {
 207         return IsBadWritePtr (lp, ucb);
 208 }
 209
 210
 211 /*
 212  * @implemented
 213  */
 214 BOOL
 215 STDCALL
 216 IsBadStringPtrW (
 217         LPCWSTR lpsz,
 218         UINT    ucchMax
 219         )
 220 {
 221         UINT Len = wcsnlen (
 222                         lpsz + 1,
 223                         ucchMax >> 1
 224                         );
 225         return IsBadReadPtr (
 226                         lpsz,
 227                         Len << 1
 228                         );
 229 }
 230
 231
 232 /*
 233  * @implemented
 234  */
 235 BOOL
 236 STDCALL
 237 IsBadStringPtrA (
 238         LPCSTR  lpsz,
 239         UINT    ucchMax
 240         )
 241 {
 242         UINT Len = strnlen (
 243                         lpsz + 1,
 244                         ucchMax
 245                         );
 246         return IsBadReadPtr (
 247                         lpsz,
 248                         Len
 249                         );
 250 }
 251
 252
 253 /* EOF */