2 * Kernel synchronization objects
4 * Copyright 1998 Alexandre Julliard
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.
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.
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
22 #include "wine/port.h"
32 #define NONAMELESSUNION
33 #define NONAMELESSSTRUCT
36 #define WIN32_NO_STATUS
45 #include "wine/unicode.h"
46 #include "kernel_private.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(sync
);
52 /* check if current version is NT or Win95 */
53 static inline BOOL
is_version_nt(void)
55 return !(GetVersion() & 0x80000000);
58 /* returns directory handle to \\BaseNamedObjects */
59 HANDLE
get_BaseNamedObjects_handle(void)
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};
65 OBJECT_ATTRIBUTES attr
;
71 RtlInitUnicodeString(&str
, basenameW
);
72 InitializeObjectAttributes(&attr
, &str
, 0, 0, NULL
);
73 NtOpenDirectoryObject(&dir
, DIRECTORY_CREATE_OBJECT
|DIRECTORY_TRAVERSE
,
75 if (InterlockedCompareExchangePointer( &handle
, dir
, 0 ) != 0)
77 /* someone beat us here... */
84 /* helper for kernel32->ntdll timeout format conversion */
85 static inline PLARGE_INTEGER
get_nt_timeout( PLARGE_INTEGER pTime
, DWORD timeout
)
87 if (timeout
== INFINITE
) return NULL
;
88 pTime
->QuadPart
= (ULONGLONG
)timeout
* -10000;
92 /***********************************************************************
95 VOID WINAPI DECLSPEC_HOTPATCH
Sleep( DWORD timeout
)
97 SleepEx( timeout
, FALSE
);
100 /******************************************************************************
101 * SleepEx (KERNEL32.@)
103 DWORD WINAPI
SleepEx( DWORD timeout
, BOOL alertable
)
108 status
= NtDelayExecution( alertable
, get_nt_timeout( &time
, timeout
) );
109 if (status
== STATUS_USER_APC
) return WAIT_IO_COMPLETION
;
114 /***********************************************************************
115 * SwitchToThread (KERNEL32.@)
117 BOOL WINAPI
SwitchToThread(void)
119 return (NtYieldExecution() != STATUS_NO_YIELD_PERFORMED
);
123 /***********************************************************************
124 * WaitForSingleObject (KERNEL32.@)
126 DWORD WINAPI
WaitForSingleObject( HANDLE handle
, DWORD timeout
)
128 return WaitForMultipleObjectsEx( 1, &handle
, FALSE
, timeout
, FALSE
);
132 /***********************************************************************
133 * WaitForSingleObjectEx (KERNEL32.@)
135 DWORD WINAPI
WaitForSingleObjectEx( HANDLE handle
, DWORD timeout
,
138 return WaitForMultipleObjectsEx( 1, &handle
, FALSE
, timeout
, alertable
);
142 /***********************************************************************
143 * WaitForMultipleObjects (KERNEL32.@)
145 DWORD WINAPI
WaitForMultipleObjects( DWORD count
, const HANDLE
*handles
,
146 BOOL wait_all
, DWORD timeout
)
148 return WaitForMultipleObjectsEx( count
, handles
, wait_all
, timeout
, FALSE
);
152 /***********************************************************************
153 * WaitForMultipleObjectsEx (KERNEL32.@)
155 DWORD WINAPI
WaitForMultipleObjectsEx( DWORD count
, const HANDLE
*handles
,
156 BOOL wait_all
, DWORD timeout
,
160 HANDLE hloc
[MAXIMUM_WAIT_OBJECTS
];
164 if (count
> MAXIMUM_WAIT_OBJECTS
)
166 SetLastError(ERROR_INVALID_PARAMETER
);
169 for (i
= 0; i
< count
; i
++)
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
]) );
176 hloc
[i
] = handles
[i
];
178 /* yes, even screen buffer console handles are waitable, and are
179 * handled as a handle to the console itself !!
181 if (is_console_handle(hloc
[i
]))
183 if (VerifyConsoleIoHandle(hloc
[i
]))
184 hloc
[i
] = GetConsoleInputWaitHandle();
188 status
= NtWaitForMultipleObjects( count
, hloc
, wait_all
, alertable
,
189 get_nt_timeout( &time
, timeout
) );
191 if (HIWORD(status
)) /* is it an error code? */
193 SetLastError( RtlNtStatusToDosError(status
) );
194 status
= WAIT_FAILED
;
200 /***********************************************************************
201 * RegisterWaitForSingleObject (KERNEL32.@)
203 BOOL WINAPI
RegisterWaitForSingleObject(PHANDLE phNewWaitObject
, HANDLE hObject
,
204 WAITORTIMERCALLBACK Callback
, PVOID Context
,
205 ULONG dwMilliseconds
, ULONG dwFlags
)
209 TRACE("%p %p %p %p %d %d\n",
210 phNewWaitObject
,hObject
,Callback
,Context
,dwMilliseconds
,dwFlags
);
212 status
= RtlRegisterWait( phNewWaitObject
, hObject
, Callback
, Context
, dwMilliseconds
, dwFlags
);
213 if (status
!= STATUS_SUCCESS
)
215 SetLastError( RtlNtStatusToDosError(status
) );
221 /***********************************************************************
222 * RegisterWaitForSingleObjectEx (KERNEL32.@)
224 HANDLE WINAPI
RegisterWaitForSingleObjectEx( HANDLE hObject
,
225 WAITORTIMERCALLBACK Callback
, PVOID Context
,
226 ULONG dwMilliseconds
, ULONG dwFlags
)
229 HANDLE hNewWaitObject
;
231 TRACE("%p %p %p %d %d\n",
232 hObject
,Callback
,Context
,dwMilliseconds
,dwFlags
);
234 status
= RtlRegisterWait( &hNewWaitObject
, hObject
, Callback
, Context
, dwMilliseconds
, dwFlags
);
235 if (status
!= STATUS_SUCCESS
)
237 SetLastError( RtlNtStatusToDosError(status
) );
240 return hNewWaitObject
;
243 /***********************************************************************
244 * UnregisterWait (KERNEL32.@)
246 BOOL WINAPI
UnregisterWait( HANDLE WaitHandle
)
250 TRACE("%p\n",WaitHandle
);
252 status
= RtlDeregisterWait( WaitHandle
);
253 if (status
!= STATUS_SUCCESS
)
255 SetLastError( RtlNtStatusToDosError(status
) );
261 /***********************************************************************
262 * UnregisterWaitEx (KERNEL32.@)
264 BOOL WINAPI
UnregisterWaitEx( HANDLE WaitHandle
, HANDLE CompletionEvent
)
268 TRACE("%p %p\n",WaitHandle
, CompletionEvent
);
270 status
= RtlDeregisterWaitEx( WaitHandle
, CompletionEvent
);
271 if (status
!= STATUS_SUCCESS
) SetLastError( RtlNtStatusToDosError(status
) );
275 /***********************************************************************
276 * SignalObjectAndWait (KERNEL32.@)
278 * Makes it possible to atomically signal any of the synchronization
279 * objects (semaphore, mutex, event) and wait on another.
281 DWORD WINAPI
SignalObjectAndWait( HANDLE hObjectToSignal
, HANDLE hObjectToWaitOn
,
282 DWORD dwMilliseconds
, BOOL bAlertable
)
285 LARGE_INTEGER timeout
;
287 TRACE("%p %p %d %d\n", hObjectToSignal
,
288 hObjectToWaitOn
, dwMilliseconds
, bAlertable
);
290 status
= NtSignalAndWaitForSingleObject( hObjectToSignal
, hObjectToWaitOn
, bAlertable
,
291 get_nt_timeout( &timeout
, dwMilliseconds
) );
294 SetLastError( RtlNtStatusToDosError(status
) );
295 status
= WAIT_FAILED
;
300 /***********************************************************************
301 * InitializeCriticalSection (KERNEL32.@)
303 * Initialise a critical section before use.
306 * crit [O] Critical section to initialise.
309 * Nothing. If the function fails an exception is raised.
311 void WINAPI
InitializeCriticalSection( CRITICAL_SECTION
*crit
)
313 InitializeCriticalSectionEx( crit
, 0, 0 );
316 /***********************************************************************
317 * InitializeCriticalSectionAndSpinCount (KERNEL32.@)
319 * Initialise a critical section with a spin count.
322 * crit [O] Critical section to initialise.
323 * spincount [I] Number of times to spin upon contention.
327 * Failure: Nothing. If the function fails an exception is raised.
330 * spincount is ignored on uni-processor systems.
332 BOOL WINAPI
InitializeCriticalSectionAndSpinCount( CRITICAL_SECTION
*crit
, DWORD spincount
)
334 return InitializeCriticalSectionEx( crit
, spincount
, 0 );
337 /***********************************************************************
338 * InitializeCriticalSectionEx (KERNEL32.@)
340 * Initialise a critical section with a spin count and flags.
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.
349 * Failure: Nothing. If the function fails an exception is raised.
352 * spincount is ignored on uni-processor systems.
354 BOOL WINAPI
InitializeCriticalSectionEx( CRITICAL_SECTION
*crit
, DWORD spincount
, DWORD flags
)
356 NTSTATUS ret
= RtlInitializeCriticalSectionEx( crit
, spincount
, flags
);
357 if (ret
) RtlRaiseStatus( ret
);
361 /***********************************************************************
362 * MakeCriticalSectionGlobal (KERNEL32.@)
364 void WINAPI
MakeCriticalSectionGlobal( CRITICAL_SECTION
*crit
)
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
;
375 /***********************************************************************
376 * ReinitializeCriticalSection (KERNEL32.@)
378 * Initialise an already used critical section.
381 * crit [O] Critical section to initialise.
386 void WINAPI
ReinitializeCriticalSection( CRITICAL_SECTION
*crit
)
388 if ( !crit
->LockSemaphore
)
389 RtlInitializeCriticalSection( crit
);
393 /***********************************************************************
394 * UninitializeCriticalSection (KERNEL32.@)
396 * UnInitialise a critical section after use.
399 * crit [O] Critical section to uninitialise (destroy).
404 void WINAPI
UninitializeCriticalSection( CRITICAL_SECTION
*crit
)
406 RtlDeleteCriticalSection( crit
);
410 /***********************************************************************
411 * CreateEventA (KERNEL32.@)
413 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateEventA( SECURITY_ATTRIBUTES
*sa
, BOOL manual_reset
,
414 BOOL initial_state
, LPCSTR name
)
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
);
424 /***********************************************************************
425 * CreateEventW (KERNEL32.@)
427 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateEventW( SECURITY_ATTRIBUTES
*sa
, BOOL manual_reset
,
428 BOOL initial_state
, LPCWSTR name
)
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
);
438 /***********************************************************************
439 * CreateEventExA (KERNEL32.@)
441 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateEventExA( SECURITY_ATTRIBUTES
*sa
, LPCSTR name
, DWORD flags
, DWORD access
)
443 WCHAR buffer
[MAX_PATH
];
445 if (!name
) return CreateEventExW( sa
, NULL
, flags
, access
);
447 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
449 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
452 return CreateEventExW( sa
, buffer
, flags
, access
);
456 /***********************************************************************
457 * CreateEventExW (KERNEL32.@)
459 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateEventExW( SECURITY_ATTRIBUTES
*sa
, LPCWSTR name
, DWORD flags
, DWORD access
)
462 UNICODE_STRING nameW
;
463 OBJECT_ATTRIBUTES attr
;
466 /* one buggy program needs this
467 * ("Van Dale Groot woordenboek der Nederlandse taal")
469 if (sa
&& IsBadReadPtr(sa
,sizeof(SECURITY_ATTRIBUTES
)))
471 ERR("Bad security attributes pointer %p\n",sa
);
472 SetLastError( ERROR_INVALID_PARAMETER
);
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
;
484 RtlInitUnicodeString( &nameW
, name
);
485 attr
.ObjectName
= &nameW
;
486 attr
.RootDirectory
= get_BaseNamedObjects_handle();
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
);
495 SetLastError( RtlNtStatusToDosError(status
) );
500 /***********************************************************************
501 * OpenEventA (KERNEL32.@)
503 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenEventA( DWORD access
, BOOL inherit
, LPCSTR name
)
505 WCHAR buffer
[MAX_PATH
];
507 if (!name
) return OpenEventW( access
, inherit
, NULL
);
509 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
511 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
514 return OpenEventW( access
, inherit
, buffer
);
518 /***********************************************************************
519 * OpenEventW (KERNEL32.@)
521 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenEventW( DWORD access
, BOOL inherit
, LPCWSTR name
)
524 UNICODE_STRING nameW
;
525 OBJECT_ATTRIBUTES attr
;
528 if (!is_version_nt()) access
= EVENT_ALL_ACCESS
;
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
;
538 RtlInitUnicodeString( &nameW
, name
);
539 attr
.ObjectName
= &nameW
;
540 attr
.RootDirectory
= get_BaseNamedObjects_handle();
543 status
= NtOpenEvent( &ret
, access
, &attr
);
544 if (status
!= STATUS_SUCCESS
)
546 SetLastError( RtlNtStatusToDosError(status
) );
552 /***********************************************************************
553 * PulseEvent (KERNEL32.@)
555 BOOL WINAPI DECLSPEC_HOTPATCH
PulseEvent( HANDLE handle
)
559 if ((status
= NtPulseEvent( handle
, NULL
)))
560 SetLastError( RtlNtStatusToDosError(status
) );
565 /***********************************************************************
566 * SetEvent (KERNEL32.@)
568 BOOL WINAPI DECLSPEC_HOTPATCH
SetEvent( HANDLE handle
)
572 if ((status
= NtSetEvent( handle
, NULL
)))
573 SetLastError( RtlNtStatusToDosError(status
) );
578 /***********************************************************************
579 * ResetEvent (KERNEL32.@)
581 BOOL WINAPI DECLSPEC_HOTPATCH
ResetEvent( HANDLE handle
)
585 if ((status
= NtResetEvent( handle
, NULL
)))
586 SetLastError( RtlNtStatusToDosError(status
) );
591 /***********************************************************************
592 * CreateMutexA (KERNEL32.@)
594 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateMutexA( SECURITY_ATTRIBUTES
*sa
, BOOL owner
, LPCSTR name
)
596 return CreateMutexExA( sa
, name
, owner
? CREATE_MUTEX_INITIAL_OWNER
: 0, MUTEX_ALL_ACCESS
);
600 /***********************************************************************
601 * CreateMutexW (KERNEL32.@)
603 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateMutexW( SECURITY_ATTRIBUTES
*sa
, BOOL owner
, LPCWSTR name
)
605 return CreateMutexExW( sa
, name
, owner
? CREATE_MUTEX_INITIAL_OWNER
: 0, MUTEX_ALL_ACCESS
);
609 /***********************************************************************
610 * CreateMutexExA (KERNEL32.@)
612 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateMutexExA( SECURITY_ATTRIBUTES
*sa
, LPCSTR name
, DWORD flags
, DWORD access
)
617 if (!name
) return CreateMutexExW( sa
, NULL
, flags
, access
);
619 RtlInitAnsiString( &nameA
, name
);
620 status
= RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString
, &nameA
, FALSE
);
621 if (status
!= STATUS_SUCCESS
)
623 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
626 return CreateMutexExW( sa
, NtCurrentTeb()->StaticUnicodeString
.Buffer
, flags
, access
);
630 /***********************************************************************
631 * CreateMutexExW (KERNEL32.@)
633 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateMutexExW( SECURITY_ATTRIBUTES
*sa
, LPCWSTR name
, DWORD flags
, DWORD access
)
636 UNICODE_STRING nameW
;
637 OBJECT_ATTRIBUTES attr
;
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
;
648 RtlInitUnicodeString( &nameW
, name
);
649 attr
.ObjectName
= &nameW
;
650 attr
.RootDirectory
= get_BaseNamedObjects_handle();
653 status
= NtCreateMutant( &ret
, access
, &attr
, (flags
& CREATE_MUTEX_INITIAL_OWNER
) != 0 );
654 if (status
== STATUS_OBJECT_NAME_EXISTS
)
655 SetLastError( ERROR_ALREADY_EXISTS
);
657 SetLastError( RtlNtStatusToDosError(status
) );
662 /***********************************************************************
663 * OpenMutexA (KERNEL32.@)
665 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenMutexA( DWORD access
, BOOL inherit
, LPCSTR name
)
667 WCHAR buffer
[MAX_PATH
];
669 if (!name
) return OpenMutexW( access
, inherit
, NULL
);
671 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
673 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
676 return OpenMutexW( access
, inherit
, buffer
);
680 /***********************************************************************
681 * OpenMutexW (KERNEL32.@)
683 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenMutexW( DWORD access
, BOOL inherit
, LPCWSTR name
)
686 UNICODE_STRING nameW
;
687 OBJECT_ATTRIBUTES attr
;
690 if (!is_version_nt()) access
= MUTEX_ALL_ACCESS
;
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
;
700 RtlInitUnicodeString( &nameW
, name
);
701 attr
.ObjectName
= &nameW
;
702 attr
.RootDirectory
= get_BaseNamedObjects_handle();
705 status
= NtOpenMutant( &ret
, access
, &attr
);
706 if (status
!= STATUS_SUCCESS
)
708 SetLastError( RtlNtStatusToDosError(status
) );
715 /***********************************************************************
716 * ReleaseMutex (KERNEL32.@)
718 BOOL WINAPI DECLSPEC_HOTPATCH
ReleaseMutex( HANDLE handle
)
722 status
= NtReleaseMutant(handle
, NULL
);
723 if (status
!= STATUS_SUCCESS
)
725 SetLastError( RtlNtStatusToDosError(status
) );
737 /***********************************************************************
738 * CreateSemaphoreA (KERNEL32.@)
740 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateSemaphoreA( SECURITY_ATTRIBUTES
*sa
, LONG initial
, LONG max
, LPCSTR name
)
742 return CreateSemaphoreExA( sa
, initial
, max
, name
, 0, SEMAPHORE_ALL_ACCESS
);
746 /***********************************************************************
747 * CreateSemaphoreW (KERNEL32.@)
749 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateSemaphoreW( SECURITY_ATTRIBUTES
*sa
, LONG initial
, LONG max
, LPCWSTR name
)
751 return CreateSemaphoreExW( sa
, initial
, max
, name
, 0, SEMAPHORE_ALL_ACCESS
);
755 /***********************************************************************
756 * CreateSemaphoreExA (KERNEL32.@)
758 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateSemaphoreExA( SECURITY_ATTRIBUTES
*sa
, LONG initial
, LONG max
,
759 LPCSTR name
, DWORD flags
, DWORD access
)
761 WCHAR buffer
[MAX_PATH
];
763 if (!name
) return CreateSemaphoreExW( sa
, initial
, max
, NULL
, flags
, access
);
765 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
767 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
770 return CreateSemaphoreExW( sa
, initial
, max
, buffer
, flags
, access
);
774 /***********************************************************************
775 * CreateSemaphoreExW (KERNEL32.@)
777 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateSemaphoreExW( SECURITY_ATTRIBUTES
*sa
, LONG initial
, LONG max
,
778 LPCWSTR name
, DWORD flags
, DWORD access
)
781 UNICODE_STRING nameW
;
782 OBJECT_ATTRIBUTES attr
;
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
;
793 RtlInitUnicodeString( &nameW
, name
);
794 attr
.ObjectName
= &nameW
;
795 attr
.RootDirectory
= get_BaseNamedObjects_handle();
798 status
= NtCreateSemaphore( &ret
, access
, &attr
, initial
, max
);
799 if (status
== STATUS_OBJECT_NAME_EXISTS
)
800 SetLastError( ERROR_ALREADY_EXISTS
);
802 SetLastError( RtlNtStatusToDosError(status
) );
807 /***********************************************************************
808 * OpenSemaphoreA (KERNEL32.@)
810 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenSemaphoreA( DWORD access
, BOOL inherit
, LPCSTR name
)
812 WCHAR buffer
[MAX_PATH
];
814 if (!name
) return OpenSemaphoreW( access
, inherit
, NULL
);
816 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
818 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
821 return OpenSemaphoreW( access
, inherit
, buffer
);
825 /***********************************************************************
826 * OpenSemaphoreW (KERNEL32.@)
828 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenSemaphoreW( DWORD access
, BOOL inherit
, LPCWSTR name
)
831 UNICODE_STRING nameW
;
832 OBJECT_ATTRIBUTES attr
;
835 if (!is_version_nt()) access
= SEMAPHORE_ALL_ACCESS
;
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
;
845 RtlInitUnicodeString( &nameW
, name
);
846 attr
.ObjectName
= &nameW
;
847 attr
.RootDirectory
= get_BaseNamedObjects_handle();
850 status
= NtOpenSemaphore( &ret
, access
, &attr
);
851 if (status
!= STATUS_SUCCESS
)
853 SetLastError( RtlNtStatusToDosError(status
) );
860 /***********************************************************************
861 * ReleaseSemaphore (KERNEL32.@)
863 BOOL WINAPI DECLSPEC_HOTPATCH
ReleaseSemaphore( HANDLE handle
, LONG count
, LONG
*previous
)
865 NTSTATUS status
= NtReleaseSemaphore( handle
, count
, (PULONG
)previous
);
866 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
875 /******************************************************************************
876 * CreateJobObjectW (KERNEL32.@)
878 HANDLE WINAPI
CreateJobObjectW( LPSECURITY_ATTRIBUTES sa
, LPCWSTR name
)
881 UNICODE_STRING nameW
;
882 OBJECT_ATTRIBUTES attr
;
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
;
893 RtlInitUnicodeString( &nameW
, name
);
894 attr
.ObjectName
= &nameW
;
895 attr
.RootDirectory
= get_BaseNamedObjects_handle();
898 status
= NtCreateJobObject( &ret
, JOB_OBJECT_ALL_ACCESS
, &attr
);
899 if (status
== STATUS_OBJECT_NAME_EXISTS
)
900 SetLastError( ERROR_ALREADY_EXISTS
);
902 SetLastError( RtlNtStatusToDosError(status
) );
906 /******************************************************************************
907 * CreateJobObjectA (KERNEL32.@)
909 HANDLE WINAPI
CreateJobObjectA( LPSECURITY_ATTRIBUTES attr
, LPCSTR name
)
911 WCHAR buffer
[MAX_PATH
];
913 if (!name
) return CreateJobObjectW( attr
, NULL
);
915 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
917 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
920 return CreateJobObjectW( attr
, buffer
);
923 /******************************************************************************
924 * OpenJobObjectW (KERNEL32.@)
926 HANDLE WINAPI
OpenJobObjectW( DWORD access
, BOOL inherit
, LPCWSTR name
)
929 UNICODE_STRING nameW
;
930 OBJECT_ATTRIBUTES attr
;
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
;
941 RtlInitUnicodeString( &nameW
, name
);
942 attr
.ObjectName
= &nameW
;
943 attr
.RootDirectory
= get_BaseNamedObjects_handle();
946 status
= NtOpenJobObject( &ret
, access
, &attr
);
947 if (status
!= STATUS_SUCCESS
)
949 SetLastError( RtlNtStatusToDosError(status
) );
955 /******************************************************************************
956 * OpenJobObjectA (KERNEL32.@)
958 HANDLE WINAPI
OpenJobObjectA( DWORD access
, BOOL inherit
, LPCSTR name
)
960 WCHAR buffer
[MAX_PATH
];
962 if (!name
) return OpenJobObjectW( access
, inherit
, NULL
);
964 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
966 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
969 return OpenJobObjectW( access
, inherit
, buffer
);
972 /******************************************************************************
973 * TerminateJobObject (KERNEL32.@)
975 BOOL WINAPI
TerminateJobObject( HANDLE job
, UINT exit_code
)
977 NTSTATUS status
= NtTerminateJobObject( job
, exit_code
);
978 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
982 /******************************************************************************
983 * QueryInformationJobObject (KERNEL32.@)
985 BOOL WINAPI
QueryInformationJobObject( HANDLE job
, JOBOBJECTINFOCLASS
class, LPVOID info
,
986 DWORD len
, DWORD
*ret_len
)
988 NTSTATUS status
= NtQueryInformationJobObject( job
, class, info
, len
, ret_len
);
989 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
993 /******************************************************************************
994 * SetInformationJobObject (KERNEL32.@)
996 BOOL WINAPI
SetInformationJobObject( HANDLE job
, JOBOBJECTINFOCLASS
class, LPVOID info
, DWORD len
)
998 NTSTATUS status
= NtSetInformationJobObject( job
, class, info
, len
);
999 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
1003 /******************************************************************************
1004 * AssignProcessToJobObject (KERNEL32.@)
1006 BOOL WINAPI
AssignProcessToJobObject( HANDLE job
, HANDLE process
)
1008 NTSTATUS status
= NtAssignProcessToJobObject( job
, process
);
1009 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
1013 /******************************************************************************
1014 * IsProcessInJob (KERNEL32.@)
1016 BOOL WINAPI
IsProcessInJob( HANDLE process
, HANDLE job
, PBOOL result
)
1018 NTSTATUS status
= NtIsProcessInJob( process
, job
);
1021 case STATUS_PROCESS_IN_JOB
:
1024 case STATUS_PROCESS_NOT_IN_JOB
:
1028 SetLastError( RtlNtStatusToDosError(status
) );
1039 /***********************************************************************
1040 * CreateWaitableTimerA (KERNEL32.@)
1042 HANDLE WINAPI
CreateWaitableTimerA( SECURITY_ATTRIBUTES
*sa
, BOOL manual
, LPCSTR name
)
1044 return CreateWaitableTimerExA( sa
, name
, manual
? CREATE_WAITABLE_TIMER_MANUAL_RESET
: 0,
1049 /***********************************************************************
1050 * CreateWaitableTimerW (KERNEL32.@)
1052 HANDLE WINAPI
CreateWaitableTimerW( SECURITY_ATTRIBUTES
*sa
, BOOL manual
, LPCWSTR name
)
1054 return CreateWaitableTimerExW( sa
, name
, manual
? CREATE_WAITABLE_TIMER_MANUAL_RESET
: 0,
1059 /***********************************************************************
1060 * CreateWaitableTimerExA (KERNEL32.@)
1062 HANDLE WINAPI
CreateWaitableTimerExA( SECURITY_ATTRIBUTES
*sa
, LPCSTR name
, DWORD flags
, DWORD access
)
1064 WCHAR buffer
[MAX_PATH
];
1066 if (!name
) return CreateWaitableTimerExW( sa
, NULL
, flags
, access
);
1068 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
1070 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1073 return CreateWaitableTimerExW( sa
, buffer
, flags
, access
);
1077 /***********************************************************************
1078 * CreateWaitableTimerExW (KERNEL32.@)
1080 HANDLE WINAPI
CreateWaitableTimerExW( SECURITY_ATTRIBUTES
*sa
, LPCWSTR name
, DWORD flags
, DWORD access
)
1084 UNICODE_STRING nameW
;
1085 OBJECT_ATTRIBUTES attr
;
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
;
1095 RtlInitUnicodeString( &nameW
, name
);
1096 attr
.ObjectName
= &nameW
;
1097 attr
.RootDirectory
= get_BaseNamedObjects_handle();
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
);
1105 SetLastError( RtlNtStatusToDosError(status
) );
1110 /***********************************************************************
1111 * OpenWaitableTimerA (KERNEL32.@)
1113 HANDLE WINAPI
OpenWaitableTimerA( DWORD access
, BOOL inherit
, LPCSTR name
)
1115 WCHAR buffer
[MAX_PATH
];
1117 if (!name
) return OpenWaitableTimerW( access
, inherit
, NULL
);
1119 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
1121 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1124 return OpenWaitableTimerW( access
, inherit
, buffer
);
1128 /***********************************************************************
1129 * OpenWaitableTimerW (KERNEL32.@)
1131 HANDLE WINAPI
OpenWaitableTimerW( DWORD access
, BOOL inherit
, LPCWSTR name
)
1134 UNICODE_STRING nameW
;
1135 OBJECT_ATTRIBUTES attr
;
1138 if (!is_version_nt()) access
= TIMER_ALL_ACCESS
;
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
;
1148 RtlInitUnicodeString( &nameW
, name
);
1149 attr
.ObjectName
= &nameW
;
1150 attr
.RootDirectory
= get_BaseNamedObjects_handle();
1153 status
= NtOpenTimer(&handle
, access
, &attr
);
1154 if (status
!= STATUS_SUCCESS
)
1156 SetLastError( RtlNtStatusToDosError(status
) );
1163 /***********************************************************************
1164 * SetWaitableTimer (KERNEL32.@)
1166 BOOL WINAPI
SetWaitableTimer( HANDLE handle
, const LARGE_INTEGER
*when
, LONG period
,
1167 PTIMERAPCROUTINE callback
, LPVOID arg
, BOOL resume
)
1169 NTSTATUS status
= NtSetTimer(handle
, when
, (PTIMER_APC_ROUTINE
)callback
,
1170 arg
, resume
, period
, NULL
);
1172 if (status
!= STATUS_SUCCESS
)
1174 SetLastError( RtlNtStatusToDosError(status
) );
1175 if (status
!= STATUS_TIMER_RESUME_IGNORED
) return FALSE
;
1180 /***********************************************************************
1181 * SetWaitableTimerEx (KERNEL32.@)
1183 BOOL WINAPI
SetWaitableTimerEx( HANDLE handle
, const LARGE_INTEGER
*when
, LONG period
,
1184 PTIMERAPCROUTINE callback
, LPVOID arg
, REASON_CONTEXT
*context
, ULONG tolerabledelay
)
1186 FIXME("(%p, %p, %d, %p, %p, %p, %d) semi-stub\n",
1187 handle
, when
, period
, callback
, arg
, context
, tolerabledelay
);
1188 return SetWaitableTimer(handle
, when
, period
, callback
, arg
, FALSE
);
1191 /***********************************************************************
1192 * CancelWaitableTimer (KERNEL32.@)
1194 BOOL WINAPI
CancelWaitableTimer( HANDLE handle
)
1198 status
= NtCancelTimer(handle
, NULL
);
1199 if (status
!= STATUS_SUCCESS
)
1201 SetLastError( RtlNtStatusToDosError(status
) );
1208 /***********************************************************************
1209 * CreateTimerQueue (KERNEL32.@)
1211 HANDLE WINAPI
CreateTimerQueue(void)
1214 NTSTATUS status
= RtlCreateTimerQueue(&q
);
1216 if (status
!= STATUS_SUCCESS
)
1218 SetLastError( RtlNtStatusToDosError(status
) );
1226 /***********************************************************************
1227 * DeleteTimerQueueEx (KERNEL32.@)
1229 BOOL WINAPI
DeleteTimerQueueEx(HANDLE TimerQueue
, HANDLE CompletionEvent
)
1231 NTSTATUS status
= RtlDeleteTimerQueueEx(TimerQueue
, CompletionEvent
);
1233 if (status
!= STATUS_SUCCESS
)
1235 SetLastError( RtlNtStatusToDosError(status
) );
1242 /***********************************************************************
1243 * DeleteTimerQueue (KERNEL32.@)
1245 BOOL WINAPI
DeleteTimerQueue(HANDLE TimerQueue
)
1247 return DeleteTimerQueueEx(TimerQueue
, NULL
);
1250 /***********************************************************************
1251 * CreateTimerQueueTimer (KERNEL32.@)
1253 * Creates a timer-queue timer. This timer expires at the specified due
1254 * time (in ms), then after every specified period (in ms). When the timer
1255 * expires, the callback function is called.
1258 * nonzero on success or zero on failure
1260 BOOL WINAPI
CreateTimerQueueTimer( PHANDLE phNewTimer
, HANDLE TimerQueue
,
1261 WAITORTIMERCALLBACK Callback
, PVOID Parameter
,
1262 DWORD DueTime
, DWORD Period
, ULONG Flags
)
1264 NTSTATUS status
= RtlCreateTimer(phNewTimer
, TimerQueue
, Callback
,
1265 Parameter
, DueTime
, Period
, Flags
);
1267 if (status
!= STATUS_SUCCESS
)
1269 SetLastError( RtlNtStatusToDosError(status
) );
1276 /***********************************************************************
1277 * ChangeTimerQueueTimer (KERNEL32.@)
1279 * Changes the times at which the timer expires.
1282 * nonzero on success or zero on failure
1284 BOOL WINAPI
ChangeTimerQueueTimer( HANDLE TimerQueue
, HANDLE Timer
,
1285 ULONG DueTime
, ULONG Period
)
1287 NTSTATUS status
= RtlUpdateTimer(TimerQueue
, Timer
, DueTime
, Period
);
1289 if (status
!= STATUS_SUCCESS
)
1291 SetLastError( RtlNtStatusToDosError(status
) );
1298 /***********************************************************************
1299 * DeleteTimerQueueTimer (KERNEL32.@)
1301 * Cancels a timer-queue timer.
1304 * nonzero on success or zero on failure
1306 BOOL WINAPI
DeleteTimerQueueTimer( HANDLE TimerQueue
, HANDLE Timer
,
1307 HANDLE CompletionEvent
)
1309 NTSTATUS status
= RtlDeleteTimer(TimerQueue
, Timer
, CompletionEvent
);
1310 if (status
!= STATUS_SUCCESS
)
1312 SetLastError( RtlNtStatusToDosError(status
) );
1324 /***********************************************************************
1325 * CreateNamedPipeA (KERNEL32.@)
1327 HANDLE WINAPI
CreateNamedPipeA( LPCSTR name
, DWORD dwOpenMode
,
1328 DWORD dwPipeMode
, DWORD nMaxInstances
,
1329 DWORD nOutBufferSize
, DWORD nInBufferSize
,
1330 DWORD nDefaultTimeOut
, LPSECURITY_ATTRIBUTES attr
)
1332 WCHAR buffer
[MAX_PATH
];
1334 if (!name
) return CreateNamedPipeW( NULL
, dwOpenMode
, dwPipeMode
, nMaxInstances
,
1335 nOutBufferSize
, nInBufferSize
, nDefaultTimeOut
, attr
);
1337 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
1339 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1340 return INVALID_HANDLE_VALUE
;
1342 return CreateNamedPipeW( buffer
, dwOpenMode
, dwPipeMode
, nMaxInstances
,
1343 nOutBufferSize
, nInBufferSize
, nDefaultTimeOut
, attr
);
1347 /***********************************************************************
1348 * CreateNamedPipeW (KERNEL32.@)
1350 HANDLE WINAPI
CreateNamedPipeW( LPCWSTR name
, DWORD dwOpenMode
,
1351 DWORD dwPipeMode
, DWORD nMaxInstances
,
1352 DWORD nOutBufferSize
, DWORD nInBufferSize
,
1353 DWORD nDefaultTimeOut
, LPSECURITY_ATTRIBUTES sa
)
1356 UNICODE_STRING nt_name
;
1357 OBJECT_ATTRIBUTES attr
;
1358 DWORD access
, options
, sharing
;
1359 BOOLEAN pipe_type
, read_mode
, non_block
;
1361 IO_STATUS_BLOCK iosb
;
1362 LARGE_INTEGER timeout
;
1364 TRACE("(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n",
1365 debugstr_w(name
), dwOpenMode
, dwPipeMode
, nMaxInstances
,
1366 nOutBufferSize
, nInBufferSize
, nDefaultTimeOut
, sa
);
1368 if (!RtlDosPathNameToNtPathName_U( name
, &nt_name
, NULL
, NULL
))
1370 SetLastError( ERROR_PATH_NOT_FOUND
);
1371 return INVALID_HANDLE_VALUE
;
1373 if (nt_name
.Length
>= MAX_PATH
* sizeof(WCHAR
) )
1375 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1376 RtlFreeUnicodeString( &nt_name
);
1377 return INVALID_HANDLE_VALUE
;
1380 attr
.Length
= sizeof(attr
);
1381 attr
.RootDirectory
= 0;
1382 attr
.ObjectName
= &nt_name
;
1383 attr
.Attributes
= OBJ_CASE_INSENSITIVE
|
1384 ((sa
&& sa
->bInheritHandle
) ? OBJ_INHERIT
: 0);
1385 attr
.SecurityDescriptor
= sa
? sa
->lpSecurityDescriptor
: NULL
;
1386 attr
.SecurityQualityOfService
= NULL
;
1388 switch(dwOpenMode
& 3)
1390 case PIPE_ACCESS_INBOUND
:
1391 sharing
= FILE_SHARE_WRITE
;
1392 access
= GENERIC_READ
;
1394 case PIPE_ACCESS_OUTBOUND
:
1395 sharing
= FILE_SHARE_READ
;
1396 access
= GENERIC_WRITE
;
1398 case PIPE_ACCESS_DUPLEX
:
1399 sharing
= FILE_SHARE_READ
| FILE_SHARE_WRITE
;
1400 access
= GENERIC_READ
| GENERIC_WRITE
;
1403 SetLastError( ERROR_INVALID_PARAMETER
);
1404 return INVALID_HANDLE_VALUE
;
1406 access
|= SYNCHRONIZE
;
1408 if (dwOpenMode
& WRITE_DAC
) access
|= WRITE_DAC
;
1409 if (dwOpenMode
& WRITE_OWNER
) access
|= WRITE_OWNER
;
1410 if (dwOpenMode
& ACCESS_SYSTEM_SECURITY
) access
|= ACCESS_SYSTEM_SECURITY
;
1411 if (dwOpenMode
& FILE_FLAG_WRITE_THROUGH
) options
|= FILE_WRITE_THROUGH
;
1412 if (!(dwOpenMode
& FILE_FLAG_OVERLAPPED
)) options
|= FILE_SYNCHRONOUS_IO_NONALERT
;
1413 pipe_type
= (dwPipeMode
& PIPE_TYPE_MESSAGE
) != 0;
1414 read_mode
= (dwPipeMode
& PIPE_READMODE_MESSAGE
) != 0;
1415 non_block
= (dwPipeMode
& PIPE_NOWAIT
) != 0;
1416 if (nMaxInstances
>= PIPE_UNLIMITED_INSTANCES
) nMaxInstances
= ~0U;
1418 timeout
.QuadPart
= (ULONGLONG
)nDefaultTimeOut
* -10000;
1422 status
= NtCreateNamedPipeFile(&handle
, access
, &attr
, &iosb
, sharing
,
1423 FILE_OVERWRITE_IF
, options
, pipe_type
,
1424 read_mode
, non_block
, nMaxInstances
,
1425 nInBufferSize
, nOutBufferSize
, &timeout
);
1427 RtlFreeUnicodeString( &nt_name
);
1430 handle
= INVALID_HANDLE_VALUE
;
1431 SetLastError( RtlNtStatusToDosError(status
) );
1437 /***********************************************************************
1438 * PeekNamedPipe (KERNEL32.@)
1440 BOOL WINAPI
PeekNamedPipe( HANDLE hPipe
, LPVOID lpvBuffer
, DWORD cbBuffer
,
1441 LPDWORD lpcbRead
, LPDWORD lpcbAvail
, LPDWORD lpcbMessage
)
1443 FILE_PIPE_PEEK_BUFFER local_buffer
;
1444 FILE_PIPE_PEEK_BUFFER
*buffer
= &local_buffer
;
1448 if (cbBuffer
&& !(buffer
= HeapAlloc( GetProcessHeap(), 0,
1449 FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
[cbBuffer
] ))))
1451 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
1455 status
= NtFsControlFile( hPipe
, 0, NULL
, NULL
, &io
, FSCTL_PIPE_PEEK
, NULL
, 0,
1456 buffer
, FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
[cbBuffer
] ) );
1459 ULONG read_size
= io
.Information
- FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
);
1460 if (lpcbAvail
) *lpcbAvail
= buffer
->ReadDataAvailable
;
1461 if (lpcbRead
) *lpcbRead
= read_size
;
1462 if (lpcbMessage
) *lpcbMessage
= 0; /* FIXME */
1463 if (lpvBuffer
) memcpy( lpvBuffer
, buffer
->Data
, read_size
);
1465 else SetLastError( RtlNtStatusToDosError(status
) );
1467 if (buffer
!= &local_buffer
) HeapFree( GetProcessHeap(), 0, buffer
);
1471 /***********************************************************************
1472 * WaitNamedPipeA (KERNEL32.@)
1474 BOOL WINAPI
WaitNamedPipeA (LPCSTR name
, DWORD nTimeOut
)
1476 WCHAR buffer
[MAX_PATH
];
1478 if (!name
) return WaitNamedPipeW( NULL
, nTimeOut
);
1480 if (!MultiByteToWideChar( CP_ACP
, 0, name
, -1, buffer
, MAX_PATH
))
1482 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1485 return WaitNamedPipeW( buffer
, nTimeOut
);
1489 /***********************************************************************
1490 * WaitNamedPipeW (KERNEL32.@)
1492 * Waits for a named pipe instance to become available
1495 * name [I] Pointer to a named pipe name to wait for
1496 * nTimeOut [I] How long to wait in ms
1499 * TRUE: Success, named pipe can be opened with CreateFile
1500 * FALSE: Failure, GetLastError can be called for further details
1502 BOOL WINAPI
WaitNamedPipeW (LPCWSTR name
, DWORD nTimeOut
)
1504 static const WCHAR leadin
[] = {'\\','?','?','\\','P','I','P','E','\\'};
1506 UNICODE_STRING nt_name
, pipe_dev_name
;
1507 FILE_PIPE_WAIT_FOR_BUFFER
*pipe_wait
;
1508 IO_STATUS_BLOCK iosb
;
1509 OBJECT_ATTRIBUTES attr
;
1513 TRACE("%s 0x%08x\n",debugstr_w(name
),nTimeOut
);
1515 if (!RtlDosPathNameToNtPathName_U( name
, &nt_name
, NULL
, NULL
))
1518 if (nt_name
.Length
>= MAX_PATH
* sizeof(WCHAR
) ||
1519 nt_name
.Length
< sizeof(leadin
) ||
1520 strncmpiW( nt_name
.Buffer
, leadin
, sizeof(leadin
)/sizeof(WCHAR
)) != 0)
1522 RtlFreeUnicodeString( &nt_name
);
1523 SetLastError( ERROR_PATH_NOT_FOUND
);
1527 sz_pipe_wait
= sizeof(*pipe_wait
) + nt_name
.Length
- sizeof(leadin
) - sizeof(WCHAR
);
1528 if (!(pipe_wait
= HeapAlloc( GetProcessHeap(), 0, sz_pipe_wait
)))
1530 RtlFreeUnicodeString( &nt_name
);
1531 SetLastError( ERROR_OUTOFMEMORY
);
1535 pipe_dev_name
.Buffer
= nt_name
.Buffer
;
1536 pipe_dev_name
.Length
= sizeof(leadin
);
1537 pipe_dev_name
.MaximumLength
= sizeof(leadin
);
1538 InitializeObjectAttributes(&attr
,&pipe_dev_name
, OBJ_CASE_INSENSITIVE
, NULL
, NULL
);
1539 status
= NtOpenFile( &pipe_dev
, FILE_READ_ATTRIBUTES
, &attr
,
1540 &iosb
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1541 FILE_SYNCHRONOUS_IO_NONALERT
);
1542 if (status
!= ERROR_SUCCESS
)
1544 HeapFree( GetProcessHeap(), 0, pipe_wait
);
1545 RtlFreeUnicodeString( &nt_name
);
1546 SetLastError( ERROR_PATH_NOT_FOUND
);
1550 pipe_wait
->TimeoutSpecified
= !(nTimeOut
== NMPWAIT_USE_DEFAULT_WAIT
);
1551 if (nTimeOut
== NMPWAIT_WAIT_FOREVER
)
1552 pipe_wait
->Timeout
.QuadPart
= ((ULONGLONG
)0x7fffffff << 32) | 0xffffffff;
1554 pipe_wait
->Timeout
.QuadPart
= (ULONGLONG
)nTimeOut
* -10000;
1555 pipe_wait
->NameLength
= nt_name
.Length
- sizeof(leadin
);
1556 memcpy(pipe_wait
->Name
, nt_name
.Buffer
+ sizeof(leadin
)/sizeof(WCHAR
),
1557 pipe_wait
->NameLength
);
1558 RtlFreeUnicodeString( &nt_name
);
1560 status
= NtFsControlFile( pipe_dev
, NULL
, NULL
, NULL
, &iosb
, FSCTL_PIPE_WAIT
,
1561 pipe_wait
, sz_pipe_wait
, NULL
, 0 );
1563 HeapFree( GetProcessHeap(), 0, pipe_wait
);
1564 NtClose( pipe_dev
);
1566 if(status
!= STATUS_SUCCESS
)
1568 SetLastError(RtlNtStatusToDosError(status
));
1576 /***********************************************************************
1577 * ConnectNamedPipe (KERNEL32.@)
1579 * Connects to a named pipe
1582 * hPipe: A handle to a named pipe returned by CreateNamedPipe
1583 * overlapped: Optional OVERLAPPED struct
1587 * FALSE: Failure, GetLastError can be called for further details
1589 BOOL WINAPI
ConnectNamedPipe(HANDLE hPipe
, LPOVERLAPPED overlapped
)
1592 IO_STATUS_BLOCK status_block
;
1593 LPVOID cvalue
= NULL
;
1595 TRACE("(%p,%p)\n", hPipe
, overlapped
);
1599 overlapped
->Internal
= STATUS_PENDING
;
1600 overlapped
->InternalHigh
= 0;
1601 if (((ULONG_PTR
)overlapped
->hEvent
& 1) == 0) cvalue
= overlapped
;
1604 status
= NtFsControlFile(hPipe
, overlapped
? overlapped
->hEvent
: NULL
, NULL
, cvalue
,
1605 overlapped
? (IO_STATUS_BLOCK
*)overlapped
: &status_block
,
1606 FSCTL_PIPE_LISTEN
, NULL
, 0, NULL
, 0);
1608 if (status
== STATUS_SUCCESS
) return TRUE
;
1609 SetLastError( RtlNtStatusToDosError(status
) );
1613 /***********************************************************************
1614 * DisconnectNamedPipe (KERNEL32.@)
1616 * Disconnects from a named pipe
1619 * hPipe: A handle to a named pipe returned by CreateNamedPipe
1623 * FALSE: Failure, GetLastError can be called for further details
1625 BOOL WINAPI
DisconnectNamedPipe(HANDLE hPipe
)
1628 IO_STATUS_BLOCK io_block
;
1630 TRACE("(%p)\n",hPipe
);
1632 status
= NtFsControlFile(hPipe
, 0, NULL
, NULL
, &io_block
, FSCTL_PIPE_DISCONNECT
,
1634 if (status
== STATUS_SUCCESS
) return TRUE
;
1635 SetLastError( RtlNtStatusToDosError(status
) );
1639 /***********************************************************************
1640 * TransactNamedPipe (KERNEL32.@)
1643 * should be done as a single operation in the wineserver or kernel
1645 BOOL WINAPI
TransactNamedPipe(
1646 HANDLE handle
, LPVOID write_buf
, DWORD write_size
, LPVOID read_buf
,
1647 DWORD read_size
, LPDWORD bytes_read
, LPOVERLAPPED overlapped
)
1652 TRACE("%p %p %d %p %d %p %p\n",
1653 handle
, write_buf
, write_size
, read_buf
,
1654 read_size
, bytes_read
, overlapped
);
1658 FIXME("Doesn't support overlapped operation as yet\n");
1662 r
= WriteFile(handle
, write_buf
, write_size
, &count
, NULL
);
1664 r
= ReadFile(handle
, read_buf
, read_size
, bytes_read
, NULL
);
1669 /***********************************************************************
1670 * GetNamedPipeInfo (KERNEL32.@)
1672 BOOL WINAPI
GetNamedPipeInfo(
1673 HANDLE hNamedPipe
, LPDWORD lpFlags
, LPDWORD lpOutputBufferSize
,
1674 LPDWORD lpInputBufferSize
, LPDWORD lpMaxInstances
)
1676 FILE_PIPE_LOCAL_INFORMATION fpli
;
1677 IO_STATUS_BLOCK iosb
;
1680 status
= NtQueryInformationFile(hNamedPipe
, &iosb
, &fpli
, sizeof(fpli
),
1681 FilePipeLocalInformation
);
1684 SetLastError( RtlNtStatusToDosError(status
) );
1690 *lpFlags
= (fpli
.NamedPipeEnd
& FILE_PIPE_SERVER_END
) ?
1691 PIPE_SERVER_END
: PIPE_CLIENT_END
;
1692 *lpFlags
|= (fpli
.NamedPipeType
& FILE_PIPE_TYPE_MESSAGE
) ?
1693 PIPE_TYPE_MESSAGE
: PIPE_TYPE_BYTE
;
1696 if (lpOutputBufferSize
) *lpOutputBufferSize
= fpli
.OutboundQuota
;
1697 if (lpInputBufferSize
) *lpInputBufferSize
= fpli
.InboundQuota
;
1698 if (lpMaxInstances
) *lpMaxInstances
= fpli
.MaximumInstances
;
1703 /***********************************************************************
1704 * GetNamedPipeHandleStateA (KERNEL32.@)
1706 BOOL WINAPI
GetNamedPipeHandleStateA(
1707 HANDLE hNamedPipe
, LPDWORD lpState
, LPDWORD lpCurInstances
,
1708 LPDWORD lpMaxCollectionCount
, LPDWORD lpCollectDataTimeout
,
1709 LPSTR lpUsername
, DWORD nUsernameMaxSize
)
1711 FIXME("%p %p %p %p %p %p %d\n",
1712 hNamedPipe
, lpState
, lpCurInstances
,
1713 lpMaxCollectionCount
, lpCollectDataTimeout
,
1714 lpUsername
, nUsernameMaxSize
);
1719 /***********************************************************************
1720 * GetNamedPipeHandleStateW (KERNEL32.@)
1722 BOOL WINAPI
GetNamedPipeHandleStateW(
1723 HANDLE hNamedPipe
, LPDWORD lpState
, LPDWORD lpCurInstances
,
1724 LPDWORD lpMaxCollectionCount
, LPDWORD lpCollectDataTimeout
,
1725 LPWSTR lpUsername
, DWORD nUsernameMaxSize
)
1727 FIXME("%p %p %p %p %p %p %d\n",
1728 hNamedPipe
, lpState
, lpCurInstances
,
1729 lpMaxCollectionCount
, lpCollectDataTimeout
,
1730 lpUsername
, nUsernameMaxSize
);
1735 /***********************************************************************
1736 * SetNamedPipeHandleState (KERNEL32.@)
1738 BOOL WINAPI
SetNamedPipeHandleState(
1739 HANDLE hNamedPipe
, LPDWORD lpMode
, LPDWORD lpMaxCollectionCount
,
1740 LPDWORD lpCollectDataTimeout
)
1742 /* should be a fixme, but this function is called a lot by the RPC
1743 * runtime, and it slows down InstallShield a fair bit. */
1744 WARN("stub: %p %p/%d %p %p\n",
1745 hNamedPipe
, lpMode
, lpMode
? *lpMode
: 0, lpMaxCollectionCount
, lpCollectDataTimeout
);
1749 /***********************************************************************
1750 * CallNamedPipeA (KERNEL32.@)
1752 BOOL WINAPI
CallNamedPipeA(
1753 LPCSTR lpNamedPipeName
, LPVOID lpInput
, DWORD dwInputSize
,
1754 LPVOID lpOutput
, DWORD dwOutputSize
,
1755 LPDWORD lpBytesRead
, DWORD nTimeout
)
1761 TRACE("%s %p %d %p %d %p %d\n",
1762 debugstr_a(lpNamedPipeName
), lpInput
, dwInputSize
,
1763 lpOutput
, dwOutputSize
, lpBytesRead
, nTimeout
);
1765 if( lpNamedPipeName
)
1767 len
= MultiByteToWideChar( CP_ACP
, 0, lpNamedPipeName
, -1, NULL
, 0 );
1768 str
= HeapAlloc( GetProcessHeap(), 0, len
*sizeof(WCHAR
) );
1769 MultiByteToWideChar( CP_ACP
, 0, lpNamedPipeName
, -1, str
, len
);
1771 ret
= CallNamedPipeW( str
, lpInput
, dwInputSize
, lpOutput
,
1772 dwOutputSize
, lpBytesRead
, nTimeout
);
1773 if( lpNamedPipeName
)
1774 HeapFree( GetProcessHeap(), 0, str
);
1779 /***********************************************************************
1780 * CallNamedPipeW (KERNEL32.@)
1782 BOOL WINAPI
CallNamedPipeW(
1783 LPCWSTR lpNamedPipeName
, LPVOID lpInput
, DWORD lpInputSize
,
1784 LPVOID lpOutput
, DWORD lpOutputSize
,
1785 LPDWORD lpBytesRead
, DWORD nTimeout
)
1791 TRACE("%s %p %d %p %d %p %d\n",
1792 debugstr_w(lpNamedPipeName
), lpInput
, lpInputSize
,
1793 lpOutput
, lpOutputSize
, lpBytesRead
, nTimeout
);
1795 pipe
= CreateFileW(lpNamedPipeName
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
1796 if (pipe
== INVALID_HANDLE_VALUE
)
1798 ret
= WaitNamedPipeW(lpNamedPipeName
, nTimeout
);
1801 pipe
= CreateFileW(lpNamedPipeName
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, NULL
);
1802 if (pipe
== INVALID_HANDLE_VALUE
)
1806 mode
= PIPE_READMODE_MESSAGE
;
1807 ret
= SetNamedPipeHandleState(pipe
, &mode
, NULL
, NULL
);
1809 /* Currently SetNamedPipeHandleState() is a stub returning FALSE */
1810 if (ret
) FIXME("Now that SetNamedPipeHandleState() is more than a stub, please update CallNamedPipeW\n");
1818 ret
= TransactNamedPipe(pipe
, lpInput
, lpInputSize
, lpOutput
, lpOutputSize
, lpBytesRead
, NULL
);
1826 /******************************************************************
1827 * CreatePipe (KERNEL32.@)
1830 BOOL WINAPI
CreatePipe( PHANDLE hReadPipe
, PHANDLE hWritePipe
,
1831 LPSECURITY_ATTRIBUTES sa
, DWORD size
)
1833 static unsigned index
/* = 0 */;
1836 unsigned in_index
= index
;
1837 UNICODE_STRING nt_name
;
1838 OBJECT_ATTRIBUTES attr
;
1840 IO_STATUS_BLOCK iosb
;
1841 LARGE_INTEGER timeout
;
1843 *hReadPipe
= *hWritePipe
= INVALID_HANDLE_VALUE
;
1845 attr
.Length
= sizeof(attr
);
1846 attr
.RootDirectory
= 0;
1847 attr
.ObjectName
= &nt_name
;
1848 attr
.Attributes
= OBJ_CASE_INSENSITIVE
|
1849 ((sa
&& sa
->bInheritHandle
) ? OBJ_INHERIT
: 0);
1850 attr
.SecurityDescriptor
= sa
? sa
->lpSecurityDescriptor
: NULL
;
1851 attr
.SecurityQualityOfService
= NULL
;
1853 timeout
.QuadPart
= (ULONGLONG
)NMPWAIT_USE_DEFAULT_WAIT
* -10000;
1854 /* generate a unique pipe name (system wide) */
1857 static const WCHAR nameFmt
[] = { '\\','?','?','\\','p','i','p','e',
1858 '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1859 'u','.','%','0','8','u','\0' };
1861 snprintfW(name
, sizeof(name
) / sizeof(name
[0]), nameFmt
,
1862 GetCurrentProcessId(), ++index
);
1863 RtlInitUnicodeString(&nt_name
, name
);
1864 status
= NtCreateNamedPipeFile(&hr
, GENERIC_READ
| SYNCHRONIZE
, &attr
, &iosb
,
1865 FILE_SHARE_WRITE
, FILE_OVERWRITE_IF
,
1866 FILE_SYNCHRONOUS_IO_NONALERT
,
1867 FALSE
, FALSE
, FALSE
,
1868 1, size
, size
, &timeout
);
1871 SetLastError( RtlNtStatusToDosError(status
) );
1872 hr
= INVALID_HANDLE_VALUE
;
1874 } while (hr
== INVALID_HANDLE_VALUE
&& index
!= in_index
);
1875 /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1876 if (hr
== INVALID_HANDLE_VALUE
) return FALSE
;
1878 status
= NtOpenFile(&hw
, GENERIC_WRITE
| SYNCHRONIZE
, &attr
, &iosb
, 0,
1879 FILE_SYNCHRONOUS_IO_NONALERT
| FILE_NON_DIRECTORY_FILE
);
1883 SetLastError( RtlNtStatusToDosError(status
) );
1894 /******************************************************************************
1895 * CreateMailslotA [KERNEL32.@]
1897 * See CreateMailslotW.
1899 HANDLE WINAPI
CreateMailslotA( LPCSTR lpName
, DWORD nMaxMessageSize
,
1900 DWORD lReadTimeout
, LPSECURITY_ATTRIBUTES sa
)
1906 TRACE("%s %d %d %p\n", debugstr_a(lpName
),
1907 nMaxMessageSize
, lReadTimeout
, sa
);
1911 len
= MultiByteToWideChar( CP_ACP
, 0, lpName
, -1, NULL
, 0 );
1912 name
= HeapAlloc( GetProcessHeap(), 0, len
*sizeof(WCHAR
) );
1913 MultiByteToWideChar( CP_ACP
, 0, lpName
, -1, name
, len
);
1916 handle
= CreateMailslotW( name
, nMaxMessageSize
, lReadTimeout
, sa
);
1918 HeapFree( GetProcessHeap(), 0, name
);
1924 /******************************************************************************
1925 * CreateMailslotW [KERNEL32.@]
1927 * Create a mailslot with specified name.
1930 * lpName [I] Pointer to string for mailslot name
1931 * nMaxMessageSize [I] Maximum message size
1932 * lReadTimeout [I] Milliseconds before read time-out
1933 * sa [I] Pointer to security structure
1936 * Success: Handle to mailslot
1937 * Failure: INVALID_HANDLE_VALUE
1939 HANDLE WINAPI
CreateMailslotW( LPCWSTR lpName
, DWORD nMaxMessageSize
,
1940 DWORD lReadTimeout
, LPSECURITY_ATTRIBUTES sa
)
1942 HANDLE handle
= INVALID_HANDLE_VALUE
;
1943 OBJECT_ATTRIBUTES attr
;
1944 UNICODE_STRING nameW
;
1945 LARGE_INTEGER timeout
;
1946 IO_STATUS_BLOCK iosb
;
1949 TRACE("%s %d %d %p\n", debugstr_w(lpName
),
1950 nMaxMessageSize
, lReadTimeout
, sa
);
1952 if (!RtlDosPathNameToNtPathName_U( lpName
, &nameW
, NULL
, NULL
))
1954 SetLastError( ERROR_PATH_NOT_FOUND
);
1955 return INVALID_HANDLE_VALUE
;
1958 if (nameW
.Length
>= MAX_PATH
* sizeof(WCHAR
) )
1960 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1961 RtlFreeUnicodeString( &nameW
);
1962 return INVALID_HANDLE_VALUE
;
1965 attr
.Length
= sizeof(attr
);
1966 attr
.RootDirectory
= 0;
1967 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1968 attr
.ObjectName
= &nameW
;
1969 attr
.SecurityDescriptor
= sa
? sa
->lpSecurityDescriptor
: NULL
;
1970 attr
.SecurityQualityOfService
= NULL
;
1972 if (lReadTimeout
!= MAILSLOT_WAIT_FOREVER
)
1973 timeout
.QuadPart
= (ULONGLONG
) lReadTimeout
* -10000;
1975 timeout
.QuadPart
= ((LONGLONG
)0x7fffffff << 32) | 0xffffffff;
1977 status
= NtCreateMailslotFile( &handle
, GENERIC_READ
| SYNCHRONIZE
, &attr
,
1978 &iosb
, 0, 0, nMaxMessageSize
, &timeout
);
1981 SetLastError( RtlNtStatusToDosError(status
) );
1982 handle
= INVALID_HANDLE_VALUE
;
1985 RtlFreeUnicodeString( &nameW
);
1990 /******************************************************************************
1991 * GetMailslotInfo [KERNEL32.@]
1993 * Retrieve information about a mailslot.
1996 * hMailslot [I] Mailslot handle
1997 * lpMaxMessageSize [O] Address of maximum message size
1998 * lpNextSize [O] Address of size of next message
1999 * lpMessageCount [O] Address of number of messages
2000 * lpReadTimeout [O] Address of read time-out
2006 BOOL WINAPI
GetMailslotInfo( HANDLE hMailslot
, LPDWORD lpMaxMessageSize
,
2007 LPDWORD lpNextSize
, LPDWORD lpMessageCount
,
2008 LPDWORD lpReadTimeout
)
2010 FILE_MAILSLOT_QUERY_INFORMATION info
;
2011 IO_STATUS_BLOCK iosb
;
2014 TRACE("%p %p %p %p %p\n",hMailslot
, lpMaxMessageSize
,
2015 lpNextSize
, lpMessageCount
, lpReadTimeout
);
2017 status
= NtQueryInformationFile( hMailslot
, &iosb
, &info
, sizeof info
,
2018 FileMailslotQueryInformation
);
2020 if( status
!= STATUS_SUCCESS
)
2022 SetLastError( RtlNtStatusToDosError(status
) );
2026 if( lpMaxMessageSize
)
2027 *lpMaxMessageSize
= info
.MaximumMessageSize
;
2029 *lpNextSize
= info
.NextMessageSize
;
2030 if( lpMessageCount
)
2031 *lpMessageCount
= info
.MessagesAvailable
;
2034 if (info
.ReadTimeout
.QuadPart
== (((LONGLONG
)0x7fffffff << 32) | 0xffffffff))
2035 *lpReadTimeout
= MAILSLOT_WAIT_FOREVER
;
2037 *lpReadTimeout
= info
.ReadTimeout
.QuadPart
/ -10000;
2043 /******************************************************************************
2044 * SetMailslotInfo [KERNEL32.@]
2046 * Set the read timeout of a mailslot.
2049 * hMailslot [I] Mailslot handle
2050 * dwReadTimeout [I] Timeout in milliseconds.
2056 BOOL WINAPI
SetMailslotInfo( HANDLE hMailslot
, DWORD dwReadTimeout
)
2058 FILE_MAILSLOT_SET_INFORMATION info
;
2059 IO_STATUS_BLOCK iosb
;
2062 TRACE("%p %d\n", hMailslot
, dwReadTimeout
);
2064 if (dwReadTimeout
!= MAILSLOT_WAIT_FOREVER
)
2065 info
.ReadTimeout
.QuadPart
= (ULONGLONG
)dwReadTimeout
* -10000;
2067 info
.ReadTimeout
.QuadPart
= ((LONGLONG
)0x7fffffff << 32) | 0xffffffff;
2068 status
= NtSetInformationFile( hMailslot
, &iosb
, &info
, sizeof info
,
2069 FileMailslotSetInformation
);
2070 if( status
!= STATUS_SUCCESS
)
2072 SetLastError( RtlNtStatusToDosError(status
) );
2079 /******************************************************************************
2080 * CreateIoCompletionPort (KERNEL32.@)
2082 HANDLE WINAPI
CreateIoCompletionPort(HANDLE hFileHandle
, HANDLE hExistingCompletionPort
,
2083 ULONG_PTR CompletionKey
, DWORD dwNumberOfConcurrentThreads
)
2088 TRACE("(%p, %p, %08lx, %08x)\n",
2089 hFileHandle
, hExistingCompletionPort
, CompletionKey
, dwNumberOfConcurrentThreads
);
2091 if (hExistingCompletionPort
&& hFileHandle
== INVALID_HANDLE_VALUE
)
2093 SetLastError( ERROR_INVALID_PARAMETER
);
2097 if (hExistingCompletionPort
)
2098 ret
= hExistingCompletionPort
;
2101 status
= NtCreateIoCompletion( &ret
, IO_COMPLETION_ALL_ACCESS
, NULL
, dwNumberOfConcurrentThreads
);
2102 if (status
!= STATUS_SUCCESS
) goto fail
;
2105 if (hFileHandle
!= INVALID_HANDLE_VALUE
)
2107 FILE_COMPLETION_INFORMATION info
;
2108 IO_STATUS_BLOCK iosb
;
2110 info
.CompletionPort
= ret
;
2111 info
.CompletionKey
= CompletionKey
;
2112 status
= NtSetInformationFile( hFileHandle
, &iosb
, &info
, sizeof(info
), FileCompletionInformation
);
2113 if (status
!= STATUS_SUCCESS
) goto fail
;
2119 if (ret
&& !hExistingCompletionPort
)
2121 SetLastError( RtlNtStatusToDosError(status
) );
2125 /******************************************************************************
2126 * GetQueuedCompletionStatus (KERNEL32.@)
2128 BOOL WINAPI
GetQueuedCompletionStatus( HANDLE CompletionPort
, LPDWORD lpNumberOfBytesTransferred
,
2129 PULONG_PTR pCompletionKey
, LPOVERLAPPED
*lpOverlapped
,
2130 DWORD dwMilliseconds
)
2133 IO_STATUS_BLOCK iosb
;
2134 LARGE_INTEGER wait_time
;
2136 TRACE("(%p,%p,%p,%p,%d)\n",
2137 CompletionPort
,lpNumberOfBytesTransferred
,pCompletionKey
,lpOverlapped
,dwMilliseconds
);
2139 *lpOverlapped
= NULL
;
2141 status
= NtRemoveIoCompletion( CompletionPort
, pCompletionKey
, (PULONG_PTR
)lpOverlapped
,
2142 &iosb
, get_nt_timeout( &wait_time
, dwMilliseconds
) );
2143 if (status
== STATUS_SUCCESS
)
2145 *lpNumberOfBytesTransferred
= iosb
.Information
;
2146 if (iosb
.u
.Status
>= 0) return TRUE
;
2147 SetLastError( RtlNtStatusToDosError(iosb
.u
.Status
) );
2151 if (status
== STATUS_TIMEOUT
) SetLastError( WAIT_TIMEOUT
);
2152 else SetLastError( RtlNtStatusToDosError(status
) );
2157 /******************************************************************************
2158 * PostQueuedCompletionStatus (KERNEL32.@)
2160 BOOL WINAPI
PostQueuedCompletionStatus( HANDLE CompletionPort
, DWORD dwNumberOfBytes
,
2161 ULONG_PTR dwCompletionKey
, LPOVERLAPPED lpOverlapped
)
2165 TRACE("%p %d %08lx %p\n", CompletionPort
, dwNumberOfBytes
, dwCompletionKey
, lpOverlapped
);
2167 status
= NtSetIoCompletion( CompletionPort
, dwCompletionKey
, (ULONG_PTR
)lpOverlapped
,
2168 STATUS_SUCCESS
, dwNumberOfBytes
);
2170 if (status
== STATUS_SUCCESS
) return TRUE
;
2171 SetLastError( RtlNtStatusToDosError(status
) );
2175 /******************************************************************************
2176 * BindIoCompletionCallback (KERNEL32.@)
2178 BOOL WINAPI
BindIoCompletionCallback( HANDLE FileHandle
, LPOVERLAPPED_COMPLETION_ROUTINE Function
, ULONG Flags
)
2182 TRACE("(%p, %p, %d)\n", FileHandle
, Function
, Flags
);
2184 status
= RtlSetIoCompletionCallback( FileHandle
, (PRTL_OVERLAPPED_COMPLETION_ROUTINE
)Function
, Flags
);
2185 if (status
== STATUS_SUCCESS
) return TRUE
;
2186 SetLastError( RtlNtStatusToDosError(status
) );
2191 /***********************************************************************
2192 * CreateMemoryResourceNotification (KERNEL32.@)
2194 HANDLE WINAPI
CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE type
)
2196 static const WCHAR lowmemW
[] =
2197 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2198 '\\','L','o','w','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2199 static const WCHAR highmemW
[] =
2200 {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
2201 '\\','H','i','g','h','M','e','m','o','r','y','C','o','n','d','i','t','i','o','n',0};
2203 UNICODE_STRING nameW
;
2204 OBJECT_ATTRIBUTES attr
;
2209 case LowMemoryResourceNotification
:
2210 RtlInitUnicodeString( &nameW
, lowmemW
);
2212 case HighMemoryResourceNotification
:
2213 RtlInitUnicodeString( &nameW
, highmemW
);
2216 SetLastError( ERROR_INVALID_PARAMETER
);
2220 attr
.Length
= sizeof(attr
);
2221 attr
.RootDirectory
= 0;
2222 attr
.ObjectName
= &nameW
;
2223 attr
.Attributes
= 0;
2224 attr
.SecurityDescriptor
= NULL
;
2225 attr
.SecurityQualityOfService
= NULL
;
2226 status
= NtOpenEvent( &ret
, EVENT_ALL_ACCESS
, &attr
);
2227 if (status
!= STATUS_SUCCESS
)
2229 SetLastError( RtlNtStatusToDosError(status
) );
2235 /***********************************************************************
2236 * QueryMemoryResourceNotification (KERNEL32.@)
2238 BOOL WINAPI
QueryMemoryResourceNotification(HANDLE handle
, PBOOL state
)
2240 switch (WaitForSingleObject( handle
, 0 ))
2249 SetLastError( ERROR_INVALID_PARAMETER
);
2253 /***********************************************************************
2254 * InitOnceBeginInitialize (KERNEL32.@)
2256 BOOL WINAPI
InitOnceBeginInitialize( INIT_ONCE
*once
, DWORD flags
, BOOL
*pending
, void **context
)
2258 NTSTATUS status
= RtlRunOnceBeginInitialize( once
, flags
, context
);
2259 if (status
>= 0) *pending
= (status
== STATUS_PENDING
);
2260 else SetLastError( RtlNtStatusToDosError(status
) );
2264 /***********************************************************************
2265 * InitOnceComplete (KERNEL32.@)
2267 BOOL WINAPI
InitOnceComplete( INIT_ONCE
*once
, DWORD flags
, void *context
)
2269 NTSTATUS status
= RtlRunOnceComplete( once
, flags
, context
);
2270 if (status
!= STATUS_SUCCESS
) SetLastError( RtlNtStatusToDosError(status
) );
2274 /***********************************************************************
2275 * InitOnceExecuteOnce (KERNEL32.@)
2277 BOOL WINAPI
InitOnceExecuteOnce( INIT_ONCE
*once
, PINIT_ONCE_FN func
, void *param
, void **context
)
2279 return !RtlRunOnceExecuteOnce( once
, (PRTL_RUN_ONCE_INIT_FN
)func
, param
, context
);
2284 /***********************************************************************
2285 * InterlockedCompareExchange (KERNEL32.@)
2287 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2288 __ASM_STDCALL_FUNC(InterlockedCompareExchange
, 12,
2289 "movl 12(%esp),%eax\n\t"
2290 "movl 8(%esp),%ecx\n\t"
2291 "movl 4(%esp),%edx\n\t"
2292 "lock; cmpxchgl %ecx,(%edx)\n\t"
2295 /***********************************************************************
2296 * InterlockedExchange (KERNEL32.@)
2298 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2299 __ASM_STDCALL_FUNC(InterlockedExchange
, 8,
2300 "movl 8(%esp),%eax\n\t"
2301 "movl 4(%esp),%edx\n\t"
2302 "lock; xchgl %eax,(%edx)\n\t"
2305 /***********************************************************************
2306 * InterlockedExchangeAdd (KERNEL32.@)
2308 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2309 __ASM_STDCALL_FUNC(InterlockedExchangeAdd
, 8,
2310 "movl 8(%esp),%eax\n\t"
2311 "movl 4(%esp),%edx\n\t"
2312 "lock; xaddl %eax,(%edx)\n\t"
2315 /***********************************************************************
2316 * InterlockedIncrement (KERNEL32.@)
2318 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2319 __ASM_STDCALL_FUNC(InterlockedIncrement
, 4,
2320 "movl 4(%esp),%edx\n\t"
2322 "lock; xaddl %eax,(%edx)\n\t"
2326 /***********************************************************************
2327 * InterlockedDecrement (KERNEL32.@)
2329 __ASM_STDCALL_FUNC(InterlockedDecrement
, 4,
2330 "movl 4(%esp),%edx\n\t"
2332 "lock; xaddl %eax,(%edx)\n\t"
2336 #endif /* __i386__ */
2338 /***********************************************************************
2339 * SleepConditionVariableCS (KERNEL32.@)
2341 BOOL WINAPI
SleepConditionVariableCS( CONDITION_VARIABLE
*variable
, CRITICAL_SECTION
*crit
, DWORD timeout
)
2346 status
= RtlSleepConditionVariableCS( variable
, crit
, get_nt_timeout( &time
, timeout
) );
2348 if (status
!= STATUS_SUCCESS
)
2350 SetLastError( RtlNtStatusToDosError(status
) );
2356 /***********************************************************************
2357 * SleepConditionVariableSRW (KERNEL32.@)
2359 BOOL WINAPI
SleepConditionVariableSRW( RTL_CONDITION_VARIABLE
*variable
, RTL_SRWLOCK
*lock
, DWORD timeout
, ULONG flags
)
2364 status
= RtlSleepConditionVariableSRW( variable
, lock
, get_nt_timeout( &time
, timeout
), flags
);
2366 if (status
!= STATUS_SUCCESS
)
2368 SetLastError( RtlNtStatusToDosError(status
) );