kernel32: Add a stub for OpenProfileUserMapping.
[wine] / dlls / kernel32 / virtual.c
1 /*
2  * Win32 virtual memory functions
3  *
4  * Copyright 1997 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <fcntl.h>
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/types.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32
33 #define NONAMELESSUNION
34 #define NONAMELESSSTRUCT
35 #include "ntstatus.h"
36 #define WIN32_NO_STATUS
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winnls.h"
40 #include "winternl.h"
41 #include "winerror.h"
42 #include "wine/exception.h"
43 #include "wine/debug.h"
44
45 #include "kernel_private.h"
46
47 WINE_DECLARE_DEBUG_CHANNEL(seh);
48
49 static unsigned int page_size;
50
51
52 /***********************************************************************
53  *             VirtualAlloc   (KERNEL32.@)
54  *
55  * Reserves or commits a region of pages in virtual address space.
56  *
57  * PARAMS
58  *  addr    [I] Address of region to reserve or commit.
59  *  size    [I] Size of region.
60  *  type    [I] Type of allocation.
61  *  protect [I] Type of access protection.
62  *
63  * RETURNS
64  *      Success: Base address of allocated region of pages.
65  *      Failure: NULL.
66  */
67 LPVOID WINAPI VirtualAlloc( LPVOID addr, SIZE_T size, DWORD type, DWORD protect )
68 {
69     return VirtualAllocEx( GetCurrentProcess(), addr, size, type, protect );
70 }
71
72
73 /***********************************************************************
74  *             VirtualAllocEx   (KERNEL32.@)
75  *
76  * Seems to be just as VirtualAlloc, but with process handle.
77  *
78  * PARAMS
79  *  hProcess [I] Handle to process to do mem operation.
80  *  addr     [I] Address of region to reserve or commit.
81  *  size     [I] Size of region.
82  *  type     [I] Type of allocation.
83  *  protect  [I] Type of access protection.
84  *
85  *
86  * RETURNS
87  *      Success: Base address of allocated region of pages.
88  *      Failure: NULL.
89  */
90 LPVOID WINAPI VirtualAllocEx( HANDLE hProcess, LPVOID addr, SIZE_T size,
91     DWORD type, DWORD protect )
92 {
93     LPVOID ret = addr;
94     NTSTATUS status;
95
96     if ((status = NtAllocateVirtualMemory( hProcess, &ret, 0, &size, type, protect )))
97     {
98         SetLastError( RtlNtStatusToDosError(status) );
99         ret = NULL;
100     }
101     return ret;
102 }
103
104
105 /***********************************************************************
106  *             VirtualFree   (KERNEL32.@)
107  *
108  * Releases or decommits a region of pages in virtual address space.
109  *
110  * PARAMS
111  *  addr [I] Address of region of committed pages.
112  *  size [I] Size of region.
113  *  type [I] Type of operation.
114  *
115  * RETURNS
116  *      Success: TRUE.
117  *      Failure: FALSE.
118  */
119 BOOL WINAPI VirtualFree( LPVOID addr, SIZE_T size, DWORD type )
120 {
121     return VirtualFreeEx( GetCurrentProcess(), addr, size, type );
122 }
123
124
125 /***********************************************************************
126  *             VirtualFreeEx   (KERNEL32.@)
127  *
128  * Releases or decommits a region of pages in virtual address space.
129  *
130  * PARAMS
131  *  process [I] Handle to process.
132  *  addr    [I] Address of region to free.
133  *  size    [I] Size of region.
134  *  type    [I] Type of operation.
135  *
136  * RETURNS
137  *      Success: TRUE.
138  *      Failure: FALSE.
139  */
140 BOOL WINAPI VirtualFreeEx( HANDLE process, LPVOID addr, SIZE_T size, DWORD type )
141 {
142     NTSTATUS status = NtFreeVirtualMemory( process, &addr, &size, type );
143     if (status) SetLastError( RtlNtStatusToDosError(status) );
144     return !status;
145 }
146
147
148 /***********************************************************************
149  *             VirtualLock   (KERNEL32.@)
150  *
151  * Locks the specified region of virtual address space.
152  *
153  * PARAMS
154  *  addr [I] Address of first byte of range to lock.
155  *  size [I] Number of bytes in range to lock.
156  *
157  * RETURNS
158  *      Success: TRUE.
159  *      Failure: FALSE.
160  *
161  * NOTES
162  *      Always returns TRUE.
163  *
164  */
165 BOOL WINAPI VirtualLock( LPVOID addr, SIZE_T size )
166 {
167     NTSTATUS status = NtLockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 );
168     if (status) SetLastError( RtlNtStatusToDosError(status) );
169     return !status;
170 }
171
172
173 /***********************************************************************
174  *             VirtualUnlock   (KERNEL32.@)
175  *
176  * Unlocks a range of pages in the virtual address space.
177  *
178  * PARAMS
179  *  addr [I] Address of first byte of range.
180  *  size [I] Number of bytes in range.
181  *
182  * RETURNS
183  *      Success: TRUE.
184  *      Failure: FALSE.
185  *
186  * NOTES
187  *      Always returns TRUE.
188  *
189  */
190 BOOL WINAPI VirtualUnlock( LPVOID addr, SIZE_T size )
191 {
192     NTSTATUS status = NtUnlockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 );
193     if (status) SetLastError( RtlNtStatusToDosError(status) );
194     return !status;
195 }
196
197
198 /***********************************************************************
199  *             VirtualProtect   (KERNEL32.@)
200  *
201  * Changes the access protection on a region of committed pages.
202  *
203  * PARAMS
204  *  addr     [I] Address of region of committed pages.
205  *  size     [I] Size of region.
206  *  new_prot [I] Desired access protection.
207  *  old_prot [O] Address of variable to get old protection.
208  *
209  * RETURNS
210  *      Success: TRUE.
211  *      Failure: FALSE.
212  */
213 BOOL WINAPI VirtualProtect( LPVOID addr, SIZE_T size, DWORD new_prot, LPDWORD old_prot)
214 {
215     return VirtualProtectEx( GetCurrentProcess(), addr, size, new_prot, old_prot );
216 }
217
218
219 /***********************************************************************
220  *             VirtualProtectEx   (KERNEL32.@)
221  *
222  * Changes the access protection on a region of committed pages in the
223  * virtual address space of a specified process.
224  *
225  * PARAMS
226  *  process  [I] Handle of process.
227  *  addr     [I] Address of region of committed pages.
228  *  size     [I] Size of region.
229  *  new_prot [I] Desired access protection.
230  *  old_prot [O] Address of variable to get old protection.
231  *
232  * RETURNS
233  *      Success: TRUE.
234  *      Failure: FALSE.
235  */
236 BOOL WINAPI VirtualProtectEx( HANDLE process, LPVOID addr, SIZE_T size,
237     DWORD new_prot, LPDWORD old_prot )
238 {
239     NTSTATUS status = NtProtectVirtualMemory( process, &addr, &size, new_prot, old_prot );
240     if (status) SetLastError( RtlNtStatusToDosError(status) );
241     return !status;
242 }
243
244
245 /***********************************************************************
246  *             VirtualQuery   (KERNEL32.@)
247  *
248  * Provides info about a range of pages in virtual address space.
249  *
250  * PARAMS
251  *  addr [I] Address of region.
252  *  info [O] Address of info buffer.
253  *  len  [I] Size of buffer.
254  *
255  * RETURNS
256  *      Number of bytes returned in information buffer or 0 if
257  *      addr >= 0xc0000000 (kernel space).
258  */
259 SIZE_T WINAPI VirtualQuery( LPCVOID addr, PMEMORY_BASIC_INFORMATION info,
260     SIZE_T len )
261 {
262     return VirtualQueryEx( GetCurrentProcess(), addr, info, len );
263 }
264
265
266 /***********************************************************************
267  *             VirtualQueryEx   (KERNEL32.@)
268  *
269  * Provides info about a range of pages in virtual address space of a
270  * specified process.
271  *
272  * PARAMS
273  *  process [I] Handle to process.
274  *  addr    [I] Address of region.
275  *  info    [O] Address of info buffer.
276  *  len     [I] Size of buffer.
277  *
278  * RETURNS
279  *      Number of bytes returned in information buffer.
280  */
281 SIZE_T WINAPI VirtualQueryEx( HANDLE process, LPCVOID addr,
282     PMEMORY_BASIC_INFORMATION info, SIZE_T len )
283 {
284     SIZE_T ret;
285     NTSTATUS status;
286
287     if ((status = NtQueryVirtualMemory( process, addr, MemoryBasicInformation, info, len, &ret )))
288     {
289         SetLastError( RtlNtStatusToDosError(status) );
290         ret = 0;
291     }
292     return ret;
293 }
294
295
296 /***********************************************************************
297  *             CreateFileMappingA   (KERNEL32.@)
298  *
299  * Creates a named or unnamed file-mapping object for the specified file.
300  *
301  * PARAMS
302  *  hFile     [I] Handle to the file to map.
303  *  sa        [I] Optional security attributes.
304  *  protect   [I] Protection for mapping object.
305  *  size_high [I] High-order 32 bits of object size.
306  *  size_low  [I] Low-order 32 bits of object size.
307  *  name      [I] Name of file-mapping object.
308  *
309  * RETURNS
310  *      Success: Handle.
311  *      Failure: NULL. Mapping object does not exist.
312  */
313 HANDLE WINAPI CreateFileMappingA( HANDLE hFile, SECURITY_ATTRIBUTES *sa,
314     DWORD protect, DWORD size_high, DWORD size_low, LPCSTR name )
315 {
316     WCHAR buffer[MAX_PATH];
317
318     if (!name) return CreateFileMappingW( hFile, sa, protect, size_high, size_low, NULL );
319
320     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
321     {
322         SetLastError( ERROR_FILENAME_EXCED_RANGE );
323         return 0;
324     }
325     return CreateFileMappingW( hFile, sa, protect, size_high, size_low, buffer );
326 }
327
328
329 /***********************************************************************
330  *             CreateFileMappingW   (KERNEL32.@)
331  *
332  * See CreateFileMappingA.
333  */
334 HANDLE WINAPI CreateFileMappingW( HANDLE hFile, LPSECURITY_ATTRIBUTES sa,
335                                   DWORD protect, DWORD size_high,
336                                   DWORD size_low, LPCWSTR name )
337 {
338     static const int sec_flags = SEC_FILE | SEC_IMAGE | SEC_RESERVE | SEC_COMMIT | SEC_NOCACHE;
339
340     HANDLE ret;
341     NTSTATUS status;
342     DWORD access, sec_type;
343     LARGE_INTEGER size;
344
345     sec_type = protect & sec_flags;
346     protect &= ~sec_flags;
347     if (!sec_type) sec_type = SEC_COMMIT;
348
349     switch(protect)
350     {
351     case 0:
352         protect = PAGE_READONLY;  /* Win9x compatibility */
353         /* fall through */
354     case PAGE_READONLY:
355     case PAGE_WRITECOPY:
356         access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_EXECUTE;
357         break;
358     case PAGE_READWRITE:
359         access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE;
360         break;
361     case PAGE_EXECUTE:
362         access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_EXECUTE | SECTION_MAP_EXECUTE_EXPLICIT;
363         break;
364     case PAGE_EXECUTE_READ:
365     case PAGE_EXECUTE_WRITECOPY:
366         access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_MAP_EXECUTE_EXPLICIT;
367         break;
368     case PAGE_EXECUTE_READWRITE:
369         access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE | SECTION_MAP_EXECUTE_EXPLICIT;
370         break;
371     default:
372         SetLastError( ERROR_INVALID_PARAMETER );
373         return 0;
374     }
375
376     if (hFile == INVALID_HANDLE_VALUE)
377     {
378         hFile = 0;
379         if (!size_low && !size_high)
380         {
381             SetLastError( ERROR_INVALID_PARAMETER );
382             return 0;
383         }
384     }
385
386     size.u.LowPart  = size_low;
387     size.u.HighPart = size_high;
388
389     if (sa || name)
390     {
391         OBJECT_ATTRIBUTES attr;
392         UNICODE_STRING nameW;
393
394         attr.Length                   = sizeof(attr);
395         attr.RootDirectory            = 0;
396         attr.ObjectName               = NULL;
397         attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
398         attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
399         attr.SecurityQualityOfService = NULL;
400         if (name)
401         {
402             RtlInitUnicodeString( &nameW, name );
403             attr.ObjectName = &nameW;
404             attr.RootDirectory = get_BaseNamedObjects_handle();
405         }
406         status = NtCreateSection( &ret, access, &attr, &size, protect, sec_type, hFile );
407     }
408     else status = NtCreateSection( &ret, access, NULL, &size, protect, sec_type, hFile );
409
410     if (status == STATUS_OBJECT_NAME_EXISTS)
411         SetLastError( ERROR_ALREADY_EXISTS );
412     else
413         SetLastError( RtlNtStatusToDosError(status) );
414     return ret;
415 }
416
417
418 /***********************************************************************
419  *             OpenFileMappingA   (KERNEL32.@)
420  *
421  * Opens a named file-mapping object.
422  *
423  * PARAMS
424  *  access  [I] Access mode.
425  *  inherit [I] Inherit flag.
426  *  name    [I] Name of file-mapping object.
427  *
428  * RETURNS
429  *      Success: Handle.
430  *      Failure: NULL.
431  */
432 HANDLE WINAPI OpenFileMappingA( DWORD access, BOOL inherit, LPCSTR name )
433 {
434     WCHAR buffer[MAX_PATH];
435
436     if (!name) return OpenFileMappingW( access, inherit, NULL );
437
438     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
439     {
440         SetLastError( ERROR_FILENAME_EXCED_RANGE );
441         return 0;
442     }
443     return OpenFileMappingW( access, inherit, buffer );
444 }
445
446
447 /***********************************************************************
448  *             OpenFileMappingW   (KERNEL32.@)
449  *
450  * See OpenFileMappingA.
451  */
452 HANDLE WINAPI OpenFileMappingW( DWORD access, BOOL inherit, LPCWSTR name)
453 {
454     OBJECT_ATTRIBUTES attr;
455     UNICODE_STRING nameW;
456     HANDLE ret;
457     NTSTATUS status;
458
459     if (!name)
460     {
461         SetLastError( ERROR_INVALID_PARAMETER );
462         return 0;
463     }
464     attr.Length = sizeof(attr);
465     attr.RootDirectory = get_BaseNamedObjects_handle();
466     attr.ObjectName = &nameW;
467     attr.Attributes = inherit ? OBJ_INHERIT : 0;
468     attr.SecurityDescriptor = NULL;
469     attr.SecurityQualityOfService = NULL;
470     RtlInitUnicodeString( &nameW, name );
471
472     if (access == FILE_MAP_COPY) access = SECTION_MAP_READ;
473     access |= SECTION_QUERY;
474
475     if (GetVersion() & 0x80000000)
476     {
477         /* win9x doesn't do access checks, so try with full access first */
478         if (!NtOpenSection( &ret, access | SECTION_MAP_READ | SECTION_MAP_WRITE, &attr )) return ret;
479     }
480
481     if ((status = NtOpenSection( &ret, access, &attr )))
482     {
483         SetLastError( RtlNtStatusToDosError(status) );
484         ret = 0;
485     }
486     return ret;
487 }
488
489
490 /***********************************************************************
491  *             MapViewOfFile   (KERNEL32.@)
492  *
493  * Maps a view of a file into the address space.
494  *
495  * PARAMS
496  *  mapping     [I] File-mapping object to map.
497  *  access      [I] Access mode.
498  *  offset_high [I] High-order 32 bits of file offset.
499  *  offset_low  [I] Low-order 32 bits of file offset.
500  *  count       [I] Number of bytes to map.
501  *
502  * RETURNS
503  *      Success: Starting address of mapped view.
504  *      Failure: NULL.
505  */
506 LPVOID WINAPI MapViewOfFile( HANDLE mapping, DWORD access,
507     DWORD offset_high, DWORD offset_low, SIZE_T count )
508 {
509     return MapViewOfFileEx( mapping, access, offset_high,
510                             offset_low, count, NULL );
511 }
512
513
514 /***********************************************************************
515  *             MapViewOfFileEx   (KERNEL32.@)
516  *
517  * Maps a view of a file into the address space.
518  *
519  * PARAMS
520  *  handle      [I] File-mapping object to map.
521  *  access      [I] Access mode.
522  *  offset_high [I] High-order 32 bits of file offset.
523  *  offset_low  [I] Low-order 32 bits of file offset.
524  *  count       [I] Number of bytes to map.
525  *  addr        [I] Suggested starting address for mapped view.
526  *
527  * RETURNS
528  *      Success: Starting address of mapped view.
529  *      Failure: NULL.
530  */
531 LPVOID WINAPI MapViewOfFileEx( HANDLE handle, DWORD access,
532     DWORD offset_high, DWORD offset_low, SIZE_T count, LPVOID addr )
533 {
534     NTSTATUS status;
535     LARGE_INTEGER offset;
536     ULONG protect;
537
538     offset.u.LowPart  = offset_low;
539     offset.u.HighPart = offset_high;
540
541     if (access & FILE_MAP_WRITE) protect = PAGE_READWRITE;
542     else if (access & FILE_MAP_READ) protect = PAGE_READONLY;
543     else if (access & FILE_MAP_COPY) protect = PAGE_WRITECOPY;
544     else protect = PAGE_NOACCESS;
545
546     if (access & FILE_MAP_EXECUTE) protect <<= 4;
547
548     if ((status = NtMapViewOfSection( handle, GetCurrentProcess(), &addr, 0, 0, &offset,
549                                       &count, ViewShare, 0, protect )))
550     {
551         SetLastError( RtlNtStatusToDosError(status) );
552         addr = NULL;
553     }
554     return addr;
555 }
556
557
558 /***********************************************************************
559  *             UnmapViewOfFile   (KERNEL32.@)
560  *
561  * Unmaps a mapped view of a file.
562  *
563  * PARAMS
564  *  addr [I] Address where mapped view begins.
565  *
566  * RETURNS
567  *      Success: TRUE.
568  *      Failure: FALSE.
569  *
570  */
571 BOOL WINAPI UnmapViewOfFile( LPCVOID addr )
572 {
573     NTSTATUS status = NtUnmapViewOfSection( GetCurrentProcess(), (void *)addr );
574     if (status) SetLastError( RtlNtStatusToDosError(status) );
575     return !status;
576 }
577
578
579 /***********************************************************************
580  *             FlushViewOfFile   (KERNEL32.@)
581  *
582  * Writes to the disk a byte range within a mapped view of a file.
583  *
584  * PARAMS
585  *  base [I] Start address of byte range to flush.
586  *  size [I] Number of bytes in range.
587  *
588  * RETURNS
589  *      Success: TRUE.
590  *      Failure: FALSE.
591  */
592 BOOL WINAPI FlushViewOfFile( LPCVOID base, SIZE_T size )
593 {
594     NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 );
595     if (status)
596     {
597         if (status == STATUS_NOT_MAPPED_DATA) status = STATUS_SUCCESS;
598         else SetLastError( RtlNtStatusToDosError(status) );
599     }
600     return !status;
601 }
602
603
604 /***********************************************************************
605  *             GetWriteWatch   (KERNEL32.@)
606  */
607 UINT WINAPI GetWriteWatch( DWORD flags, LPVOID base, SIZE_T size, LPVOID *addresses,
608                            ULONG_PTR *count, ULONG *granularity )
609 {
610     NTSTATUS status;
611
612     status = NtGetWriteWatch( GetCurrentProcess(), flags, base, size, addresses, count, granularity );
613     if (status) SetLastError( RtlNtStatusToDosError(status) );
614     return status ? ~0u : 0;
615 }
616
617
618 /***********************************************************************
619  *             ResetWriteWatch   (KERNEL32.@)
620  */
621 UINT WINAPI ResetWriteWatch( LPVOID base, SIZE_T size )
622 {
623     NTSTATUS status;
624
625     status = NtResetWriteWatch( GetCurrentProcess(), base, size );
626     if (status) SetLastError( RtlNtStatusToDosError(status) );
627     return status ? ~0u : 0;
628 }
629
630
631 /***********************************************************************
632  *             IsBadReadPtr   (KERNEL32.@)
633  *
634  * Check for read access on a memory block.
635  *
636  * ptr  [I] Address of memory block.
637  * size [I] Size of block.
638  *
639  * RETURNS
640  *  Success: TRUE.
641  *      Failure: FALSE. Process has read access to entire block.
642  */
643 BOOL WINAPI IsBadReadPtr( LPCVOID ptr, UINT size )
644 {
645     if (!size) return FALSE;  /* handle 0 size case w/o reference */
646     if (!ptr) return TRUE;
647     
648     if (!page_size) page_size = getpagesize();
649     __TRY
650     {
651         volatile const char *p = ptr;
652         char dummy;
653         UINT count = size;
654
655         while (count > page_size)
656         {
657             dummy = *p;
658             p += page_size;
659             count -= page_size;
660         }
661         dummy = p[0];
662         dummy = p[count - 1];
663     }
664     __EXCEPT_PAGE_FAULT
665     {
666         TRACE_(seh)("%p caused page fault during read\n", ptr);
667         return TRUE;
668     }
669     __ENDTRY
670     return FALSE;
671 }
672
673
674 /***********************************************************************
675  *             IsBadWritePtr   (KERNEL32.@)
676  *
677  * Check for write access on a memory block.
678  *
679  * PARAMS
680  *  ptr  [I] Address of memory block.
681  *  size [I] Size of block in bytes.
682  *
683  * RETURNS
684  *  Success: TRUE.
685  *      Failure: FALSE. Process has write access to entire block.
686  */
687 BOOL WINAPI IsBadWritePtr( LPVOID ptr, UINT size )
688 {
689     if (!size) return FALSE;  /* handle 0 size case w/o reference */
690     if (!ptr) return TRUE;
691     
692     if (!page_size) page_size = getpagesize();
693     __TRY
694     {
695         volatile char *p = ptr;
696         UINT count = size;
697
698         while (count > page_size)
699         {
700             *p |= 0;
701             p += page_size;
702             count -= page_size;
703         }
704         p[0] |= 0;
705         p[count - 1] |= 0;
706     }
707     __EXCEPT_PAGE_FAULT
708     {
709         TRACE_(seh)("%p caused page fault during write\n", ptr);
710         return TRUE;
711     }
712     __ENDTRY
713     return FALSE;
714 }
715
716
717 /***********************************************************************
718  *             IsBadHugeReadPtr   (KERNEL32.@)
719  *
720  * Check for read access on a memory block.
721  *
722  * PARAMS
723  *  ptr  [I] Address of memory block.
724  *  size [I] Size of block.
725  *
726  * RETURNS
727  *  Success: TRUE.
728  *      Failure: FALSE. Process has read access to entire block.
729  */
730 BOOL WINAPI IsBadHugeReadPtr( LPCVOID ptr, UINT size )
731 {
732     return IsBadReadPtr( ptr, size );
733 }
734
735
736 /***********************************************************************
737  *             IsBadHugeWritePtr   (KERNEL32.@)
738  *
739  * Check for write access on a memory block.
740  *
741  * PARAMS
742  *  ptr  [I] Address of memory block.
743  *  size [I] Size of block.
744  *
745  * RETURNS
746  *  Success: TRUE.
747  *      Failure: FALSE. Process has write access to entire block.
748  */
749 BOOL WINAPI IsBadHugeWritePtr( LPVOID ptr, UINT size )
750 {
751     return IsBadWritePtr( ptr, size );
752 }
753
754
755 /***********************************************************************
756  *             IsBadCodePtr   (KERNEL32.@)
757  *
758  * Check for read access on a memory address.
759  *
760  * PARAMS
761  *  ptr [I] Address of function.
762  *
763  * RETURNS
764  *      Success: TRUE.
765  *      Failure: FALSE. Process has read access to specified memory.
766  */
767 BOOL WINAPI IsBadCodePtr( FARPROC ptr )
768 {
769     return IsBadReadPtr( ptr, 1 );
770 }
771
772
773 /***********************************************************************
774  *             IsBadStringPtrA   (KERNEL32.@)
775  *
776  * Check for read access on a range of memory pointed to by a string pointer.
777  *
778  * PARAMS
779  *  str [I] Address of string.
780  *  max [I] Maximum size of string.
781  *
782  * RETURNS
783  *      Success: TRUE.
784  *      Failure: FALSE. Read access to all bytes in string.
785  */
786 BOOL WINAPI IsBadStringPtrA( LPCSTR str, UINT max )
787 {
788     if (!str) return TRUE;
789     
790     __TRY
791     {
792         volatile const char *p = str;
793         while (p != str + max) if (!*p++) break;
794     }
795     __EXCEPT_PAGE_FAULT
796     {
797         TRACE_(seh)("%p caused page fault during read\n", str);
798         return TRUE;
799     }
800     __ENDTRY
801     return FALSE;
802 }
803
804
805 /***********************************************************************
806  *             IsBadStringPtrW   (KERNEL32.@)
807  *
808  * See IsBadStringPtrA.
809  */
810 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT max )
811 {
812     if (!str) return TRUE;
813     
814     __TRY
815     {
816         volatile const WCHAR *p = str;
817         while (p != str + max) if (!*p++) break;
818     }
819     __EXCEPT_PAGE_FAULT
820     {
821         TRACE_(seh)("%p caused page fault during read\n", str);
822         return TRUE;
823     }
824     __ENDTRY
825     return FALSE;
826 }