?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
advapi32/tests: Changed an invalid comment.
[wine.git] / dlls / kernel32 / sync.c
blobd363e1f91746af30c4b32ab72b6bbfcfa87afeb3
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;
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;
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;
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 FIXME("%p %p %p %p %p %p %d\n",
1716 hNamedPipe, lpState, lpCurInstances,
1717 lpMaxCollectionCount, lpCollectDataTimeout,
1718 lpUsername, nUsernameMaxSize);
1719
1720 return FALSE;
1721 }
1722
1723 /***********************************************************************
1724 * GetNamedPipeHandleStateW (KERNEL32.@)
1725 */
1726 BOOL WINAPI GetNamedPipeHandleStateW(
1727 HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1728 LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1729 LPWSTR lpUsername, DWORD nUsernameMaxSize)
1730 {
1731 FIXME("%p %p %p %p %p %p %d\n",
1732 hNamedPipe, lpState, lpCurInstances,
1733 lpMaxCollectionCount, lpCollectDataTimeout,
1734 lpUsername, nUsernameMaxSize);
1735
1736 return FALSE;
1737 }
1738
1739 /***********************************************************************
1740 * SetNamedPipeHandleState (KERNEL32.@)
1741 */
1742 BOOL WINAPI SetNamedPipeHandleState(
1743 HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1744 LPDWORD lpCollectDataTimeout)
1745 {
1746 /* should be a fixme, but this function is called a lot by the RPC
1747 * runtime, and it slows down InstallShield a fair bit. */
1748 WARN("stub: %p %p/%d %p %p\n",
1749 hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
1750 return FALSE;
1751 }
1752
1753 /***********************************************************************
1754 * CallNamedPipeA (KERNEL32.@)
1755 */
1756 BOOL WINAPI CallNamedPipeA(
1757 LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
1758 LPVOID lpOutput, DWORD dwOutputSize,
1759 LPDWORD lpBytesRead, DWORD nTimeout)
1760 {
1761 DWORD len;
1762 LPWSTR str = NULL;
1763 BOOL ret;
1764
1765 TRACE("%s %p %d %p %d %p %d\n",
1766 debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
1767 lpOutput, dwOutputSize, lpBytesRead, nTimeout);
1768
1769 if( lpNamedPipeName )
1770 {
1771 len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
1772 str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1773 MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
1774 }
1775 ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
1776 dwOutputSize, lpBytesRead, nTimeout );
1777 if( lpNamedPipeName )
1778 HeapFree( GetProcessHeap(), 0, str );
1779
1780 return ret;
1781 }
1782
1783 /***********************************************************************
1784 * CallNamedPipeW (KERNEL32.@)
1785 */
1786 BOOL WINAPI CallNamedPipeW(
1787 LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1788 LPVOID lpOutput, DWORD lpOutputSize,
1789 LPDWORD lpBytesRead, DWORD nTimeout)
1790 {
1791 HANDLE pipe;
1792 BOOL ret;
1793 DWORD mode;
1794
1795 TRACE("%s %p %d %p %d %p %d\n",
1796 debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1797 lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1798
1799 pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1800 if (pipe == INVALID_HANDLE_VALUE)
1801 {
1802 ret = WaitNamedPipeW(lpNamedPipeName, nTimeout);
1803 if (!ret)
1804 return FALSE;
1805 pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1806 if (pipe == INVALID_HANDLE_VALUE)
1807 return FALSE;
1808 }
1809
1810 mode = PIPE_READMODE_MESSAGE;
1811 ret = SetNamedPipeHandleState(pipe, &mode, NULL, NULL);
1812
1813 /* Currently SetNamedPipeHandleState() is a stub returning FALSE */
1814 if (ret) FIXME("Now that SetNamedPipeHandleState() is more than a stub, please update CallNamedPipeW\n");
1815 /*
1816 if (!ret)
1817 {
1818 CloseHandle(pipe);
1819 return FALSE;
1820 }*/
1821
1822 ret = TransactNamedPipe(pipe, lpInput, lpInputSize, lpOutput, lpOutputSize, lpBytesRead, NULL);
1823 CloseHandle(pipe);
1824 if (!ret)
1825 return FALSE;
1826
1827 return TRUE;
1828 }
1829
1830 /******************************************************************
1831 * CreatePipe (KERNEL32.@)
1832 *
1833 */
1834 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1835 LPSECURITY_ATTRIBUTES sa, DWORD size )
1836 {
1837 static unsigned index /* = 0 */;
1838 WCHAR name[64];
1839 HANDLE hr, hw;
1840 unsigned in_index = index;
1841 UNICODE_STRING nt_name;
1842 OBJECT_ATTRIBUTES attr;
1843 NTSTATUS status;
1844 IO_STATUS_BLOCK iosb;
1845 LARGE_INTEGER timeout;
1846
1847 *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1848
1849 attr.Length = sizeof(attr);
1850 attr.RootDirectory = 0;
1851 attr.ObjectName = &nt_name;
1852 attr.Attributes = OBJ_CASE_INSENSITIVE |
1853 ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1854 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1855 attr.SecurityQualityOfService = NULL;
1856
1857 timeout.QuadPart = (ULONGLONG)NMPWAIT_USE_DEFAULT_WAIT * -10000;
1858 /* generate a unique pipe name (system wide) */
1859 do
1860 {
1861 static const WCHAR nameFmt[] = { '\\','?','?','\\','p','i','p','e',
1862 '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1863 'u','.','%','0','8','u','\0' };
1864
1865 snprintfW(name, sizeof(name) / sizeof(name[0]), nameFmt,
1866 GetCurrentProcessId(), ++index);
1867 RtlInitUnicodeString(&nt_name, name);
1868 status = NtCreateNamedPipeFile(&hr, GENERIC_READ | SYNCHRONIZE, &attr, &iosb,
1869 FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
1870 FILE_SYNCHRONOUS_IO_NONALERT,
1871 FALSE, FALSE, FALSE,
1872 1, size, size, &timeout);
1873 if (status)
1874 {
1875 SetLastError( RtlNtStatusToDosError(status) );
1876 hr = INVALID_HANDLE_VALUE;
1877 }
1878 } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1879 /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1880 if (hr == INVALID_HANDLE_VALUE) return FALSE;
1881
1882 status = NtOpenFile(&hw, GENERIC_WRITE | SYNCHRONIZE, &attr, &iosb, 0,
1883 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
1884
1885 if (status)
1886 {
1887 SetLastError( RtlNtStatusToDosError(status) );
1888 NtClose(hr);
1889 return FALSE;
1890 }
1891
1892 *hReadPipe = hr;
1893 *hWritePipe = hw;
1894 return TRUE;
1895 }
1896
1897
1898 /******************************************************************************
1899 * CreateMailslotA [KERNEL32.@]
1900 *
1901 * See CreateMailslotW.
1902 */
1903 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1904 DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1905 {
1906 DWORD len;
1907 HANDLE handle;
1908 LPWSTR name = NULL;
1909
1910 TRACE("%s %d %d %p\n", debugstr_a(lpName),
1911 nMaxMessageSize, lReadTimeout, sa);
1912
1913 if( lpName )
1914 {
1915 len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1916 name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1917 MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1918 }
1919
1920 handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1921
1922 HeapFree( GetProcessHeap(), 0, name );
1923
1924 return handle;
1925 }
1926
1927
1928 /******************************************************************************
1929 * CreateMailslotW [KERNEL32.@]
1930 *
1931 * Create a mailslot with specified name.
1932 *
1933 * PARAMS
1934 * lpName [I] Pointer to string for mailslot name
1935 * nMaxMessageSize [I] Maximum message size
1936 * lReadTimeout [I] Milliseconds before read time-out
1937 * sa [I] Pointer to security structure
1938 *
1939 * RETURNS
1940 * Success: Handle to mailslot
1941 * Failure: INVALID_HANDLE_VALUE
1942 */
1943 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
1944 DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1945 {
1946 HANDLE handle = INVALID_HANDLE_VALUE;
1947 OBJECT_ATTRIBUTES attr;
1948 UNICODE_STRING nameW;
1949 LARGE_INTEGER timeout;
1950 IO_STATUS_BLOCK iosb;
1951 NTSTATUS status;
1952
1953 TRACE("%s %d %d %p\n", debugstr_w(lpName),
1954 nMaxMessageSize, lReadTimeout, sa);
1955
1956 if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
1957 {
1958 SetLastError( ERROR_PATH_NOT_FOUND );
1959 return INVALID_HANDLE_VALUE;
1960 }
1961
1962 if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
1963 {
1964 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1965 RtlFreeUnicodeString( &nameW );
1966 return INVALID_HANDLE_VALUE;
1967 }
1968
1969 attr.Length = sizeof(attr);
1970 attr.RootDirectory = 0;
1971 attr.Attributes = OBJ_CASE_INSENSITIVE;
1972 attr.ObjectName = &nameW;
1973 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1974 attr.SecurityQualityOfService = NULL;
1975
1976 if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
1977 timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
1978 else
1979 timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1980
1981 status = NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
1982 &iosb, 0, 0, nMaxMessageSize, &timeout );
1983 if (status)
1984 {
1985 SetLastError( RtlNtStatusToDosError(status) );
1986 handle = INVALID_HANDLE_VALUE;
1987 }
1988
1989 RtlFreeUnicodeString( &nameW );
1990 return handle;
1991 }
1992
1993
1994 /******************************************************************************
1995 * GetMailslotInfo [KERNEL32.@]
1996 *
1997 * Retrieve information about a mailslot.
1998 *
1999 * PARAMS
2000 * hMailslot [I] Mailslot handle
2001 * lpMaxMessageSize [O] Address of maximum message size
2002 * lpNextSize [O] Address of size of next message
2003 * lpMessageCount [O] Address of number of messages
2004 * lpReadTimeout [O] Address of read time-out
2005 *
2006 * RETURNS
2007 * Success: TRUE
2008 * Failure: FALSE
2009 */
2010 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
2011 LPDWORD lpNextSize, LPDWORD lpMessageCount,
2012 LPDWORD lpReadTimeout )
2013 {
2014 FILE_MAILSLOT_QUERY_INFORMATION info;
2015 IO_STATUS_BLOCK iosb;
2016 NTSTATUS status;
2017
2018 TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
2019 lpNextSize, lpMessageCount, lpReadTimeout);
2020
2021 status = NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
2022 FileMailslotQueryInformation );
2023
2024 if( status != STATUS_SUCCESS )
2025 {
2026 SetLastError( RtlNtStatusToDosError(status) );
2027 return FALSE;
2028 }
2029
2030 if( lpMaxMessageSize )
2031 *lpMaxMessageSize = info.MaximumMessageSize;
2032 if( lpNextSize )
2033 *lpNextSize = info.NextMessageSize;
2034 if( lpMessageCount )
2035 *lpMessageCount = info.MessagesAvailable;
2036 if( lpReadTimeout )
2037 {
2038 if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
2039 *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
2040 else
2041 *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
2042 }
2043 return TRUE;
2044 }
2045
2046
2047 /******************************************************************************
2048 * SetMailslotInfo [KERNEL32.@]
2049 *
2050 * Set the read timeout of a mailslot.
2051 *
2052 * PARAMS
2053 * hMailslot [I] Mailslot handle
2054 * dwReadTimeout [I] Timeout in milliseconds.
2055 *
2056 * RETURNS
2057 * Success: TRUE
2058 * Failure: FALSE
2059 */
2060 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
2061 {
2062 FILE_MAILSLOT_SET_INFORMATION info;
2063 IO_STATUS_BLOCK iosb;
2064 NTSTATUS status;
2065
2066 TRACE("%p %d\n", hMailslot, dwReadTimeout);
2067
2068 if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
2069 info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
2070 else
2071 info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
2072 status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
2073 FileMailslotSetInformation );
2074 if( status != STATUS_SUCCESS )
2075 {
2076 SetLastError( RtlNtStatusToDosError(status) );
2077 return FALSE;
2078 }
2079 return TRUE;
2080 }
2081
2082
2083 /******************************************************************************
2084 * CreateIoCompletionPort (KERNEL32.@)
2085 */
2086 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
2087 ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
2088 {
2089 NTSTATUS status;
2090 HANDLE ret = 0;
2091
2092 TRACE("(%p, %p, %08lx, %08x)\n",
2093 hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
2094
2095 if (hExistingCompletionPort && hFileHandle == INVALID_HANDLE_VALUE)
2096 {
2097 SetLastError( ERROR_INVALID_PARAMETER);
2098 return NULL;
2099 }
2100
2101 if (hExistingCompletionPort)
2102 ret = hExistingCompletionPort;
2103 else
2104 {
2105 status = NtCreateIoCompletion( &ret, IO_COMPLETION_ALL_ACCESS, NULL, dwNumberOfConcurrentThreads );
2106 if (status != STATUS_SUCCESS) goto fail;
2107 }
2108
2109 if (hFileHandle != INVALID_HANDLE_VALUE)
2110 {
2111 FILE_COMPLETION_INFORMATION info;
2112 IO_STATUS_BLOCK iosb;
2113
2114 info.CompletionPort = ret;
2115 info.CompletionKey = CompletionKey;
2116 status = NtSetInformationFile( hFileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
2117 if (status != STATUS_SUCCESS) goto fail;
2118 }
2119
2120 return ret;
2121
2122 fail:
2123 if (ret && !hExistingCompletionPort)
2124 CloseHandle( ret );
2125 SetLastError( RtlNtStatusToDosError(status) );
2126 return 0;
2127 }
2128
2129 /******************************************************************************
2130 * GetQueuedCompletionStatus (KERNEL32.@)
2131 */
2132 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
2133 PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
2134 DWORD dwMilliseconds )
2135 {
2136 NTSTATUS status;
2137 IO_STATUS_BLOCK iosb;
2138 LARGE_INTEGER wait_time;
2139
2140 TRACE("(%p,%p,%p,%p,%d)\n",
2141 CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
2142
2143 *lpOverlapped = NULL;
2144
2145 status = NtRemoveIoCompletion( CompletionPort, pCompletionKey, (PULONG_PTR)lpOverlapped,
2146 &iosb, get_nt_timeout( &wait_time, dwMilliseconds ) );
2147 if (status == STATUS_SUCCESS)
2148 {
2149 *lpNumberOfBytesTransferred = iosb.Information;
2150 if (iosb.u.Status >= 0) return TRUE;
2151 SetLastError( RtlNtStatusToDosError(iosb.u.Status) );
2152 return FALSE;
2153 }
2154
2155 if (status == STATUS_TIMEOUT) SetLastError( WAIT_TIMEOUT );
2156 else SetLastError( RtlNtStatusToDosError(status) );
2157 return FALSE;
2158 }
2159
2160
2161 /******************************************************************************
2162 * PostQueuedCompletionStatus (KERNEL32.@)
2163 */
2164 BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
2165 ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
2166 {
2167 NTSTATUS status;
2168
2169 TRACE("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
2170
2171 status = NtSetIoCompletion( CompletionPort, dwCompletionKey, (ULONG_PTR)lpOverlapped,
2172 STATUS_SUCCESS, dwNumberOfBytes );
2173
2174 if (status == STATUS_SUCCESS) return TRUE;
2175 SetLastError( RtlNtStatusToDosError(status) );
2176 return FALSE;
2177 }
2178
2179 /******************************************************************************
2180 * BindIoCompletionCallback (KERNEL32.@)
2181 */
2182 BOOL WINAPI BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
2183 {
2184 NTSTATUS status;
2185
2186 TRACE("(%p, %p, %d)\n", FileHandle, Function, Flags);
2187
2188 status = RtlSetIoCompletionCallback( FileHandle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)Function, Flags );
2189 if (status == STATUS_SUCCESS) return TRUE;
2190 SetLastError( RtlNtStatusToDosError(status) );
2191 return FALSE;
2192 }
2193
2194
2195 /***********************************************************************
2196 * CreateMemoryResourceNotification (KERNEL32.@)
2197 */
2198 HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE type)
2199 {
2200 static const WCHAR lowmemW[] =
2201 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2202 '\\','L','o','w','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2203 static const WCHAR highmemW[] =
2204 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2205 '\\','H','i','g','h','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2206 HANDLE ret;
2207 UNICODE_STRING nameW;
2208 OBJECT_ATTRIBUTES attr;
2209 NTSTATUS status;
2210
2211 switch (type)
2212 {
2213 case LowMemoryResourceNotification:
2214 RtlInitUnicodeString( &nameW, lowmemW );
2215 break;
2216 case HighMemoryResourceNotification:
2217 RtlInitUnicodeString( &nameW, highmemW );
2218 break;
2219 default:
2220 SetLastError( ERROR_INVALID_PARAMETER );
2221 return 0;
2222 }
2223
2224 attr.Length = sizeof(attr);
2225 attr.RootDirectory = 0;
2226 attr.ObjectName = &nameW;
2227 attr.Attributes = 0;
2228 attr.SecurityDescriptor = NULL;
2229 attr.SecurityQualityOfService = NULL;
2230 status = NtOpenEvent( &ret, EVENT_ALL_ACCESS, &attr );
2231 if (status != STATUS_SUCCESS)
2232 {
2233 SetLastError( RtlNtStatusToDosError(status) );
2234 return 0;
2235 }
2236 return ret;
2237 }
2238
2239 /***********************************************************************
2240 * QueryMemoryResourceNotification (KERNEL32.@)
2241 */
2242 BOOL WINAPI QueryMemoryResourceNotification(HANDLE handle, PBOOL state)
2243 {
2244 switch (WaitForSingleObject( handle, 0 ))
2245 {
2246 case WAIT_OBJECT_0:
2247 *state = TRUE;
2248 return TRUE;
2249 case WAIT_TIMEOUT:
2250 *state = FALSE;
2251 return TRUE;
2252 }
2253 SetLastError( ERROR_INVALID_PARAMETER );
2254 return FALSE;
2255 }
2256
2257 /***********************************************************************
2258 * InitOnceBeginInitialize (KERNEL32.@)
2259 */
2260 BOOL WINAPI InitOnceBeginInitialize( INIT_ONCE *once, DWORD flags, BOOL *pending, void **context )
2261 {
2262 NTSTATUS status = RtlRunOnceBeginInitialize( once, flags, context );
2263 if (status >= 0) *pending = (status == STATUS_PENDING);
2264 else SetLastError( RtlNtStatusToDosError(status) );
2265 return status >= 0;
2266 }
2267
2268 /***********************************************************************
2269 * InitOnceComplete (KERNEL32.@)
2270 */
2271 BOOL WINAPI InitOnceComplete( INIT_ONCE *once, DWORD flags, void *context )
2272 {
2273 NTSTATUS status = RtlRunOnceComplete( once, flags, context );
2274 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
2275 return !status;
2276 }
2277
2278 /***********************************************************************
2279 * InitOnceExecuteOnce (KERNEL32.@)
2280 */
2281 BOOL WINAPI InitOnceExecuteOnce( INIT_ONCE *once, PINIT_ONCE_FN func, void *param, void **context )
2282 {
2283 return !RtlRunOnceExecuteOnce( once, (PRTL_RUN_ONCE_INIT_FN)func, param, context );
2284 }
2285
2286 #ifdef __i386__
2287
2288 /***********************************************************************
2289 * InterlockedCompareExchange (KERNEL32.@)
2290 */
2291 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2292 __ASM_STDCALL_FUNC(InterlockedCompareExchange, 12,
2293 "movl 12(%esp),%eax\n\t"
2294 "movl 8(%esp),%ecx\n\t"
2295 "movl 4(%esp),%edx\n\t"
2296 "lock; cmpxchgl %ecx,(%edx)\n\t"
2297 "ret $12")
2298
2299 /***********************************************************************
2300 * InterlockedExchange (KERNEL32.@)
2301 */
2302 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2303 __ASM_STDCALL_FUNC(InterlockedExchange, 8,
2304 "movl 8(%esp),%eax\n\t"
2305 "movl 4(%esp),%edx\n\t"
2306 "lock; xchgl %eax,(%edx)\n\t"
2307 "ret $8")
2308
2309 /***********************************************************************
2310 * InterlockedExchangeAdd (KERNEL32.@)
2311 */
2312 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2313 __ASM_STDCALL_FUNC(InterlockedExchangeAdd, 8,
2314 "movl 8(%esp),%eax\n\t"
2315 "movl 4(%esp),%edx\n\t"
2316 "lock; xaddl %eax,(%edx)\n\t"
2317 "ret $8")
2318
2319 /***********************************************************************
2320 * InterlockedIncrement (KERNEL32.@)
2321 */
2322 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2323 __ASM_STDCALL_FUNC(InterlockedIncrement, 4,
2324 "movl 4(%esp),%edx\n\t"
2325 "movl $1,%eax\n\t"
2326 "lock; xaddl %eax,(%edx)\n\t"
2327 "incl %eax\n\t"
2328 "ret $4")
2329
2330 /***********************************************************************
2331 * InterlockedDecrement (KERNEL32.@)
2332 */
2333 __ASM_STDCALL_FUNC(InterlockedDecrement, 4,
2334 "movl 4(%esp),%edx\n\t"
2335 "movl $-1,%eax\n\t"
2336 "lock; xaddl %eax,(%edx)\n\t"
2337 "decl %eax\n\t"
2338 "ret $4")
2339
2340 #endif /* __i386__ */
2341
2342 /***********************************************************************
2343 * SleepConditionVariableCS (KERNEL32.@)
2344 */
2345 BOOL WINAPI SleepConditionVariableCS( CONDITION_VARIABLE *variable, CRITICAL_SECTION *crit, DWORD timeout )
2346 {
2347 NTSTATUS status;
2348 LARGE_INTEGER time;
2349
2350 status = RtlSleepConditionVariableCS( variable, crit, get_nt_timeout( &time, timeout ) );
2351
2352 if (status != STATUS_SUCCESS)
2353 {
2354 SetLastError( RtlNtStatusToDosError(status) );
2355 return FALSE;
2356 }
2357 return TRUE;
2358 }
2359
2360 /***********************************************************************
2361 * SleepConditionVariableSRW (KERNEL32.@)
2362 */
2363 BOOL WINAPI SleepConditionVariableSRW( RTL_CONDITION_VARIABLE *variable, RTL_SRWLOCK *lock, DWORD timeout, ULONG flags )
2364 {
2365 NTSTATUS status;
2366 LARGE_INTEGER time;
2367
2368 status = RtlSleepConditionVariableSRW( variable, lock, get_nt_timeout( &time, timeout ), flags );
2369
2370 if (status != STATUS_SUCCESS)
2371 {
2372 SetLastError( RtlNtStatusToDosError(status) );
2373 return FALSE;
2374 }
2375 return TRUE;
2376 }
Windows API implementation