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