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