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;
357 break;
358 case PAGE_READWRITE:
359 access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE;
360 break;
361 case PAGE_EXECUTE:
362 access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_EXECUTE;
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;
367 break;
368 case PAGE_EXECUTE_READWRITE:
369 access = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE;
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 = FILE_MAP_READ;
473
474 if ((status = NtOpenSection( &ret, access, &attr )))
475 {
476 SetLastError( RtlNtStatusToDosError(status) );
477 ret = 0;
478 }
479 return ret;
480 }
481
482
483 /***********************************************************************
484 * MapViewOfFile (KERNEL32.@)
485 *
486 * Maps a view of a file into the address space.
487 *
488 * PARAMS
489 * mapping [I] File-mapping object to map.
490 * access [I] Access mode.
491 * offset_high [I] High-order 32 bits of file offset.
492 * offset_low [I] Low-order 32 bits of file offset.
493 * count [I] Number of bytes to map.
494 *
495 * RETURNS
496 * Success: Starting address of mapped view.
497 * Failure: NULL.
498 */
499 LPVOID WINAPI MapViewOfFile( HANDLE mapping, DWORD access,
500 DWORD offset_high, DWORD offset_low, SIZE_T count )
501 {
502 return MapViewOfFileEx( mapping, access, offset_high,
503 offset_low, count, NULL );
504 }
505
506
507 /***********************************************************************
508 * MapViewOfFileEx (KERNEL32.@)
509 *
510 * Maps a view of a file into the address space.
511 *
512 * PARAMS
513 * handle [I] File-mapping object to map.
514 * access [I] Access mode.
515 * offset_high [I] High-order 32 bits of file offset.
516 * offset_low [I] Low-order 32 bits of file offset.
517 * count [I] Number of bytes to map.
518 * addr [I] Suggested starting address for mapped view.
519 *
520 * RETURNS
521 * Success: Starting address of mapped view.
522 * Failure: NULL.
523 */
524 LPVOID WINAPI MapViewOfFileEx( HANDLE handle, DWORD access,
525 DWORD offset_high, DWORD offset_low, SIZE_T count, LPVOID addr )
526 {
527 NTSTATUS status;
528 LARGE_INTEGER offset;
529 ULONG protect;
530
531 offset.u.LowPart = offset_low;
532 offset.u.HighPart = offset_high;
533
534 if (access & FILE_MAP_WRITE) protect = PAGE_READWRITE;
535 else if (access & FILE_MAP_READ) protect = PAGE_READONLY;
536 else if (access & FILE_MAP_COPY) protect = PAGE_WRITECOPY;
537 else protect = PAGE_NOACCESS;
538
539 if ((status = NtMapViewOfSection( handle, GetCurrentProcess(), &addr, 0, 0, &offset,
540 &count, ViewShare, 0, protect )))
541 {
542 SetLastError( RtlNtStatusToDosError(status) );
543 addr = NULL;
544 }
545 return addr;
546 }
547
548
549 /***********************************************************************
550 * UnmapViewOfFile (KERNEL32.@)
551 *
552 * Unmaps a mapped view of a file.
553 *
554 * PARAMS
555 * addr [I] Address where mapped view begins.
556 *
557 * RETURNS
558 * Success: TRUE.
559 * Failure: FALSE.
560 *
561 */
562 BOOL WINAPI UnmapViewOfFile( LPCVOID addr )
563 {
564 NTSTATUS status = NtUnmapViewOfSection( GetCurrentProcess(), (void *)addr );
565 if (status) SetLastError( RtlNtStatusToDosError(status) );
566 return !status;
567 }
568
569
570 /***********************************************************************
571 * FlushViewOfFile (KERNEL32.@)
572 *
573 * Writes to the disk a byte range within a mapped view of a file.
574 *
575 * PARAMS
576 * base [I] Start address of byte range to flush.
577 * size [I] Number of bytes in range.
578 *
579 * RETURNS
580 * Success: TRUE.
581 * Failure: FALSE.
582 */
583 BOOL WINAPI FlushViewOfFile( LPCVOID base, SIZE_T size )
584 {
585 NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 );
586 if (status)
587 {
588 if (status == STATUS_NOT_MAPPED_DATA) status = STATUS_SUCCESS;
589 else SetLastError( RtlNtStatusToDosError(status) );
590 }
591 return !status;
592 }
593
594
595 /***********************************************************************
596 * IsBadReadPtr (KERNEL32.@)
597 *
598 * Check for read access on a memory block.
599 *
600 * ptr [I] Address of memory block.
601 * size [I] Size of block.
602 *
603 * RETURNS
604 * Success: TRUE.
605 * Failure: FALSE. Process has read access to entire block.
606 */
607 BOOL WINAPI IsBadReadPtr( LPCVOID ptr, UINT size )
608 {
609 if (!size) return FALSE; /* handle 0 size case w/o reference */
610 if (!ptr) return TRUE;
611
612 if (!page_size) page_size = getpagesize();
613 __TRY
614 {
615 volatile const char *p = ptr;
616 char dummy;
617 UINT count = size;
618
619 while (count > page_size)
620 {
621 dummy = *p;
622 p += page_size;
623 count -= page_size;
624 }
625 dummy = p[0];
626 dummy = p[count - 1];
627 }
628 __EXCEPT_PAGE_FAULT
629 {
630 TRACE_(seh)("%p caused page fault during read\n", ptr);
631 return TRUE;
632 }
633 __ENDTRY
634 return FALSE;
635 }
636
637
638 /***********************************************************************
639 * IsBadWritePtr (KERNEL32.@)
640 *
641 * Check for write access on a memory block.
642 *
643 * PARAMS
644 * ptr [I] Address of memory block.
645 * size [I] Size of block in bytes.
646 *
647 * RETURNS
648 * Success: TRUE.
649 * Failure: FALSE. Process has write access to entire block.
650 */
651 BOOL WINAPI IsBadWritePtr( LPVOID ptr, UINT size )
652 {
653 if (!size) return FALSE; /* handle 0 size case w/o reference */
654 if (!ptr) return TRUE;
655
656 if (!page_size) page_size = getpagesize();
657 __TRY
658 {
659 volatile char *p = ptr;
660 UINT count = size;
661
662 while (count > page_size)
663 {
664 *p |= 0;
665 p += page_size;
666 count -= page_size;
667 }
668 p[0] |= 0;
669 p[count - 1] |= 0;
670 }
671 __EXCEPT_PAGE_FAULT
672 {
673 TRACE_(seh)("%p caused page fault during write\n", ptr);
674 return TRUE;
675 }
676 __ENDTRY
677 return FALSE;
678 }
679
680
681 /***********************************************************************
682 * IsBadHugeReadPtr (KERNEL32.@)
683 *
684 * Check for read access on a memory block.
685 *
686 * PARAMS
687 * ptr [I] Address of memory block.
688 * size [I] Size of block.
689 *
690 * RETURNS
691 * Success: TRUE.
692 * Failure: FALSE. Process has read access to entire block.
693 */
694 BOOL WINAPI IsBadHugeReadPtr( LPCVOID ptr, UINT size )
695 {
696 return IsBadReadPtr( ptr, size );
697 }
698
699
700 /***********************************************************************
701 * IsBadHugeWritePtr (KERNEL32.@)
702 *
703 * Check for write access on a memory block.
704 *
705 * PARAMS
706 * ptr [I] Address of memory block.
707 * size [I] Size of block.
708 *
709 * RETURNS
710 * Success: TRUE.
711 * Failure: FALSE. Process has write access to entire block.
712 */
713 BOOL WINAPI IsBadHugeWritePtr( LPVOID ptr, UINT size )
714 {
715 return IsBadWritePtr( ptr, size );
716 }
717
718
719 /***********************************************************************
720 * IsBadCodePtr (KERNEL32.@)
721 *
722 * Check for read access on a memory address.
723 *
724 * PARAMS
725 * ptr [I] Address of function.
726 *
727 * RETURNS
728 * Success: TRUE.
729 * Failure: FALSE. Process has read access to specified memory.
730 */
731 BOOL WINAPI IsBadCodePtr( FARPROC ptr )
732 {
733 return IsBadReadPtr( ptr, 1 );
734 }
735
736
737 /***********************************************************************
738 * IsBadStringPtrA (KERNEL32.@)
739 *
740 * Check for read access on a range of memory pointed to by a string pointer.
741 *
742 * PARAMS
743 * str [I] Address of string.
744 * max [I] Maximum size of string.
745 *
746 * RETURNS
747 * Success: TRUE.
748 * Failure: FALSE. Read access to all bytes in string.
749 */
750 BOOL WINAPI IsBadStringPtrA( LPCSTR str, UINT max )
751 {
752 if (!str) return TRUE;
753
754 __TRY
755 {
756 volatile const char *p = str;
757 while (p != str + max) if (!*p++) break;
758 }
759 __EXCEPT_PAGE_FAULT
760 {
761 TRACE_(seh)("%p caused page fault during read\n", str);
762 return TRUE;
763 }
764 __ENDTRY
765 return FALSE;
766 }
767
768
769 /***********************************************************************
770 * IsBadStringPtrW (KERNEL32.@)
771 *
772 * See IsBadStringPtrA.
773 */
774 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT max )
775 {
776 if (!str) return TRUE;
777
778 __TRY
779 {
780 volatile const WCHAR *p = str;
781 while (p != str + max) if (!*p++) break;
782 }
783 __EXCEPT_PAGE_FAULT
784 {
785 TRACE_(seh)("%p caused page fault during read\n", str);
786 return TRUE;
787 }
788 __ENDTRY
789 return FALSE;
790 }
791
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.