oleaut32: Added MEMBERID_NIL handling to ICreateTypeInfo_LayOut.
[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_COPY) protect = PAGE_WRITECOPY;
543     else protect = PAGE_READONLY;
544
545     if (access & FILE_MAP_EXECUTE) protect <<= 4;
546
547     if ((status = NtMapViewOfSection( handle, GetCurrentProcess(), &addr, 0, 0, &offset,
548                                       &count, ViewShare, 0, protect )))
549     {
550         SetLastError( RtlNtStatusToDosError(status) );
551         addr = NULL;
552     }
553     return addr;
554 }
555
556
557 /***********************************************************************
558  *             UnmapViewOfFile   (KERNEL32.@)
559  *
560  * Unmaps a mapped view of a file.
561  *
562  * PARAMS
563  *  addr [I] Address where mapped view begins.
564  *
565  * RETURNS
566  *      Success: TRUE.
567  *      Failure: FALSE.
568  *
569  */
570 BOOL WINAPI UnmapViewOfFile( LPCVOID addr )
571 {
572     NTSTATUS status = NtUnmapViewOfSection( GetCurrentProcess(), (void *)addr );
573     if (status) SetLastError( RtlNtStatusToDosError(status) );
574     return !status;
575 }
576
577
578 /***********************************************************************
579  *             FlushViewOfFile   (KERNEL32.@)
580  *
581  * Writes to the disk a byte range within a mapped view of a file.
582  *
583  * PARAMS
584  *  base [I] Start address of byte range to flush.
585  *  size [I] Number of bytes in range.
586  *
587  * RETURNS
588  *      Success: TRUE.
589  *      Failure: FALSE.
590  */
591 BOOL WINAPI FlushViewOfFile( LPCVOID base, SIZE_T size )
592 {
593     NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 );
594     if (status)
595     {
596         if (status == STATUS_NOT_MAPPED_DATA) status = STATUS_SUCCESS;
597         else SetLastError( RtlNtStatusToDosError(status) );
598     }
599     return !status;
600 }
601
602
603 /***********************************************************************
604  *             GetWriteWatch   (KERNEL32.@)
605  */
606 UINT WINAPI GetWriteWatch( DWORD flags, LPVOID base, SIZE_T size, LPVOID *addresses,
607                            ULONG_PTR *count, ULONG *granularity )
608 {
609     NTSTATUS status;
610
611     status = NtGetWriteWatch( GetCurrentProcess(), flags, base, size, addresses, count, granularity );
612     if (status) SetLastError( RtlNtStatusToDosError(status) );
613     return status ? ~0u : 0;
614 }
615
616
617 /***********************************************************************
618  *             ResetWriteWatch   (KERNEL32.@)
619  */
620 UINT WINAPI ResetWriteWatch( LPVOID base, SIZE_T size )
621 {
622     NTSTATUS status;
623
624     status = NtResetWriteWatch( GetCurrentProcess(), base, size );
625     if (status) SetLastError( RtlNtStatusToDosError(status) );
626     return status ? ~0u : 0;
627 }
628
629
630 /***********************************************************************
631  *             IsBadReadPtr   (KERNEL32.@)
632  *
633  * Check for read access on a memory block.
634  *
635  * ptr  [I] Address of memory block.
636  * size [I] Size of block.
637  *
638  * RETURNS
639  *  Success: TRUE.
640  *      Failure: FALSE. Process has read access to entire block.
641  */
642 BOOL WINAPI IsBadReadPtr( LPCVOID ptr, UINT size )
643 {
644     if (!size) return FALSE;  /* handle 0 size case w/o reference */
645     if (!ptr) return TRUE;
646     
647     if (!page_size) page_size = getpagesize();
648     __TRY
649     {
650         volatile const char *p = ptr;
651         char dummy;
652         UINT count = size;
653
654         while (count > page_size)
655         {
656             dummy = *p;
657             p += page_size;
658             count -= page_size;
659         }
660         dummy = p[0];
661         dummy = p[count - 1];
662     }
663     __EXCEPT_PAGE_FAULT
664     {
665         TRACE_(seh)("%p caused page fault during read\n", ptr);
666         return TRUE;
667     }
668     __ENDTRY
669     return FALSE;
670 }
671
672
673 /***********************************************************************
674  *             IsBadWritePtr   (KERNEL32.@)
675  *
676  * Check for write access on a memory block.
677  *
678  * PARAMS
679  *  ptr  [I] Address of memory block.
680  *  size [I] Size of block in bytes.
681  *
682  * RETURNS
683  *  Success: TRUE.
684  *      Failure: FALSE. Process has write access to entire block.
685  */
686 BOOL WINAPI IsBadWritePtr( LPVOID ptr, UINT size )
687 {
688     if (!size) return FALSE;  /* handle 0 size case w/o reference */
689     if (!ptr) return TRUE;
690     
691     if (!page_size) page_size = getpagesize();
692     __TRY
693     {
694         volatile char *p = ptr;
695         UINT count = size;
696
697         while (count > page_size)
698         {
699             *p |= 0;
700             p += page_size;
701             count -= page_size;
702         }
703         p[0] |= 0;
704         p[count - 1] |= 0;
705     }
706     __EXCEPT_PAGE_FAULT
707     {
708         TRACE_(seh)("%p caused page fault during write\n", ptr);
709         return TRUE;
710     }
711     __ENDTRY
712     return FALSE;
713 }
714
715
716 /***********************************************************************
717  *             IsBadHugeReadPtr   (KERNEL32.@)
718  *
719  * Check for read access on a memory block.
720  *
721  * PARAMS
722  *  ptr  [I] Address of memory block.
723  *  size [I] Size of block.
724  *
725  * RETURNS
726  *  Success: TRUE.
727  *      Failure: FALSE. Process has read access to entire block.
728  */
729 BOOL WINAPI IsBadHugeReadPtr( LPCVOID ptr, UINT size )
730 {
731     return IsBadReadPtr( ptr, size );
732 }
733
734
735 /***********************************************************************
736  *             IsBadHugeWritePtr   (KERNEL32.@)
737  *
738  * Check for write access on a memory block.
739  *
740  * PARAMS
741  *  ptr  [I] Address of memory block.
742  *  size [I] Size of block.
743  *
744  * RETURNS
745  *  Success: TRUE.
746  *      Failure: FALSE. Process has write access to entire block.
747  */
748 BOOL WINAPI IsBadHugeWritePtr( LPVOID ptr, UINT size )
749 {
750     return IsBadWritePtr( ptr, size );
751 }
752
753
754 /***********************************************************************
755  *             IsBadCodePtr   (KERNEL32.@)
756  *
757  * Check for read access on a memory address.
758  *
759  * PARAMS
760  *  ptr [I] Address of function.
761  *
762  * RETURNS
763  *      Success: TRUE.
764  *      Failure: FALSE. Process has read access to specified memory.
765  */
766 BOOL WINAPI IsBadCodePtr( FARPROC ptr )
767 {
768     return IsBadReadPtr( ptr, 1 );
769 }
770
771
772 /***********************************************************************
773  *             IsBadStringPtrA   (KERNEL32.@)
774  *
775  * Check for read access on a range of memory pointed to by a string pointer.
776  *
777  * PARAMS
778  *  str [I] Address of string.
779  *  max [I] Maximum size of string.
780  *
781  * RETURNS
782  *      Success: TRUE.
783  *      Failure: FALSE. Read access to all bytes in string.
784  */
785 BOOL WINAPI IsBadStringPtrA( LPCSTR str, UINT max )
786 {
787     if (!str) return TRUE;
788     
789     __TRY
790     {
791         volatile const char *p = str;
792         while (p != str + max) if (!*p++) break;
793     }
794     __EXCEPT_PAGE_FAULT
795     {
796         TRACE_(seh)("%p caused page fault during read\n", str);
797         return TRUE;
798     }
799     __ENDTRY
800     return FALSE;
801 }
802
803
804 /***********************************************************************
805  *             IsBadStringPtrW   (KERNEL32.@)
806  *
807  * See IsBadStringPtrA.
808  */
809 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT max )
810 {
811     if (!str) return TRUE;
812     
813     __TRY
814     {
815         volatile const WCHAR *p = str;
816         while (p != str + max) if (!*p++) break;
817     }
818     __EXCEPT_PAGE_FAULT
819     {
820         TRACE_(seh)("%p caused page fault during read\n", str);
821         return TRUE;
822     }
823     __ENDTRY
824     return FALSE;
825 }