dlls/kernel32/sync.c

   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 int 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 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  * Allows to atomically signal any of the synchro objects (semaphore,
 279  * 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
 750                                 LONG max, LPCWSTR name )
 751 {
 752     return CreateSemaphoreExW( sa, initial, max, name, 0, SEMAPHORE_ALL_ACCESS );
 753 }
 754
 755
 756 /***********************************************************************
 757  *           CreateSemaphoreExA   (KERNEL32.@)
 758  */
 759 HANDLE WINAPI CreateSemaphoreExA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name,
 760                                   DWORD flags, DWORD access )
 761 {
 762     WCHAR buffer[MAX_PATH];
 763
 764     if (!name) return CreateSemaphoreExW( sa, initial, max, NULL, flags, access );
 765
 766     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 767     {
 768         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 769         return 0;
 770     }
 771     return CreateSemaphoreExW( sa, initial, max, buffer, flags, access );
 772 }
 773
 774
 775 /***********************************************************************
 776  *           CreateSemaphoreExW   (KERNEL32.@)
 777  */
 778 HANDLE WINAPI CreateSemaphoreExW( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCWSTR name,
 779                                   DWORD flags, DWORD access )
 780 {
 781     HANDLE ret;
 782     UNICODE_STRING nameW;
 783     OBJECT_ATTRIBUTES attr;
 784     NTSTATUS status;
 785
 786     attr.Length                   = sizeof(attr);
 787     attr.RootDirectory            = 0;
 788     attr.ObjectName               = NULL;
 789     attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 790     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
 791     attr.SecurityQualityOfService = NULL;
 792     if (name)
 793     {
 794         RtlInitUnicodeString( &nameW, name );
 795         attr.ObjectName = &nameW;
 796         attr.RootDirectory = get_BaseNamedObjects_handle();
 797     }
 798
 799     status = NtCreateSemaphore( &ret, access, &attr, initial, max );
 800     if (status == STATUS_OBJECT_NAME_EXISTS)
 801         SetLastError( ERROR_ALREADY_EXISTS );
 802     else
 803         SetLastError( RtlNtStatusToDosError(status) );
 804     return ret;
 805 }
 806
 807
 808 /***********************************************************************
 809  *           OpenSemaphoreA   (KERNEL32.@)
 810  */
 811 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 812 {
 813     WCHAR buffer[MAX_PATH];
 814
 815     if (!name) return OpenSemaphoreW( access, inherit, NULL );
 816
 817     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 818     {
 819         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 820         return 0;
 821     }
 822     return OpenSemaphoreW( access, inherit, buffer );
 823 }
 824
 825
 826 /***********************************************************************
 827  *           OpenSemaphoreW   (KERNEL32.@)
 828  */
 829 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 830 {
 831     HANDLE ret;
 832     UNICODE_STRING nameW;
 833     OBJECT_ATTRIBUTES attr;
 834     NTSTATUS status;
 835
 836     if (!is_version_nt()) access = SEMAPHORE_ALL_ACCESS;
 837
 838     attr.Length                   = sizeof(attr);
 839     attr.RootDirectory            = 0;
 840     attr.ObjectName               = NULL;
 841     attr.Attributes               = inherit ? OBJ_INHERIT : 0;
 842     attr.SecurityDescriptor       = NULL;
 843     attr.SecurityQualityOfService = NULL;
 844     if (name)
 845     {
 846         RtlInitUnicodeString( &nameW, name );
 847         attr.ObjectName = &nameW;
 848         attr.RootDirectory = get_BaseNamedObjects_handle();
 849     }
 850
 851     status = NtOpenSemaphore( &ret, access, &attr );
 852     if (status != STATUS_SUCCESS)
 853     {
 854         SetLastError( RtlNtStatusToDosError(status) );
 855         return 0;
 856     }
 857     return ret;
 858 }
 859
 860
 861 /***********************************************************************
 862  *           ReleaseSemaphore   (KERNEL32.@)
 863  */
 864 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 865 {
 866     NTSTATUS status = NtReleaseSemaphore( handle, count, (PULONG)previous );
 867     if (status) SetLastError( RtlNtStatusToDosError(status) );
 868     return !status;
 869 }
 870
 871
 872 /*
 873  * Jobs
 874  */
 875
 876 /******************************************************************************
 877  *              CreateJobObjectW (KERNEL32.@)
 878  */
 879 HANDLE WINAPI CreateJobObjectW( LPSECURITY_ATTRIBUTES sa, LPCWSTR name )
 880 {
 881     HANDLE ret = 0;
 882     UNICODE_STRING nameW;
 883     OBJECT_ATTRIBUTES attr;
 884     NTSTATUS status;
 885
 886     attr.Length                   = sizeof(attr);
 887     attr.RootDirectory            = 0;
 888     attr.ObjectName               = NULL;
 889     attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 890     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
 891     attr.SecurityQualityOfService = NULL;
 892     if (name)
 893     {
 894         RtlInitUnicodeString( &nameW, name );
 895         attr.ObjectName = &nameW;
 896         attr.RootDirectory = get_BaseNamedObjects_handle();
 897     }
 898
 899     status = NtCreateJobObject( &ret, JOB_OBJECT_ALL_ACCESS, &attr );
 900     if (status == STATUS_OBJECT_NAME_EXISTS)
 901         SetLastError( ERROR_ALREADY_EXISTS );
 902     else
 903         SetLastError( RtlNtStatusToDosError(status) );
 904     return ret;
 905 }
 906
 907 /******************************************************************************
 908  *              CreateJobObjectA (KERNEL32.@)
 909  */
 910 HANDLE WINAPI CreateJobObjectA( LPSECURITY_ATTRIBUTES attr, LPCSTR name )
 911 {
 912     WCHAR buffer[MAX_PATH];
 913
 914     if (!name) return CreateJobObjectW( attr, NULL );
 915
 916     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 917     {
 918         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 919         return 0;
 920     }
 921     return CreateJobObjectW( attr, buffer );
 922 }
 923
 924 /******************************************************************************
 925  *              OpenJobObjectW (KERNEL32.@)
 926  */
 927 HANDLE WINAPI OpenJobObjectW( DWORD access, BOOL inherit, LPCWSTR name )
 928 {
 929     HANDLE ret;
 930     UNICODE_STRING nameW;
 931     OBJECT_ATTRIBUTES attr;
 932     NTSTATUS status;
 933
 934     attr.Length                   = sizeof(attr);
 935     attr.RootDirectory            = 0;
 936     attr.ObjectName               = NULL;
 937     attr.Attributes               = inherit ? OBJ_INHERIT : 0;
 938     attr.SecurityDescriptor       = NULL;
 939     attr.SecurityQualityOfService = NULL;
 940     if (name)
 941     {
 942         RtlInitUnicodeString( &nameW, name );
 943         attr.ObjectName = &nameW;
 944         attr.RootDirectory = get_BaseNamedObjects_handle();
 945     }
 946
 947     status = NtOpenJobObject( &ret, access, &attr );
 948     if (status != STATUS_SUCCESS)
 949     {
 950         SetLastError( RtlNtStatusToDosError(status) );
 951         return 0;
 952     }
 953     return ret;
 954 }
 955
 956 /******************************************************************************
 957  *              OpenJobObjectA (KERNEL32.@)
 958  */
 959 HANDLE WINAPI OpenJobObjectA( DWORD access, BOOL inherit, LPCSTR name )
 960 {
 961     WCHAR buffer[MAX_PATH];
 962
 963     if (!name) return OpenJobObjectW( access, inherit, NULL );
 964
 965     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 966     {
 967         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 968         return 0;
 969     }
 970     return OpenJobObjectW( access, inherit, buffer );
 971 }
 972
 973 /******************************************************************************
 974  *              TerminateJobObject (KERNEL32.@)
 975  */
 976 BOOL WINAPI TerminateJobObject( HANDLE job, UINT exit_code )
 977 {
 978     NTSTATUS status = NtTerminateJobObject( job, exit_code );
 979     if (status) SetLastError( RtlNtStatusToDosError(status) );
 980     return !status;
 981 }
 982
 983 /******************************************************************************
 984  *              QueryInformationJobObject (KERNEL32.@)
 985  */
 986 BOOL WINAPI QueryInformationJobObject( HANDLE job, JOBOBJECTINFOCLASS class, LPVOID info,
 987                                        DWORD len, DWORD *ret_len )
 988 {
 989     NTSTATUS status = NtQueryInformationJobObject( job, class, info, len, ret_len );
 990     if (status) SetLastError( RtlNtStatusToDosError(status) );
 991     return !status;
 992 }
 993
 994 /******************************************************************************
 995  *              SetInformationJobObject (KERNEL32.@)
 996  */
 997 BOOL WINAPI SetInformationJobObject( HANDLE job, JOBOBJECTINFOCLASS class, LPVOID info, DWORD len )
 998 {
 999     NTSTATUS status = NtSetInformationJobObject( job, class, info, len );
1000     if (status) SetLastError( RtlNtStatusToDosError(status) );
1001     return !status;
1002 }
1003
1004 /******************************************************************************
1005  *              AssignProcessToJobObject (KERNEL32.@)
1006  */
1007 BOOL WINAPI AssignProcessToJobObject( HANDLE job, HANDLE process )
1008 {
1009     NTSTATUS status = NtAssignProcessToJobObject( job, process );
1010     if (status) SetLastError( RtlNtStatusToDosError(status) );
1011     return !status;
1012 }
1013
1014 /******************************************************************************
1015  *              IsProcessInJob (KERNEL32.@)
1016  */
1017 BOOL WINAPI IsProcessInJob( HANDLE process, HANDLE job, PBOOL result )
1018 {
1019     NTSTATUS status = NtIsProcessInJob( job, process );
1020     switch(status)
1021     {
1022     case STATUS_PROCESS_IN_JOB:
1023         *result = TRUE;
1024         return TRUE;
1025     case STATUS_PROCESS_NOT_IN_JOB:
1026         *result = FALSE;
1027         return TRUE;
1028     default:
1029         SetLastError( RtlNtStatusToDosError(status) );
1030         return FALSE;
1031     }
1032 }
1033
1034
1035 /*
1036  * Timers
1037  */
1038
1039
1040 /***********************************************************************
1041  *           CreateWaitableTimerA    (KERNEL32.@)
1042  */
1043 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
1044 {
1045     return CreateWaitableTimerExA( sa, name, manual ? CREATE_WAITABLE_TIMER_MANUAL_RESET : 0,
1046                                    TIMER_ALL_ACCESS );
1047 }
1048
1049
1050 /***********************************************************************
1051  *           CreateWaitableTimerW    (KERNEL32.@)
1052  */
1053 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
1054 {
1055     return CreateWaitableTimerExW( sa, name, manual ? CREATE_WAITABLE_TIMER_MANUAL_RESET : 0,
1056                                    TIMER_ALL_ACCESS );
1057 }
1058
1059
1060 /***********************************************************************
1061  *           CreateWaitableTimerExA    (KERNEL32.@)
1062  */
1063 HANDLE WINAPI CreateWaitableTimerExA( SECURITY_ATTRIBUTES *sa, LPCSTR name, DWORD flags, DWORD access )
1064 {
1065     WCHAR buffer[MAX_PATH];
1066
1067     if (!name) return CreateWaitableTimerExW( sa, NULL, flags, access );
1068
1069     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1070     {
1071         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1072         return 0;
1073     }
1074     return CreateWaitableTimerExW( sa, buffer, flags, access );
1075 }
1076
1077
1078 /***********************************************************************
1079  *           CreateWaitableTimerExW    (KERNEL32.@)
1080  */
1081 HANDLE WINAPI CreateWaitableTimerExW( SECURITY_ATTRIBUTES *sa, LPCWSTR name, DWORD flags, DWORD access )
1082 {
1083     HANDLE handle;
1084     NTSTATUS status;
1085     UNICODE_STRING nameW;
1086     OBJECT_ATTRIBUTES attr;
1087
1088     attr.Length                   = sizeof(attr);
1089     attr.RootDirectory            = 0;
1090     attr.ObjectName               = NULL;
1091     attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1092     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
1093     attr.SecurityQualityOfService = NULL;
1094     if (name)
1095     {
1096         RtlInitUnicodeString( &nameW, name );
1097         attr.ObjectName = &nameW;
1098         attr.RootDirectory = get_BaseNamedObjects_handle();
1099     }
1100
1101     status = NtCreateTimer( &handle, access, &attr,
1102                  (flags & CREATE_WAITABLE_TIMER_MANUAL_RESET) ? NotificationTimer : SynchronizationTimer );
1103     if (status == STATUS_OBJECT_NAME_EXISTS)
1104         SetLastError( ERROR_ALREADY_EXISTS );
1105     else
1106         SetLastError( RtlNtStatusToDosError(status) );
1107     return handle;
1108 }
1109
1110
1111 /***********************************************************************
1112  *           OpenWaitableTimerA    (KERNEL32.@)
1113  */
1114 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
1115 {
1116     WCHAR buffer[MAX_PATH];
1117
1118     if (!name) return OpenWaitableTimerW( access, inherit, NULL );
1119
1120     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1121     {
1122         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1123         return 0;
1124     }
1125     return OpenWaitableTimerW( access, inherit, buffer );
1126 }
1127
1128
1129 /***********************************************************************
1130  *           OpenWaitableTimerW    (KERNEL32.@)
1131  */
1132 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
1133 {
1134     HANDLE handle;
1135     UNICODE_STRING nameW;
1136     OBJECT_ATTRIBUTES attr;
1137     NTSTATUS status;
1138
1139     if (!is_version_nt()) access = TIMER_ALL_ACCESS;
1140
1141     attr.Length                   = sizeof(attr);
1142     attr.RootDirectory            = 0;
1143     attr.ObjectName               = NULL;
1144     attr.Attributes               = inherit ? OBJ_INHERIT : 0;
1145     attr.SecurityDescriptor       = NULL;
1146     attr.SecurityQualityOfService = NULL;
1147     if (name)
1148     {
1149         RtlInitUnicodeString( &nameW, name );
1150         attr.ObjectName = &nameW;
1151         attr.RootDirectory = get_BaseNamedObjects_handle();
1152     }
1153
1154     status = NtOpenTimer(&handle, access, &attr);
1155     if (status != STATUS_SUCCESS)
1156     {
1157         SetLastError( RtlNtStatusToDosError(status) );
1158         return 0;
1159     }
1160     return handle;
1161 }
1162
1163
1164 /***********************************************************************
1165  *           SetWaitableTimer    (KERNEL32.@)
1166  */
1167 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
1168                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
1169 {
1170     NTSTATUS status = NtSetTimer(handle, when, (PTIMER_APC_ROUTINE)callback,
1171                                  arg, resume, period, NULL);
1172
1173     if (status != STATUS_SUCCESS)
1174     {
1175         SetLastError( RtlNtStatusToDosError(status) );
1176         if (status != STATUS_TIMER_RESUME_IGNORED) return FALSE;
1177     }
1178     return TRUE;
1179 }
1180
1181
1182 /***********************************************************************
1183  *           CancelWaitableTimer    (KERNEL32.@)
1184  */
1185 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
1186 {
1187     NTSTATUS status;
1188
1189     status = NtCancelTimer(handle, NULL);
1190     if (status != STATUS_SUCCESS)
1191     {
1192         SetLastError( RtlNtStatusToDosError(status) );
1193         return FALSE;
1194     }
1195     return TRUE;
1196 }
1197
1198
1199 /***********************************************************************
1200  *           CreateTimerQueue  (KERNEL32.@)
1201  */
1202 HANDLE WINAPI CreateTimerQueue(void)
1203 {
1204     HANDLE q;
1205     NTSTATUS status = RtlCreateTimerQueue(&q);
1206
1207     if (status != STATUS_SUCCESS)
1208     {
1209         SetLastError( RtlNtStatusToDosError(status) );
1210         return NULL;
1211     }
1212
1213     return q;
1214 }
1215
1216
1217 /***********************************************************************
1218  *           DeleteTimerQueueEx  (KERNEL32.@)
1219  */
1220 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
1221 {
1222     NTSTATUS status = RtlDeleteTimerQueueEx(TimerQueue, CompletionEvent);
1223
1224     if (status != STATUS_SUCCESS)
1225     {
1226         SetLastError( RtlNtStatusToDosError(status) );
1227         return FALSE;
1228     }
1229
1230     return TRUE;
1231 }
1232
1233 /***********************************************************************
1234  *           DeleteTimerQueue  (KERNEL32.@)
1235  */
1236 BOOL WINAPI DeleteTimerQueue(HANDLE TimerQueue)
1237 {
1238     return DeleteTimerQueueEx(TimerQueue, NULL);
1239 }
1240
1241 /***********************************************************************
1242  *           CreateTimerQueueTimer  (KERNEL32.@)
1243  *
1244  * Creates a timer-queue timer. This timer expires at the specified due
1245  * time (in ms), then after every specified period (in ms). When the timer
1246  * expires, the callback function is called.
1247  *
1248  * RETURNS
1249  *   nonzero on success or zero on failure
1250  */
1251 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
1252                                    WAITORTIMERCALLBACK Callback, PVOID Parameter,
1253                                    DWORD DueTime, DWORD Period, ULONG Flags )
1254 {
1255     NTSTATUS status = RtlCreateTimer(phNewTimer, TimerQueue, Callback,
1256                                      Parameter, DueTime, Period, Flags);
1257
1258     if (status != STATUS_SUCCESS)
1259     {
1260         SetLastError( RtlNtStatusToDosError(status) );
1261         return FALSE;
1262     }
1263
1264     return TRUE;
1265 }
1266
1267 /***********************************************************************
1268  *           ChangeTimerQueueTimer  (KERNEL32.@)
1269  *
1270  * Changes the times at which the timer expires.
1271  *
1272  * RETURNS
1273  *   nonzero on success or zero on failure
1274  */
1275 BOOL WINAPI ChangeTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1276                                    ULONG DueTime, ULONG Period )
1277 {
1278     NTSTATUS status = RtlUpdateTimer(TimerQueue, Timer, DueTime, Period);
1279
1280     if (status != STATUS_SUCCESS)
1281     {
1282         SetLastError( RtlNtStatusToDosError(status) );
1283         return FALSE;
1284     }
1285
1286     return TRUE;
1287 }
1288
1289 /***********************************************************************
1290  *           DeleteTimerQueueTimer  (KERNEL32.@)
1291  *
1292  * Cancels a timer-queue timer.
1293  *
1294  * RETURNS
1295  *   nonzero on success or zero on failure
1296  */
1297 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1298                                    HANDLE CompletionEvent )
1299 {
1300     NTSTATUS status = RtlDeleteTimer(TimerQueue, Timer, CompletionEvent);
1301     if (status != STATUS_SUCCESS)
1302     {
1303         SetLastError( RtlNtStatusToDosError(status) );
1304         return FALSE;
1305     }
1306     return TRUE;
1307 }
1308
1309
1310 /*
1311  * Pipes
1312  */
1313
1314
1315 /***********************************************************************
1316  *           CreateNamedPipeA   (KERNEL32.@)
1317  */
1318 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
1319                                 DWORD dwPipeMode, DWORD nMaxInstances,
1320                                 DWORD nOutBufferSize, DWORD nInBufferSize,
1321                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
1322 {
1323     WCHAR buffer[MAX_PATH];
1324
1325     if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
1326                                         nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1327
1328     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1329     {
1330         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1331         return INVALID_HANDLE_VALUE;
1332     }
1333     return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
1334                              nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1335 }
1336
1337
1338 /***********************************************************************
1339  *           CreateNamedPipeW   (KERNEL32.@)
1340  */
1341 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
1342                                 DWORD dwPipeMode, DWORD nMaxInstances,
1343                                 DWORD nOutBufferSize, DWORD nInBufferSize,
1344                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES sa )
1345 {
1346     HANDLE handle;
1347     UNICODE_STRING nt_name;
1348     OBJECT_ATTRIBUTES attr;
1349     DWORD access, options;
1350     BOOLEAN pipe_type, read_mode, non_block;
1351     NTSTATUS status;
1352     IO_STATUS_BLOCK iosb;
1353     LARGE_INTEGER timeout;
1354
1355     TRACE("(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n",
1356           debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
1357           nOutBufferSize, nInBufferSize, nDefaultTimeOut, sa );
1358
1359     if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1360     {
1361         SetLastError( ERROR_PATH_NOT_FOUND );
1362         return INVALID_HANDLE_VALUE;
1363     }
1364     if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) )
1365     {
1366         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1367         RtlFreeUnicodeString( &nt_name );
1368         return INVALID_HANDLE_VALUE;
1369     }
1370
1371     attr.Length                   = sizeof(attr);
1372     attr.RootDirectory            = 0;
1373     attr.ObjectName               = &nt_name;
1374     attr.Attributes               = OBJ_CASE_INSENSITIVE |
1375                                     ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1376     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
1377     attr.SecurityQualityOfService = NULL;
1378
1379     switch(dwOpenMode & 3)
1380     {
1381     case PIPE_ACCESS_INBOUND:
1382         options = FILE_PIPE_INBOUND;
1383         access  = GENERIC_READ;
1384         break;
1385     case PIPE_ACCESS_OUTBOUND:
1386         options = FILE_PIPE_OUTBOUND;
1387         access  = GENERIC_WRITE;
1388         break;
1389     case PIPE_ACCESS_DUPLEX:
1390         options = FILE_PIPE_FULL_DUPLEX;
1391         access  = GENERIC_READ | GENERIC_WRITE;
1392         break;
1393     default:
1394         SetLastError( ERROR_INVALID_PARAMETER );
1395         return INVALID_HANDLE_VALUE;
1396     }
1397     access |= SYNCHRONIZE;
1398     if (dwOpenMode & FILE_FLAG_WRITE_THROUGH) options |= FILE_WRITE_THROUGH;
1399     if (!(dwOpenMode & FILE_FLAG_OVERLAPPED)) options |= FILE_SYNCHRONOUS_IO_NONALERT;
1400     pipe_type = (dwPipeMode & PIPE_TYPE_MESSAGE) ? TRUE : FALSE;
1401     read_mode = (dwPipeMode & PIPE_READMODE_MESSAGE) ? TRUE : FALSE;
1402     non_block = (dwPipeMode & PIPE_NOWAIT) ? TRUE : FALSE;
1403     if (nMaxInstances >= PIPE_UNLIMITED_INSTANCES) nMaxInstances = ~0U;
1404
1405     timeout.QuadPart = (ULONGLONG)nDefaultTimeOut * -10000;
1406
1407     SetLastError(0);
1408
1409     status = NtCreateNamedPipeFile(&handle, access, &attr, &iosb, 0,
1410                                    FILE_OVERWRITE_IF, options, pipe_type,
1411                                    read_mode, non_block, nMaxInstances,
1412                                    nInBufferSize, nOutBufferSize, &timeout);
1413
1414     RtlFreeUnicodeString( &nt_name );
1415     if (status)
1416     {
1417         handle = INVALID_HANDLE_VALUE;
1418         SetLastError( RtlNtStatusToDosError(status) );
1419     }
1420     return handle;
1421 }
1422
1423
1424 /***********************************************************************
1425  *           PeekNamedPipe   (KERNEL32.@)
1426  */
1427 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
1428                            LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
1429 {
1430     FILE_PIPE_PEEK_BUFFER local_buffer;
1431     FILE_PIPE_PEEK_BUFFER *buffer = &local_buffer;
1432     IO_STATUS_BLOCK io;
1433     NTSTATUS status;
1434
1435     if (cbBuffer && !(buffer = HeapAlloc( GetProcessHeap(), 0,
1436                                           FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ))))
1437     {
1438         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1439         return FALSE;
1440     }
1441
1442     status = NtFsControlFile( hPipe, 0, NULL, NULL, &io, FSCTL_PIPE_PEEK, NULL, 0,
1443                               buffer, FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ) );
1444     if (!status)
1445     {
1446         ULONG read_size = io.Information - FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data );
1447         if (lpcbAvail) *lpcbAvail = buffer->ReadDataAvailable;
1448         if (lpcbRead) *lpcbRead = read_size;
1449         if (lpcbMessage) *lpcbMessage = 0;  /* FIXME */
1450         if (lpvBuffer) memcpy( lpvBuffer, buffer->Data, read_size );
1451     }
1452     else SetLastError( RtlNtStatusToDosError(status) );
1453
1454     if (buffer != &local_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1455     return !status;
1456 }
1457
1458 /***********************************************************************
1459  *           WaitNamedPipeA   (KERNEL32.@)
1460  */
1461 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
1462 {
1463     WCHAR buffer[MAX_PATH];
1464
1465     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
1466
1467     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1468     {
1469         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1470         return 0;
1471     }
1472     return WaitNamedPipeW( buffer, nTimeOut );
1473 }
1474
1475
1476 /***********************************************************************
1477  *           WaitNamedPipeW   (KERNEL32.@)
1478  *
1479  *  Waits for a named pipe instance to become available
1480  *
1481  *  PARAMS
1482  *   name     [I] Pointer to a named pipe name to wait for
1483  *   nTimeOut [I] How long to wait in ms
1484  *
1485  *  RETURNS
1486  *   TRUE: Success, named pipe can be opened with CreateFile
1487  *   FALSE: Failure, GetLastError can be called for further details
1488  */
1489 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
1490 {
1491     static const WCHAR leadin[] = {'\\','?','?','\\','P','I','P','E','\\'};
1492     NTSTATUS status;
1493     UNICODE_STRING nt_name, pipe_dev_name;
1494     FILE_PIPE_WAIT_FOR_BUFFER *pipe_wait;
1495     IO_STATUS_BLOCK iosb;
1496     OBJECT_ATTRIBUTES attr;
1497     ULONG sz_pipe_wait;
1498     HANDLE pipe_dev;
1499
1500     TRACE("%s 0x%08x\n",debugstr_w(name),nTimeOut);
1501
1502     if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1503         return FALSE;
1504
1505     if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) ||
1506         nt_name.Length < sizeof(leadin) ||
1507         strncmpiW( nt_name.Buffer, leadin, sizeof(leadin)/sizeof(WCHAR)) != 0)
1508     {
1509         RtlFreeUnicodeString( &nt_name );
1510         SetLastError( ERROR_PATH_NOT_FOUND );
1511         return FALSE;
1512     }
1513
1514     sz_pipe_wait = sizeof(*pipe_wait) + nt_name.Length - sizeof(leadin) - sizeof(WCHAR);
1515     if (!(pipe_wait = HeapAlloc( GetProcessHeap(), 0,  sz_pipe_wait)))
1516     {
1517         RtlFreeUnicodeString( &nt_name );
1518         SetLastError( ERROR_OUTOFMEMORY );
1519         return FALSE;
1520     }
1521
1522     pipe_dev_name.Buffer = nt_name.Buffer;
1523     pipe_dev_name.Length = sizeof(leadin);
1524     pipe_dev_name.MaximumLength = sizeof(leadin);
1525     InitializeObjectAttributes(&attr,&pipe_dev_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1526     status = NtOpenFile( &pipe_dev, FILE_READ_ATTRIBUTES, &attr,
1527                          &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
1528                          FILE_SYNCHRONOUS_IO_NONALERT);
1529     if (status != ERROR_SUCCESS)
1530     {
1531         SetLastError( ERROR_PATH_NOT_FOUND );
1532         return FALSE;
1533     }
1534
1535     pipe_wait->TimeoutSpecified = !(nTimeOut == NMPWAIT_USE_DEFAULT_WAIT);
1536     if (nTimeOut == NMPWAIT_WAIT_FOREVER)
1537         pipe_wait->Timeout.QuadPart = ((ULONGLONG)0x7fffffff << 32) | 0xffffffff;
1538     else
1539         pipe_wait->Timeout.QuadPart = (ULONGLONG)nTimeOut * -10000;
1540     pipe_wait->NameLength = nt_name.Length - sizeof(leadin);
1541     memcpy(pipe_wait->Name, nt_name.Buffer + sizeof(leadin)/sizeof(WCHAR),
1542            pipe_wait->NameLength);
1543     RtlFreeUnicodeString( &nt_name );
1544
1545     status = NtFsControlFile( pipe_dev, NULL, NULL, NULL, &iosb, FSCTL_PIPE_WAIT,
1546                               pipe_wait, sz_pipe_wait, NULL, 0 );
1547
1548     HeapFree( GetProcessHeap(), 0, pipe_wait );
1549     NtClose( pipe_dev );
1550
1551     if(status != STATUS_SUCCESS)
1552     {
1553         SetLastError(RtlNtStatusToDosError(status));
1554         return FALSE;
1555     }
1556     else
1557         return TRUE;
1558 }
1559
1560
1561 /***********************************************************************
1562  *           ConnectNamedPipe   (KERNEL32.@)
1563  *
1564  *  Connects to a named pipe
1565  *
1566  *  Parameters
1567  *  hPipe: A handle to a named pipe returned by CreateNamedPipe
1568  *  overlapped: Optional OVERLAPPED struct
1569  *
1570  *  Return values
1571  *  TRUE: Success
1572  *  FALSE: Failure, GetLastError can be called for further details
1573  */
1574 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1575 {
1576     NTSTATUS status;
1577     IO_STATUS_BLOCK status_block;
1578     LPVOID   cvalue = NULL;
1579
1580     TRACE("(%p,%p)\n", hPipe, overlapped);
1581
1582     if(overlapped)
1583     {
1584         overlapped->Internal = STATUS_PENDING;
1585         overlapped->InternalHigh = 0;
1586         if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
1587     }
1588
1589     status = NtFsControlFile(hPipe, overlapped ? overlapped->hEvent : NULL, NULL, cvalue,
1590                              overlapped ? (IO_STATUS_BLOCK *)overlapped : &status_block,
1591                              FSCTL_PIPE_LISTEN, NULL, 0, NULL, 0);
1592
1593     if (status == STATUS_SUCCESS) return TRUE;
1594     SetLastError( RtlNtStatusToDosError(status) );
1595     return FALSE;
1596 }
1597
1598 /***********************************************************************
1599  *           DisconnectNamedPipe   (KERNEL32.@)
1600  *
1601  *  Disconnects from a named pipe
1602  *
1603  *  Parameters
1604  *  hPipe: A handle to a named pipe returned by CreateNamedPipe
1605  *
1606  *  Return values
1607  *  TRUE: Success
1608  *  FALSE: Failure, GetLastError can be called for further details
1609  */
1610 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
1611 {
1612     NTSTATUS status;
1613     IO_STATUS_BLOCK io_block;
1614
1615     TRACE("(%p)\n",hPipe);
1616
1617     status = NtFsControlFile(hPipe, 0, NULL, NULL, &io_block, FSCTL_PIPE_DISCONNECT,
1618                              NULL, 0, NULL, 0);
1619     if (status == STATUS_SUCCESS) return TRUE;
1620     SetLastError( RtlNtStatusToDosError(status) );
1621     return FALSE;
1622 }
1623
1624 /***********************************************************************
1625  *           TransactNamedPipe   (KERNEL32.@)
1626  *
1627  * BUGS
1628  *  should be done as a single operation in the wineserver or kernel
1629  */
1630 BOOL WINAPI TransactNamedPipe(
1631     HANDLE handle, LPVOID write_buf, DWORD write_size, LPVOID read_buf,
1632     DWORD read_size, LPDWORD bytes_read, LPOVERLAPPED overlapped)
1633 {
1634     BOOL r;
1635     DWORD count;
1636
1637     TRACE("%p %p %d %p %d %p %p\n",
1638           handle, write_buf, write_size, read_buf,
1639           read_size, bytes_read, overlapped);
1640
1641     if (overlapped)
1642     {
1643         FIXME("Doesn't support overlapped operation as yet\n");
1644         return FALSE;
1645     }
1646
1647     r = WriteFile(handle, write_buf, write_size, &count, NULL);
1648     if (r)
1649         r = ReadFile(handle, read_buf, read_size, bytes_read, NULL);
1650
1651     return r;
1652 }
1653
1654 /***********************************************************************
1655  *           GetNamedPipeInfo   (KERNEL32.@)
1656  */
1657 BOOL WINAPI GetNamedPipeInfo(
1658     HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
1659     LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
1660 {
1661     FILE_PIPE_LOCAL_INFORMATION fpli;
1662     IO_STATUS_BLOCK iosb;
1663     NTSTATUS status;
1664
1665     status = NtQueryInformationFile(hNamedPipe, &iosb, &fpli, sizeof(fpli),
1666                                     FilePipeLocalInformation);
1667     if (status)
1668     {
1669         SetLastError( RtlNtStatusToDosError(status) );
1670         return FALSE;
1671     }
1672
1673     if (lpFlags)
1674     {
1675         *lpFlags = (fpli.NamedPipeEnd & FILE_PIPE_SERVER_END) ?
1676             PIPE_SERVER_END : PIPE_CLIENT_END;
1677         *lpFlags |= (fpli.NamedPipeType & FILE_PIPE_TYPE_MESSAGE) ?
1678             PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
1679     }
1680
1681     if (lpOutputBufferSize) *lpOutputBufferSize = fpli.OutboundQuota;
1682     if (lpInputBufferSize) *lpInputBufferSize = fpli.InboundQuota;
1683     if (lpMaxInstances) *lpMaxInstances = fpli.MaximumInstances;
1684
1685     return TRUE;
1686 }
1687
1688 /***********************************************************************
1689  *           GetNamedPipeHandleStateA  (KERNEL32.@)
1690  */
1691 BOOL WINAPI GetNamedPipeHandleStateA(
1692     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1693     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1694     LPSTR lpUsername, DWORD nUsernameMaxSize)
1695 {
1696     FIXME("%p %p %p %p %p %p %d\n",
1697           hNamedPipe, lpState, lpCurInstances,
1698           lpMaxCollectionCount, lpCollectDataTimeout,
1699           lpUsername, nUsernameMaxSize);
1700
1701     return FALSE;
1702 }
1703
1704 /***********************************************************************
1705  *           GetNamedPipeHandleStateW  (KERNEL32.@)
1706  */
1707 BOOL WINAPI GetNamedPipeHandleStateW(
1708     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1709     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1710     LPWSTR lpUsername, DWORD nUsernameMaxSize)
1711 {
1712     FIXME("%p %p %p %p %p %p %d\n",
1713           hNamedPipe, lpState, lpCurInstances,
1714           lpMaxCollectionCount, lpCollectDataTimeout,
1715           lpUsername, nUsernameMaxSize);
1716
1717     return FALSE;
1718 }
1719
1720 /***********************************************************************
1721  *           SetNamedPipeHandleState  (KERNEL32.@)
1722  */
1723 BOOL WINAPI SetNamedPipeHandleState(
1724     HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1725     LPDWORD lpCollectDataTimeout)
1726 {
1727     /* should be a fixme, but this function is called a lot by the RPC
1728      * runtime, and it slows down InstallShield a fair bit. */
1729     WARN("stub: %p %p/%d %p %p\n",
1730           hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
1731     return FALSE;
1732 }
1733
1734 /***********************************************************************
1735  *           CallNamedPipeA  (KERNEL32.@)
1736  */
1737 BOOL WINAPI CallNamedPipeA(
1738     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
1739     LPVOID lpOutput, DWORD dwOutputSize,
1740     LPDWORD lpBytesRead, DWORD nTimeout)
1741 {
1742     DWORD len;
1743     LPWSTR str = NULL;
1744     BOOL ret;
1745
1746     TRACE("%s %p %d %p %d %p %d\n",
1747            debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
1748            lpOutput, dwOutputSize, lpBytesRead, nTimeout);
1749
1750     if( lpNamedPipeName )
1751     {
1752         len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
1753         str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1754         MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
1755     }
1756     ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
1757                           dwOutputSize, lpBytesRead, nTimeout );
1758     if( lpNamedPipeName )
1759         HeapFree( GetProcessHeap(), 0, str );
1760
1761     return ret;
1762 }
1763
1764 /***********************************************************************
1765  *           CallNamedPipeW  (KERNEL32.@)
1766  */
1767 BOOL WINAPI CallNamedPipeW(
1768     LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1769     LPVOID lpOutput, DWORD lpOutputSize,
1770     LPDWORD lpBytesRead, DWORD nTimeout)
1771 {
1772     HANDLE pipe;
1773     BOOL ret;
1774     DWORD mode;
1775
1776     TRACE("%s %p %d %p %d %p %d\n",
1777           debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1778           lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1779
1780     pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1781     if (pipe == INVALID_HANDLE_VALUE)
1782     {
1783         ret = WaitNamedPipeW(lpNamedPipeName, nTimeout);
1784         if (!ret)
1785             return FALSE;
1786         pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1787         if (pipe == INVALID_HANDLE_VALUE)
1788             return FALSE;
1789     }
1790
1791     mode = PIPE_READMODE_MESSAGE;
1792     ret = SetNamedPipeHandleState(pipe, &mode, NULL, NULL);
1793
1794     /* Currently SetNamedPipeHandleState() is a stub returning FALSE */
1795     if (ret) FIXME("Now that SetNamedPipeHandleState() is more than a stub, please update CallNamedPipeW\n");
1796     /*
1797     if (!ret)
1798     {
1799         CloseHandle(pipe);
1800         return FALSE;
1801     }*/
1802
1803     ret = TransactNamedPipe(pipe, lpInput, lpInputSize, lpOutput, lpOutputSize, lpBytesRead, NULL);
1804     CloseHandle(pipe);
1805     if (!ret)
1806         return FALSE;
1807
1808     return TRUE;
1809 }
1810
1811 /******************************************************************
1812  *              CreatePipe (KERNEL32.@)
1813  *
1814  */
1815 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1816                         LPSECURITY_ATTRIBUTES sa, DWORD size )
1817 {
1818     static unsigned     index /* = 0 */;
1819     WCHAR               name[64];
1820     HANDLE              hr, hw;
1821     unsigned            in_index = index;
1822     UNICODE_STRING      nt_name;
1823     OBJECT_ATTRIBUTES   attr;
1824     NTSTATUS            status;
1825     IO_STATUS_BLOCK     iosb;
1826     LARGE_INTEGER       timeout;
1827
1828     *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1829
1830     attr.Length                   = sizeof(attr);
1831     attr.RootDirectory            = 0;
1832     attr.ObjectName               = &nt_name;
1833     attr.Attributes               = OBJ_CASE_INSENSITIVE |
1834                                     ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1835     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
1836     attr.SecurityQualityOfService = NULL;
1837
1838     timeout.QuadPart = (ULONGLONG)NMPWAIT_USE_DEFAULT_WAIT * -10000;
1839     /* generate a unique pipe name (system wide) */
1840     do
1841     {
1842         static const WCHAR nameFmt[] = { '\\','?','?','\\','p','i','p','e',
1843          '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1844          'u','.','%','0','8','u','\0' };
1845
1846         snprintfW(name, sizeof(name) / sizeof(name[0]), nameFmt,
1847                   GetCurrentProcessId(), ++index);
1848         RtlInitUnicodeString(&nt_name, name);
1849         status = NtCreateNamedPipeFile(&hr, GENERIC_READ | SYNCHRONIZE, &attr, &iosb,
1850                                        0, FILE_OVERWRITE_IF,
1851                                        FILE_SYNCHRONOUS_IO_NONALERT | FILE_PIPE_INBOUND,
1852                                        FALSE, FALSE, FALSE,
1853                                        1, size, size, &timeout);
1854         if (status)
1855         {
1856             SetLastError( RtlNtStatusToDosError(status) );
1857             hr = INVALID_HANDLE_VALUE;
1858         }
1859     } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1860     /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1861     if (hr == INVALID_HANDLE_VALUE) return FALSE;
1862
1863     status = NtOpenFile(&hw, GENERIC_WRITE | SYNCHRONIZE, &attr, &iosb, 0,
1864                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
1865
1866     if (status)
1867     {
1868         SetLastError( RtlNtStatusToDosError(status) );
1869         NtClose(hr);
1870         return FALSE;
1871     }
1872
1873     *hReadPipe = hr;
1874     *hWritePipe = hw;
1875     return TRUE;
1876 }
1877
1878
1879 /******************************************************************************
1880  * CreateMailslotA [KERNEL32.@]
1881  *
1882  * See CreateMailslotW.
1883  */
1884 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1885                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1886 {
1887     DWORD len;
1888     HANDLE handle;
1889     LPWSTR name = NULL;
1890
1891     TRACE("%s %d %d %p\n", debugstr_a(lpName),
1892           nMaxMessageSize, lReadTimeout, sa);
1893
1894     if( lpName )
1895     {
1896         len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1897         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1898         MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1899     }
1900
1901     handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1902
1903     HeapFree( GetProcessHeap(), 0, name );
1904
1905     return handle;
1906 }
1907
1908
1909 /******************************************************************************
1910  * CreateMailslotW [KERNEL32.@]
1911  *
1912  * Create a mailslot with specified name.
1913  *
1914  * PARAMS
1915  *    lpName          [I] Pointer to string for mailslot name
1916  *    nMaxMessageSize [I] Maximum message size
1917  *    lReadTimeout    [I] Milliseconds before read time-out
1918  *    sa              [I] Pointer to security structure
1919  *
1920  * RETURNS
1921  *    Success: Handle to mailslot
1922  *    Failure: INVALID_HANDLE_VALUE
1923  */
1924 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
1925                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1926 {
1927     HANDLE handle = INVALID_HANDLE_VALUE;
1928     OBJECT_ATTRIBUTES attr;
1929     UNICODE_STRING nameW;
1930     LARGE_INTEGER timeout;
1931     IO_STATUS_BLOCK iosb;
1932     NTSTATUS status;
1933
1934     TRACE("%s %d %d %p\n", debugstr_w(lpName),
1935           nMaxMessageSize, lReadTimeout, sa);
1936
1937     if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
1938     {
1939         SetLastError( ERROR_PATH_NOT_FOUND );
1940         return INVALID_HANDLE_VALUE;
1941     }
1942
1943     if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
1944     {
1945         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1946         RtlFreeUnicodeString( &nameW );
1947         return INVALID_HANDLE_VALUE;
1948     }
1949
1950     attr.Length = sizeof(attr);
1951     attr.RootDirectory = 0;
1952     attr.Attributes = OBJ_CASE_INSENSITIVE;
1953     attr.ObjectName = &nameW;
1954     attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1955     attr.SecurityQualityOfService = NULL;
1956
1957     if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
1958         timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
1959     else
1960         timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1961
1962     status = NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
1963                                    &iosb, 0, 0, nMaxMessageSize, &timeout );
1964     if (status)
1965     {
1966         SetLastError( RtlNtStatusToDosError(status) );
1967         handle = INVALID_HANDLE_VALUE;
1968     }
1969
1970     RtlFreeUnicodeString( &nameW );
1971     return handle;
1972 }
1973
1974
1975 /******************************************************************************
1976  * GetMailslotInfo [KERNEL32.@]
1977  *
1978  * Retrieve information about a mailslot.
1979  *
1980  * PARAMS
1981  *    hMailslot        [I] Mailslot handle
1982  *    lpMaxMessageSize [O] Address of maximum message size
1983  *    lpNextSize       [O] Address of size of next message
1984  *    lpMessageCount   [O] Address of number of messages
1985  *    lpReadTimeout    [O] Address of read time-out
1986  *
1987  * RETURNS
1988  *    Success: TRUE
1989  *    Failure: FALSE
1990  */
1991 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
1992                                LPDWORD lpNextSize, LPDWORD lpMessageCount,
1993                                LPDWORD lpReadTimeout )
1994 {
1995     FILE_MAILSLOT_QUERY_INFORMATION info;
1996     IO_STATUS_BLOCK iosb;
1997     NTSTATUS status;
1998
1999     TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
2000           lpNextSize, lpMessageCount, lpReadTimeout);
2001
2002     status = NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
2003                                      FileMailslotQueryInformation );
2004
2005     if( status != STATUS_SUCCESS )
2006     {
2007         SetLastError( RtlNtStatusToDosError(status) );
2008         return FALSE;
2009     }
2010
2011     if( lpMaxMessageSize )
2012         *lpMaxMessageSize = info.MaximumMessageSize;
2013     if( lpNextSize )
2014         *lpNextSize = info.NextMessageSize;
2015     if( lpMessageCount )
2016         *lpMessageCount = info.MessagesAvailable;
2017     if( lpReadTimeout )
2018     {
2019         if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
2020             *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
2021         else
2022             *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
2023     }
2024     return TRUE;
2025 }
2026
2027
2028 /******************************************************************************
2029  * SetMailslotInfo [KERNEL32.@]
2030  *
2031  * Set the read timeout of a mailslot.
2032  *
2033  * PARAMS
2034  *  hMailslot     [I] Mailslot handle
2035  *  dwReadTimeout [I] Timeout in milliseconds.
2036  *
2037  * RETURNS
2038  *    Success: TRUE
2039  *    Failure: FALSE
2040  */
2041 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
2042 {
2043     FILE_MAILSLOT_SET_INFORMATION info;
2044     IO_STATUS_BLOCK iosb;
2045     NTSTATUS status;
2046
2047     TRACE("%p %d\n", hMailslot, dwReadTimeout);
2048
2049     if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
2050         info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
2051     else
2052         info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
2053     status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
2054                                    FileMailslotSetInformation );
2055     if( status != STATUS_SUCCESS )
2056     {
2057         SetLastError( RtlNtStatusToDosError(status) );
2058         return FALSE;
2059     }
2060     return TRUE;
2061 }
2062
2063
2064 /******************************************************************************
2065  *              CreateIoCompletionPort (KERNEL32.@)
2066  */
2067 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
2068                                      ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
2069 {
2070     NTSTATUS status;
2071     HANDLE ret = 0;
2072
2073     TRACE("(%p, %p, %08lx, %08x)\n",
2074           hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
2075
2076     if (hExistingCompletionPort && hFileHandle == INVALID_HANDLE_VALUE)
2077     {
2078         SetLastError( ERROR_INVALID_PARAMETER);
2079         return NULL;
2080     }
2081
2082     if (hExistingCompletionPort)
2083         ret = hExistingCompletionPort;
2084     else
2085     {
2086         status = NtCreateIoCompletion( &ret, IO_COMPLETION_ALL_ACCESS, NULL, dwNumberOfConcurrentThreads );
2087         if (status != STATUS_SUCCESS) goto fail;
2088     }
2089
2090     if (hFileHandle != INVALID_HANDLE_VALUE)
2091     {
2092         FILE_COMPLETION_INFORMATION info;
2093         IO_STATUS_BLOCK iosb;
2094
2095         info.CompletionPort = ret;
2096         info.CompletionKey = CompletionKey;
2097         status = NtSetInformationFile( hFileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
2098         if (status != STATUS_SUCCESS) goto fail;
2099     }
2100
2101     return ret;
2102
2103 fail:
2104     if (ret && !hExistingCompletionPort)
2105         CloseHandle( ret );
2106     SetLastError( RtlNtStatusToDosError(status) );
2107     return 0;
2108 }
2109
2110 /******************************************************************************
2111  *              GetQueuedCompletionStatus (KERNEL32.@)
2112  */
2113 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
2114                                        PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
2115                                        DWORD dwMilliseconds )
2116 {
2117     NTSTATUS status;
2118     IO_STATUS_BLOCK iosb;
2119     LARGE_INTEGER wait_time;
2120
2121     TRACE("(%p,%p,%p,%p,%d)\n",
2122           CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
2123
2124     *lpOverlapped = NULL;
2125
2126     status = NtRemoveIoCompletion( CompletionPort, pCompletionKey, (PULONG_PTR)lpOverlapped,
2127                                    &iosb, get_nt_timeout( &wait_time, dwMilliseconds ) );
2128     if (status == STATUS_SUCCESS)
2129     {
2130         *lpNumberOfBytesTransferred = iosb.Information;
2131         if (iosb.u.Status >= 0) return TRUE;
2132         SetLastError( RtlNtStatusToDosError(iosb.u.Status) );
2133         return FALSE;
2134     }
2135
2136     if (status == STATUS_TIMEOUT) SetLastError( WAIT_TIMEOUT );
2137     else SetLastError( RtlNtStatusToDosError(status) );
2138     return FALSE;
2139 }
2140
2141
2142 /******************************************************************************
2143  *              PostQueuedCompletionStatus (KERNEL32.@)
2144  */
2145 BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
2146                                         ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
2147 {
2148     NTSTATUS status;
2149
2150     TRACE("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
2151
2152     status = NtSetIoCompletion( CompletionPort, dwCompletionKey, (ULONG_PTR)lpOverlapped,
2153                                 STATUS_SUCCESS, dwNumberOfBytes );
2154
2155     if (status == STATUS_SUCCESS) return TRUE;
2156     SetLastError( RtlNtStatusToDosError(status) );
2157     return FALSE;
2158 }
2159
2160 /******************************************************************************
2161  *              BindIoCompletionCallback (KERNEL32.@)
2162  */
2163 BOOL WINAPI BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
2164 {
2165     NTSTATUS status;
2166
2167     TRACE("(%p, %p, %d)\n", FileHandle, Function, Flags);
2168
2169     status = RtlSetIoCompletionCallback( FileHandle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)Function, Flags );
2170     if (status == STATUS_SUCCESS) return TRUE;
2171     SetLastError( RtlNtStatusToDosError(status) );
2172     return FALSE;
2173 }
2174
2175
2176 /***********************************************************************
2177  *           CreateMemoryResourceNotification   (KERNEL32.@)
2178  */
2179 HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE nt)
2180 {
2181     FIXME("(%d) stub\n", nt);
2182     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2183     return NULL;
2184 }
2185
2186 /***********************************************************************
2187  *          QueryMemoryResourceNotification   (KERNEL32.@)
2188  */
2189 BOOL WINAPI QueryMemoryResourceNotification(HANDLE rnh, PBOOL rs)
2190 {
2191     FIXME("(%p, %p) stub\n", rnh, rs);
2192     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2193     return 0;
2194 }
2195
2196 #ifdef __i386__
2197
2198 /***********************************************************************
2199  *              InterlockedCompareExchange (KERNEL32.@)
2200  */
2201 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2202 __ASM_STDCALL_FUNC(InterlockedCompareExchange, 12,
2203                   "movl 12(%esp),%eax\n\t"
2204                   "movl 8(%esp),%ecx\n\t"
2205                   "movl 4(%esp),%edx\n\t"
2206                   "lock; cmpxchgl %ecx,(%edx)\n\t"
2207                   "ret $12")
2208
2209 /***********************************************************************
2210  *              InterlockedExchange (KERNEL32.@)
2211  */
2212 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2213 __ASM_STDCALL_FUNC(InterlockedExchange, 8,
2214                   "movl 8(%esp),%eax\n\t"
2215                   "movl 4(%esp),%edx\n\t"
2216                   "lock; xchgl %eax,(%edx)\n\t"
2217                   "ret $8")
2218
2219 /***********************************************************************
2220  *              InterlockedExchangeAdd (KERNEL32.@)
2221  */
2222 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2223 __ASM_STDCALL_FUNC(InterlockedExchangeAdd, 8,
2224                   "movl 8(%esp),%eax\n\t"
2225                   "movl 4(%esp),%edx\n\t"
2226                   "lock; xaddl %eax,(%edx)\n\t"
2227                   "ret $8")
2228
2229 /***********************************************************************
2230  *              InterlockedIncrement (KERNEL32.@)
2231  */
2232 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2233 __ASM_STDCALL_FUNC(InterlockedIncrement, 4,
2234                   "movl 4(%esp),%edx\n\t"
2235                   "movl $1,%eax\n\t"
2236                   "lock; xaddl %eax,(%edx)\n\t"
2237                   "incl %eax\n\t"
2238                   "ret $4")
2239
2240 /***********************************************************************
2241  *              InterlockedDecrement (KERNEL32.@)
2242  */
2243 __ASM_STDCALL_FUNC(InterlockedDecrement, 4,
2244                   "movl 4(%esp),%edx\n\t"
2245                   "movl $-1,%eax\n\t"
2246                   "lock; xaddl %eax,(%edx)\n\t"
2247                   "decl %eax\n\t"
2248                   "ret $4")
2249
2250 #endif  /* __i386__ */