?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d10core: Implement ID3D10Multithread.
[wine/multimedia.git] / dlls / kernel32 / sync.c
blob0f442407e96c1aede4b2ec3b3a52f6986741b1ed
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 /***********************************************************************
1182 * CancelWaitableTimer (KERNEL32.@)
1183 */
1184 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
1185 {
1186 NTSTATUS status;
1187
1188 status = NtCancelTimer(handle, NULL);
1189 if (status != STATUS_SUCCESS)
1190 {
1191 SetLastError( RtlNtStatusToDosError(status) );
1192 return FALSE;
1193 }
1194 return TRUE;
1195 }
1196
1197
1198 /***********************************************************************
1199 * CreateTimerQueue (KERNEL32.@)
1200 */
1201 HANDLE WINAPI CreateTimerQueue(void)
1202 {
1203 HANDLE q;
1204 NTSTATUS status = RtlCreateTimerQueue(&q);
1205
1206 if (status != STATUS_SUCCESS)
1207 {
1208 SetLastError( RtlNtStatusToDosError(status) );
1209 return NULL;
1210 }
1211
1212 return q;
1213 }
1214
1215
1216 /***********************************************************************
1217 * DeleteTimerQueueEx (KERNEL32.@)
1218 */
1219 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
1220 {
1221 NTSTATUS status = RtlDeleteTimerQueueEx(TimerQueue, CompletionEvent);
1222
1223 if (status != STATUS_SUCCESS)
1224 {
1225 SetLastError( RtlNtStatusToDosError(status) );
1226 return FALSE;
1227 }
1228
1229 return TRUE;
1230 }
1231
1232 /***********************************************************************
1233 * DeleteTimerQueue (KERNEL32.@)
1234 */
1235 BOOL WINAPI DeleteTimerQueue(HANDLE TimerQueue)
1236 {
1237 return DeleteTimerQueueEx(TimerQueue, NULL);
1238 }
1239
1240 /***********************************************************************
1241 * CreateTimerQueueTimer (KERNEL32.@)
1242 *
1243 * Creates a timer-queue timer. This timer expires at the specified due
1244 * time (in ms), then after every specified period (in ms). When the timer
1245 * expires, the callback function is called.
1246 *
1247 * RETURNS
1248 * nonzero on success or zero on failure
1249 */
1250 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
1251 WAITORTIMERCALLBACK Callback, PVOID Parameter,
1252 DWORD DueTime, DWORD Period, ULONG Flags )
1253 {
1254 NTSTATUS status = RtlCreateTimer(phNewTimer, TimerQueue, Callback,
1255 Parameter, DueTime, Period, Flags);
1256
1257 if (status != STATUS_SUCCESS)
1258 {
1259 SetLastError( RtlNtStatusToDosError(status) );
1260 return FALSE;
1261 }
1262
1263 return TRUE;
1264 }
1265
1266 /***********************************************************************
1267 * ChangeTimerQueueTimer (KERNEL32.@)
1268 *
1269 * Changes the times at which the timer expires.
1270 *
1271 * RETURNS
1272 * nonzero on success or zero on failure
1273 */
1274 BOOL WINAPI ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1275 ULONG DueTime, ULONG Period )
1276 {
1277 NTSTATUS status = RtlUpdateTimer(TimerQueue, Timer, DueTime, Period);
1278
1279 if (status != STATUS_SUCCESS)
1280 {
1281 SetLastError( RtlNtStatusToDosError(status) );
1282 return FALSE;
1283 }
1284
1285 return TRUE;
1286 }
1287
1288 /***********************************************************************
1289 * DeleteTimerQueueTimer (KERNEL32.@)
1290 *
1291 * Cancels a timer-queue timer.
1292 *
1293 * RETURNS
1294 * nonzero on success or zero on failure
1295 */
1296 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1297 HANDLE CompletionEvent )
1298 {
1299 NTSTATUS status = RtlDeleteTimer(TimerQueue, Timer, CompletionEvent);
1300 if (status != STATUS_SUCCESS)
1301 {
1302 SetLastError( RtlNtStatusToDosError(status) );
1303 return FALSE;
1304 }
1305 return TRUE;
1306 }
1307
1308
1309 /*
1310 * Pipes
1311 */
1312
1313
1314 /***********************************************************************
1315 * CreateNamedPipeA (KERNEL32.@)
1316 */
1317 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
1318 DWORD dwPipeMode, DWORD nMaxInstances,
1319 DWORD nOutBufferSize, DWORD nInBufferSize,
1320 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
1321 {
1322 WCHAR buffer[MAX_PATH];
1323
1324 if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
1325 nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1326
1327 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1328 {
1329 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1330 return INVALID_HANDLE_VALUE;
1331 }
1332 return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
1333 nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1334 }
1335
1336
1337 /***********************************************************************
1338 * CreateNamedPipeW (KERNEL32.@)
1339 */
1340 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
1341 DWORD dwPipeMode, DWORD nMaxInstances,
1342 DWORD nOutBufferSize, DWORD nInBufferSize,
1343 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES sa )
1344 {
1345 HANDLE handle;
1346 UNICODE_STRING nt_name;
1347 OBJECT_ATTRIBUTES attr;
1348 DWORD access, options, sharing;
1349 BOOLEAN pipe_type, read_mode, non_block;
1350 NTSTATUS status;
1351 IO_STATUS_BLOCK iosb;
1352 LARGE_INTEGER timeout;
1353
1354 TRACE("(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n",
1355 debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
1356 nOutBufferSize, nInBufferSize, nDefaultTimeOut, sa );
1357
1358 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1359 {
1360 SetLastError( ERROR_PATH_NOT_FOUND );
1361 return INVALID_HANDLE_VALUE;
1362 }
1363 if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) )
1364 {
1365 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1366 RtlFreeUnicodeString( &nt_name );
1367 return INVALID_HANDLE_VALUE;
1368 }
1369
1370 attr.Length = sizeof(attr);
1371 attr.RootDirectory = 0;
1372 attr.ObjectName = &nt_name;
1373 attr.Attributes = OBJ_CASE_INSENSITIVE |
1374 ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1375 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1376 attr.SecurityQualityOfService = NULL;
1377
1378 switch(dwOpenMode & 3)
1379 {
1380 case PIPE_ACCESS_INBOUND:
1381 sharing = FILE_SHARE_WRITE;
1382 access = GENERIC_READ;
1383 break;
1384 case PIPE_ACCESS_OUTBOUND:
1385 sharing = FILE_SHARE_READ;
1386 access = GENERIC_WRITE;
1387 break;
1388 case PIPE_ACCESS_DUPLEX:
1389 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1390 access = GENERIC_READ | GENERIC_WRITE;
1391 break;
1392 default:
1393 SetLastError( ERROR_INVALID_PARAMETER );
1394 return INVALID_HANDLE_VALUE;
1395 }
1396 access |= SYNCHRONIZE;
1397 options = 0;
1398 if (dwOpenMode & WRITE_DAC) access |= WRITE_DAC;
1399 if (dwOpenMode & WRITE_OWNER) access |= WRITE_OWNER;
1400 if (dwOpenMode & ACCESS_SYSTEM_SECURITY) access |= ACCESS_SYSTEM_SECURITY;
1401 if (dwOpenMode & FILE_FLAG_WRITE_THROUGH) options |= FILE_WRITE_THROUGH;
1402 if (!(dwOpenMode & FILE_FLAG_OVERLAPPED)) options |= FILE_SYNCHRONOUS_IO_NONALERT;
1403 pipe_type = (dwPipeMode & PIPE_TYPE_MESSAGE) != 0;
1404 read_mode = (dwPipeMode & PIPE_READMODE_MESSAGE) != 0;
1405 non_block = (dwPipeMode & PIPE_NOWAIT) != 0;
1406 if (nMaxInstances >= PIPE_UNLIMITED_INSTANCES) nMaxInstances = ~0U;
1407
1408 timeout.QuadPart = (ULONGLONG)nDefaultTimeOut * -10000;
1409
1410 SetLastError(0);
1411
1412 status = NtCreateNamedPipeFile(&handle, access, &attr, &iosb, sharing,
1413 FILE_OVERWRITE_IF, options, pipe_type,
1414 read_mode, non_block, nMaxInstances,
1415 nInBufferSize, nOutBufferSize, &timeout);
1416
1417 RtlFreeUnicodeString( &nt_name );
1418 if (status)
1419 {
1420 handle = INVALID_HANDLE_VALUE;
1421 SetLastError( RtlNtStatusToDosError(status) );
1422 }
1423 return handle;
1424 }
1425
1426
1427 /***********************************************************************
1428 * PeekNamedPipe (KERNEL32.@)
1429 */
1430 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
1431 LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
1432 {
1433 FILE_PIPE_PEEK_BUFFER local_buffer;
1434 FILE_PIPE_PEEK_BUFFER *buffer = &local_buffer;
1435 IO_STATUS_BLOCK io;
1436 NTSTATUS status;
1437
1438 if (cbBuffer && !(buffer = HeapAlloc( GetProcessHeap(), 0,
1439 FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ))))
1440 {
1441 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1442 return FALSE;
1443 }
1444
1445 status = NtFsControlFile( hPipe, 0, NULL, NULL, &io, FSCTL_PIPE_PEEK, NULL, 0,
1446 buffer, FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ) );
1447 if (!status)
1448 {
1449 ULONG read_size = io.Information - FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data );
1450 if (lpcbAvail) *lpcbAvail = buffer->ReadDataAvailable;
1451 if (lpcbRead) *lpcbRead = read_size;
1452 if (lpcbMessage) *lpcbMessage = 0; /* FIXME */
1453 if (lpvBuffer) memcpy( lpvBuffer, buffer->Data, read_size );
1454 }
1455 else SetLastError( RtlNtStatusToDosError(status) );
1456
1457 if (buffer != &local_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1458 return !status;
1459 }
1460
1461 /***********************************************************************
1462 * WaitNamedPipeA (KERNEL32.@)
1463 */
1464 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
1465 {
1466 WCHAR buffer[MAX_PATH];
1467
1468 if (!name) return WaitNamedPipeW( NULL, nTimeOut );
1469
1470 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1471 {
1472 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1473 return FALSE;
1474 }
1475 return WaitNamedPipeW( buffer, nTimeOut );
1476 }
1477
1478
1479 /***********************************************************************
1480 * WaitNamedPipeW (KERNEL32.@)
1481 *
1482 * Waits for a named pipe instance to become available
1483 *
1484 * PARAMS
1485 * name [I] Pointer to a named pipe name to wait for
1486 * nTimeOut [I] How long to wait in ms
1487 *
1488 * RETURNS
1489 * TRUE: Success, named pipe can be opened with CreateFile
1490 * FALSE: Failure, GetLastError can be called for further details
1491 */
1492 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
1493 {
1494 static const WCHAR leadin[] = {'\\','?','?','\\','P','I','P','E','\\'};
1495 NTSTATUS status;
1496 UNICODE_STRING nt_name, pipe_dev_name;
1497 FILE_PIPE_WAIT_FOR_BUFFER *pipe_wait;
1498 IO_STATUS_BLOCK iosb;
1499 OBJECT_ATTRIBUTES attr;
1500 ULONG sz_pipe_wait;
1501 HANDLE pipe_dev;
1502
1503 TRACE("%s 0x%08x\n",debugstr_w(name),nTimeOut);
1504
1505 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1506 return FALSE;
1507
1508 if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) ||
1509 nt_name.Length < sizeof(leadin) ||
1510 strncmpiW( nt_name.Buffer, leadin, sizeof(leadin)/sizeof(WCHAR)) != 0)
1511 {
1512 RtlFreeUnicodeString( &nt_name );
1513 SetLastError( ERROR_PATH_NOT_FOUND );
1514 return FALSE;
1515 }
1516
1517 sz_pipe_wait = sizeof(*pipe_wait) + nt_name.Length - sizeof(leadin) - sizeof(WCHAR);
1518 if (!(pipe_wait = HeapAlloc( GetProcessHeap(), 0, sz_pipe_wait)))
1519 {
1520 RtlFreeUnicodeString( &nt_name );
1521 SetLastError( ERROR_OUTOFMEMORY );
1522 return FALSE;
1523 }
1524
1525 pipe_dev_name.Buffer = nt_name.Buffer;
1526 pipe_dev_name.Length = sizeof(leadin);
1527 pipe_dev_name.MaximumLength = sizeof(leadin);
1528 InitializeObjectAttributes(&attr,&pipe_dev_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1529 status = NtOpenFile( &pipe_dev, FILE_READ_ATTRIBUTES, &attr,
1530 &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
1531 FILE_SYNCHRONOUS_IO_NONALERT);
1532 if (status != ERROR_SUCCESS)
1533 {
1534 HeapFree( GetProcessHeap(), 0, pipe_wait);
1535 RtlFreeUnicodeString( &nt_name );
1536 SetLastError( ERROR_PATH_NOT_FOUND );
1537 return FALSE;
1538 }
1539
1540 pipe_wait->TimeoutSpecified = !(nTimeOut == NMPWAIT_USE_DEFAULT_WAIT);
1541 if (nTimeOut == NMPWAIT_WAIT_FOREVER)
1542 pipe_wait->Timeout.QuadPart = ((ULONGLONG)0x7fffffff << 32) | 0xffffffff;
1543 else
1544 pipe_wait->Timeout.QuadPart = (ULONGLONG)nTimeOut * -10000;
1545 pipe_wait->NameLength = nt_name.Length - sizeof(leadin);
1546 memcpy(pipe_wait->Name, nt_name.Buffer + sizeof(leadin)/sizeof(WCHAR),
1547 pipe_wait->NameLength);
1548 RtlFreeUnicodeString( &nt_name );
1549
1550 status = NtFsControlFile( pipe_dev, NULL, NULL, NULL, &iosb, FSCTL_PIPE_WAIT,
1551 pipe_wait, sz_pipe_wait, NULL, 0 );
1552
1553 HeapFree( GetProcessHeap(), 0, pipe_wait );
1554 NtClose( pipe_dev );
1555
1556 if(status != STATUS_SUCCESS)
1557 {
1558 SetLastError(RtlNtStatusToDosError(status));
1559 return FALSE;
1560 }
1561 else
1562 return TRUE;
1563 }
1564
1565
1566 /***********************************************************************
1567 * ConnectNamedPipe (KERNEL32.@)
1568 *
1569 * Connects to a named pipe
1570 *
1571 * Parameters
1572 * hPipe: A handle to a named pipe returned by CreateNamedPipe
1573 * overlapped: Optional OVERLAPPED struct
1574 *
1575 * Return values
1576 * TRUE: Success
1577 * FALSE: Failure, GetLastError can be called for further details
1578 */
1579 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1580 {
1581 NTSTATUS status;
1582 IO_STATUS_BLOCK status_block;
1583 LPVOID cvalue = NULL;
1584
1585 TRACE("(%p,%p)\n", hPipe, overlapped);
1586
1587 if(overlapped)
1588 {
1589 overlapped->Internal = STATUS_PENDING;
1590 overlapped->InternalHigh = 0;
1591 if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
1592 }
1593
1594 status = NtFsControlFile(hPipe, overlapped ? overlapped->hEvent : NULL, NULL, cvalue,
1595 overlapped ? (IO_STATUS_BLOCK *)overlapped : &status_block,
1596 FSCTL_PIPE_LISTEN, NULL, 0, NULL, 0);
1597
1598 if (status == STATUS_SUCCESS) return TRUE;
1599 SetLastError( RtlNtStatusToDosError(status) );
1600 return FALSE;
1601 }
1602
1603 /***********************************************************************
1604 * DisconnectNamedPipe (KERNEL32.@)
1605 *
1606 * Disconnects from a named pipe
1607 *
1608 * Parameters
1609 * hPipe: A handle to a named pipe returned by CreateNamedPipe
1610 *
1611 * Return values
1612 * TRUE: Success
1613 * FALSE: Failure, GetLastError can be called for further details
1614 */
1615 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
1616 {
1617 NTSTATUS status;
1618 IO_STATUS_BLOCK io_block;
1619
1620 TRACE("(%p)\n",hPipe);
1621
1622 status = NtFsControlFile(hPipe, 0, NULL, NULL, &io_block, FSCTL_PIPE_DISCONNECT,
1623 NULL, 0, NULL, 0);
1624 if (status == STATUS_SUCCESS) return TRUE;
1625 SetLastError( RtlNtStatusToDosError(status) );
1626 return FALSE;
1627 }
1628
1629 /***********************************************************************
1630 * TransactNamedPipe (KERNEL32.@)
1631 *
1632 * BUGS
1633 * should be done as a single operation in the wineserver or kernel
1634 */
1635 BOOL WINAPI TransactNamedPipe(
1636 HANDLE handle, LPVOID write_buf, DWORD write_size, LPVOID read_buf,
1637 DWORD read_size, LPDWORD bytes_read, LPOVERLAPPED overlapped)
1638 {
1639 BOOL r;
1640 DWORD count;
1641
1642 TRACE("%p %p %d %p %d %p %p\n",
1643 handle, write_buf, write_size, read_buf,
1644 read_size, bytes_read, overlapped);
1645
1646 if (overlapped)
1647 {
1648 FIXME("Doesn't support overlapped operation as yet\n");
1649 return FALSE;
1650 }
1651
1652 r = WriteFile(handle, write_buf, write_size, &count, NULL);
1653 if (r)
1654 r = ReadFile(handle, read_buf, read_size, bytes_read, NULL);
1655
1656 return r;
1657 }
1658
1659 /***********************************************************************
1660 * GetNamedPipeInfo (KERNEL32.@)
1661 */
1662 BOOL WINAPI GetNamedPipeInfo(
1663 HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
1664 LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
1665 {
1666 FILE_PIPE_LOCAL_INFORMATION fpli;
1667 IO_STATUS_BLOCK iosb;
1668 NTSTATUS status;
1669
1670 status = NtQueryInformationFile(hNamedPipe, &iosb, &fpli, sizeof(fpli),
1671 FilePipeLocalInformation);
1672 if (status)
1673 {
1674 SetLastError( RtlNtStatusToDosError(status) );
1675 return FALSE;
1676 }
1677
1678 if (lpFlags)
1679 {
1680 *lpFlags = (fpli.NamedPipeEnd & FILE_PIPE_SERVER_END) ?
1681 PIPE_SERVER_END : PIPE_CLIENT_END;
1682 *lpFlags |= (fpli.NamedPipeType & FILE_PIPE_TYPE_MESSAGE) ?
1683 PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
1684 }
1685
1686 if (lpOutputBufferSize) *lpOutputBufferSize = fpli.OutboundQuota;
1687 if (lpInputBufferSize) *lpInputBufferSize = fpli.InboundQuota;
1688 if (lpMaxInstances) *lpMaxInstances = fpli.MaximumInstances;
1689
1690 return TRUE;
1691 }
1692
1693 /***********************************************************************
1694 * GetNamedPipeHandleStateA (KERNEL32.@)
1695 */
1696 BOOL WINAPI GetNamedPipeHandleStateA(
1697 HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1698 LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1699 LPSTR lpUsername, DWORD nUsernameMaxSize)
1700 {
1701 FIXME("%p %p %p %p %p %p %d\n",
1702 hNamedPipe, lpState, lpCurInstances,
1703 lpMaxCollectionCount, lpCollectDataTimeout,
1704 lpUsername, nUsernameMaxSize);
1705
1706 return FALSE;
1707 }
1708
1709 /***********************************************************************
1710 * GetNamedPipeHandleStateW (KERNEL32.@)
1711 */
1712 BOOL WINAPI GetNamedPipeHandleStateW(
1713 HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1714 LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1715 LPWSTR lpUsername, DWORD nUsernameMaxSize)
1716 {
1717 FIXME("%p %p %p %p %p %p %d\n",
1718 hNamedPipe, lpState, lpCurInstances,
1719 lpMaxCollectionCount, lpCollectDataTimeout,
1720 lpUsername, nUsernameMaxSize);
1721
1722 return FALSE;
1723 }
1724
1725 /***********************************************************************
1726 * SetNamedPipeHandleState (KERNEL32.@)
1727 */
1728 BOOL WINAPI SetNamedPipeHandleState(
1729 HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1730 LPDWORD lpCollectDataTimeout)
1731 {
1732 /* should be a fixme, but this function is called a lot by the RPC
1733 * runtime, and it slows down InstallShield a fair bit. */
1734 WARN("stub: %p %p/%d %p %p\n",
1735 hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
1736 return FALSE;
1737 }
1738
1739 /***********************************************************************
1740 * CallNamedPipeA (KERNEL32.@)
1741 */
1742 BOOL WINAPI CallNamedPipeA(
1743 LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
1744 LPVOID lpOutput, DWORD dwOutputSize,
1745 LPDWORD lpBytesRead, DWORD nTimeout)
1746 {
1747 DWORD len;
1748 LPWSTR str = NULL;
1749 BOOL ret;
1750
1751 TRACE("%s %p %d %p %d %p %d\n",
1752 debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
1753 lpOutput, dwOutputSize, lpBytesRead, nTimeout);
1754
1755 if( lpNamedPipeName )
1756 {
1757 len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
1758 str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1759 MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
1760 }
1761 ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
1762 dwOutputSize, lpBytesRead, nTimeout );
1763 if( lpNamedPipeName )
1764 HeapFree( GetProcessHeap(), 0, str );
1765
1766 return ret;
1767 }
1768
1769 /***********************************************************************
1770 * CallNamedPipeW (KERNEL32.@)
1771 */
1772 BOOL WINAPI CallNamedPipeW(
1773 LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1774 LPVOID lpOutput, DWORD lpOutputSize,
1775 LPDWORD lpBytesRead, DWORD nTimeout)
1776 {
1777 HANDLE pipe;
1778 BOOL ret;
1779 DWORD mode;
1780
1781 TRACE("%s %p %d %p %d %p %d\n",
1782 debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1783 lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1784
1785 pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1786 if (pipe == INVALID_HANDLE_VALUE)
1787 {
1788 ret = WaitNamedPipeW(lpNamedPipeName, nTimeout);
1789 if (!ret)
1790 return FALSE;
1791 pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1792 if (pipe == INVALID_HANDLE_VALUE)
1793 return FALSE;
1794 }
1795
1796 mode = PIPE_READMODE_MESSAGE;
1797 ret = SetNamedPipeHandleState(pipe, &mode, NULL, NULL);
1798
1799 /* Currently SetNamedPipeHandleState() is a stub returning FALSE */
1800 if (ret) FIXME("Now that SetNamedPipeHandleState() is more than a stub, please update CallNamedPipeW\n");
1801 /*
1802 if (!ret)
1803 {
1804 CloseHandle(pipe);
1805 return FALSE;
1806 }*/
1807
1808 ret = TransactNamedPipe(pipe, lpInput, lpInputSize, lpOutput, lpOutputSize, lpBytesRead, NULL);
1809 CloseHandle(pipe);
1810 if (!ret)
1811 return FALSE;
1812
1813 return TRUE;
1814 }
1815
1816 /******************************************************************
1817 * CreatePipe (KERNEL32.@)
1818 *
1819 */
1820 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1821 LPSECURITY_ATTRIBUTES sa, DWORD size )
1822 {
1823 static unsigned index /* = 0 */;
1824 WCHAR name[64];
1825 HANDLE hr, hw;
1826 unsigned in_index = index;
1827 UNICODE_STRING nt_name;
1828 OBJECT_ATTRIBUTES attr;
1829 NTSTATUS status;
1830 IO_STATUS_BLOCK iosb;
1831 LARGE_INTEGER timeout;
1832
1833 *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1834
1835 attr.Length = sizeof(attr);
1836 attr.RootDirectory = 0;
1837 attr.ObjectName = &nt_name;
1838 attr.Attributes = OBJ_CASE_INSENSITIVE |
1839 ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1840 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1841 attr.SecurityQualityOfService = NULL;
1842
1843 timeout.QuadPart = (ULONGLONG)NMPWAIT_USE_DEFAULT_WAIT * -10000;
1844 /* generate a unique pipe name (system wide) */
1845 do
1846 {
1847 static const WCHAR nameFmt[] = { '\\','?','?','\\','p','i','p','e',
1848 '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1849 'u','.','%','0','8','u','\0' };
1850
1851 snprintfW(name, sizeof(name) / sizeof(name[0]), nameFmt,
1852 GetCurrentProcessId(), ++index);
1853 RtlInitUnicodeString(&nt_name, name);
1854 status = NtCreateNamedPipeFile(&hr, GENERIC_READ | SYNCHRONIZE, &attr, &iosb,
1855 FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
1856 FILE_SYNCHRONOUS_IO_NONALERT,
1857 FALSE, FALSE, FALSE,
1858 1, size, size, &timeout);
1859 if (status)
1860 {
1861 SetLastError( RtlNtStatusToDosError(status) );
1862 hr = INVALID_HANDLE_VALUE;
1863 }
1864 } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1865 /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1866 if (hr == INVALID_HANDLE_VALUE) return FALSE;
1867
1868 status = NtOpenFile(&hw, GENERIC_WRITE | SYNCHRONIZE, &attr, &iosb, 0,
1869 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
1870
1871 if (status)
1872 {
1873 SetLastError( RtlNtStatusToDosError(status) );
1874 NtClose(hr);
1875 return FALSE;
1876 }
1877
1878 *hReadPipe = hr;
1879 *hWritePipe = hw;
1880 return TRUE;
1881 }
1882
1883
1884 /******************************************************************************
1885 * CreateMailslotA [KERNEL32.@]
1886 *
1887 * See CreateMailslotW.
1888 */
1889 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1890 DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1891 {
1892 DWORD len;
1893 HANDLE handle;
1894 LPWSTR name = NULL;
1895
1896 TRACE("%s %d %d %p\n", debugstr_a(lpName),
1897 nMaxMessageSize, lReadTimeout, sa);
1898
1899 if( lpName )
1900 {
1901 len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1902 name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1903 MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1904 }
1905
1906 handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1907
1908 HeapFree( GetProcessHeap(), 0, name );
1909
1910 return handle;
1911 }
1912
1913
1914 /******************************************************************************
1915 * CreateMailslotW [KERNEL32.@]
1916 *
1917 * Create a mailslot with specified name.
1918 *
1919 * PARAMS
1920 * lpName [I] Pointer to string for mailslot name
1921 * nMaxMessageSize [I] Maximum message size
1922 * lReadTimeout [I] Milliseconds before read time-out
1923 * sa [I] Pointer to security structure
1924 *
1925 * RETURNS
1926 * Success: Handle to mailslot
1927 * Failure: INVALID_HANDLE_VALUE
1928 */
1929 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
1930 DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1931 {
1932 HANDLE handle = INVALID_HANDLE_VALUE;
1933 OBJECT_ATTRIBUTES attr;
1934 UNICODE_STRING nameW;
1935 LARGE_INTEGER timeout;
1936 IO_STATUS_BLOCK iosb;
1937 NTSTATUS status;
1938
1939 TRACE("%s %d %d %p\n", debugstr_w(lpName),
1940 nMaxMessageSize, lReadTimeout, sa);
1941
1942 if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
1943 {
1944 SetLastError( ERROR_PATH_NOT_FOUND );
1945 return INVALID_HANDLE_VALUE;
1946 }
1947
1948 if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
1949 {
1950 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1951 RtlFreeUnicodeString( &nameW );
1952 return INVALID_HANDLE_VALUE;
1953 }
1954
1955 attr.Length = sizeof(attr);
1956 attr.RootDirectory = 0;
1957 attr.Attributes = OBJ_CASE_INSENSITIVE;
1958 attr.ObjectName = &nameW;
1959 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1960 attr.SecurityQualityOfService = NULL;
1961
1962 if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
1963 timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
1964 else
1965 timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1966
1967 status = NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
1968 &iosb, 0, 0, nMaxMessageSize, &timeout );
1969 if (status)
1970 {
1971 SetLastError( RtlNtStatusToDosError(status) );
1972 handle = INVALID_HANDLE_VALUE;
1973 }
1974
1975 RtlFreeUnicodeString( &nameW );
1976 return handle;
1977 }
1978
1979
1980 /******************************************************************************
1981 * GetMailslotInfo [KERNEL32.@]
1982 *
1983 * Retrieve information about a mailslot.
1984 *
1985 * PARAMS
1986 * hMailslot [I] Mailslot handle
1987 * lpMaxMessageSize [O] Address of maximum message size
1988 * lpNextSize [O] Address of size of next message
1989 * lpMessageCount [O] Address of number of messages
1990 * lpReadTimeout [O] Address of read time-out
1991 *
1992 * RETURNS
1993 * Success: TRUE
1994 * Failure: FALSE
1995 */
1996 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
1997 LPDWORD lpNextSize, LPDWORD lpMessageCount,
1998 LPDWORD lpReadTimeout )
1999 {
2000 FILE_MAILSLOT_QUERY_INFORMATION info;
2001 IO_STATUS_BLOCK iosb;
2002 NTSTATUS status;
2003
2004 TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
2005 lpNextSize, lpMessageCount, lpReadTimeout);
2006
2007 status = NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
2008 FileMailslotQueryInformation );
2009
2010 if( status != STATUS_SUCCESS )
2011 {
2012 SetLastError( RtlNtStatusToDosError(status) );
2013 return FALSE;
2014 }
2015
2016 if( lpMaxMessageSize )
2017 *lpMaxMessageSize = info.MaximumMessageSize;
2018 if( lpNextSize )
2019 *lpNextSize = info.NextMessageSize;
2020 if( lpMessageCount )
2021 *lpMessageCount = info.MessagesAvailable;
2022 if( lpReadTimeout )
2023 {
2024 if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
2025 *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
2026 else
2027 *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
2028 }
2029 return TRUE;
2030 }
2031
2032
2033 /******************************************************************************
2034 * SetMailslotInfo [KERNEL32.@]
2035 *
2036 * Set the read timeout of a mailslot.
2037 *
2038 * PARAMS
2039 * hMailslot [I] Mailslot handle
2040 * dwReadTimeout [I] Timeout in milliseconds.
2041 *
2042 * RETURNS
2043 * Success: TRUE
2044 * Failure: FALSE
2045 */
2046 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
2047 {
2048 FILE_MAILSLOT_SET_INFORMATION info;
2049 IO_STATUS_BLOCK iosb;
2050 NTSTATUS status;
2051
2052 TRACE("%p %d\n", hMailslot, dwReadTimeout);
2053
2054 if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
2055 info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
2056 else
2057 info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
2058 status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
2059 FileMailslotSetInformation );
2060 if( status != STATUS_SUCCESS )
2061 {
2062 SetLastError( RtlNtStatusToDosError(status) );
2063 return FALSE;
2064 }
2065 return TRUE;
2066 }
2067
2068
2069 /******************************************************************************
2070 * CreateIoCompletionPort (KERNEL32.@)
2071 */
2072 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
2073 ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
2074 {
2075 NTSTATUS status;
2076 HANDLE ret = 0;
2077
2078 TRACE("(%p, %p, %08lx, %08x)\n",
2079 hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
2080
2081 if (hExistingCompletionPort && hFileHandle == INVALID_HANDLE_VALUE)
2082 {
2083 SetLastError( ERROR_INVALID_PARAMETER);
2084 return NULL;
2085 }
2086
2087 if (hExistingCompletionPort)
2088 ret = hExistingCompletionPort;
2089 else
2090 {
2091 status = NtCreateIoCompletion( &ret, IO_COMPLETION_ALL_ACCESS, NULL, dwNumberOfConcurrentThreads );
2092 if (status != STATUS_SUCCESS) goto fail;
2093 }
2094
2095 if (hFileHandle != INVALID_HANDLE_VALUE)
2096 {
2097 FILE_COMPLETION_INFORMATION info;
2098 IO_STATUS_BLOCK iosb;
2099
2100 info.CompletionPort = ret;
2101 info.CompletionKey = CompletionKey;
2102 status = NtSetInformationFile( hFileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
2103 if (status != STATUS_SUCCESS) goto fail;
2104 }
2105
2106 return ret;
2107
2108 fail:
2109 if (ret && !hExistingCompletionPort)
2110 CloseHandle( ret );
2111 SetLastError( RtlNtStatusToDosError(status) );
2112 return 0;
2113 }
2114
2115 /******************************************************************************
2116 * GetQueuedCompletionStatus (KERNEL32.@)
2117 */
2118 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
2119 PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
2120 DWORD dwMilliseconds )
2121 {
2122 NTSTATUS status;
2123 IO_STATUS_BLOCK iosb;
2124 LARGE_INTEGER wait_time;
2125
2126 TRACE("(%p,%p,%p,%p,%d)\n",
2127 CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
2128
2129 *lpOverlapped = NULL;
2130
2131 status = NtRemoveIoCompletion( CompletionPort, pCompletionKey, (PULONG_PTR)lpOverlapped,
2132 &iosb, get_nt_timeout( &wait_time, dwMilliseconds ) );
2133 if (status == STATUS_SUCCESS)
2134 {
2135 *lpNumberOfBytesTransferred = iosb.Information;
2136 if (iosb.u.Status >= 0) return TRUE;
2137 SetLastError( RtlNtStatusToDosError(iosb.u.Status) );
2138 return FALSE;
2139 }
2140
2141 if (status == STATUS_TIMEOUT) SetLastError( WAIT_TIMEOUT );
2142 else SetLastError( RtlNtStatusToDosError(status) );
2143 return FALSE;
2144 }
2145
2146
2147 /******************************************************************************
2148 * PostQueuedCompletionStatus (KERNEL32.@)
2149 */
2150 BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
2151 ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
2152 {
2153 NTSTATUS status;
2154
2155 TRACE("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
2156
2157 status = NtSetIoCompletion( CompletionPort, dwCompletionKey, (ULONG_PTR)lpOverlapped,
2158 STATUS_SUCCESS, dwNumberOfBytes );
2159
2160 if (status == STATUS_SUCCESS) return TRUE;
2161 SetLastError( RtlNtStatusToDosError(status) );
2162 return FALSE;
2163 }
2164
2165 /******************************************************************************
2166 * BindIoCompletionCallback (KERNEL32.@)
2167 */
2168 BOOL WINAPI BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
2169 {
2170 NTSTATUS status;
2171
2172 TRACE("(%p, %p, %d)\n", FileHandle, Function, Flags);
2173
2174 status = RtlSetIoCompletionCallback( FileHandle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)Function, Flags );
2175 if (status == STATUS_SUCCESS) return TRUE;
2176 SetLastError( RtlNtStatusToDosError(status) );
2177 return FALSE;
2178 }
2179
2180
2181 /***********************************************************************
2182 * CreateMemoryResourceNotification (KERNEL32.@)
2183 */
2184 HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE type)
2185 {
2186 static const WCHAR lowmemW[] =
2187 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2188 '\\','L','o','w','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2189 static const WCHAR highmemW[] =
2190 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2191 '\\','H','i','g','h','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2192 HANDLE ret;
2193 UNICODE_STRING nameW;
2194 OBJECT_ATTRIBUTES attr;
2195 NTSTATUS status;
2196
2197 switch (type)
2198 {
2199 case LowMemoryResourceNotification:
2200 RtlInitUnicodeString( &nameW, lowmemW );
2201 break;
2202 case HighMemoryResourceNotification:
2203 RtlInitUnicodeString( &nameW, highmemW );
2204 break;
2205 default:
2206 SetLastError( ERROR_INVALID_PARAMETER );
2207 return 0;
2208 }
2209
2210 attr.Length = sizeof(attr);
2211 attr.RootDirectory = 0;
2212 attr.ObjectName = &nameW;
2213 attr.Attributes = 0;
2214 attr.SecurityDescriptor = NULL;
2215 attr.SecurityQualityOfService = NULL;
2216 status = NtOpenEvent( &ret, EVENT_ALL_ACCESS, &attr );
2217 if (status != STATUS_SUCCESS)
2218 {
2219 SetLastError( RtlNtStatusToDosError(status) );
2220 return 0;
2221 }
2222 return ret;
2223 }
2224
2225 /***********************************************************************
2226 * QueryMemoryResourceNotification (KERNEL32.@)
2227 */
2228 BOOL WINAPI QueryMemoryResourceNotification(HANDLE handle, PBOOL state)
2229 {
2230 switch (WaitForSingleObject( handle, 0 ))
2231 {
2232 case WAIT_OBJECT_0:
2233 *state = TRUE;
2234 return TRUE;
2235 case WAIT_TIMEOUT:
2236 *state = FALSE;
2237 return TRUE;
2238 }
2239 SetLastError( ERROR_INVALID_PARAMETER );
2240 return FALSE;
2241 }
2242
2243 /***********************************************************************
2244 * InitOnceBeginInitialize (KERNEL32.@)
2245 */
2246 BOOL WINAPI InitOnceBeginInitialize( INIT_ONCE *once, DWORD flags, BOOL *pending, void **context )
2247 {
2248 NTSTATUS status = RtlRunOnceBeginInitialize( once, flags, context );
2249 if (status >= 0) *pending = (status == STATUS_PENDING);
2250 else SetLastError( RtlNtStatusToDosError(status) );
2251 return status >= 0;
2252 }
2253
2254 /***********************************************************************
2255 * InitOnceComplete (KERNEL32.@)
2256 */
2257 BOOL WINAPI InitOnceComplete( INIT_ONCE *once, DWORD flags, void *context )
2258 {
2259 NTSTATUS status = RtlRunOnceComplete( once, flags, context );
2260 if (status != STATUS_SUCCESS) SetLastError( RtlNtStatusToDosError(status) );
2261 return !status;
2262 }
2263
2264 /***********************************************************************
2265 * InitOnceExecuteOnce (KERNEL32.@)
2266 */
2267 BOOL WINAPI InitOnceExecuteOnce( INIT_ONCE *once, PINIT_ONCE_FN func, void *param, void **context )
2268 {
2269 return !RtlRunOnceExecuteOnce( once, (PRTL_RUN_ONCE_INIT_FN)func, param, context );
2270 }
2271
2272 #ifdef __i386__
2273
2274 /***********************************************************************
2275 * InterlockedCompareExchange (KERNEL32.@)
2276 */
2277 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2278 __ASM_STDCALL_FUNC(InterlockedCompareExchange, 12,
2279 "movl 12(%esp),%eax\n\t"
2280 "movl 8(%esp),%ecx\n\t"
2281 "movl 4(%esp),%edx\n\t"
2282 "lock; cmpxchgl %ecx,(%edx)\n\t"
2283 "ret $12")
2284
2285 /***********************************************************************
2286 * InterlockedExchange (KERNEL32.@)
2287 */
2288 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2289 __ASM_STDCALL_FUNC(InterlockedExchange, 8,
2290 "movl 8(%esp),%eax\n\t"
2291 "movl 4(%esp),%edx\n\t"
2292 "lock; xchgl %eax,(%edx)\n\t"
2293 "ret $8")
2294
2295 /***********************************************************************
2296 * InterlockedExchangeAdd (KERNEL32.@)
2297 */
2298 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2299 __ASM_STDCALL_FUNC(InterlockedExchangeAdd, 8,
2300 "movl 8(%esp),%eax\n\t"
2301 "movl 4(%esp),%edx\n\t"
2302 "lock; xaddl %eax,(%edx)\n\t"
2303 "ret $8")
2304
2305 /***********************************************************************
2306 * InterlockedIncrement (KERNEL32.@)
2307 */
2308 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2309 __ASM_STDCALL_FUNC(InterlockedIncrement, 4,
2310 "movl 4(%esp),%edx\n\t"
2311 "movl $1,%eax\n\t"
2312 "lock; xaddl %eax,(%edx)\n\t"
2313 "incl %eax\n\t"
2314 "ret $4")
2315
2316 /***********************************************************************
2317 * InterlockedDecrement (KERNEL32.@)
2318 */
2319 __ASM_STDCALL_FUNC(InterlockedDecrement, 4,
2320 "movl 4(%esp),%edx\n\t"
2321 "movl $-1,%eax\n\t"
2322 "lock; xaddl %eax,(%edx)\n\t"
2323 "decl %eax\n\t"
2324 "ret $4")
2325
2326 #endif /* __i386__ */
2327
2328 /***********************************************************************
2329 * SleepConditionVariableCS (KERNEL32.@)
2330 */
2331 BOOL WINAPI SleepConditionVariableCS( CONDITION_VARIABLE *variable, CRITICAL_SECTION *crit, DWORD timeout )
2332 {
2333 NTSTATUS status;
2334 LARGE_INTEGER time;
2335
2336 status = RtlSleepConditionVariableCS( variable, crit, get_nt_timeout( &time, timeout ) );
2337
2338 if (status != STATUS_SUCCESS)
2339 {
2340 SetLastError( RtlNtStatusToDosError(status) );
2341 return FALSE;
2342 }
2343 return TRUE;
2344 }
2345
2346 /***********************************************************************
2347 * SleepConditionVariableSRW (KERNEL32.@)
2348 */
2349 BOOL WINAPI SleepConditionVariableSRW( RTL_CONDITION_VARIABLE *variable, RTL_SRWLOCK *lock, DWORD timeout, ULONG flags )
2350 {
2351 NTSTATUS status;
2352 LARGE_INTEGER time;
2353
2354 status = RtlSleepConditionVariableSRW( variable, lock, get_nt_timeout( &time, timeout ), flags );
2355
2356 if (status != STATUS_SUCCESS)
2357 {
2358 SetLastError( RtlNtStatusToDosError(status) );
2359 return FALSE;
2360 }
2361 return TRUE;
2362 }
Maarten's multimedia branch