git.oblomov.eu Git - wine/blob - 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, sharing;
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         sharing = FILE_SHARE_WRITE;
1383         access  = GENERIC_READ;
1384         break;
1385     case PIPE_ACCESS_OUTBOUND:
1386         sharing = FILE_SHARE_READ;
1387         access  = GENERIC_WRITE;
1388         break;
1389     case PIPE_ACCESS_DUPLEX:
1390         sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
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     options = 0;
1399     if (dwOpenMode & FILE_FLAG_WRITE_THROUGH) options |= FILE_WRITE_THROUGH;
1400     if (!(dwOpenMode & FILE_FLAG_OVERLAPPED)) options |= FILE_SYNCHRONOUS_IO_NONALERT;
1401     pipe_type = (dwPipeMode & PIPE_TYPE_MESSAGE) ? TRUE : FALSE;
1402     read_mode = (dwPipeMode & PIPE_READMODE_MESSAGE) ? TRUE : FALSE;
1403     non_block = (dwPipeMode & PIPE_NOWAIT) ? TRUE : FALSE;
1404     if (nMaxInstances >= PIPE_UNLIMITED_INSTANCES) nMaxInstances = ~0U;
1405
1406     timeout.QuadPart = (ULONGLONG)nDefaultTimeOut * -10000;
1407
1408     SetLastError(0);
1409
1410     status = NtCreateNamedPipeFile(&handle, access, &attr, &iosb, sharing,
1411                                    FILE_OVERWRITE_IF, options, pipe_type,
1412                                    read_mode, non_block, nMaxInstances,
1413                                    nInBufferSize, nOutBufferSize, &timeout);
1414
1415     RtlFreeUnicodeString( &nt_name );
1416     if (status)
1417     {
1418         handle = INVALID_HANDLE_VALUE;
1419         SetLastError( RtlNtStatusToDosError(status) );
1420     }
1421     return handle;
1422 }
1423
1424
1425 /***********************************************************************
1426  *           PeekNamedPipe   (KERNEL32.@)
1427  */
1428 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
1429                            LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
1430 {
1431     FILE_PIPE_PEEK_BUFFER local_buffer;
1432     FILE_PIPE_PEEK_BUFFER *buffer = &local_buffer;
1433     IO_STATUS_BLOCK io;
1434     NTSTATUS status;
1435
1436     if (cbBuffer && !(buffer = HeapAlloc( GetProcessHeap(), 0,
1437                                           FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ))))
1438     {
1439         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1440         return FALSE;
1441     }
1442
1443     status = NtFsControlFile( hPipe, 0, NULL, NULL, &io, FSCTL_PIPE_PEEK, NULL, 0,
1444                               buffer, FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ) );
1445     if (!status)
1446     {
1447         ULONG read_size = io.Information - FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data );
1448         if (lpcbAvail) *lpcbAvail = buffer->ReadDataAvailable;
1449         if (lpcbRead) *lpcbRead = read_size;
1450         if (lpcbMessage) *lpcbMessage = 0;  /* FIXME */
1451         if (lpvBuffer) memcpy( lpvBuffer, buffer->Data, read_size );
1452     }
1453     else SetLastError( RtlNtStatusToDosError(status) );
1454
1455     if (buffer != &local_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1456     return !status;
1457 }
1458
1459 /***********************************************************************
1460  *           WaitNamedPipeA   (KERNEL32.@)
1461  */
1462 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
1463 {
1464     WCHAR buffer[MAX_PATH];
1465
1466     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
1467
1468     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1469     {
1470         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1471         return 0;
1472     }
1473     return WaitNamedPipeW( buffer, nTimeOut );
1474 }
1475
1476
1477 /***********************************************************************
1478  *           WaitNamedPipeW   (KERNEL32.@)
1479  *
1480  *  Waits for a named pipe instance to become available
1481  *
1482  *  PARAMS
1483  *   name     [I] Pointer to a named pipe name to wait for
1484  *   nTimeOut [I] How long to wait in ms
1485  *
1486  *  RETURNS
1487  *   TRUE: Success, named pipe can be opened with CreateFile
1488  *   FALSE: Failure, GetLastError can be called for further details
1489  */
1490 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
1491 {
1492     static const WCHAR leadin[] = {'\\','?','?','\\','P','I','P','E','\\'};
1493     NTSTATUS status;
1494     UNICODE_STRING nt_name, pipe_dev_name;
1495     FILE_PIPE_WAIT_FOR_BUFFER *pipe_wait;
1496     IO_STATUS_BLOCK iosb;
1497     OBJECT_ATTRIBUTES attr;
1498     ULONG sz_pipe_wait;
1499     HANDLE pipe_dev;
1500
1501     TRACE("%s 0x%08x\n",debugstr_w(name),nTimeOut);
1502
1503     if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1504         return FALSE;
1505
1506     if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) ||
1507         nt_name.Length < sizeof(leadin) ||
1508         strncmpiW( nt_name.Buffer, leadin, sizeof(leadin)/sizeof(WCHAR)) != 0)
1509     {
1510         RtlFreeUnicodeString( &nt_name );
1511         SetLastError( ERROR_PATH_NOT_FOUND );
1512         return FALSE;
1513     }
1514
1515     sz_pipe_wait = sizeof(*pipe_wait) + nt_name.Length - sizeof(leadin) - sizeof(WCHAR);
1516     if (!(pipe_wait = HeapAlloc( GetProcessHeap(), 0,  sz_pipe_wait)))
1517     {
1518         RtlFreeUnicodeString( &nt_name );
1519         SetLastError( ERROR_OUTOFMEMORY );
1520         return FALSE;
1521     }
1522
1523     pipe_dev_name.Buffer = nt_name.Buffer;
1524     pipe_dev_name.Length = sizeof(leadin);
1525     pipe_dev_name.MaximumLength = sizeof(leadin);
1526     InitializeObjectAttributes(&attr,&pipe_dev_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1527     status = NtOpenFile( &pipe_dev, FILE_READ_ATTRIBUTES, &attr,
1528                          &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
1529                          FILE_SYNCHRONOUS_IO_NONALERT);
1530     if (status != ERROR_SUCCESS)
1531     {
1532         HeapFree( GetProcessHeap(), 0, pipe_wait);
1533         RtlFreeUnicodeString( &nt_name );
1534         SetLastError( ERROR_PATH_NOT_FOUND );
1535         return FALSE;
1536     }
1537
1538     pipe_wait->TimeoutSpecified = !(nTimeOut == NMPWAIT_USE_DEFAULT_WAIT);
1539     if (nTimeOut == NMPWAIT_WAIT_FOREVER)
1540         pipe_wait->Timeout.QuadPart = ((ULONGLONG)0x7fffffff << 32) | 0xffffffff;
1541     else
1542         pipe_wait->Timeout.QuadPart = (ULONGLONG)nTimeOut * -10000;
1543     pipe_wait->NameLength = nt_name.Length - sizeof(leadin);
1544     memcpy(pipe_wait->Name, nt_name.Buffer + sizeof(leadin)/sizeof(WCHAR),
1545            pipe_wait->NameLength);
1546     RtlFreeUnicodeString( &nt_name );
1547
1548     status = NtFsControlFile( pipe_dev, NULL, NULL, NULL, &iosb, FSCTL_PIPE_WAIT,
1549                               pipe_wait, sz_pipe_wait, NULL, 0 );
1550
1551     HeapFree( GetProcessHeap(), 0, pipe_wait );
1552     NtClose( pipe_dev );
1553
1554     if(status != STATUS_SUCCESS)
1555     {
1556         SetLastError(RtlNtStatusToDosError(status));
1557         return FALSE;
1558     }
1559     else
1560         return TRUE;
1561 }
1562
1563
1564 /***********************************************************************
1565  *           ConnectNamedPipe   (KERNEL32.@)
1566  *
1567  *  Connects to a named pipe
1568  *
1569  *  Parameters
1570  *  hPipe: A handle to a named pipe returned by CreateNamedPipe
1571  *  overlapped: Optional OVERLAPPED struct
1572  *
1573  *  Return values
1574  *  TRUE: Success
1575  *  FALSE: Failure, GetLastError can be called for further details
1576  */
1577 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1578 {
1579     NTSTATUS status;
1580     IO_STATUS_BLOCK status_block;
1581     LPVOID   cvalue = NULL;
1582
1583     TRACE("(%p,%p)\n", hPipe, overlapped);
1584
1585     if(overlapped)
1586     {
1587         overlapped->Internal = STATUS_PENDING;
1588         overlapped->InternalHigh = 0;
1589         if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
1590     }
1591
1592     status = NtFsControlFile(hPipe, overlapped ? overlapped->hEvent : NULL, NULL, cvalue,
1593                              overlapped ? (IO_STATUS_BLOCK *)overlapped : &status_block,
1594                              FSCTL_PIPE_LISTEN, NULL, 0, NULL, 0);
1595
1596     if (status == STATUS_SUCCESS) return TRUE;
1597     SetLastError( RtlNtStatusToDosError(status) );
1598     return FALSE;
1599 }
1600
1601 /***********************************************************************
1602  *           DisconnectNamedPipe   (KERNEL32.@)
1603  *
1604  *  Disconnects from a named pipe
1605  *
1606  *  Parameters
1607  *  hPipe: A handle to a named pipe returned by CreateNamedPipe
1608  *
1609  *  Return values
1610  *  TRUE: Success
1611  *  FALSE: Failure, GetLastError can be called for further details
1612  */
1613 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
1614 {
1615     NTSTATUS status;
1616     IO_STATUS_BLOCK io_block;
1617
1618     TRACE("(%p)\n",hPipe);
1619
1620     status = NtFsControlFile(hPipe, 0, NULL, NULL, &io_block, FSCTL_PIPE_DISCONNECT,
1621                              NULL, 0, NULL, 0);
1622     if (status == STATUS_SUCCESS) return TRUE;
1623     SetLastError( RtlNtStatusToDosError(status) );
1624     return FALSE;
1625 }
1626
1627 /***********************************************************************
1628  *           TransactNamedPipe   (KERNEL32.@)
1629  *
1630  * BUGS
1631  *  should be done as a single operation in the wineserver or kernel
1632  */
1633 BOOL WINAPI TransactNamedPipe(
1634     HANDLE handle, LPVOID write_buf, DWORD write_size, LPVOID read_buf,
1635     DWORD read_size, LPDWORD bytes_read, LPOVERLAPPED overlapped)
1636 {
1637     BOOL r;
1638     DWORD count;
1639
1640     TRACE("%p %p %d %p %d %p %p\n",
1641           handle, write_buf, write_size, read_buf,
1642           read_size, bytes_read, overlapped);
1643
1644     if (overlapped)
1645     {
1646         FIXME("Doesn't support overlapped operation as yet\n");
1647         return FALSE;
1648     }
1649
1650     r = WriteFile(handle, write_buf, write_size, &count, NULL);
1651     if (r)
1652         r = ReadFile(handle, read_buf, read_size, bytes_read, NULL);
1653
1654     return r;
1655 }
1656
1657 /***********************************************************************
1658  *           GetNamedPipeInfo   (KERNEL32.@)
1659  */
1660 BOOL WINAPI GetNamedPipeInfo(
1661     HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
1662     LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
1663 {
1664     FILE_PIPE_LOCAL_INFORMATION fpli;
1665     IO_STATUS_BLOCK iosb;
1666     NTSTATUS status;
1667
1668     status = NtQueryInformationFile(hNamedPipe, &iosb, &fpli, sizeof(fpli),
1669                                     FilePipeLocalInformation);
1670     if (status)
1671     {
1672         SetLastError( RtlNtStatusToDosError(status) );
1673         return FALSE;
1674     }
1675
1676     if (lpFlags)
1677     {
1678         *lpFlags = (fpli.NamedPipeEnd & FILE_PIPE_SERVER_END) ?
1679             PIPE_SERVER_END : PIPE_CLIENT_END;
1680         *lpFlags |= (fpli.NamedPipeType & FILE_PIPE_TYPE_MESSAGE) ?
1681             PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
1682     }
1683
1684     if (lpOutputBufferSize) *lpOutputBufferSize = fpli.OutboundQuota;
1685     if (lpInputBufferSize) *lpInputBufferSize = fpli.InboundQuota;
1686     if (lpMaxInstances) *lpMaxInstances = fpli.MaximumInstances;
1687
1688     return TRUE;
1689 }
1690
1691 /***********************************************************************
1692  *           GetNamedPipeHandleStateA  (KERNEL32.@)
1693  */
1694 BOOL WINAPI GetNamedPipeHandleStateA(
1695     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1696     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1697     LPSTR lpUsername, DWORD nUsernameMaxSize)
1698 {
1699     FIXME("%p %p %p %p %p %p %d\n",
1700           hNamedPipe, lpState, lpCurInstances,
1701           lpMaxCollectionCount, lpCollectDataTimeout,
1702           lpUsername, nUsernameMaxSize);
1703
1704     return FALSE;
1705 }
1706
1707 /***********************************************************************
1708  *           GetNamedPipeHandleStateW  (KERNEL32.@)
1709  */
1710 BOOL WINAPI GetNamedPipeHandleStateW(
1711     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1712     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1713     LPWSTR lpUsername, DWORD nUsernameMaxSize)
1714 {
1715     FIXME("%p %p %p %p %p %p %d\n",
1716           hNamedPipe, lpState, lpCurInstances,
1717           lpMaxCollectionCount, lpCollectDataTimeout,
1718           lpUsername, nUsernameMaxSize);
1719
1720     return FALSE;
1721 }
1722
1723 /***********************************************************************
1724  *           SetNamedPipeHandleState  (KERNEL32.@)
1725  */
1726 BOOL WINAPI SetNamedPipeHandleState(
1727     HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1728     LPDWORD lpCollectDataTimeout)
1729 {
1730     /* should be a fixme, but this function is called a lot by the RPC
1731      * runtime, and it slows down InstallShield a fair bit. */
1732     WARN("stub: %p %p/%d %p %p\n",
1733           hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
1734     return FALSE;
1735 }
1736
1737 /***********************************************************************
1738  *           CallNamedPipeA  (KERNEL32.@)
1739  */
1740 BOOL WINAPI CallNamedPipeA(
1741     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
1742     LPVOID lpOutput, DWORD dwOutputSize,
1743     LPDWORD lpBytesRead, DWORD nTimeout)
1744 {
1745     DWORD len;
1746     LPWSTR str = NULL;
1747     BOOL ret;
1748
1749     TRACE("%s %p %d %p %d %p %d\n",
1750            debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
1751            lpOutput, dwOutputSize, lpBytesRead, nTimeout);
1752
1753     if( lpNamedPipeName )
1754     {
1755         len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
1756         str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1757         MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
1758     }
1759     ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
1760                           dwOutputSize, lpBytesRead, nTimeout );
1761     if( lpNamedPipeName )
1762         HeapFree( GetProcessHeap(), 0, str );
1763
1764     return ret;
1765 }
1766
1767 /***********************************************************************
1768  *           CallNamedPipeW  (KERNEL32.@)
1769  */
1770 BOOL WINAPI CallNamedPipeW(
1771     LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1772     LPVOID lpOutput, DWORD lpOutputSize,
1773     LPDWORD lpBytesRead, DWORD nTimeout)
1774 {
1775     HANDLE pipe;
1776     BOOL ret;
1777     DWORD mode;
1778
1779     TRACE("%s %p %d %p %d %p %d\n",
1780           debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1781           lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1782
1783     pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1784     if (pipe == INVALID_HANDLE_VALUE)
1785     {
1786         ret = WaitNamedPipeW(lpNamedPipeName, nTimeout);
1787         if (!ret)
1788             return FALSE;
1789         pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1790         if (pipe == INVALID_HANDLE_VALUE)
1791             return FALSE;
1792     }
1793
1794     mode = PIPE_READMODE_MESSAGE;
1795     ret = SetNamedPipeHandleState(pipe, &mode, NULL, NULL);
1796
1797     /* Currently SetNamedPipeHandleState() is a stub returning FALSE */
1798     if (ret) FIXME("Now that SetNamedPipeHandleState() is more than a stub, please update CallNamedPipeW\n");
1799     /*
1800     if (!ret)
1801     {
1802         CloseHandle(pipe);
1803         return FALSE;
1804     }*/
1805
1806     ret = TransactNamedPipe(pipe, lpInput, lpInputSize, lpOutput, lpOutputSize, lpBytesRead, NULL);
1807     CloseHandle(pipe);
1808     if (!ret)
1809         return FALSE;
1810
1811     return TRUE;
1812 }
1813
1814 /******************************************************************
1815  *              CreatePipe (KERNEL32.@)
1816  *
1817  */
1818 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1819                         LPSECURITY_ATTRIBUTES sa, DWORD size )
1820 {
1821     static unsigned     index /* = 0 */;
1822     WCHAR               name[64];
1823     HANDLE              hr, hw;
1824     unsigned            in_index = index;
1825     UNICODE_STRING      nt_name;
1826     OBJECT_ATTRIBUTES   attr;
1827     NTSTATUS            status;
1828     IO_STATUS_BLOCK     iosb;
1829     LARGE_INTEGER       timeout;
1830
1831     *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1832
1833     attr.Length                   = sizeof(attr);
1834     attr.RootDirectory            = 0;
1835     attr.ObjectName               = &nt_name;
1836     attr.Attributes               = OBJ_CASE_INSENSITIVE |
1837                                     ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1838     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
1839     attr.SecurityQualityOfService = NULL;
1840
1841     timeout.QuadPart = (ULONGLONG)NMPWAIT_USE_DEFAULT_WAIT * -10000;
1842     /* generate a unique pipe name (system wide) */
1843     do
1844     {
1845         static const WCHAR nameFmt[] = { '\\','?','?','\\','p','i','p','e',
1846          '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1847          'u','.','%','0','8','u','\0' };
1848
1849         snprintfW(name, sizeof(name) / sizeof(name[0]), nameFmt,
1850                   GetCurrentProcessId(), ++index);
1851         RtlInitUnicodeString(&nt_name, name);
1852         status = NtCreateNamedPipeFile(&hr, GENERIC_READ | SYNCHRONIZE, &attr, &iosb,
1853                                        FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
1854                                        FILE_SYNCHRONOUS_IO_NONALERT,
1855                                        FALSE, FALSE, FALSE,
1856                                        1, size, size, &timeout);
1857         if (status)
1858         {
1859             SetLastError( RtlNtStatusToDosError(status) );
1860             hr = INVALID_HANDLE_VALUE;
1861         }
1862     } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1863     /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1864     if (hr == INVALID_HANDLE_VALUE) return FALSE;
1865
1866     status = NtOpenFile(&hw, GENERIC_WRITE | SYNCHRONIZE, &attr, &iosb, 0,
1867                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
1868
1869     if (status)
1870     {
1871         SetLastError( RtlNtStatusToDosError(status) );
1872         NtClose(hr);
1873         return FALSE;
1874     }
1875
1876     *hReadPipe = hr;
1877     *hWritePipe = hw;
1878     return TRUE;
1879 }
1880
1881
1882 /******************************************************************************
1883  * CreateMailslotA [KERNEL32.@]
1884  *
1885  * See CreateMailslotW.
1886  */
1887 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1888                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1889 {
1890     DWORD len;
1891     HANDLE handle;
1892     LPWSTR name = NULL;
1893
1894     TRACE("%s %d %d %p\n", debugstr_a(lpName),
1895           nMaxMessageSize, lReadTimeout, sa);
1896
1897     if( lpName )
1898     {
1899         len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1900         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1901         MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1902     }
1903
1904     handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1905
1906     HeapFree( GetProcessHeap(), 0, name );
1907
1908     return handle;
1909 }
1910
1911
1912 /******************************************************************************
1913  * CreateMailslotW [KERNEL32.@]
1914  *
1915  * Create a mailslot with specified name.
1916  *
1917  * PARAMS
1918  *    lpName          [I] Pointer to string for mailslot name
1919  *    nMaxMessageSize [I] Maximum message size
1920  *    lReadTimeout    [I] Milliseconds before read time-out
1921  *    sa              [I] Pointer to security structure
1922  *
1923  * RETURNS
1924  *    Success: Handle to mailslot
1925  *    Failure: INVALID_HANDLE_VALUE
1926  */
1927 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
1928                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1929 {
1930     HANDLE handle = INVALID_HANDLE_VALUE;
1931     OBJECT_ATTRIBUTES attr;
1932     UNICODE_STRING nameW;
1933     LARGE_INTEGER timeout;
1934     IO_STATUS_BLOCK iosb;
1935     NTSTATUS status;
1936
1937     TRACE("%s %d %d %p\n", debugstr_w(lpName),
1938           nMaxMessageSize, lReadTimeout, sa);
1939
1940     if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
1941     {
1942         SetLastError( ERROR_PATH_NOT_FOUND );
1943         return INVALID_HANDLE_VALUE;
1944     }
1945
1946     if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
1947     {
1948         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1949         RtlFreeUnicodeString( &nameW );
1950         return INVALID_HANDLE_VALUE;
1951     }
1952
1953     attr.Length = sizeof(attr);
1954     attr.RootDirectory = 0;
1955     attr.Attributes = OBJ_CASE_INSENSITIVE;
1956     attr.ObjectName = &nameW;
1957     attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1958     attr.SecurityQualityOfService = NULL;
1959
1960     if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
1961         timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
1962     else
1963         timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1964
1965     status = NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
1966                                    &iosb, 0, 0, nMaxMessageSize, &timeout );
1967     if (status)
1968     {
1969         SetLastError( RtlNtStatusToDosError(status) );
1970         handle = INVALID_HANDLE_VALUE;
1971     }
1972
1973     RtlFreeUnicodeString( &nameW );
1974     return handle;
1975 }
1976
1977
1978 /******************************************************************************
1979  * GetMailslotInfo [KERNEL32.@]
1980  *
1981  * Retrieve information about a mailslot.
1982  *
1983  * PARAMS
1984  *    hMailslot        [I] Mailslot handle
1985  *    lpMaxMessageSize [O] Address of maximum message size
1986  *    lpNextSize       [O] Address of size of next message
1987  *    lpMessageCount   [O] Address of number of messages
1988  *    lpReadTimeout    [O] Address of read time-out
1989  *
1990  * RETURNS
1991  *    Success: TRUE
1992  *    Failure: FALSE
1993  */
1994 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
1995                                LPDWORD lpNextSize, LPDWORD lpMessageCount,
1996                                LPDWORD lpReadTimeout )
1997 {
1998     FILE_MAILSLOT_QUERY_INFORMATION info;
1999     IO_STATUS_BLOCK iosb;
2000     NTSTATUS status;
2001
2002     TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
2003           lpNextSize, lpMessageCount, lpReadTimeout);
2004
2005     status = NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
2006                                      FileMailslotQueryInformation );
2007
2008     if( status != STATUS_SUCCESS )
2009     {
2010         SetLastError( RtlNtStatusToDosError(status) );
2011         return FALSE;
2012     }
2013
2014     if( lpMaxMessageSize )
2015         *lpMaxMessageSize = info.MaximumMessageSize;
2016     if( lpNextSize )
2017         *lpNextSize = info.NextMessageSize;
2018     if( lpMessageCount )
2019         *lpMessageCount = info.MessagesAvailable;
2020     if( lpReadTimeout )
2021     {
2022         if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
2023             *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
2024         else
2025             *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
2026     }
2027     return TRUE;
2028 }
2029
2030
2031 /******************************************************************************
2032  * SetMailslotInfo [KERNEL32.@]
2033  *
2034  * Set the read timeout of a mailslot.
2035  *
2036  * PARAMS
2037  *  hMailslot     [I] Mailslot handle
2038  *  dwReadTimeout [I] Timeout in milliseconds.
2039  *
2040  * RETURNS
2041  *    Success: TRUE
2042  *    Failure: FALSE
2043  */
2044 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
2045 {
2046     FILE_MAILSLOT_SET_INFORMATION info;
2047     IO_STATUS_BLOCK iosb;
2048     NTSTATUS status;
2049
2050     TRACE("%p %d\n", hMailslot, dwReadTimeout);
2051
2052     if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
2053         info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
2054     else
2055         info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
2056     status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
2057                                    FileMailslotSetInformation );
2058     if( status != STATUS_SUCCESS )
2059     {
2060         SetLastError( RtlNtStatusToDosError(status) );
2061         return FALSE;
2062     }
2063     return TRUE;
2064 }
2065
2066
2067 /******************************************************************************
2068  *              CreateIoCompletionPort (KERNEL32.@)
2069  */
2070 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
2071                                      ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
2072 {
2073     NTSTATUS status;
2074     HANDLE ret = 0;
2075
2076     TRACE("(%p, %p, %08lx, %08x)\n",
2077           hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
2078
2079     if (hExistingCompletionPort && hFileHandle == INVALID_HANDLE_VALUE)
2080     {
2081         SetLastError( ERROR_INVALID_PARAMETER);
2082         return NULL;
2083     }
2084
2085     if (hExistingCompletionPort)
2086         ret = hExistingCompletionPort;
2087     else
2088     {
2089         status = NtCreateIoCompletion( &ret, IO_COMPLETION_ALL_ACCESS, NULL, dwNumberOfConcurrentThreads );
2090         if (status != STATUS_SUCCESS) goto fail;
2091     }
2092
2093     if (hFileHandle != INVALID_HANDLE_VALUE)
2094     {
2095         FILE_COMPLETION_INFORMATION info;
2096         IO_STATUS_BLOCK iosb;
2097
2098         info.CompletionPort = ret;
2099         info.CompletionKey = CompletionKey;
2100         status = NtSetInformationFile( hFileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
2101         if (status != STATUS_SUCCESS) goto fail;
2102     }
2103
2104     return ret;
2105
2106 fail:
2107     if (ret && !hExistingCompletionPort)
2108         CloseHandle( ret );
2109     SetLastError( RtlNtStatusToDosError(status) );
2110     return 0;
2111 }
2112
2113 /******************************************************************************
2114  *              GetQueuedCompletionStatus (KERNEL32.@)
2115  */
2116 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
2117                                        PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
2118                                        DWORD dwMilliseconds )
2119 {
2120     NTSTATUS status;
2121     IO_STATUS_BLOCK iosb;
2122     LARGE_INTEGER wait_time;
2123
2124     TRACE("(%p,%p,%p,%p,%d)\n",
2125           CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
2126
2127     *lpOverlapped = NULL;
2128
2129     status = NtRemoveIoCompletion( CompletionPort, pCompletionKey, (PULONG_PTR)lpOverlapped,
2130                                    &iosb, get_nt_timeout( &wait_time, dwMilliseconds ) );
2131     if (status == STATUS_SUCCESS)
2132     {
2133         *lpNumberOfBytesTransferred = iosb.Information;
2134         if (iosb.u.Status >= 0) return TRUE;
2135         SetLastError( RtlNtStatusToDosError(iosb.u.Status) );
2136         return FALSE;
2137     }
2138
2139     if (status == STATUS_TIMEOUT) SetLastError( WAIT_TIMEOUT );
2140     else SetLastError( RtlNtStatusToDosError(status) );
2141     return FALSE;
2142 }
2143
2144
2145 /******************************************************************************
2146  *              PostQueuedCompletionStatus (KERNEL32.@)
2147  */
2148 BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
2149                                         ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
2150 {
2151     NTSTATUS status;
2152
2153     TRACE("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
2154
2155     status = NtSetIoCompletion( CompletionPort, dwCompletionKey, (ULONG_PTR)lpOverlapped,
2156                                 STATUS_SUCCESS, dwNumberOfBytes );
2157
2158     if (status == STATUS_SUCCESS) return TRUE;
2159     SetLastError( RtlNtStatusToDosError(status) );
2160     return FALSE;
2161 }
2162
2163 /******************************************************************************
2164  *              BindIoCompletionCallback (KERNEL32.@)
2165  */
2166 BOOL WINAPI BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
2167 {
2168     NTSTATUS status;
2169
2170     TRACE("(%p, %p, %d)\n", FileHandle, Function, Flags);
2171
2172     status = RtlSetIoCompletionCallback( FileHandle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)Function, Flags );
2173     if (status == STATUS_SUCCESS) return TRUE;
2174     SetLastError( RtlNtStatusToDosError(status) );
2175     return FALSE;
2176 }
2177
2178
2179 /***********************************************************************
2180  *           CreateMemoryResourceNotification   (KERNEL32.@)
2181  */
2182 HANDLE WINAPI CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE nt)
2183 {
2184     FIXME("(%d) stub\n", nt);
2185     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2186     return NULL;
2187 }
2188
2189 /***********************************************************************
2190  *          QueryMemoryResourceNotification   (KERNEL32.@)
2191  */
2192 BOOL WINAPI QueryMemoryResourceNotification(HANDLE rnh, PBOOL rs)
2193 {
2194     FIXME("(%p, %p) stub\n", rnh, rs);
2195     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2196     return 0;
2197 }
2198
2199 #ifdef __i386__
2200
2201 /***********************************************************************
2202  *              InterlockedCompareExchange (KERNEL32.@)
2203  */
2204 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2205 __ASM_STDCALL_FUNC(InterlockedCompareExchange, 12,
2206                   "movl 12(%esp),%eax\n\t"
2207                   "movl 8(%esp),%ecx\n\t"
2208                   "movl 4(%esp),%edx\n\t"
2209                   "lock; cmpxchgl %ecx,(%edx)\n\t"
2210                   "ret $12")
2211
2212 /***********************************************************************
2213  *              InterlockedExchange (KERNEL32.@)
2214  */
2215 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2216 __ASM_STDCALL_FUNC(InterlockedExchange, 8,
2217                   "movl 8(%esp),%eax\n\t"
2218                   "movl 4(%esp),%edx\n\t"
2219                   "lock; xchgl %eax,(%edx)\n\t"
2220                   "ret $8")
2221
2222 /***********************************************************************
2223  *              InterlockedExchangeAdd (KERNEL32.@)
2224  */
2225 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2226 __ASM_STDCALL_FUNC(InterlockedExchangeAdd, 8,
2227                   "movl 8(%esp),%eax\n\t"
2228                   "movl 4(%esp),%edx\n\t"
2229                   "lock; xaddl %eax,(%edx)\n\t"
2230                   "ret $8")
2231
2232 /***********************************************************************
2233  *              InterlockedIncrement (KERNEL32.@)
2234  */
2235 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2236 __ASM_STDCALL_FUNC(InterlockedIncrement, 4,
2237                   "movl 4(%esp),%edx\n\t"
2238                   "movl $1,%eax\n\t"
2239                   "lock; xaddl %eax,(%edx)\n\t"
2240                   "incl %eax\n\t"
2241                   "ret $4")
2242
2243 /***********************************************************************
2244  *              InterlockedDecrement (KERNEL32.@)
2245  */
2246 __ASM_STDCALL_FUNC(InterlockedDecrement, 4,
2247                   "movl 4(%esp),%edx\n\t"
2248                   "movl $-1,%eax\n\t"
2249                   "lock; xaddl %eax,(%edx)\n\t"
2250                   "decl %eax\n\t"
2251                   "ret $4")
2252
2253 #endif  /* __i386__ */