?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d8: Get rid of the format switching code in d3d8_device_CopyRects().
[wine.git] / dlls / kernel32 / sync.c
blobd399b829f0dc585cf4575ac3105835c72aafce87
1 /*
2 * Kernel synchronization objects
3 *
4 * Copyright 1998 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 <string.h>
25 #ifdef HAVE_UNISTD_H
26 # include <unistd.h>
27 #endif
28 #include <errno.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31
32 #define NONAMELESSUNION
33 #define NONAMELESSSTRUCT
34
35 #include "ntstatus.h"
36 #define WIN32_NO_STATUS
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winerror.h"
40 #include "winnls.h"
41 #include "winternl.h"
42 #include "winioctl.h"
43 #include "ddk/wdm.h"
44
45 #include "wine/unicode.h"
46 #include "kernel_private.h"
47
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(sync);
51
52 /* check if current version is NT or Win95 */
53 static inline BOOL is_version_nt(void)
54 {
55 return !(GetVersion() & 0x80000000);
56 }
57
58 /* returns directory handle to \\BaseNamedObjects */
59 HANDLE get_BaseNamedObjects_handle(void)
60 {
61 static HANDLE handle = NULL;
62 static const WCHAR basenameW[] =
63 {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s',0};
64 UNICODE_STRING str;
65 OBJECT_ATTRIBUTES attr;
66
67 if (!handle)
68 {
69 HANDLE dir;
70
71 RtlInitUnicodeString(&str, basenameW);
72 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
73 NtOpenDirectoryObject(&dir, DIRECTORY_CREATE_OBJECT|DIRECTORY_TRAVERSE,
74 &attr);
75 if (InterlockedCompareExchangePointer( &handle, dir, 0 ) != 0)
76 {
77 /* someone beat us here... */
78 CloseHandle( dir );
79 }
80 }
81 return handle;
82 }
83
84 /* helper for kernel32->ntdll timeout format conversion */
85 static inline PLARGE_INTEGER get_nt_timeout( PLARGE_INTEGER pTime, DWORD timeout )
86 {
87 if (timeout == INFINITE) return NULL;
88 pTime->QuadPart = (ULONGLONG)timeout * -10000;
89 return pTime;
90 }
91
92 /***********************************************************************
93 * Sleep (KERNEL32.@)
94 */
95 VOID WINAPI DECLSPEC_HOTPATCH Sleep( DWORD timeout )
96 {
97 SleepEx( timeout, FALSE );
98 }
99
100 /******************************************************************************
101 * SleepEx (KERNEL32.@)
102 */
103 DWORD WINAPI SleepEx( DWORD timeout, BOOL alertable )
104 {
105 NTSTATUS status;
106 LARGE_INTEGER time;
107
108 status = NtDelayExecution( alertable, get_nt_timeout( &time, timeout ) );
109 if (status == STATUS_USER_APC) return WAIT_IO_COMPLETION;
110 return 0;
111 }
112
113
114 /***********************************************************************
115 * SwitchToThread (KERNEL32.@)
116 */
117 BOOL WINAPI SwitchToThread(void)
118 {
119 return (NtYieldExecution() != STATUS_NO_YIELD_PERFORMED);
120 }
121
122
123 /***********************************************************************
124 * WaitForSingleObject (KERNEL32.@)
125 */
126 DWORD WINAPI WaitForSingleObject( HANDLE handle, DWORD timeout )
127 {
128 return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE );
129 }
130
131
132 /***********************************************************************
133 * WaitForSingleObjectEx (KERNEL32.@)
134 */
135 DWORD WINAPI WaitForSingleObjectEx( HANDLE handle, DWORD timeout,
136 BOOL alertable )
137 {
138 return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable );
139 }
140
141
142 /***********************************************************************
143 * WaitForMultipleObjects (KERNEL32.@)
144 */
145 DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles,
146 BOOL wait_all, DWORD timeout )
147 {
148 return WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
149 }
150
151
152 /***********************************************************************
153 * WaitForMultipleObjectsEx (KERNEL32.@)
154 */
155 DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
156 BOOL wait_all, DWORD timeout,
157 BOOL alertable )
158 {
159 NTSTATUS status;
160 HANDLE hloc[MAXIMUM_WAIT_OBJECTS];
161 LARGE_INTEGER time;
162 unsigned int i;
163
164 if (count > MAXIMUM_WAIT_OBJECTS)
165 {
166 SetLastError(ERROR_INVALID_PARAMETER);
167 return WAIT_FAILED;
168 }
169 for (i = 0; i < count; i++)
170 {
171 if ((handles[i] == (HANDLE)STD_INPUT_HANDLE) ||
172 (handles[i] == (HANDLE)STD_OUTPUT_HANDLE) ||
173 (handles[i] == (HANDLE)STD_ERROR_HANDLE))
174 hloc[i] = GetStdHandle( HandleToULong(handles[i]) );
175 else
176 hloc[i] = handles[i];
177
178 /* yes, even screen buffer console handles are waitable, and are
179 * handled as a handle to the console itself !!
180 */
181 if (is_console_handle(hloc[i]))
182 {
183 if (VerifyConsoleIoHandle(hloc[i]))
184 hloc[i] = GetConsoleInputWaitHandle();
185 }
186 }
187
188 status = NtWaitForMultipleObjects( count, hloc, !wait_all, alertable,
189 get_nt_timeout( &time, timeout ) );
190
191 if (HIWORD(status)) /* is it an error code? */
192 {
193 SetLastError( RtlNtStatusToDosError(status) );
194 status = WAIT_FAILED;
195 }
196 return status;
197 }
198
199
200 /***********************************************************************
201 * RegisterWaitForSingleObject (KERNEL32.@)
202 */
203 BOOL WINAPI RegisterWaitForSingleObject(PHANDLE phNewWaitObject, HANDLE hObject,
204 WAITORTIMERCALLBACK Callback, PVOID Context,
205 ULONG dwMilliseconds, ULONG dwFlags)
206 {
207 NTSTATUS status;
208
209 TRACE("%p %p %p %p %d %d\n",
210 phNewWaitObject,hObject,Callback,Context,dwMilliseconds,dwFlags);
211
212 status = RtlRegisterWait( phNewWaitObject, hObject, Callback, Context, dwMilliseconds, dwFlags );
213 if (status != STATUS_SUCCESS)
214 {
215 SetLastError( RtlNtStatusToDosError(status) );
216 return FALSE;
217 }
218 return TRUE;
219 }
220
221 /***********************************************************************
222 * RegisterWaitForSingleObjectEx (KERNEL32.@)
223 */
224 HANDLE WINAPI RegisterWaitForSingleObjectEx( HANDLE hObject,
225 WAITORTIMERCALLBACK Callback, PVOID Context,
226 ULONG dwMilliseconds, ULONG dwFlags )
227 {
228 NTSTATUS status;
229 HANDLE hNewWaitObject;
230
231 TRACE("%p %p %p %d %d\n",
232 hObject,Callback,Context,dwMilliseconds,dwFlags);
233
234 status = RtlRegisterWait( &hNewWaitObject, hObject, Callback, Context, dwMilliseconds, dwFlags );
235 if (status != STATUS_SUCCESS)
236 {
237 SetLastError( RtlNtStatusToDosError(status) );
238 return NULL;
239 }
240 return hNewWaitObject;
241 }
242
243 /***********************************************************************
244 * UnregisterWait (KERNEL32.@)
245 */
246 BOOL WINAPI UnregisterWait( HANDLE WaitHandle )
247 {
248 NTSTATUS status;
249
250 TRACE("%p\n",WaitHandle);
251
252 status = RtlDeregisterWait( WaitHandle );
253 if (status != STATUS_SUCCESS)
254 {
255 SetLastError( RtlNtStatusToDosError(status) );
256 return FALSE;
257 }
258 return TRUE;
259 }
260
261 /***********************************************************************
262 * UnregisterWaitEx (KERNEL32.@)
263 */
264 BOOL WINAPI UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent )
265 {
266 NTSTATUS status;
267
268 TRACE("%p %p\n",WaitHandle, CompletionEvent);
269
270 status = RtlDeregisterWaitEx( WaitHandle, CompletionEvent );
271 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
272 return !status;
273 }
274
275 /***********************************************************************
276 * SignalObjectAndWait (KERNEL32.@)
277 *
278 * Makes it possible to atomically signal any of the synchronization
279 * objects (semaphore, mutex, event) and wait on another.
280 */
281 DWORD WINAPI SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn,
282 DWORD dwMilliseconds, BOOL bAlertable )
283 {
284 NTSTATUS status;
285 LARGE_INTEGER timeout;
286
287 TRACE("%p %p %d %d\n", hObjectToSignal,
288 hObjectToWaitOn, dwMilliseconds, bAlertable);
289
290 status = NtSignalAndWaitForSingleObject( hObjectToSignal, hObjectToWaitOn, bAlertable,
291 get_nt_timeout( &timeout, dwMilliseconds ) );
292 if (HIWORD(status))
293 {
294 SetLastError( RtlNtStatusToDosError(status) );
295 status = WAIT_FAILED;
296 }
297 return status;
298 }
299
300 /***********************************************************************
301 * InitializeCriticalSection (KERNEL32.@)
302 *
303 * Initialise a critical section before use.
304 *
305 * PARAMS
306 * crit [O] Critical section to initialise.
307 *
308 * RETURNS
309 * Nothing. If the function fails an exception is raised.
310 */
311 void WINAPI InitializeCriticalSection( CRITICAL_SECTION *crit )
312 {
313 InitializeCriticalSectionEx( crit, 0, 0 );
314 }
315
316 /***********************************************************************
317 * InitializeCriticalSectionAndSpinCount (KERNEL32.@)
318 *
319 * Initialise a critical section with a spin count.
320 *
321 * PARAMS
322 * crit [O] Critical section to initialise.
323 * spincount [I] Number of times to spin upon contention.
324 *
325 * RETURNS
326 * Success: TRUE.
327 * Failure: Nothing. If the function fails an exception is raised.
328 *
329 * NOTES
330 * spincount is ignored on uni-processor systems.
331 */
332 BOOL WINAPI InitializeCriticalSectionAndSpinCount( CRITICAL_SECTION *crit, DWORD spincount )
333 {
334 return InitializeCriticalSectionEx( crit, spincount, 0 );
335 }
336
337 /***********************************************************************
338 * InitializeCriticalSectionEx (KERNEL32.@)
339 *
340 * Initialise a critical section with a spin count and flags.
341 *
342 * PARAMS
343 * crit [O] Critical section to initialise.
344 * spincount [I] Number of times to spin upon contention.
345 * flags [I] CRITICAL_SECTION_ flags from winbase.h.
346 *
347 * RETURNS
348 * Success: TRUE.
349 * Failure: Nothing. If the function fails an exception is raised.
350 *
351 * NOTES
352 * spincount is ignored on uni-processor systems.
353 */
354 BOOL WINAPI InitializeCriticalSectionEx( CRITICAL_SECTION *crit, DWORD spincount, DWORD flags )
355 {
356 NTSTATUS ret = RtlInitializeCriticalSectionEx( crit, spincount, flags );
357 if (ret) RtlRaiseStatus( ret );
358 return !ret;
359 }
360
361 /***********************************************************************
362 * MakeCriticalSectionGlobal (KERNEL32.@)
363 */
364 void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *crit )
365 {
366 /* let's assume that only one thread at a time will try to do this */
367 HANDLE sem = crit->LockSemaphore;
368 if (!sem) NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 );
369 crit->LockSemaphore = ConvertToGlobalHandle( sem );
370 RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
371 crit->DebugInfo = NULL;
372 }
373
374
375 /***********************************************************************
376 * ReinitializeCriticalSection (KERNEL32.@)
377 *
378 * Initialise an already used critical section.
379 *
380 * PARAMS
381 * crit [O] Critical section to initialise.
382 *
383 * RETURNS
384 * Nothing.
385 */
386 void WINAPI ReinitializeCriticalSection( CRITICAL_SECTION *crit )
387 {
388 if ( !crit->LockSemaphore )
389 RtlInitializeCriticalSection( crit );
390 }
391
392
393 /***********************************************************************
394 * UninitializeCriticalSection (KERNEL32.@)
395 *
396 * UnInitialise a critical section after use.
397 *
398 * PARAMS
399 * crit [O] Critical section to uninitialise (destroy).
400 *
401 * RETURNS
402 * Nothing.
403 */
404 void WINAPI UninitializeCriticalSection( CRITICAL_SECTION *crit )
405 {
406 RtlDeleteCriticalSection( crit );
407 }
408
409
410 /***********************************************************************
411 * CreateEventA (KERNEL32.@)
412 */
413 HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
414 BOOL initial_state, LPCSTR name )
415 {
416 DWORD flags = 0;
417
418 if (manual_reset) flags |= CREATE_EVENT_MANUAL_RESET;
419 if (initial_state) flags |= CREATE_EVENT_INITIAL_SET;
420 return CreateEventExA( sa, name, flags, EVENT_ALL_ACCESS );
421 }
422
423
424 /***********************************************************************
425 * CreateEventW (KERNEL32.@)
426 */
427 HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
428 BOOL initial_state, LPCWSTR name )
429 {
430 DWORD flags = 0;
431
432 if (manual_reset) flags |= CREATE_EVENT_MANUAL_RESET;
433 if (initial_state) flags |= CREATE_EVENT_INITIAL_SET;
434 return CreateEventExW( sa, name, flags, EVENT_ALL_ACCESS );
435 }
436
437
438 /***********************************************************************
439 * CreateEventExA (KERNEL32.@)
440 */
441 HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventExA( SECURITY_ATTRIBUTES *sa, LPCSTR name, DWORD flags, DWORD access )
442 {
443 WCHAR buffer[MAX_PATH];
444
445 if (!name) return CreateEventExW( sa, NULL, flags, access );
446
447 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
448 {
449 SetLastError( ERROR_FILENAME_EXCED_RANGE );
450 return 0;
451 }
452 return CreateEventExW( sa, buffer, flags, access );
453 }
454
455
456 /***********************************************************************
457 * CreateEventExW (KERNEL32.@)
458 */
459 HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventExW( SECURITY_ATTRIBUTES *sa, LPCWSTR name, DWORD flags, DWORD access )
460 {
461 HANDLE ret = 0;
462 UNICODE_STRING nameW;
463 OBJECT_ATTRIBUTES attr;
464 NTSTATUS status;
465
466 /* one buggy program needs this
467 * ("Van Dale Groot woordenboek der Nederlandse taal")
468 */
469 if (sa && IsBadReadPtr(sa,sizeof(SECURITY_ATTRIBUTES)))
470 {
471 ERR("Bad security attributes pointer %p\n",sa);
472 SetLastError( ERROR_INVALID_PARAMETER);
473 return 0;
474 }
475
476 attr.Length = sizeof(attr);
477 attr.RootDirectory = 0;
478 attr.ObjectName = NULL;
479 attr.Attributes = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
480 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
481 attr.SecurityQualityOfService = NULL;
482 if (name)
483 {
484 RtlInitUnicodeString( &nameW, name );
485 attr.ObjectName = &nameW;
486 attr.RootDirectory = get_BaseNamedObjects_handle();
487 }
488
489 status = NtCreateEvent( &ret, access, &attr,
490 (flags & CREATE_EVENT_MANUAL_RESET) ? NotificationEvent : SynchronizationEvent,
491 (flags & CREATE_EVENT_INITIAL_SET) != 0 );
492 if (status == STATUS_OBJECT_NAME_EXISTS)
493 SetLastError( ERROR_ALREADY_EXISTS );
494 else
495 SetLastError( RtlNtStatusToDosError(status) );
496 return ret;
497 }
498
499
500 /***********************************************************************
501 * OpenEventA (KERNEL32.@)
502 */
503 HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
504 {
505 WCHAR buffer[MAX_PATH];
506
507 if (!name) return OpenEventW( access, inherit, NULL );
508
509 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
510 {
511 SetLastError( ERROR_FILENAME_EXCED_RANGE );
512 return 0;
513 }
514 return OpenEventW( access, inherit, buffer );
515 }
516
517
518 /***********************************************************************
519 * OpenEventW (KERNEL32.@)
520 */
521 HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
522 {
523 HANDLE ret;
524 UNICODE_STRING nameW;
525 OBJECT_ATTRIBUTES attr;
526 NTSTATUS status;
527
528 if (!is_version_nt()) access = EVENT_ALL_ACCESS;
529
530 attr.Length = sizeof(attr);
531 attr.RootDirectory = 0;
532 attr.ObjectName = NULL;
533 attr.Attributes = inherit ? OBJ_INHERIT : 0;
534 attr.SecurityDescriptor = NULL;
535 attr.SecurityQualityOfService = NULL;
536 if (name)
537 {
538 RtlInitUnicodeString( &nameW, name );
539 attr.ObjectName = &nameW;
540 attr.RootDirectory = get_BaseNamedObjects_handle();
541 }
542
543 status = NtOpenEvent( &ret, access, &attr );
544 if (status != STATUS_SUCCESS)
545 {
546 SetLastError( RtlNtStatusToDosError(status) );
547 return 0;
548 }
549 return ret;
550 }
551
552 /***********************************************************************
553 * PulseEvent (KERNEL32.@)
554 */
555 BOOL WINAPI DECLSPEC_HOTPATCH PulseEvent( HANDLE handle )
556 {
557 NTSTATUS status;
558
559 if ((status = NtPulseEvent( handle, NULL )))
560 SetLastError( RtlNtStatusToDosError(status) );
561 return !status;
562 }
563
564
565 /***********************************************************************
566 * SetEvent (KERNEL32.@)
567 */
568 BOOL WINAPI DECLSPEC_HOTPATCH SetEvent( HANDLE handle )
569 {
570 NTSTATUS status;
571
572 if ((status = NtSetEvent( handle, NULL )))
573 SetLastError( RtlNtStatusToDosError(status) );
574 return !status;
575 }
576
577
578 /***********************************************************************
579 * ResetEvent (KERNEL32.@)
580 */
581 BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent( HANDLE handle )
582 {
583 NTSTATUS status;
584
585 if ((status = NtResetEvent( handle, NULL )))
586 SetLastError( RtlNtStatusToDosError(status) );
587 return !status;
588 }
589
590
591 /***********************************************************************
592 * CreateMutexA (KERNEL32.@)
593 */
594 HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
595 {
596 return CreateMutexExA( sa, name, owner ? CREATE_MUTEX_INITIAL_OWNER : 0, MUTEX_ALL_ACCESS );
597 }
598
599
600 /***********************************************************************
601 * CreateMutexW (KERNEL32.@)
602 */
603 HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
604 {
605 return CreateMutexExW( sa, name, owner ? CREATE_MUTEX_INITIAL_OWNER : 0, MUTEX_ALL_ACCESS );
606 }
607
608
609 /***********************************************************************
610 * CreateMutexExA (KERNEL32.@)
611 */
612 HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexExA( SECURITY_ATTRIBUTES *sa, LPCSTR name, DWORD flags, DWORD access )
613 {
614 ANSI_STRING nameA;
615 NTSTATUS status;
616
617 if (!name) return CreateMutexExW( sa, NULL, flags, access );
618
619 RtlInitAnsiString( &nameA, name );
620 status = RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString, &nameA, FALSE );
621 if (status != STATUS_SUCCESS)
622 {
623 SetLastError( ERROR_FILENAME_EXCED_RANGE );
624 return 0;
625 }
626 return CreateMutexExW( sa, NtCurrentTeb()->StaticUnicodeString.Buffer, flags, access );
627 }
628
629
630 /***********************************************************************
631 * CreateMutexExW (KERNEL32.@)
632 */
633 HANDLE WINAPI DECLSPEC_HOTPATCH CreateMutexExW( SECURITY_ATTRIBUTES *sa, LPCWSTR name, DWORD flags, DWORD access )
634 {
635 HANDLE ret = 0;
636 UNICODE_STRING nameW;
637 OBJECT_ATTRIBUTES attr;
638 NTSTATUS status;
639
640 attr.Length = sizeof(attr);
641 attr.RootDirectory = 0;
642 attr.ObjectName = NULL;
643 attr.Attributes = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
644 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
645 attr.SecurityQualityOfService = NULL;
646 if (name)
647 {
648 RtlInitUnicodeString( &nameW, name );
649 attr.ObjectName = &nameW;
650 attr.RootDirectory = get_BaseNamedObjects_handle();
651 }
652
653 status = NtCreateMutant( &ret, access, &attr, (flags & CREATE_MUTEX_INITIAL_OWNER) != 0 );
654 if (status == STATUS_OBJECT_NAME_EXISTS)
655 SetLastError( ERROR_ALREADY_EXISTS );
656 else
657 SetLastError( RtlNtStatusToDosError(status) );
658 return ret;
659 }
660
661
662 /***********************************************************************
663 * OpenMutexA (KERNEL32.@)
664 */
665 HANDLE WINAPI DECLSPEC_HOTPATCH OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
666 {
667 WCHAR buffer[MAX_PATH];
668
669 if (!name) return OpenMutexW( access, inherit, NULL );
670
671 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
672 {
673 SetLastError( ERROR_FILENAME_EXCED_RANGE );
674 return 0;
675 }
676 return OpenMutexW( access, inherit, buffer );
677 }
678
679
680 /***********************************************************************
681 * OpenMutexW (KERNEL32.@)
682 */
683 HANDLE WINAPI DECLSPEC_HOTPATCH OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
684 {
685 HANDLE ret;
686 UNICODE_STRING nameW;
687 OBJECT_ATTRIBUTES attr;
688 NTSTATUS status;
689
690 if (!is_version_nt()) access = MUTEX_ALL_ACCESS;
691
692 attr.Length = sizeof(attr);
693 attr.RootDirectory = 0;
694 attr.ObjectName = NULL;
695 attr.Attributes = inherit ? OBJ_INHERIT : 0;
696 attr.SecurityDescriptor = NULL;
697 attr.SecurityQualityOfService = NULL;
698 if (name)
699 {
700 RtlInitUnicodeString( &nameW, name );
701 attr.ObjectName = &nameW;
702 attr.RootDirectory = get_BaseNamedObjects_handle();
703 }
704
705 status = NtOpenMutant( &ret, access, &attr );
706 if (status != STATUS_SUCCESS)
707 {
708 SetLastError( RtlNtStatusToDosError(status) );
709 return 0;
710 }
711 return ret;
712 }
713
714
715 /***********************************************************************
716 * ReleaseMutex (KERNEL32.@)
717 */
718 BOOL WINAPI DECLSPEC_HOTPATCH ReleaseMutex( HANDLE handle )
719 {
720 NTSTATUS status;
721
722 status = NtReleaseMutant(handle, NULL);
723 if (status != STATUS_SUCCESS)
724 {
725 SetLastError( RtlNtStatusToDosError(status) );
726 return FALSE;
727 }
728 return TRUE;
729 }
730
731
732 /*
733 * Semaphores
734 */
735
736
737 /***********************************************************************
738 * CreateSemaphoreA (KERNEL32.@)
739 */
740 HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
741 {
742 return CreateSemaphoreExA( sa, initial, max, name, 0, SEMAPHORE_ALL_ACCESS );
743 }
744
745
746 /***********************************************************************
747 * CreateSemaphoreW (KERNEL32.@)
748 */
749 HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCWSTR name )
750 {
751 return CreateSemaphoreExW( sa, initial, max, name, 0, SEMAPHORE_ALL_ACCESS );
752 }
753
754
755 /***********************************************************************
756 * CreateSemaphoreExA (KERNEL32.@)
757 */
758 HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreExA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max,
759 LPCSTR name, DWORD flags, DWORD access )
760 {
761 WCHAR buffer[MAX_PATH];
762
763 if (!name) return CreateSemaphoreExW( sa, initial, max, NULL, flags, access );
764
765 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
766 {
767 SetLastError( ERROR_FILENAME_EXCED_RANGE );
768 return 0;
769 }
770 return CreateSemaphoreExW( sa, initial, max, buffer, flags, access );
771 }
772
773
774 /***********************************************************************
775 * CreateSemaphoreExW (KERNEL32.@)
776 */
777 HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreExW( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max,
778 LPCWSTR name, DWORD flags, DWORD access )
779 {
780 HANDLE ret = 0;
781 UNICODE_STRING nameW;
782 OBJECT_ATTRIBUTES attr;
783 NTSTATUS status;
784
785 attr.Length = sizeof(attr);
786 attr.RootDirectory = 0;
787 attr.ObjectName = NULL;
788 attr.Attributes = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
789 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
790 attr.SecurityQualityOfService = NULL;
791 if (name)
792 {
793 RtlInitUnicodeString( &nameW, name );
794 attr.ObjectName = &nameW;
795 attr.RootDirectory = get_BaseNamedObjects_handle();
796 }
797
798 status = NtCreateSemaphore( &ret, access, &attr, initial, max );
799 if (status == STATUS_OBJECT_NAME_EXISTS)
800 SetLastError( ERROR_ALREADY_EXISTS );
801 else
802 SetLastError( RtlNtStatusToDosError(status) );
803 return ret;
804 }
805
806
807 /***********************************************************************
808 * OpenSemaphoreA (KERNEL32.@)
809 */
810 HANDLE WINAPI DECLSPEC_HOTPATCH OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
811 {
812 WCHAR buffer[MAX_PATH];
813
814 if (!name) return OpenSemaphoreW( access, inherit, NULL );
815
816 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
817 {
818 SetLastError( ERROR_FILENAME_EXCED_RANGE );
819 return 0;
820 }
821 return OpenSemaphoreW( access, inherit, buffer );
822 }
823
824
825 /***********************************************************************
826 * OpenSemaphoreW (KERNEL32.@)
827 */
828 HANDLE WINAPI DECLSPEC_HOTPATCH OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
829 {
830 HANDLE ret;
831 UNICODE_STRING nameW;
832 OBJECT_ATTRIBUTES attr;
833 NTSTATUS status;
834
835 if (!is_version_nt()) access = SEMAPHORE_ALL_ACCESS;
836
837 attr.Length = sizeof(attr);
838 attr.RootDirectory = 0;
839 attr.ObjectName = NULL;
840 attr.Attributes = inherit ? OBJ_INHERIT : 0;
841 attr.SecurityDescriptor = NULL;
842 attr.SecurityQualityOfService = NULL;
843 if (name)
844 {
845 RtlInitUnicodeString( &nameW, name );
846 attr.ObjectName = &nameW;
847 attr.RootDirectory = get_BaseNamedObjects_handle();
848 }
849
850 status = NtOpenSemaphore( &ret, access, &attr );
851 if (status != STATUS_SUCCESS)
852 {
853 SetLastError( RtlNtStatusToDosError(status) );
854 return 0;
855 }
856 return ret;
857 }
858
859
860 /***********************************************************************
861 * ReleaseSemaphore (KERNEL32.@)
862 */
863 BOOL WINAPI DECLSPEC_HOTPATCH ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
864 {
865 NTSTATUS status = NtReleaseSemaphore( handle, count, (PULONG)previous );
866 if (status) SetLastError( RtlNtStatusToDosError(status) );
867 return !status;
868 }
869
870
871 /*
872 * Jobs
873 */
874
875 /******************************************************************************
876 * CreateJobObjectW (KERNEL32.@)
877 */
878 HANDLE WINAPI CreateJobObjectW( LPSECURITY_ATTRIBUTES sa, LPCWSTR name )
879 {
880 HANDLE ret = 0;
881 UNICODE_STRING nameW;
882 OBJECT_ATTRIBUTES attr;
883 NTSTATUS status;
884
885 attr.Length = sizeof(attr);
886 attr.RootDirectory = 0;
887 attr.ObjectName = NULL;
888 attr.Attributes = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
889 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
890 attr.SecurityQualityOfService = NULL;
891 if (name)
892 {
893 RtlInitUnicodeString( &nameW, name );
894 attr.ObjectName = &nameW;
895 attr.RootDirectory = get_BaseNamedObjects_handle();
896 }
897
898 status = NtCreateJobObject( &ret, JOB_OBJECT_ALL_ACCESS, &attr );
899 if (status == STATUS_OBJECT_NAME_EXISTS)
900 SetLastError( ERROR_ALREADY_EXISTS );
901 else
902 SetLastError( RtlNtStatusToDosError(status) );
903 return ret;
904 }
905
906 /******************************************************************************
907 * CreateJobObjectA (KERNEL32.@)
908 */
909 HANDLE WINAPI CreateJobObjectA( LPSECURITY_ATTRIBUTES attr, LPCSTR name )
910 {
911 WCHAR buffer[MAX_PATH];
912
913 if (!name) return CreateJobObjectW( attr, NULL );
914
915 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
916 {
917 SetLastError( ERROR_FILENAME_EXCED_RANGE );
918 return 0;
919 }
920 return CreateJobObjectW( attr, buffer );
921 }
922
923 /******************************************************************************
924 * OpenJobObjectW (KERNEL32.@)
925 */
926 HANDLE WINAPI OpenJobObjectW( DWORD access, BOOL inherit, LPCWSTR name )
927 {
928 HANDLE ret;
929 UNICODE_STRING nameW;
930 OBJECT_ATTRIBUTES attr;
931 NTSTATUS status;
932
933 attr.Length = sizeof(attr);
934 attr.RootDirectory = 0;
935 attr.ObjectName = NULL;
936 attr.Attributes = inherit ? OBJ_INHERIT : 0;
937 attr.SecurityDescriptor = NULL;
938 attr.SecurityQualityOfService = NULL;
939 if (name)
940 {
941 RtlInitUnicodeString( &nameW, name );
942 attr.ObjectName = &nameW;
943 attr.RootDirectory = get_BaseNamedObjects_handle();
944 }
945
946 status = NtOpenJobObject( &ret, access, &attr );
947 if (status != STATUS_SUCCESS)
948 {
949 SetLastError( RtlNtStatusToDosError(status) );
950 return 0;
951 }
952 return ret;
953 }
954
955 /******************************************************************************
956 * OpenJobObjectA (KERNEL32.@)
957 */
958 HANDLE WINAPI OpenJobObjectA( DWORD access, BOOL inherit, LPCSTR name )
959 {
960 WCHAR buffer[MAX_PATH];
961
962 if (!name) return OpenJobObjectW( access, inherit, NULL );
963
964 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
965 {
966 SetLastError( ERROR_FILENAME_EXCED_RANGE );
967 return 0;
968 }
969 return OpenJobObjectW( access, inherit, buffer );
970 }
971
972 /******************************************************************************
973 * TerminateJobObject (KERNEL32.@)
974 */
975 BOOL WINAPI TerminateJobObject( HANDLE job, UINT exit_code )
976 {
977 NTSTATUS status = NtTerminateJobObject( job, exit_code );
978 if (status) SetLastError( RtlNtStatusToDosError(status) );
979 return !status;
980 }
981
982 /******************************************************************************
983 * QueryInformationJobObject (KERNEL32.@)
984 */
985 BOOL WINAPI QueryInformationJobObject( HANDLE job, JOBOBJECTINFOCLASS class, LPVOID info,
986 DWORD len, DWORD *ret_len )
987 {
988 NTSTATUS status = NtQueryInformationJobObject( job, class, info, len, ret_len );
989 if (status) SetLastError( RtlNtStatusToDosError(status) );
990 return !status;
991 }
992
993 /******************************************************************************
994 * SetInformationJobObject (KERNEL32.@)
995 */
996 BOOL WINAPI SetInformationJobObject( HANDLE job, JOBOBJECTINFOCLASS class, LPVOID info, DWORD len )
997 {
998 NTSTATUS status = NtSetInformationJobObject( job, class, info, len );
999 if (status) SetLastError( RtlNtStatusToDosError(status) );
1000 return !status;
1001 }
1002
1003 /******************************************************************************
1004 * AssignProcessToJobObject (KERNEL32.@)
1005 */
1006 BOOL WINAPI AssignProcessToJobObject( HANDLE job, HANDLE process )
1007 {
1008 NTSTATUS status = NtAssignProcessToJobObject( job, process );
1009 if (status) SetLastError( RtlNtStatusToDosError(status) );
1010 return !status;
1011 }
1012
1013 /******************************************************************************
1014 * IsProcessInJob (KERNEL32.@)
1015 */
1016 BOOL WINAPI IsProcessInJob( HANDLE process, HANDLE job, PBOOL result )
1017 {
1018 NTSTATUS status = NtIsProcessInJob( process, job );
1019 switch(status)
1020 {
1021 case STATUS_PROCESS_IN_JOB:
1022 *result = TRUE;
1023 return TRUE;
1024 case STATUS_PROCESS_NOT_IN_JOB:
1025 *result = FALSE;
1026 return TRUE;
1027 default:
1028 SetLastError( RtlNtStatusToDosError(status) );
1029 return FALSE;
1030 }
1031 }
1032
1033
1034 /*
1035 * Timers
1036 */
1037
1038
1039 /***********************************************************************
1040 * CreateWaitableTimerA (KERNEL32.@)
1041 */
1042 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
1043 {
1044 return CreateWaitableTimerExA( sa, name, manual ? CREATE_WAITABLE_TIMER_MANUAL_RESET : 0,
1045 TIMER_ALL_ACCESS );
1046 }
1047
1048
1049 /***********************************************************************
1050 * CreateWaitableTimerW (KERNEL32.@)
1051 */
1052 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
1053 {
1054 return CreateWaitableTimerExW( sa, name, manual ? CREATE_WAITABLE_TIMER_MANUAL_RESET : 0,
1055 TIMER_ALL_ACCESS );
1056 }
1057
1058
1059 /***********************************************************************
1060 * CreateWaitableTimerExA (KERNEL32.@)
1061 */
1062 HANDLE WINAPI CreateWaitableTimerExA( SECURITY_ATTRIBUTES *sa, LPCSTR name, DWORD flags, DWORD access )
1063 {
1064 WCHAR buffer[MAX_PATH];
1065
1066 if (!name) return CreateWaitableTimerExW( sa, NULL, flags, access );
1067
1068 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1069 {
1070 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1071 return 0;
1072 }
1073 return CreateWaitableTimerExW( sa, buffer, flags, access );
1074 }
1075
1076
1077 /***********************************************************************
1078 * CreateWaitableTimerExW (KERNEL32.@)
1079 */
1080 HANDLE WINAPI CreateWaitableTimerExW( SECURITY_ATTRIBUTES *sa, LPCWSTR name, DWORD flags, DWORD access )
1081 {
1082 HANDLE handle;
1083 NTSTATUS status;
1084 UNICODE_STRING nameW;
1085 OBJECT_ATTRIBUTES attr;
1086
1087 attr.Length = sizeof(attr);
1088 attr.RootDirectory = 0;
1089 attr.ObjectName = NULL;
1090 attr.Attributes = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1091 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1092 attr.SecurityQualityOfService = NULL;
1093 if (name)
1094 {
1095 RtlInitUnicodeString( &nameW, name );
1096 attr.ObjectName = &nameW;
1097 attr.RootDirectory = get_BaseNamedObjects_handle();
1098 }
1099
1100 status = NtCreateTimer( &handle, access, &attr,
1101 (flags & CREATE_WAITABLE_TIMER_MANUAL_RESET) ? NotificationTimer : SynchronizationTimer );
1102 if (status == STATUS_OBJECT_NAME_EXISTS)
1103 SetLastError( ERROR_ALREADY_EXISTS );
1104 else
1105 SetLastError( RtlNtStatusToDosError(status) );
1106 return handle;
1107 }
1108
1109
1110 /***********************************************************************
1111 * OpenWaitableTimerA (KERNEL32.@)
1112 */
1113 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
1114 {
1115 WCHAR buffer[MAX_PATH];
1116
1117 if (!name) return OpenWaitableTimerW( access, inherit, NULL );
1118
1119 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1120 {
1121 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1122 return 0;
1123 }
1124 return OpenWaitableTimerW( access, inherit, buffer );
1125 }
1126
1127
1128 /***********************************************************************
1129 * OpenWaitableTimerW (KERNEL32.@)
1130 */
1131 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
1132 {
1133 HANDLE handle;
1134 UNICODE_STRING nameW;
1135 OBJECT_ATTRIBUTES attr;
1136 NTSTATUS status;
1137
1138 if (!is_version_nt()) access = TIMER_ALL_ACCESS;
1139
1140 attr.Length = sizeof(attr);
1141 attr.RootDirectory = 0;
1142 attr.ObjectName = NULL;
1143 attr.Attributes = inherit ? OBJ_INHERIT : 0;
1144 attr.SecurityDescriptor = NULL;
1145 attr.SecurityQualityOfService = NULL;
1146 if (name)
1147 {
1148 RtlInitUnicodeString( &nameW, name );
1149 attr.ObjectName = &nameW;
1150 attr.RootDirectory = get_BaseNamedObjects_handle();
1151 }
1152
1153 status = NtOpenTimer(&handle, access, &attr);
1154 if (status != STATUS_SUCCESS)
1155 {
1156 SetLastError( RtlNtStatusToDosError(status) );
1157 return 0;
1158 }
1159 return handle;
1160 }
1161
1162
1163 /***********************************************************************
1164 * SetWaitableTimer (KERNEL32.@)
1165 */
1166 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
1167 PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
1168 {
1169 NTSTATUS status = NtSetTimer(handle, when, (PTIMER_APC_ROUTINE)callback,
1170 arg, resume, period, NULL);
1171
1172 if (status != STATUS_SUCCESS)
1173 {
1174 SetLastError( RtlNtStatusToDosError(status) );
1175 if (status != STATUS_TIMER_RESUME_IGNORED) return FALSE;
1176 }
1177 return TRUE;
1178 }
1179
1180 /***********************************************************************
1181 * SetWaitableTimerEx (KERNEL32.@)
1182 */
1183 BOOL WINAPI SetWaitableTimerEx( HANDLE handle, const LARGE_INTEGER *when, LONG period,
1184 PTIMERAPCROUTINE callback, LPVOID arg, REASON_CONTEXT *context, ULONG tolerabledelay )
1185 {
1186 static int once;
1187 if (!once++)
1188 {
1189 FIXME("(%p, %p, %d, %p, %p, %p, %d) semi-stub\n",
1190 handle, when, period, callback, arg, context, tolerabledelay);
1191 }
1192 return SetWaitableTimer(handle, when, period, callback, arg, FALSE);
1193 }
1194
1195 /***********************************************************************
1196 * CancelWaitableTimer (KERNEL32.@)
1197 */
1198 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
1199 {
1200 NTSTATUS status;
1201
1202 status = NtCancelTimer(handle, NULL);
1203 if (status != STATUS_SUCCESS)
1204 {
1205 SetLastError( RtlNtStatusToDosError(status) );
1206 return FALSE;
1207 }
1208 return TRUE;
1209 }
1210
1211
1212 /***********************************************************************
1213 * CreateTimerQueue (KERNEL32.@)
1214 */
1215 HANDLE WINAPI CreateTimerQueue(void)
1216 {
1217 HANDLE q;
1218 NTSTATUS status = RtlCreateTimerQueue(&q);
1219
1220 if (status != STATUS_SUCCESS)
1221 {
1222 SetLastError( RtlNtStatusToDosError(status) );
1223 return NULL;
1224 }
1225
1226 return q;
1227 }
1228
1229
1230 /***********************************************************************
1231 * DeleteTimerQueueEx (KERNEL32.@)
1232 */
1233 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
1234 {
1235 NTSTATUS status = RtlDeleteTimerQueueEx(TimerQueue, CompletionEvent);
1236
1237 if (status != STATUS_SUCCESS)
1238 {
1239 SetLastError( RtlNtStatusToDosError(status) );
1240 return FALSE;
1241 }
1242
1243 return TRUE;
1244 }
1245
1246 /***********************************************************************
1247 * DeleteTimerQueue (KERNEL32.@)
1248 */
1249 BOOL WINAPI DeleteTimerQueue(HANDLE TimerQueue)
1250 {
1251 return DeleteTimerQueueEx(TimerQueue, NULL);
1252 }
1253
1254 /***********************************************************************
1255 * CreateTimerQueueTimer (KERNEL32.@)
1256 *
1257 * Creates a timer-queue timer. This timer expires at the specified due
1258 * time (in ms), then after every specified period (in ms). When the timer
1259 * expires, the callback function is called.
1260 *
1261 * RETURNS
1262 * nonzero on success or zero on failure
1263 */
1264 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
1265 WAITORTIMERCALLBACK Callback, PVOID Parameter,
1266 DWORD DueTime, DWORD Period, ULONG Flags )
1267 {
1268 NTSTATUS status = RtlCreateTimer(phNewTimer, TimerQueue, Callback,
1269 Parameter, DueTime, Period, Flags);
1270
1271 if (status != STATUS_SUCCESS)
1272 {
1273 SetLastError( RtlNtStatusToDosError(status) );
1274 return FALSE;
1275 }
1276
1277 return TRUE;
1278 }
1279
1280 /***********************************************************************
1281 * ChangeTimerQueueTimer (KERNEL32.@)
1282 *
1283 * Changes the times at which the timer expires.
1284 *
1285 * RETURNS
1286 * nonzero on success or zero on failure
1287 */
1288 BOOL WINAPI ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1289 ULONG DueTime, ULONG Period )
1290 {
1291 NTSTATUS status = RtlUpdateTimer(TimerQueue, Timer, DueTime, Period);
1292
1293 if (status != STATUS_SUCCESS)
1294 {
1295 SetLastError( RtlNtStatusToDosError(status) );
1296 return FALSE;
1297 }
1298
1299 return TRUE;
1300 }
1301
1302 /***********************************************************************
1303 * DeleteTimerQueueTimer (KERNEL32.@)
1304 *
1305 * Cancels a timer-queue timer.
1306 *
1307 * RETURNS
1308 * nonzero on success or zero on failure
1309 */
1310 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1311 HANDLE CompletionEvent )
1312 {
1313 NTSTATUS status = RtlDeleteTimer(TimerQueue, Timer, CompletionEvent);
1314 if (status != STATUS_SUCCESS)
1315 {
1316 SetLastError( RtlNtStatusToDosError(status) );
1317 return FALSE;
1318 }
1319 return TRUE;
1320 }
1321
1322
1323 /*
1324 * Pipes
1325 */
1326
1327
1328 /***********************************************************************
1329 * CreateNamedPipeA (KERNEL32.@)
1330 */
1331 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
1332 DWORD dwPipeMode, DWORD nMaxInstances,
1333 DWORD nOutBufferSize, DWORD nInBufferSize,
1334 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
1335 {
1336 WCHAR buffer[MAX_PATH];
1337
1338 if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
1339 nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1340
1341 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1342 {
1343 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1344 return INVALID_HANDLE_VALUE;
1345 }
1346 return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
1347 nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1348 }
1349
1350
1351 /***********************************************************************
1352 * CreateNamedPipeW (KERNEL32.@)
1353 */
1354 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
1355 DWORD dwPipeMode, DWORD nMaxInstances,
1356 DWORD nOutBufferSize, DWORD nInBufferSize,
1357 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES sa )
1358 {
1359 HANDLE handle;
1360 UNICODE_STRING nt_name;
1361 OBJECT_ATTRIBUTES attr;
1362 DWORD access, options, sharing;
1363 BOOLEAN pipe_type, read_mode, non_block;
1364 NTSTATUS status;
1365 IO_STATUS_BLOCK iosb;
1366 LARGE_INTEGER timeout;
1367
1368 TRACE("(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n",
1369 debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
1370 nOutBufferSize, nInBufferSize, nDefaultTimeOut, sa );
1371
1372 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1373 {
1374 SetLastError( ERROR_PATH_NOT_FOUND );
1375 return INVALID_HANDLE_VALUE;
1376 }
1377 if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) )
1378 {
1379 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1380 RtlFreeUnicodeString( &nt_name );
1381 return INVALID_HANDLE_VALUE;
1382 }
1383
1384 attr.Length = sizeof(attr);
1385 attr.RootDirectory = 0;
1386 attr.ObjectName = &nt_name;
1387 attr.Attributes = OBJ_CASE_INSENSITIVE |
1388 ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1389 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1390 attr.SecurityQualityOfService = NULL;
1391
1392 switch(dwOpenMode & 3)
1393 {
1394 case PIPE_ACCESS_INBOUND:
1395 sharing = FILE_SHARE_WRITE;
1396 access = GENERIC_READ;
1397 break;
1398 case PIPE_ACCESS_OUTBOUND:
1399 sharing = FILE_SHARE_READ;
1400 access = GENERIC_WRITE;
1401 break;
1402 case PIPE_ACCESS_DUPLEX:
1403 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1404 access = GENERIC_READ | GENERIC_WRITE;
1405 break;
1406 default:
1407 SetLastError( ERROR_INVALID_PARAMETER );
1408 return INVALID_HANDLE_VALUE;
1409 }
1410 access |= SYNCHRONIZE;
1411 options = 0;
1412 if (dwOpenMode & WRITE_DAC) access |= WRITE_DAC;
1413 if (dwOpenMode & WRITE_OWNER) access |= WRITE_OWNER;
1414 if (dwOpenMode & ACCESS_SYSTEM_SECURITY) access |= ACCESS_SYSTEM_SECURITY;
1415 if (dwOpenMode & FILE_FLAG_WRITE_THROUGH) options |= FILE_WRITE_THROUGH;
1416 if (!(dwOpenMode & FILE_FLAG_OVERLAPPED)) options |= FILE_SYNCHRONOUS_IO_NONALERT;
1417 pipe_type = (dwPipeMode & PIPE_TYPE_MESSAGE) != 0;
1418 read_mode = (dwPipeMode & PIPE_READMODE_MESSAGE) != 0;
1419 non_block = (dwPipeMode & PIPE_NOWAIT) != 0;
1420 if (nMaxInstances >= PIPE_UNLIMITED_INSTANCES) nMaxInstances = ~0U;
1421
1422 timeout.QuadPart = (ULONGLONG)nDefaultTimeOut * -10000;
1423
1424 SetLastError(0);
1425
1426 status = NtCreateNamedPipeFile(&handle, access, &attr, &iosb, sharing,
1427 FILE_OVERWRITE_IF, options, pipe_type,
1428 read_mode, non_block, nMaxInstances,
1429 nInBufferSize, nOutBufferSize, &timeout);
1430
1431 RtlFreeUnicodeString( &nt_name );
1432 if (status)
1433 {
1434 handle = INVALID_HANDLE_VALUE;
1435 SetLastError( RtlNtStatusToDosError(status) );
1436 }
1437 return handle;
1438 }
1439
1440
1441 /***********************************************************************
1442 * PeekNamedPipe (KERNEL32.@)
1443 */
1444 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
1445 LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
1446 {
1447 FILE_PIPE_PEEK_BUFFER local_buffer;
1448 FILE_PIPE_PEEK_BUFFER *buffer = &local_buffer;
1449 IO_STATUS_BLOCK io;
1450 NTSTATUS status;
1451
1452 if (cbBuffer && !(buffer = HeapAlloc( GetProcessHeap(), 0,
1453 FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ))))
1454 {
1455 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1456 return FALSE;
1457 }
1458
1459 status = NtFsControlFile( hPipe, 0, NULL, NULL, &io, FSCTL_PIPE_PEEK, NULL, 0,
1460 buffer, FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ) );
1461 if (!status)
1462 {
1463 ULONG read_size = io.Information - FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data );
1464 if (lpcbAvail) *lpcbAvail = buffer->ReadDataAvailable;
1465 if (lpcbRead) *lpcbRead = read_size;
1466 if (lpcbMessage) *lpcbMessage = 0; /* FIXME */
1467 if (lpvBuffer) memcpy( lpvBuffer, buffer->Data, read_size );
1468 }
1469 else SetLastError( RtlNtStatusToDosError(status) );
1470
1471 if (buffer != &local_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1472 return !status;
1473 }
1474
1475 /***********************************************************************
1476 * WaitNamedPipeA (KERNEL32.@)
1477 */
1478 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
1479 {
1480 WCHAR buffer[MAX_PATH];
1481
1482 if (!name) return WaitNamedPipeW( NULL, nTimeOut );
1483
1484 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1485 {
1486 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1487 return FALSE;
1488 }
1489 return WaitNamedPipeW( buffer, nTimeOut );
1490 }
1491
1492
1493 /***********************************************************************
1494 * WaitNamedPipeW (KERNEL32.@)
1495 *
1496 * Waits for a named pipe instance to become available
1497 *
1498 * PARAMS
1499 * name [I] Pointer to a named pipe name to wait for
1500 * nTimeOut [I] How long to wait in ms
1501 *
1502 * RETURNS
1503 * TRUE: Success, named pipe can be opened with CreateFile
1504 * FALSE: Failure, GetLastError can be called for further details
1505 */
1506 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
1507 {
1508 static const WCHAR leadin[] = {'\\','?','?','\\','P','I','P','E','\\'};
1509 NTSTATUS status;
1510 UNICODE_STRING nt_name, pipe_dev_name;
1511 FILE_PIPE_WAIT_FOR_BUFFER *pipe_wait;
1512 IO_STATUS_BLOCK iosb;
1513 OBJECT_ATTRIBUTES attr;
1514 ULONG sz_pipe_wait;
1515 HANDLE pipe_dev;
1516
1517 TRACE("%s 0x%08x\n",debugstr_w(name),nTimeOut);
1518
1519 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1520 return FALSE;
1521
1522 if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) ||
1523 nt_name.Length < sizeof(leadin) ||
1524 strncmpiW( nt_name.Buffer, leadin, sizeof(leadin)/sizeof(WCHAR)) != 0)
1525 {
1526 RtlFreeUnicodeString( &nt_name );
1527 SetLastError( ERROR_PATH_NOT_FOUND );
1528 return FALSE;
1529 }
1530
1531 sz_pipe_wait = sizeof(*pipe_wait) + nt_name.Length - sizeof(leadin) - sizeof(WCHAR);
1532 if (!(pipe_wait = HeapAlloc( GetProcessHeap(), 0, sz_pipe_wait)))
1533 {
1534 RtlFreeUnicodeString( &nt_name );
1535 SetLastError( ERROR_OUTOFMEMORY );
1536 return FALSE;
1537 }
1538
1539 pipe_dev_name.Buffer = nt_name.Buffer;
1540 pipe_dev_name.Length = sizeof(leadin);
1541 pipe_dev_name.MaximumLength = sizeof(leadin);
1542 InitializeObjectAttributes(&attr,&pipe_dev_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1543 status = NtOpenFile( &pipe_dev, FILE_READ_ATTRIBUTES, &attr,
1544 &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
1545 FILE_SYNCHRONOUS_IO_NONALERT);
1546 if (status != ERROR_SUCCESS)
1547 {
1548 HeapFree( GetProcessHeap(), 0, pipe_wait);
1549 RtlFreeUnicodeString( &nt_name );
1550 SetLastError( ERROR_PATH_NOT_FOUND );
1551 return FALSE;
1552 }
1553
1554 pipe_wait->TimeoutSpecified = !(nTimeOut == NMPWAIT_USE_DEFAULT_WAIT);
1555 if (nTimeOut == NMPWAIT_WAIT_FOREVER)
1556 pipe_wait->Timeout.QuadPart = ((ULONGLONG)0x7fffffff << 32) | 0xffffffff;
1557 else
1558 pipe_wait->Timeout.QuadPart = (ULONGLONG)nTimeOut * -10000;
1559 pipe_wait->NameLength = nt_name.Length - sizeof(leadin);
1560 memcpy(pipe_wait->Name, nt_name.Buffer + sizeof(leadin)/sizeof(WCHAR),
1561 pipe_wait->NameLength);
1562 RtlFreeUnicodeString( &nt_name );
1563
1564 status = NtFsControlFile( pipe_dev, NULL, NULL, NULL, &iosb, FSCTL_PIPE_WAIT,
1565 pipe_wait, sz_pipe_wait, NULL, 0 );
1566
1567 HeapFree( GetProcessHeap(), 0, pipe_wait );
1568 NtClose( pipe_dev );
1569
1570 if(status != STATUS_SUCCESS)
1571 {
1572 SetLastError(RtlNtStatusToDosError(status));
1573 return FALSE;
1574 }
1575 else
1576 return TRUE;
1577 }
1578
1579
1580 /***********************************************************************
1581 * ConnectNamedPipe (KERNEL32.@)
1582 *
1583 * Connects to a named pipe
1584 *
1585 * Parameters
1586 * hPipe: A handle to a named pipe returned by CreateNamedPipe
1587 * overlapped: Optional OVERLAPPED struct
1588 *
1589 * Return values
1590 * TRUE: Success
1591 * FALSE: Failure, GetLastError can be called for further details
1592 */
1593 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1594 {
1595 NTSTATUS status;
1596 IO_STATUS_BLOCK status_block;
1597 LPVOID cvalue = NULL;
1598
1599 TRACE("(%p,%p)\n", hPipe, overlapped);
1600
1601 if(overlapped)
1602 {
1603 overlapped->Internal = STATUS_PENDING;
1604 overlapped->InternalHigh = 0;
1605 if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
1606 }
1607
1608 status = NtFsControlFile(hPipe, overlapped ? overlapped->hEvent : NULL, NULL, cvalue,
1609 overlapped ? (IO_STATUS_BLOCK *)overlapped : &status_block,
1610 FSCTL_PIPE_LISTEN, NULL, 0, NULL, 0);
1611
1612 if (status == STATUS_SUCCESS) return TRUE;
1613 SetLastError( RtlNtStatusToDosError(status) );
1614 return FALSE;
1615 }
1616
1617 /***********************************************************************
1618 * DisconnectNamedPipe (KERNEL32.@)
1619 *
1620 * Disconnects from a named pipe
1621 *
1622 * Parameters
1623 * hPipe: A handle to a named pipe returned by CreateNamedPipe
1624 *
1625 * Return values
1626 * TRUE: Success
1627 * FALSE: Failure, GetLastError can be called for further details
1628 */
1629 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
1630 {
1631 NTSTATUS status;
1632 IO_STATUS_BLOCK io_block;
1633
1634 TRACE("(%p)\n",hPipe);
1635
1636 status = NtFsControlFile(hPipe, 0, NULL, NULL, &io_block, FSCTL_PIPE_DISCONNECT,
1637 NULL, 0, NULL, 0);
1638 if (status == STATUS_SUCCESS) return TRUE;
1639 SetLastError( RtlNtStatusToDosError(status) );
1640 return FALSE;
1641 }
1642
1643 /***********************************************************************
1644 * TransactNamedPipe (KERNEL32.@)
1645 *
1646 * BUGS
1647 * should be done as a single operation in the wineserver or kernel
1648 */
1649 BOOL WINAPI TransactNamedPipe(
1650 HANDLE handle, LPVOID write_buf, DWORD write_size, LPVOID read_buf,
1651 DWORD read_size, LPDWORD bytes_read, LPOVERLAPPED overlapped)
1652 {
1653 BOOL r;
1654 DWORD count;
1655
1656 TRACE("%p %p %d %p %d %p %p\n",
1657 handle, write_buf, write_size, read_buf,
1658 read_size, bytes_read, overlapped);
1659
1660 if (overlapped)
1661 {
1662 FIXME("Doesn't support overlapped operation as yet\n");
1663 return FALSE;
1664 }
1665
1666 r = WriteFile(handle, write_buf, write_size, &count, NULL);
1667 if (r)
1668 r = ReadFile(handle, read_buf, read_size, bytes_read, NULL);
1669
1670 return r;
1671 }
1672
1673 /***********************************************************************
1674 * GetNamedPipeInfo (KERNEL32.@)
1675 */
1676 BOOL WINAPI GetNamedPipeInfo(
1677 HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
1678 LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
1679 {
1680 FILE_PIPE_LOCAL_INFORMATION fpli;
1681 IO_STATUS_BLOCK iosb;
1682 NTSTATUS status;
1683
1684 status = NtQueryInformationFile(hNamedPipe, &iosb, &fpli, sizeof(fpli),
1685 FilePipeLocalInformation);
1686 if (status)
1687 {
1688 SetLastError( RtlNtStatusToDosError(status) );
1689 return FALSE;
1690 }
1691
1692 if (lpFlags)
1693 {
1694 *lpFlags = (fpli.NamedPipeEnd & FILE_PIPE_SERVER_END) ?
1695 PIPE_SERVER_END : PIPE_CLIENT_END;
1696 *lpFlags |= (fpli.NamedPipeType & FILE_PIPE_TYPE_MESSAGE) ?
1697 PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
1698 }
1699
1700 if (lpOutputBufferSize) *lpOutputBufferSize = fpli.OutboundQuota;
1701 if (lpInputBufferSize) *lpInputBufferSize = fpli.InboundQuota;
1702 if (lpMaxInstances) *lpMaxInstances = fpli.MaximumInstances;
1703
1704 return TRUE;
1705 }
1706
1707 /***********************************************************************
1708 * GetNamedPipeHandleStateA (KERNEL32.@)
1709 */
1710 BOOL WINAPI GetNamedPipeHandleStateA(
1711 HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1712 LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1713 LPSTR lpUsername, DWORD nUsernameMaxSize)
1714 {
1715 WARN("%p %p %p %p %p %p %d: semi-stub\n",
1716 hNamedPipe, lpState, lpCurInstances,
1717 lpMaxCollectionCount, lpCollectDataTimeout,
1718 lpUsername, nUsernameMaxSize);
1719
1720 if (lpUsername && nUsernameMaxSize)
1721 *lpUsername = 0;
1722
1723 return GetNamedPipeHandleStateW(hNamedPipe, lpState, lpCurInstances,
1724 lpMaxCollectionCount, lpCollectDataTimeout, NULL, 0);
1725 }
1726
1727 /***********************************************************************
1728 * GetNamedPipeHandleStateW (KERNEL32.@)
1729 */
1730 BOOL WINAPI GetNamedPipeHandleStateW(
1731 HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1732 LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1733 LPWSTR lpUsername, DWORD nUsernameMaxSize)
1734 {
1735 IO_STATUS_BLOCK iosb;
1736 NTSTATUS status;
1737
1738 FIXME("%p %p %p %p %p %p %d: semi-stub\n",
1739 hNamedPipe, lpState, lpCurInstances,
1740 lpMaxCollectionCount, lpCollectDataTimeout,
1741 lpUsername, nUsernameMaxSize);
1742
1743 if (lpMaxCollectionCount)
1744 *lpMaxCollectionCount = 0;
1745
1746 if (lpCollectDataTimeout)
1747 *lpCollectDataTimeout = 0;
1748
1749 if (lpUsername && nUsernameMaxSize)
1750 *lpUsername = 0;
1751
1752 if (lpState)
1753 {
1754 FILE_PIPE_INFORMATION fpi;
1755 status = NtQueryInformationFile(hNamedPipe, &iosb, &fpi, sizeof(fpi),
1756 FilePipeInformation);
1757 if (status)
1758 {
1759 SetLastError( RtlNtStatusToDosError(status) );
1760 return FALSE;
1761 }
1762
1763 *lpState = (fpi.ReadMode ? PIPE_READMODE_MESSAGE : PIPE_READMODE_BYTE) |
1764 (fpi.CompletionMode ? PIPE_NOWAIT : PIPE_WAIT);
1765 }
1766
1767 if (lpCurInstances)
1768 {
1769 FILE_PIPE_LOCAL_INFORMATION fpli;
1770 status = NtQueryInformationFile(hNamedPipe, &iosb, &fpli, sizeof(fpli),
1771 FilePipeLocalInformation);
1772 if (status)
1773 {
1774 SetLastError( RtlNtStatusToDosError(status) );
1775 return FALSE;
1776 }
1777
1778 *lpCurInstances = fpli.CurrentInstances;
1779 }
1780
1781 return TRUE;
1782 }
1783
1784 /***********************************************************************
1785 * SetNamedPipeHandleState (KERNEL32.@)
1786 */
1787 BOOL WINAPI SetNamedPipeHandleState(
1788 HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1789 LPDWORD lpCollectDataTimeout)
1790 {
1791 /* should be a fixme, but this function is called a lot by the RPC
1792 * runtime, and it slows down InstallShield a fair bit. */
1793 WARN("semi-stub: %p %p/%d %p %p\n",
1794 hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
1795
1796 if (lpMode)
1797 {
1798 FILE_PIPE_INFORMATION fpi;
1799 IO_STATUS_BLOCK iosb;
1800 NTSTATUS status;
1801
1802 if (*lpMode & ~(PIPE_READMODE_MESSAGE | PIPE_NOWAIT))
1803 status = STATUS_INVALID_PARAMETER;
1804 else
1805 {
1806 fpi.CompletionMode = (*lpMode & PIPE_NOWAIT) ?
1807 FILE_PIPE_COMPLETE_OPERATION : FILE_PIPE_QUEUE_OPERATION;
1808 fpi.ReadMode = (*lpMode & PIPE_READMODE_MESSAGE) ?
1809 FILE_PIPE_MESSAGE_MODE : FILE_PIPE_BYTE_STREAM_MODE;
1810 status = NtSetInformationFile(hNamedPipe, &iosb, &fpi, sizeof(fpi), FilePipeInformation);
1811 }
1812
1813 if (status)
1814 {
1815 SetLastError( RtlNtStatusToDosError(status) );
1816 return FALSE;
1817 }
1818 }
1819
1820 return TRUE;
1821 }
1822
1823 /***********************************************************************
1824 * CallNamedPipeA (KERNEL32.@)
1825 */
1826 BOOL WINAPI CallNamedPipeA(
1827 LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
1828 LPVOID lpOutput, DWORD dwOutputSize,
1829 LPDWORD lpBytesRead, DWORD nTimeout)
1830 {
1831 DWORD len;
1832 LPWSTR str = NULL;
1833 BOOL ret;
1834
1835 TRACE("%s %p %d %p %d %p %d\n",
1836 debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
1837 lpOutput, dwOutputSize, lpBytesRead, nTimeout);
1838
1839 if( lpNamedPipeName )
1840 {
1841 len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
1842 str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1843 MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
1844 }
1845 ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
1846 dwOutputSize, lpBytesRead, nTimeout );
1847 if( lpNamedPipeName )
1848 HeapFree( GetProcessHeap(), 0, str );
1849
1850 return ret;
1851 }
1852
1853 /***********************************************************************
1854 * CallNamedPipeW (KERNEL32.@)
1855 */
1856 BOOL WINAPI CallNamedPipeW(
1857 LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1858 LPVOID lpOutput, DWORD lpOutputSize,
1859 LPDWORD lpBytesRead, DWORD nTimeout)
1860 {
1861 HANDLE pipe;
1862 BOOL ret;
1863 DWORD mode;
1864
1865 TRACE("%s %p %d %p %d %p %d\n",
1866 debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1867 lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1868
1869 pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1870 if (pipe == INVALID_HANDLE_VALUE)
1871 {
1872 ret = WaitNamedPipeW(lpNamedPipeName, nTimeout);
1873 if (!ret)
1874 return FALSE;
1875 pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1876 if (pipe == INVALID_HANDLE_VALUE)
1877 return FALSE;
1878 }
1879
1880 mode = PIPE_READMODE_MESSAGE;
1881 ret = SetNamedPipeHandleState(pipe, &mode, NULL, NULL);
1882 if (!ret)
1883 {
1884 CloseHandle(pipe);
1885 return FALSE;
1886 }
1887
1888 ret = TransactNamedPipe(pipe, lpInput, lpInputSize, lpOutput, lpOutputSize, lpBytesRead, NULL);
1889 CloseHandle(pipe);
1890 if (!ret)
1891 return FALSE;
1892
1893 return TRUE;
1894 }
1895
1896 /******************************************************************
1897 * CreatePipe (KERNEL32.@)
1898 *
1899 */
1900 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1901 LPSECURITY_ATTRIBUTES sa, DWORD size )
1902 {
1903 static unsigned index /* = 0 */;
1904 WCHAR name[64];
1905 HANDLE hr, hw;
1906 unsigned in_index = index;
1907 UNICODE_STRING nt_name;
1908 OBJECT_ATTRIBUTES attr;
1909 NTSTATUS status;
1910 IO_STATUS_BLOCK iosb;
1911 LARGE_INTEGER timeout;
1912
1913 *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1914
1915 attr.Length = sizeof(attr);
1916 attr.RootDirectory = 0;
1917 attr.ObjectName = &nt_name;
1918 attr.Attributes = OBJ_CASE_INSENSITIVE |
1919 ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1920 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1921 attr.SecurityQualityOfService = NULL;
1922
1923 timeout.QuadPart = (ULONGLONG)NMPWAIT_USE_DEFAULT_WAIT * -10000;
1924 /* generate a unique pipe name (system wide) */
1925 do
1926 {
1927 static const WCHAR nameFmt[] = { '\\','?','?','\\','p','i','p','e',
1928 '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1929 'u','.','%','0','8','u','\0' };
1930
1931 snprintfW(name, sizeof(name) / sizeof(name[0]), nameFmt,
1932 GetCurrentProcessId(), ++index);
1933 RtlInitUnicodeString(&nt_name, name);
1934 status = NtCreateNamedPipeFile(&hr, GENERIC_READ | SYNCHRONIZE, &attr, &iosb,
1935 FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
1936 FILE_SYNCHRONOUS_IO_NONALERT,
1937 FALSE, FALSE, FALSE,
1938 1, size, size, &timeout);
1939 if (status)
1940 {
1941 SetLastError( RtlNtStatusToDosError(status) );
1942 hr = INVALID_HANDLE_VALUE;
1943 }
1944 } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1945 /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1946 if (hr == INVALID_HANDLE_VALUE) return FALSE;
1947
1948 status = NtOpenFile(&hw, GENERIC_WRITE | SYNCHRONIZE, &attr, &iosb, 0,
1949 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
1950
1951 if (status)
1952 {
1953 SetLastError( RtlNtStatusToDosError(status) );
1954 NtClose(hr);
1955 return FALSE;
1956 }
1957
1958 *hReadPipe = hr;
1959 *hWritePipe = hw;
1960 return TRUE;
1961 }
1962
1963
1964 /******************************************************************************
1965 * CreateMailslotA [KERNEL32.@]
1966 *
1967 * See CreateMailslotW.
1968 */
1969 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1970 DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1971 {
1972 DWORD len;
1973 HANDLE handle;
1974 LPWSTR name = NULL;
1975
1976 TRACE("%s %d %d %p\n", debugstr_a(lpName),
1977 nMaxMessageSize, lReadTimeout, sa);
1978
1979 if( lpName )
1980 {
1981 len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1982 name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1983 MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1984 }
1985
1986 handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1987
1988 HeapFree( GetProcessHeap(), 0, name );
1989
1990 return handle;
1991 }
1992
1993
1994 /******************************************************************************
1995 * CreateMailslotW [KERNEL32.@]
1996 *
1997 * Create a mailslot with specified name.
1998 *
1999 * PARAMS
2000 * lpName [I] Pointer to string for mailslot name
2001 * nMaxMessageSize [I] Maximum message size
2002 * lReadTimeout [I] Milliseconds before read time-out
2003 * sa [I] Pointer to security structure
2004 *
2005 * RETURNS
2006 * Success: Handle to mailslot
2007 * Failure: INVALID_HANDLE_VALUE
2008 */
2009 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
2010 DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
2011 {
2012 HANDLE handle = INVALID_HANDLE_VALUE;
2013 OBJECT_ATTRIBUTES attr;
2014 UNICODE_STRING nameW;
2015 LARGE_INTEGER timeout;
2016 IO_STATUS_BLOCK iosb;
2017 NTSTATUS status;
2018
2019 TRACE("%s %d %d %p\n", debugstr_w(lpName),
2020 nMaxMessageSize, lReadTimeout, sa);
2021
2022 if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
2023 {
2024 SetLastError( ERROR_PATH_NOT_FOUND );
2025 return INVALID_HANDLE_VALUE;
2026 }
2027
2028 if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
2029 {
2030 SetLastError( ERROR_FILENAME_EXCED_RANGE );
2031 RtlFreeUnicodeString( &nameW );
2032 return INVALID_HANDLE_VALUE;
2033 }
2034
2035 attr.Length = sizeof(attr);
2036 attr.RootDirectory = 0;
2037 attr.Attributes = OBJ_CASE_INSENSITIVE;
2038 attr.ObjectName = &nameW;
2039 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
2040 attr.SecurityQualityOfService = NULL;
2041
2042 if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
2043 timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
2044 else
2045 timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
2046
2047 status = NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
2048 &iosb, 0, 0, nMaxMessageSize, &timeout );
2049 if (status)
2050 {
2051 SetLastError( RtlNtStatusToDosError(status) );
2052 handle = INVALID_HANDLE_VALUE;
2053 }
2054
2055 RtlFreeUnicodeString( &nameW );
2056 return handle;
2057 }
2058
2059
2060 /******************************************************************************
2061 * GetMailslotInfo [KERNEL32.@]
2062 *
2063 * Retrieve information about a mailslot.
2064 *
2065 * PARAMS
2066 * hMailslot [I] Mailslot handle
2067 * lpMaxMessageSize [O] Address of maximum message size
2068 * lpNextSize [O] Address of size of next message
2069 * lpMessageCount [O] Address of number of messages
2070 * lpReadTimeout [O] Address of read time-out
2071 *
2072 * RETURNS
2073 * Success: TRUE
2074 * Failure: FALSE
2075 */
2076 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
2077 LPDWORD lpNextSize, LPDWORD lpMessageCount,
2078 LPDWORD lpReadTimeout )
2079 {
2080 FILE_MAILSLOT_QUERY_INFORMATION info;
2081 IO_STATUS_BLOCK iosb;
2082 NTSTATUS status;
2083
2084 TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
2085 lpNextSize, lpMessageCount, lpReadTimeout);
2086
2087 status = NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
2088 FileMailslotQueryInformation );
2089
2090 if( status != STATUS_SUCCESS )
2091 {
2092 SetLastError( RtlNtStatusToDosError(status) );
2093 return FALSE;
2094 }
2095
2096 if( lpMaxMessageSize )
2097 *lpMaxMessageSize = info.MaximumMessageSize;
2098 if( lpNextSize )
2099 *lpNextSize = info.NextMessageSize;
2100 if( lpMessageCount )
2101 *lpMessageCount = info.MessagesAvailable;
2102 if( lpReadTimeout )
2103 {
2104 if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
2105 *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
2106 else
2107 *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
2108 }
2109 return TRUE;
2110 }
2111
2112
2113 /******************************************************************************
2114 * SetMailslotInfo [KERNEL32.@]
2115 *
2116 * Set the read timeout of a mailslot.
2117 *
2118 * PARAMS
2119 * hMailslot [I] Mailslot handle
2120 * dwReadTimeout [I] Timeout in milliseconds.
2121 *
2122 * RETURNS
2123 * Success: TRUE
2124 * Failure: FALSE
2125 */
2126 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
2127 {
2128 FILE_MAILSLOT_SET_INFORMATION info;
2129 IO_STATUS_BLOCK iosb;
2130 NTSTATUS status;
2131
2132 TRACE("%p %d\n", hMailslot, dwReadTimeout);
2133
2134 if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
2135 info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
2136 else
2137 info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
2138 status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
2139 FileMailslotSetInformation );
2140 if( status != STATUS_SUCCESS )
2141 {
2142 SetLastError( RtlNtStatusToDosError(status) );
2143 return FALSE;
2144 }
2145 return TRUE;
2146 }
2147
2148
2149 /******************************************************************************
2150 * CreateIoCompletionPort (KERNEL32.@)
2151 */
2152 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
2153 ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
2154 {
2155 NTSTATUS status;
2156 HANDLE ret = 0;
2157
2158 TRACE("(%p, %p, %08lx, %08x)\n",
2159 hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
2160
2161 if (hExistingCompletionPort && hFileHandle == INVALID_HANDLE_VALUE)
2162 {
2163 SetLastError( ERROR_INVALID_PARAMETER);
2164 return NULL;
2165 }
2166
2167 if (hExistingCompletionPort)
2168 ret = hExistingCompletionPort;
2169 else
2170 {
2171 status = NtCreateIoCompletion( &ret, IO_COMPLETION_ALL_ACCESS, NULL, dwNumberOfConcurrentThreads );
2172 if (status != STATUS_SUCCESS) goto fail;
2173 }
2174
2175 if (hFileHandle != INVALID_HANDLE_VALUE)
2176 {
2177 FILE_COMPLETION_INFORMATION info;
2178 IO_STATUS_BLOCK iosb;
2179
2180 info.CompletionPort = ret;
2181 info.CompletionKey = CompletionKey;
2182 status = NtSetInformationFile( hFileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
2183 if (status != STATUS_SUCCESS) goto fail;
2184 }
2185
2186 return ret;
2187
2188 fail:
2189 if (ret && !hExistingCompletionPort)
2190 CloseHandle( ret );
2191 SetLastError( RtlNtStatusToDosError(status) );
2192 return 0;
2193 }
2194
2195 /******************************************************************************
2196 * GetQueuedCompletionStatus (KERNEL32.@)
2197 */
2198 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
2199 PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
2200 DWORD dwMilliseconds )
2201 {
2202 NTSTATUS status;
2203 IO_STATUS_BLOCK iosb;
2204 LARGE_INTEGER wait_time;
2205
2206 TRACE("(%p,%p,%p,%p,%d)\n",
2207 CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
2208
2209 *lpOverlapped = NULL;
2210
2211 status = NtRemoveIoCompletion( CompletionPort, pCompletionKey, (PULONG_PTR)lpOverlapped,
2212 &iosb, get_nt_timeout( &wait_time, dwMilliseconds ) );
2213 if (status == STATUS_SUCCESS)
2214 {
2215 *lpNumberOfBytesTransferred = iosb.Information;
2216 if (iosb.u.Status >= 0) return TRUE;
2217 SetLastError( RtlNtStatusToDosError(iosb.u.Status) );
2218 return FALSE;
2219 }
2220
2221 if (status == STATUS_TIMEOUT) SetLastError( WAIT_TIMEOUT );
2222 else SetLastError( RtlNtStatusToDosError(status) );
2223 return FALSE;
2224 }
2225
2226
2227 /******************************************************************************
2228 * PostQueuedCompletionStatus (KERNEL32.@)
2229 */
2230 BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
2231 ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
2232 {
2233 NTSTATUS status;
2234
2235 TRACE("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
2236
2237 status = NtSetIoCompletion( CompletionPort, dwCompletionKey, (ULONG_PTR)lpOverlapped,
2238 STATUS_SUCCESS, dwNumberOfBytes );
2239
2240 if (status == STATUS_SUCCESS) return TRUE;
2241 SetLastError( RtlNtStatusToDosError(status) );
2242 return FALSE;
2243 }
2244
2245 /******************************************************************************
2246 * BindIoCompletionCallback (KERNEL32.@)
2247 */
2248 BOOL WINAPI BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
2249 {
2250 NTSTATUS status;
2251
2252 TRACE("(%p, %p, %d)\n", FileHandle, Function, Flags);
2253
2254 status = RtlSetIoCompletionCallback( FileHandle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)Function, Flags );
2255 if (status == STATUS_SUCCESS) return TRUE;
2256 SetLastError( RtlNtStatusToDosError(status) );
2257 return FALSE;
2258 }
2259
2260
2261 /***********************************************************************
2262 * CreateMemoryResourceNotification (KERNEL32.@)
2263 */
2264 HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE type)
2265 {
2266 static const WCHAR lowmemW[] =
2267 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2268 '\\','L','o','w','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2269 static const WCHAR highmemW[] =
2270 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2271 '\\','H','i','g','h','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2272 HANDLE ret;
2273 UNICODE_STRING nameW;
2274 OBJECT_ATTRIBUTES attr;
2275 NTSTATUS status;
2276
2277 switch (type)
2278 {
2279 case LowMemoryResourceNotification:
2280 RtlInitUnicodeString( &nameW, lowmemW );
2281 break;
2282 case HighMemoryResourceNotification:
2283 RtlInitUnicodeString( &nameW, highmemW );
2284 break;
2285 default:
2286 SetLastError( ERROR_INVALID_PARAMETER );
2287 return 0;
2288 }
2289
2290 attr.Length = sizeof(attr);
2291 attr.RootDirectory = 0;
2292 attr.ObjectName = &nameW;
2293 attr.Attributes = 0;
2294 attr.SecurityDescriptor = NULL;
2295 attr.SecurityQualityOfService = NULL;
2296 status = NtOpenEvent( &ret, EVENT_ALL_ACCESS, &attr );
2297 if (status != STATUS_SUCCESS)
2298 {
2299 SetLastError( RtlNtStatusToDosError(status) );
2300 return 0;
2301 }
2302 return ret;
2303 }
2304
2305 /***********************************************************************
2306 * QueryMemoryResourceNotification (KERNEL32.@)
2307 */
2308 BOOL WINAPI QueryMemoryResourceNotification(HANDLE handle, PBOOL state)
2309 {
2310 switch (WaitForSingleObject( handle, 0 ))
2311 {
2312 case WAIT_OBJECT_0:
2313 *state = TRUE;
2314 return TRUE;
2315 case WAIT_TIMEOUT:
2316 *state = FALSE;
2317 return TRUE;
2318 }
2319 SetLastError( ERROR_INVALID_PARAMETER );
2320 return FALSE;
2321 }
2322
2323 /***********************************************************************
2324 * InitOnceBeginInitialize (KERNEL32.@)
2325 */
2326 BOOL WINAPI InitOnceBeginInitialize( INIT_ONCE *once, DWORD flags, BOOL *pending, void **context )
2327 {
2328 NTSTATUS status = RtlRunOnceBeginInitialize( once, flags, context );
2329 if (status >= 0) *pending = (status == STATUS_PENDING);
2330 else SetLastError( RtlNtStatusToDosError(status) );
2331 return status >= 0;
2332 }
2333
2334 /***********************************************************************
2335 * InitOnceComplete (KERNEL32.@)
2336 */
2337 BOOL WINAPI InitOnceComplete( INIT_ONCE *once, DWORD flags, void *context )
2338 {
2339 NTSTATUS status = RtlRunOnceComplete( once, flags, context );
2340 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
2341 return !status;
2342 }
2343
2344 /***********************************************************************
2345 * InitOnceExecuteOnce (KERNEL32.@)
2346 */
2347 BOOL WINAPI InitOnceExecuteOnce( INIT_ONCE *once, PINIT_ONCE_FN func, void *param, void **context )
2348 {
2349 return !RtlRunOnceExecuteOnce( once, (PRTL_RUN_ONCE_INIT_FN)func, param, context );
2350 }
2351
2352 #ifdef __i386__
2353
2354 /***********************************************************************
2355 * InterlockedCompareExchange (KERNEL32.@)
2356 */
2357 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2358 __ASM_STDCALL_FUNC(InterlockedCompareExchange, 12,
2359 "movl 12(%esp),%eax\n\t"
2360 "movl 8(%esp),%ecx\n\t"
2361 "movl 4(%esp),%edx\n\t"
2362 "lock; cmpxchgl %ecx,(%edx)\n\t"
2363 "ret $12")
2364
2365 /***********************************************************************
2366 * InterlockedExchange (KERNEL32.@)
2367 */
2368 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2369 __ASM_STDCALL_FUNC(InterlockedExchange, 8,
2370 "movl 8(%esp),%eax\n\t"
2371 "movl 4(%esp),%edx\n\t"
2372 "lock; xchgl %eax,(%edx)\n\t"
2373 "ret $8")
2374
2375 /***********************************************************************
2376 * InterlockedExchangeAdd (KERNEL32.@)
2377 */
2378 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2379 __ASM_STDCALL_FUNC(InterlockedExchangeAdd, 8,
2380 "movl 8(%esp),%eax\n\t"
2381 "movl 4(%esp),%edx\n\t"
2382 "lock; xaddl %eax,(%edx)\n\t"
2383 "ret $8")
2384
2385 /***********************************************************************
2386 * InterlockedIncrement (KERNEL32.@)
2387 */
2388 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2389 __ASM_STDCALL_FUNC(InterlockedIncrement, 4,
2390 "movl 4(%esp),%edx\n\t"
2391 "movl $1,%eax\n\t"
2392 "lock; xaddl %eax,(%edx)\n\t"
2393 "incl %eax\n\t"
2394 "ret $4")
2395
2396 /***********************************************************************
2397 * InterlockedDecrement (KERNEL32.@)
2398 */
2399 __ASM_STDCALL_FUNC(InterlockedDecrement, 4,
2400 "movl 4(%esp),%edx\n\t"
2401 "movl $-1,%eax\n\t"
2402 "lock; xaddl %eax,(%edx)\n\t"
2403 "decl %eax\n\t"
2404 "ret $4")
2405
2406 #endif /* __i386__ */
2407
2408 /***********************************************************************
2409 * SleepConditionVariableCS (KERNEL32.@)
2410 */
2411 BOOL WINAPI SleepConditionVariableCS( CONDITION_VARIABLE *variable, CRITICAL_SECTION *crit, DWORD timeout )
2412 {
2413 NTSTATUS status;
2414 LARGE_INTEGER time;
2415
2416 status = RtlSleepConditionVariableCS( variable, crit, get_nt_timeout( &time, timeout ) );
2417
2418 if (status != STATUS_SUCCESS)
2419 {
2420 SetLastError( RtlNtStatusToDosError(status) );
2421 return FALSE;
2422 }
2423 return TRUE;
2424 }
2425
2426 /***********************************************************************
2427 * SleepConditionVariableSRW (KERNEL32.@)
2428 */
2429 BOOL WINAPI SleepConditionVariableSRW( RTL_CONDITION_VARIABLE *variable, RTL_SRWLOCK *lock, DWORD timeout, ULONG flags )
2430 {
2431 NTSTATUS status;
2432 LARGE_INTEGER time;
2433
2434 status = RtlSleepConditionVariableSRW( variable, lock, get_nt_timeout( &time, timeout ), flags );
2435
2436 if (status != STATUS_SUCCESS)
2437 {
2438 SetLastError( RtlNtStatusToDosError(status) );
2439 return FALSE;
2440 }
2441 return TRUE;
2442 }
Windows API implementation