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 "wine/winbase16.h"
  47 #include "kernel_private.h"
  48
  49 #include "wine/debug.h"
  50
  51 WINE_DEFAULT_DEBUG_CHANNEL(sync);
  52
  53 /* check if current version is NT or Win95 */
  54 static inline int is_version_nt(void)
  55 {
  56     return !(GetVersion() & 0x80000000);
  57 }
  58
  59 /* returns directory handle to \\BaseNamedObjects */
  60 HANDLE get_BaseNamedObjects_handle(void)
  61 {
  62     static HANDLE handle = NULL;
  63     static const WCHAR basenameW[] =
  64         {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s',0};
  65     UNICODE_STRING str;
  66     OBJECT_ATTRIBUTES attr;
  67
  68     if (!handle)
  69     {
  70         HANDLE dir;
  71
  72         RtlInitUnicodeString(&str, basenameW);
  73         InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
  74         NtOpenDirectoryObject(&dir, DIRECTORY_CREATE_OBJECT|DIRECTORY_TRAVERSE,
  75                               &attr);
  76         if (InterlockedCompareExchangePointer( (PVOID)&handle, dir, 0 ) != 0)
  77         {
  78             /* someone beat us here... */
  79             CloseHandle( dir );
  80         }
  81     }
  82     return handle;
  83 }
  84
  85 /* helper for kernel32->ntdll timeout format conversion */
  86 static inline PLARGE_INTEGER get_nt_timeout( PLARGE_INTEGER pTime, DWORD timeout )
  87 {
  88     if (timeout == INFINITE) return NULL;
  89     pTime->QuadPart = (ULONGLONG)timeout * -10000;
  90     return pTime;
  91 }
  92
  93 /***********************************************************************
  94  *              Sleep  (KERNEL32.@)
  95  */
  96 VOID WINAPI Sleep( DWORD timeout )
  97 {
  98     SleepEx( timeout, FALSE );
  99 }
 100
 101 /******************************************************************************
 102  *              SleepEx   (KERNEL32.@)
 103  */
 104 DWORD WINAPI SleepEx( DWORD timeout, BOOL alertable )
 105 {
 106     NTSTATUS status;
 107     LARGE_INTEGER time;
 108
 109     status = NtDelayExecution( alertable, get_nt_timeout( &time, timeout ) );
 110     if (status == STATUS_USER_APC) return WAIT_IO_COMPLETION;
 111     return 0;
 112 }
 113
 114
 115 /***********************************************************************
 116  *              SwitchToThread (KERNEL32.@)
 117  */
 118 BOOL WINAPI SwitchToThread(void)
 119 {
 120     return (NtYieldExecution() != STATUS_NO_YIELD_PERFORMED);
 121 }
 122
 123
 124 /***********************************************************************
 125  *           WaitForSingleObject   (KERNEL32.@)
 126  */
 127 DWORD WINAPI WaitForSingleObject( HANDLE handle, DWORD timeout )
 128 {
 129     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE );
 130 }
 131
 132
 133 /***********************************************************************
 134  *           WaitForSingleObjectEx   (KERNEL32.@)
 135  */
 136 DWORD WINAPI WaitForSingleObjectEx( HANDLE handle, DWORD timeout,
 137                                     BOOL alertable )
 138 {
 139     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable );
 140 }
 141
 142
 143 /***********************************************************************
 144  *           WaitForMultipleObjects   (KERNEL32.@)
 145  */
 146 DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles,
 147                                      BOOL wait_all, DWORD timeout )
 148 {
 149     return WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
 150 }
 151
 152
 153 /***********************************************************************
 154  *           WaitForMultipleObjectsEx   (KERNEL32.@)
 155  */
 156 DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
 157                                        BOOL wait_all, DWORD timeout,
 158                                        BOOL alertable )
 159 {
 160     NTSTATUS status;
 161     HANDLE hloc[MAXIMUM_WAIT_OBJECTS];
 162     LARGE_INTEGER time;
 163     unsigned int i;
 164
 165     if (count > MAXIMUM_WAIT_OBJECTS)
 166     {
 167         SetLastError(ERROR_INVALID_PARAMETER);
 168         return WAIT_FAILED;
 169     }
 170     for (i = 0; i < count; i++)
 171     {
 172         if ((handles[i] == (HANDLE)STD_INPUT_HANDLE) ||
 173             (handles[i] == (HANDLE)STD_OUTPUT_HANDLE) ||
 174             (handles[i] == (HANDLE)STD_ERROR_HANDLE))
 175             hloc[i] = GetStdHandle( HandleToULong(handles[i]) );
 176         else
 177             hloc[i] = handles[i];
 178
 179         /* yes, even screen buffer console handles are waitable, and are
 180          * handled as a handle to the console itself !!
 181          */
 182         if (is_console_handle(hloc[i]))
 183         {
 184             if (!VerifyConsoleIoHandle(hloc[i]))
 185             {
 186                 return FALSE;
 187             }
 188             hloc[i] = GetConsoleInputWaitHandle();
 189         }
 190     }
 191
 192     status = NtWaitForMultipleObjects( count, hloc, wait_all, alertable,
 193                                        get_nt_timeout( &time, timeout ) );
 194
 195     if (HIWORD(status))  /* is it an error code? */
 196     {
 197         SetLastError( RtlNtStatusToDosError(status) );
 198         status = WAIT_FAILED;
 199     }
 200     return status;
 201 }
 202
 203
 204 /***********************************************************************
 205  *           WaitForSingleObject   (KERNEL.460)
 206  */
 207 DWORD WINAPI WaitForSingleObject16( HANDLE handle, DWORD timeout )
 208 {
 209     DWORD retval, mutex_count;
 210
 211     ReleaseThunkLock( &mutex_count );
 212     retval = WaitForSingleObject( handle, timeout );
 213     RestoreThunkLock( mutex_count );
 214     return retval;
 215 }
 216
 217 /***********************************************************************
 218  *           WaitForMultipleObjects   (KERNEL.461)
 219  */
 220 DWORD WINAPI WaitForMultipleObjects16( DWORD count, const HANDLE *handles,
 221                                        BOOL wait_all, DWORD timeout )
 222 {
 223     DWORD retval, mutex_count;
 224
 225     ReleaseThunkLock( &mutex_count );
 226     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
 227     RestoreThunkLock( mutex_count );
 228     return retval;
 229 }
 230
 231 /***********************************************************************
 232  *           WaitForMultipleObjectsEx   (KERNEL.495)
 233  */
 234 DWORD WINAPI WaitForMultipleObjectsEx16( DWORD count, const HANDLE *handles,
 235                                          BOOL wait_all, DWORD timeout, BOOL alertable )
 236 {
 237     DWORD retval, mutex_count;
 238
 239     ReleaseThunkLock( &mutex_count );
 240     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, alertable );
 241     RestoreThunkLock( mutex_count );
 242     return retval;
 243 }
 244
 245 /***********************************************************************
 246  *           RegisterWaitForSingleObject   (KERNEL32.@)
 247  */
 248 BOOL WINAPI RegisterWaitForSingleObject(PHANDLE phNewWaitObject, HANDLE hObject,
 249                 WAITORTIMERCALLBACK Callback, PVOID Context,
 250                 ULONG dwMilliseconds, ULONG dwFlags)
 251 {
 252     NTSTATUS status;
 253
 254     TRACE("%p %p %p %p %d %d\n",
 255           phNewWaitObject,hObject,Callback,Context,dwMilliseconds,dwFlags);
 256
 257     status = RtlRegisterWait( phNewWaitObject, hObject, Callback, Context, dwMilliseconds, dwFlags );
 258     if (status != STATUS_SUCCESS)
 259     {
 260         SetLastError( RtlNtStatusToDosError(status) );
 261         return FALSE;
 262     }
 263     return TRUE;
 264 }
 265
 266 /***********************************************************************
 267  *           RegisterWaitForSingleObjectEx   (KERNEL32.@)
 268  */
 269 HANDLE WINAPI RegisterWaitForSingleObjectEx( HANDLE hObject,
 270                 WAITORTIMERCALLBACK Callback, PVOID Context,
 271                 ULONG dwMilliseconds, ULONG dwFlags )
 272 {
 273     NTSTATUS status;
 274     HANDLE hNewWaitObject;
 275
 276     TRACE("%p %p %p %d %d\n",
 277           hObject,Callback,Context,dwMilliseconds,dwFlags);
 278
 279     status = RtlRegisterWait( &hNewWaitObject, hObject, Callback, Context, dwMilliseconds, dwFlags );
 280     if (status != STATUS_SUCCESS)
 281     {
 282         SetLastError( RtlNtStatusToDosError(status) );
 283         return NULL;
 284     }
 285     return hNewWaitObject;
 286 }
 287
 288 /***********************************************************************
 289  *           UnregisterWait   (KERNEL32.@)
 290  */
 291 BOOL WINAPI UnregisterWait( HANDLE WaitHandle )
 292 {
 293     NTSTATUS status;
 294
 295     TRACE("%p\n",WaitHandle);
 296
 297     status = RtlDeregisterWait( WaitHandle );
 298     if (status != STATUS_SUCCESS)
 299     {
 300         SetLastError( RtlNtStatusToDosError(status) );
 301         return FALSE;
 302     }
 303     return TRUE;
 304 }
 305
 306 /***********************************************************************
 307  *           UnregisterWaitEx   (KERNEL32.@)
 308  */
 309 BOOL WINAPI UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent )
 310 {
 311     FIXME("%p %p\n",WaitHandle, CompletionEvent);
 312     return FALSE;
 313 }
 314
 315 /***********************************************************************
 316  *           SignalObjectAndWait  (KERNEL32.@)
 317  *
 318  * Allows to atomically signal any of the synchro objects (semaphore,
 319  * mutex, event) and wait on another.
 320  */
 321 DWORD WINAPI SignalObjectAndWait( HANDLE hObjectToSignal, HANDLE hObjectToWaitOn,
 322                                   DWORD dwMilliseconds, BOOL bAlertable )
 323 {
 324     NTSTATUS status;
 325     LARGE_INTEGER timeout;
 326
 327     TRACE("%p %p %d %d\n", hObjectToSignal,
 328           hObjectToWaitOn, dwMilliseconds, bAlertable);
 329
 330     status = NtSignalAndWaitForSingleObject( hObjectToSignal, hObjectToWaitOn, bAlertable,
 331                                              get_nt_timeout( &timeout, dwMilliseconds ) );
 332     if (HIWORD(status))
 333     {
 334         SetLastError( RtlNtStatusToDosError(status) );
 335         status = WAIT_FAILED;
 336     }
 337     return status;
 338 }
 339
 340 /***********************************************************************
 341  *           InitializeCriticalSection   (KERNEL32.@)
 342  *
 343  * Initialise a critical section before use.
 344  *
 345  * PARAMS
 346  *  crit [O] Critical section to initialise.
 347  *
 348  * RETURNS
 349  *  Nothing. If the function fails an exception is raised.
 350  */
 351 void WINAPI InitializeCriticalSection( CRITICAL_SECTION *crit )
 352 {
 353     NTSTATUS ret = RtlInitializeCriticalSection( crit );
 354     if (ret) RtlRaiseStatus( ret );
 355 }
 356
 357 /***********************************************************************
 358  *           InitializeCriticalSectionAndSpinCount   (KERNEL32.@)
 359  *
 360  * Initialise a critical section with a spin count.
 361  *
 362  * PARAMS
 363  *  crit      [O] Critical section to initialise.
 364  *  spincount [I] Number of times to spin upon contention.
 365  *
 366  * RETURNS
 367  *  Success: TRUE.
 368  *  Failure: Nothing. If the function fails an exception is raised.
 369  *
 370  * NOTES
 371  *  spincount is ignored on uni-processor systems.
 372  */
 373 BOOL WINAPI InitializeCriticalSectionAndSpinCount( CRITICAL_SECTION *crit, DWORD spincount )
 374 {
 375     NTSTATUS ret = RtlInitializeCriticalSectionAndSpinCount( crit, spincount );
 376     if (ret) RtlRaiseStatus( ret );
 377     return !ret;
 378 }
 379
 380 /***********************************************************************
 381  *           MakeCriticalSectionGlobal   (KERNEL32.@)
 382  */
 383 void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *crit )
 384 {
 385     /* let's assume that only one thread at a time will try to do this */
 386     HANDLE sem = crit->LockSemaphore;
 387     if (!sem) NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 );
 388     crit->LockSemaphore = ConvertToGlobalHandle( sem );
 389     RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 390     crit->DebugInfo = NULL;
 391 }
 392
 393
 394 /***********************************************************************
 395  *           ReinitializeCriticalSection   (KERNEL32.@)
 396  *
 397  * Initialise an already used critical section.
 398  *
 399  * PARAMS
 400  *  crit [O] Critical section to initialise.
 401  *
 402  * RETURNS
 403  *  Nothing.
 404  */
 405 void WINAPI ReinitializeCriticalSection( CRITICAL_SECTION *crit )
 406 {
 407     if ( !crit->LockSemaphore )
 408         RtlInitializeCriticalSection( crit );
 409 }
 410
 411
 412 /***********************************************************************
 413  *           UninitializeCriticalSection   (KERNEL32.@)
 414  *
 415  * UnInitialise a critical section after use.
 416  *
 417  * PARAMS
 418  *  crit [O] Critical section to uninitialise (destroy).
 419  *
 420  * RETURNS
 421  *  Nothing.
 422  */
 423 void WINAPI UninitializeCriticalSection( CRITICAL_SECTION *crit )
 424 {
 425     RtlDeleteCriticalSection( crit );
 426 }
 427
 428
 429 /***********************************************************************
 430  *           CreateEventA    (KERNEL32.@)
 431  */
 432 HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
 433                             BOOL initial_state, LPCSTR name )
 434 {
 435     WCHAR buffer[MAX_PATH];
 436
 437     if (!name) return CreateEventW( sa, manual_reset, initial_state, NULL );
 438
 439     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 440     {
 441         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 442         return 0;
 443     }
 444     return CreateEventW( sa, manual_reset, initial_state, buffer );
 445 }
 446
 447
 448 /***********************************************************************
 449  *           CreateEventW    (KERNEL32.@)
 450  */
 451 HANDLE WINAPI CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
 452                             BOOL initial_state, LPCWSTR name )
 453 {
 454     HANDLE ret;
 455     UNICODE_STRING nameW;
 456     OBJECT_ATTRIBUTES attr;
 457     NTSTATUS status;
 458
 459     /* one buggy program needs this
 460      * ("Van Dale Groot woordenboek der Nederlandse taal")
 461      */
 462     if (sa && IsBadReadPtr(sa,sizeof(SECURITY_ATTRIBUTES)))
 463     {
 464         ERR("Bad security attributes pointer %p\n",sa);
 465         SetLastError( ERROR_INVALID_PARAMETER);
 466         return 0;
 467     }
 468
 469     attr.Length                   = sizeof(attr);
 470     attr.RootDirectory            = 0;
 471     attr.ObjectName               = NULL;
 472     attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 473     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
 474     attr.SecurityQualityOfService = NULL;
 475     if (name)
 476     {
 477         RtlInitUnicodeString( &nameW, name );
 478         attr.ObjectName = &nameW;
 479         attr.RootDirectory = get_BaseNamedObjects_handle();
 480     }
 481
 482     status = NtCreateEvent( &ret, EVENT_ALL_ACCESS, &attr, manual_reset, initial_state );
 483     if (status == STATUS_OBJECT_NAME_EXISTS)
 484         SetLastError( ERROR_ALREADY_EXISTS );
 485     else
 486         SetLastError( RtlNtStatusToDosError(status) );
 487     return ret;
 488 }
 489
 490
 491 /***********************************************************************
 492  *           CreateW32Event    (KERNEL.457)
 493  */
 494 HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
 495 {
 496     return CreateEventW( NULL, manual_reset, initial_state, NULL );
 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  *           SetW32Event (KERNEL.458)
 567  *           SetEvent    (KERNEL32.@)
 568  */
 569 BOOL WINAPI SetEvent( HANDLE handle )
 570 {
 571     NTSTATUS status;
 572
 573     if ((status = NtSetEvent( handle, NULL )))
 574         SetLastError( RtlNtStatusToDosError(status) );
 575     return !status;
 576 }
 577
 578
 579 /***********************************************************************
 580  *           ResetW32Event (KERNEL.459)
 581  *           ResetEvent    (KERNEL32.@)
 582  */
 583 BOOL WINAPI ResetEvent( HANDLE handle )
 584 {
 585     NTSTATUS status;
 586
 587     if ((status = NtResetEvent( handle, NULL )))
 588         SetLastError( RtlNtStatusToDosError(status) );
 589     return !status;
 590 }
 591
 592
 593 /***********************************************************************
 594  * NOTE: The Win95 VWin32_Event routines given below are really low-level
 595  *       routines implemented directly by VWin32. The user-mode libraries
 596  *       implement Win32 synchronisation routines on top of these low-level
 597  *       primitives. We do it the other way around here :-)
 598  */
 599
 600 /***********************************************************************
 601  *       VWin32_EventCreate     (KERNEL.442)
 602  */
 603 HANDLE WINAPI VWin32_EventCreate(VOID)
 604 {
 605     HANDLE hEvent = CreateEventW( NULL, FALSE, 0, NULL );
 606     return ConvertToGlobalHandle( hEvent );
 607 }
 608
 609 /***********************************************************************
 610  *       VWin32_EventDestroy    (KERNEL.443)
 611  */
 612 VOID WINAPI VWin32_EventDestroy(HANDLE event)
 613 {
 614     CloseHandle( event );
 615 }
 616
 617 /***********************************************************************
 618  *       VWin32_EventWait       (KERNEL.450)
 619  */
 620 VOID WINAPI VWin32_EventWait(HANDLE event)
 621 {
 622     DWORD mutex_count;
 623
 624     ReleaseThunkLock( &mutex_count );
 625     WaitForSingleObject( event, INFINITE );
 626     RestoreThunkLock( mutex_count );
 627 }
 628
 629 /***********************************************************************
 630  *       VWin32_EventSet        (KERNEL.451)
 631  *       KERNEL_479             (KERNEL.479)
 632  */
 633 VOID WINAPI VWin32_EventSet(HANDLE event)
 634 {
 635     SetEvent( event );
 636 }
 637
 638
 639
 640 /***********************************************************************
 641  *           CreateMutexA   (KERNEL32.@)
 642  */
 643 HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
 644 {
 645     WCHAR buffer[MAX_PATH];
 646
 647     if (!name) return CreateMutexW( sa, owner, NULL );
 648
 649     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 650     {
 651         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 652         return 0;
 653     }
 654     return CreateMutexW( sa, owner, buffer );
 655 }
 656
 657
 658 /***********************************************************************
 659  *           CreateMutexW   (KERNEL32.@)
 660  */
 661 HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
 662 {
 663     HANDLE ret;
 664     UNICODE_STRING nameW;
 665     OBJECT_ATTRIBUTES attr;
 666     NTSTATUS status;
 667
 668     attr.Length                   = sizeof(attr);
 669     attr.RootDirectory            = 0;
 670     attr.ObjectName               = NULL;
 671     attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 672     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
 673     attr.SecurityQualityOfService = NULL;
 674     if (name)
 675     {
 676         RtlInitUnicodeString( &nameW, name );
 677         attr.ObjectName = &nameW;
 678         attr.RootDirectory = get_BaseNamedObjects_handle();
 679     }
 680
 681     status = NtCreateMutant( &ret, MUTEX_ALL_ACCESS, &attr, owner );
 682     if (status == STATUS_OBJECT_NAME_EXISTS)
 683         SetLastError( ERROR_ALREADY_EXISTS );
 684     else
 685         SetLastError( RtlNtStatusToDosError(status) );
 686     return ret;
 687 }
 688
 689
 690 /***********************************************************************
 691  *           OpenMutexA   (KERNEL32.@)
 692  */
 693 HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
 694 {
 695     WCHAR buffer[MAX_PATH];
 696
 697     if (!name) return OpenMutexW( access, inherit, NULL );
 698
 699     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 700     {
 701         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 702         return 0;
 703     }
 704     return OpenMutexW( access, inherit, buffer );
 705 }
 706
 707
 708 /***********************************************************************
 709  *           OpenMutexW   (KERNEL32.@)
 710  */
 711 HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
 712 {
 713     HANDLE ret;
 714     UNICODE_STRING nameW;
 715     OBJECT_ATTRIBUTES attr;
 716     NTSTATUS status;
 717
 718     if (!is_version_nt()) access = MUTEX_ALL_ACCESS;
 719
 720     attr.Length                   = sizeof(attr);
 721     attr.RootDirectory            = 0;
 722     attr.ObjectName               = NULL;
 723     attr.Attributes               = inherit ? OBJ_INHERIT : 0;
 724     attr.SecurityDescriptor       = NULL;
 725     attr.SecurityQualityOfService = NULL;
 726     if (name)
 727     {
 728         RtlInitUnicodeString( &nameW, name );
 729         attr.ObjectName = &nameW;
 730         attr.RootDirectory = get_BaseNamedObjects_handle();
 731     }
 732
 733     status = NtOpenMutant( &ret, access, &attr );
 734     if (status != STATUS_SUCCESS)
 735     {
 736         SetLastError( RtlNtStatusToDosError(status) );
 737         return 0;
 738     }
 739     return ret;
 740 }
 741
 742
 743 /***********************************************************************
 744  *           ReleaseMutex   (KERNEL32.@)
 745  */
 746 BOOL WINAPI ReleaseMutex( HANDLE handle )
 747 {
 748     NTSTATUS    status;
 749
 750     status = NtReleaseMutant(handle, NULL);
 751     if (status != STATUS_SUCCESS)
 752     {
 753         SetLastError( RtlNtStatusToDosError(status) );
 754         return FALSE;
 755     }
 756     return TRUE;
 757 }
 758
 759
 760 /*
 761  * Semaphores
 762  */
 763
 764
 765 /***********************************************************************
 766  *           CreateSemaphoreA   (KERNEL32.@)
 767  */
 768 HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
 769 {
 770     WCHAR buffer[MAX_PATH];
 771
 772     if (!name) return CreateSemaphoreW( sa, initial, max, NULL );
 773
 774     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 775     {
 776         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 777         return 0;
 778     }
 779     return CreateSemaphoreW( sa, initial, max, buffer );
 780 }
 781
 782
 783 /***********************************************************************
 784  *           CreateSemaphoreW   (KERNEL32.@)
 785  */
 786 HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
 787                                 LONG max, LPCWSTR name )
 788 {
 789     HANDLE ret;
 790     UNICODE_STRING nameW;
 791     OBJECT_ATTRIBUTES attr;
 792     NTSTATUS status;
 793
 794     attr.Length                   = sizeof(attr);
 795     attr.RootDirectory            = 0;
 796     attr.ObjectName               = NULL;
 797     attr.Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 798     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
 799     attr.SecurityQualityOfService = NULL;
 800     if (name)
 801     {
 802         RtlInitUnicodeString( &nameW, name );
 803         attr.ObjectName = &nameW;
 804         attr.RootDirectory = get_BaseNamedObjects_handle();
 805     }
 806
 807     status = NtCreateSemaphore( &ret, SEMAPHORE_ALL_ACCESS, &attr, initial, max );
 808     if (status == STATUS_OBJECT_NAME_EXISTS)
 809         SetLastError( ERROR_ALREADY_EXISTS );
 810     else
 811         SetLastError( RtlNtStatusToDosError(status) );
 812     return ret;
 813 }
 814
 815
 816 /***********************************************************************
 817  *           OpenSemaphoreA   (KERNEL32.@)
 818  */
 819 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 820 {
 821     WCHAR buffer[MAX_PATH];
 822
 823     if (!name) return OpenSemaphoreW( access, inherit, NULL );
 824
 825     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 826     {
 827         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 828         return 0;
 829     }
 830     return OpenSemaphoreW( access, inherit, buffer );
 831 }
 832
 833
 834 /***********************************************************************
 835  *           OpenSemaphoreW   (KERNEL32.@)
 836  */
 837 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 838 {
 839     HANDLE ret;
 840     UNICODE_STRING nameW;
 841     OBJECT_ATTRIBUTES attr;
 842     NTSTATUS status;
 843
 844     if (!is_version_nt()) access = SEMAPHORE_ALL_ACCESS;
 845
 846     attr.Length                   = sizeof(attr);
 847     attr.RootDirectory            = 0;
 848     attr.ObjectName               = NULL;
 849     attr.Attributes               = inherit ? OBJ_INHERIT : 0;
 850     attr.SecurityDescriptor       = NULL;
 851     attr.SecurityQualityOfService = NULL;
 852     if (name)
 853     {
 854         RtlInitUnicodeString( &nameW, name );
 855         attr.ObjectName = &nameW;
 856         attr.RootDirectory = get_BaseNamedObjects_handle();
 857     }
 858
 859     status = NtOpenSemaphore( &ret, access, &attr );
 860     if (status != STATUS_SUCCESS)
 861     {
 862         SetLastError( RtlNtStatusToDosError(status) );
 863         return 0;
 864     }
 865     return ret;
 866 }
 867
 868
 869 /***********************************************************************
 870  *           ReleaseSemaphore   (KERNEL32.@)
 871  */
 872 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 873 {
 874     NTSTATUS status = NtReleaseSemaphore( handle, count, (PULONG)previous );
 875     if (status) SetLastError( RtlNtStatusToDosError(status) );
 876     return !status;
 877 }
 878
 879
 880 /*
 881  * Timers
 882  */
 883
 884
 885 /***********************************************************************
 886  *           CreateWaitableTimerA    (KERNEL32.@)
 887  */
 888 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
 889 {
 890     WCHAR buffer[MAX_PATH];
 891
 892     if (!name) return CreateWaitableTimerW( sa, manual, NULL );
 893
 894     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 895     {
 896         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 897         return 0;
 898     }
 899     return CreateWaitableTimerW( sa, manual, buffer );
 900 }
 901
 902
 903 /***********************************************************************
 904  *           CreateWaitableTimerW    (KERNEL32.@)
 905  */
 906 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
 907 {
 908     HANDLE handle;
 909     NTSTATUS status;
 910     UNICODE_STRING nameW;
 911     OBJECT_ATTRIBUTES attr;
 912
 913     attr.Length                   = sizeof(attr);
 914     attr.RootDirectory            = 0;
 915     attr.ObjectName               = NULL;
 916     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF |
 917                                     ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
 918     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
 919     attr.SecurityQualityOfService = NULL;
 920     if (name)
 921     {
 922         RtlInitUnicodeString( &nameW, name );
 923         attr.ObjectName = &nameW;
 924         attr.RootDirectory = get_BaseNamedObjects_handle();
 925     }
 926
 927     status = NtCreateTimer(&handle, TIMER_ALL_ACCESS, &attr,
 928                            manual ? NotificationTimer : SynchronizationTimer);
 929     if (status == STATUS_OBJECT_NAME_EXISTS)
 930         SetLastError( ERROR_ALREADY_EXISTS );
 931     else
 932         SetLastError( RtlNtStatusToDosError(status) );
 933     return handle;
 934 }
 935
 936
 937 /***********************************************************************
 938  *           OpenWaitableTimerA    (KERNEL32.@)
 939  */
 940 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
 941 {
 942     WCHAR buffer[MAX_PATH];
 943
 944     if (!name) return OpenWaitableTimerW( access, inherit, NULL );
 945
 946     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 947     {
 948         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 949         return 0;
 950     }
 951     return OpenWaitableTimerW( access, inherit, buffer );
 952 }
 953
 954
 955 /***********************************************************************
 956  *           OpenWaitableTimerW    (KERNEL32.@)
 957  */
 958 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 959 {
 960     HANDLE handle;
 961     UNICODE_STRING nameW;
 962     OBJECT_ATTRIBUTES attr;
 963     NTSTATUS status;
 964
 965     if (!is_version_nt()) access = TIMER_ALL_ACCESS;
 966
 967     attr.Length                   = sizeof(attr);
 968     attr.RootDirectory            = 0;
 969     attr.ObjectName               = NULL;
 970     attr.Attributes               = OBJ_CASE_INSENSITIVE | (inherit ? OBJ_INHERIT : 0);
 971     attr.SecurityDescriptor       = NULL;
 972     attr.SecurityQualityOfService = NULL;
 973     if (name)
 974     {
 975         RtlInitUnicodeString( &nameW, name );
 976         attr.ObjectName = &nameW;
 977         attr.RootDirectory = get_BaseNamedObjects_handle();
 978     }
 979
 980     status = NtOpenTimer(&handle, access, &attr);
 981     if (status != STATUS_SUCCESS)
 982     {
 983         SetLastError( RtlNtStatusToDosError(status) );
 984         return 0;
 985     }
 986     return handle;
 987 }
 988
 989
 990 /***********************************************************************
 991  *           SetWaitableTimer    (KERNEL32.@)
 992  */
 993 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
 994                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
 995 {
 996     NTSTATUS status = NtSetTimer(handle, when, (PTIMER_APC_ROUTINE)callback,
 997                                  arg, resume, period, NULL);
 998
 999     if (status != STATUS_SUCCESS)
1000     {
1001         SetLastError( RtlNtStatusToDosError(status) );
1002         if (status != STATUS_TIMER_RESUME_IGNORED) return FALSE;
1003     }
1004     return TRUE;
1005 }
1006
1007
1008 /***********************************************************************
1009  *           CancelWaitableTimer    (KERNEL32.@)
1010  */
1011 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
1012 {
1013     NTSTATUS status;
1014
1015     status = NtCancelTimer(handle, NULL);
1016     if (status != STATUS_SUCCESS)
1017     {
1018         SetLastError( RtlNtStatusToDosError(status) );
1019         return FALSE;
1020     }
1021     return TRUE;
1022 }
1023
1024
1025 /***********************************************************************
1026  *           CreateTimerQueue  (KERNEL32.@)
1027  */
1028 HANDLE WINAPI CreateTimerQueue(void)
1029 {
1030     FIXME("stub\n");
1031     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1032     return NULL;
1033 }
1034
1035
1036 /***********************************************************************
1037  *           DeleteTimerQueueEx  (KERNEL32.@)
1038  */
1039 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
1040 {
1041     FIXME("(%p, %p): stub\n", TimerQueue, CompletionEvent);
1042     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1043     return 0;
1044 }
1045
1046 /***********************************************************************
1047  *           CreateTimerQueueTimer  (KERNEL32.@)
1048  *
1049  * Creates a timer-queue timer. This timer expires at the specified due
1050  * time (in ms), then after every specified period (in ms). When the timer
1051  * expires, the callback function is called.
1052  *
1053  * RETURNS
1054  *   nonzero on success or zero on failure
1055  *
1056  * BUGS
1057  *   Unimplemented
1058  */
1059 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
1060                                    WAITORTIMERCALLBACK Callback, PVOID Parameter,
1061                                    DWORD DueTime, DWORD Period, ULONG Flags )
1062 {
1063     FIXME("stub\n");
1064     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1065     return TRUE;
1066 }
1067
1068 /***********************************************************************
1069  *           DeleteTimerQueueTimer  (KERNEL32.@)
1070  *
1071  * Cancels a timer-queue timer.
1072  *
1073  * RETURNS
1074  *   nonzero on success or zero on failure
1075  *
1076  * BUGS
1077  *   Unimplemented
1078  */
1079 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
1080                                    HANDLE CompletionEvent )
1081 {
1082     FIXME("stub\n");
1083     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1084     return TRUE;
1085 }
1086
1087
1088 /*
1089  * Pipes
1090  */
1091
1092
1093 /***********************************************************************
1094  *           CreateNamedPipeA   (KERNEL32.@)
1095  */
1096 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
1097                                 DWORD dwPipeMode, DWORD nMaxInstances,
1098                                 DWORD nOutBufferSize, DWORD nInBufferSize,
1099                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
1100 {
1101     WCHAR buffer[MAX_PATH];
1102
1103     if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
1104                                         nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1105
1106     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1107     {
1108         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1109         return INVALID_HANDLE_VALUE;
1110     }
1111     return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
1112                              nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1113 }
1114
1115
1116 /***********************************************************************
1117  *           CreateNamedPipeW   (KERNEL32.@)
1118  */
1119 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
1120                                 DWORD dwPipeMode, DWORD nMaxInstances,
1121                                 DWORD nOutBufferSize, DWORD nInBufferSize,
1122                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES sa )
1123 {
1124     HANDLE handle;
1125     UNICODE_STRING nt_name;
1126     OBJECT_ATTRIBUTES attr;
1127     DWORD access, options;
1128     BOOLEAN pipe_type, read_mode, non_block;
1129     NTSTATUS status;
1130     IO_STATUS_BLOCK iosb;
1131     LARGE_INTEGER timeout;
1132
1133     TRACE("(%s, %#08x, %#08x, %d, %d, %d, %d, %p)\n",
1134           debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
1135           nOutBufferSize, nInBufferSize, nDefaultTimeOut, sa );
1136
1137     if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1138     {
1139         SetLastError( ERROR_PATH_NOT_FOUND );
1140         return INVALID_HANDLE_VALUE;
1141     }
1142     if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) )
1143     {
1144         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1145         RtlFreeUnicodeString( &nt_name );
1146         return INVALID_HANDLE_VALUE;
1147     }
1148
1149     attr.Length                   = sizeof(attr);
1150     attr.RootDirectory            = 0;
1151     attr.ObjectName               = &nt_name;
1152     attr.Attributes               = OBJ_CASE_INSENSITIVE |
1153                                     ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1154     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
1155     attr.SecurityQualityOfService = NULL;
1156
1157     switch(dwOpenMode & 3)
1158     {
1159     case PIPE_ACCESS_INBOUND:
1160         options = FILE_PIPE_INBOUND;
1161         access  = GENERIC_READ;
1162         break;
1163     case PIPE_ACCESS_OUTBOUND:
1164         options = FILE_PIPE_OUTBOUND;
1165         access  = GENERIC_WRITE;
1166         break;
1167     case PIPE_ACCESS_DUPLEX:
1168         options = FILE_PIPE_FULL_DUPLEX;
1169         access  = GENERIC_READ | GENERIC_WRITE;
1170         break;
1171     default:
1172         SetLastError( ERROR_INVALID_PARAMETER );
1173         return INVALID_HANDLE_VALUE;
1174     }
1175     access |= SYNCHRONIZE;
1176     if (dwOpenMode & FILE_FLAG_WRITE_THROUGH) options |= FILE_WRITE_THROUGH;
1177     if (!(dwOpenMode & FILE_FLAG_OVERLAPPED)) options |= FILE_SYNCHRONOUS_IO_ALERT;
1178     pipe_type = (dwPipeMode & PIPE_TYPE_MESSAGE) ? TRUE : FALSE;
1179     read_mode = (dwPipeMode & PIPE_READMODE_MESSAGE) ? TRUE : FALSE;
1180     non_block = (dwPipeMode & PIPE_NOWAIT) ? TRUE : FALSE;
1181     if (nMaxInstances >= PIPE_UNLIMITED_INSTANCES) nMaxInstances = ~0U;
1182
1183     timeout.QuadPart = (ULONGLONG)nDefaultTimeOut * -10000;
1184
1185     SetLastError(0);
1186
1187     status = NtCreateNamedPipeFile(&handle, access, &attr, &iosb, 0,
1188                                    FILE_OVERWRITE_IF, options, pipe_type,
1189                                    read_mode, non_block, nMaxInstances,
1190                                    nInBufferSize, nOutBufferSize, &timeout);
1191
1192     RtlFreeUnicodeString( &nt_name );
1193     if (status)
1194     {
1195         handle = INVALID_HANDLE_VALUE;
1196         SetLastError( RtlNtStatusToDosError(status) );
1197     }
1198     return handle;
1199 }
1200
1201
1202 /***********************************************************************
1203  *           PeekNamedPipe   (KERNEL32.@)
1204  */
1205 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
1206                            LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
1207 {
1208     FILE_PIPE_PEEK_BUFFER local_buffer;
1209     FILE_PIPE_PEEK_BUFFER *buffer = &local_buffer;
1210     IO_STATUS_BLOCK io;
1211     NTSTATUS status;
1212
1213     if (cbBuffer && !(buffer = HeapAlloc( GetProcessHeap(), 0,
1214                                           FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ))))
1215     {
1216         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1217         return FALSE;
1218     }
1219
1220     status = NtFsControlFile( hPipe, 0, NULL, NULL, &io, FSCTL_PIPE_PEEK, NULL, 0,
1221                               buffer, FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data[cbBuffer] ) );
1222     if (!status)
1223     {
1224         ULONG read_size = io.Information - FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER, Data );
1225         if (lpcbAvail) *lpcbAvail = buffer->ReadDataAvailable;
1226         if (lpcbRead) *lpcbRead = read_size;
1227         if (lpcbMessage) *lpcbMessage = 0;  /* FIXME */
1228         if (lpvBuffer) memcpy( lpvBuffer, buffer->Data, read_size );
1229     }
1230     else SetLastError( RtlNtStatusToDosError(status) );
1231
1232     if (buffer != &local_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1233     return !status;
1234 }
1235
1236 /***********************************************************************
1237  *           WaitNamedPipeA   (KERNEL32.@)
1238  */
1239 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
1240 {
1241     WCHAR buffer[MAX_PATH];
1242
1243     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
1244
1245     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1246     {
1247         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1248         return 0;
1249     }
1250     return WaitNamedPipeW( buffer, nTimeOut );
1251 }
1252
1253
1254 /***********************************************************************
1255  *           WaitNamedPipeW   (KERNEL32.@)
1256  *
1257  *  Waits for a named pipe instance to become available
1258  *
1259  *  PARAMS
1260  *   name     [I] Pointer to a named pipe name to wait for
1261  *   nTimeOut [I] How long to wait in ms
1262  *
1263  *  RETURNS
1264  *   TRUE: Success, named pipe can be opened with CreateFile
1265  *   FALSE: Failure, GetLastError can be called for further details
1266  */
1267 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
1268 {
1269     static const WCHAR leadin[] = {'\\','?','?','\\','P','I','P','E','\\'};
1270     NTSTATUS status;
1271     UNICODE_STRING nt_name, pipe_dev_name;
1272     FILE_PIPE_WAIT_FOR_BUFFER *pipe_wait;
1273     IO_STATUS_BLOCK iosb;
1274     OBJECT_ATTRIBUTES attr;
1275     ULONG sz_pipe_wait;
1276     HANDLE pipe_dev;
1277
1278     TRACE("%s 0x%08x\n",debugstr_w(name),nTimeOut);
1279
1280     if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1281         return FALSE;
1282
1283     if (nt_name.Length >= MAX_PATH * sizeof(WCHAR) ||
1284         nt_name.Length < sizeof(leadin) ||
1285         strncmpiW( nt_name.Buffer, leadin, sizeof(leadin)/sizeof(WCHAR) != 0))
1286     {
1287         RtlFreeUnicodeString( &nt_name );
1288         SetLastError( ERROR_PATH_NOT_FOUND );
1289         return FALSE;
1290     }
1291
1292     sz_pipe_wait = sizeof(*pipe_wait) + nt_name.Length - sizeof(leadin) - sizeof(WCHAR);
1293     if (!(pipe_wait = HeapAlloc( GetProcessHeap(), 0,  sz_pipe_wait)))
1294     {
1295         RtlFreeUnicodeString( &nt_name );
1296         SetLastError( ERROR_OUTOFMEMORY );
1297         return FALSE;
1298     }
1299
1300     pipe_dev_name.Buffer = nt_name.Buffer;
1301     pipe_dev_name.Length = sizeof(leadin);
1302     pipe_dev_name.MaximumLength = sizeof(leadin);
1303     InitializeObjectAttributes(&attr,&pipe_dev_name, OBJ_CASE_INSENSITIVE, NULL, NULL);
1304     status = NtOpenFile( &pipe_dev, FILE_READ_ATTRIBUTES, &attr,
1305                          &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE,
1306                          FILE_SYNCHRONOUS_IO_NONALERT);
1307     if (status != ERROR_SUCCESS)
1308     {
1309         SetLastError( ERROR_PATH_NOT_FOUND );
1310         return FALSE;
1311     }
1312
1313     pipe_wait->TimeoutSpecified = !(nTimeOut == NMPWAIT_USE_DEFAULT_WAIT);
1314     if (nTimeOut == NMPWAIT_WAIT_FOREVER)
1315         pipe_wait->Timeout.QuadPart = ((ULONGLONG)0x7fffffff << 32) | 0xffffffff;
1316     else
1317         pipe_wait->Timeout.QuadPart = (ULONGLONG)nTimeOut * -10000;
1318     pipe_wait->NameLength = nt_name.Length - sizeof(leadin);
1319     memcpy(pipe_wait->Name, nt_name.Buffer + sizeof(leadin)/sizeof(WCHAR),
1320            pipe_wait->NameLength);
1321     RtlFreeUnicodeString( &nt_name );
1322
1323     status = NtFsControlFile( pipe_dev, NULL, NULL, NULL, &iosb, FSCTL_PIPE_WAIT,
1324                               pipe_wait, sz_pipe_wait, NULL, 0 );
1325
1326     HeapFree( GetProcessHeap(), 0, pipe_wait );
1327     NtClose( pipe_dev );
1328
1329     if(status != STATUS_SUCCESS)
1330     {
1331         SetLastError(RtlNtStatusToDosError(status));
1332         return FALSE;
1333     }
1334     else
1335         return TRUE;
1336 }
1337
1338
1339 /***********************************************************************
1340  *           ConnectNamedPipe   (KERNEL32.@)
1341  *
1342  *  Connects to a named pipe
1343  *
1344  *  Parameters
1345  *  hPipe: A handle to a named pipe returned by CreateNamedPipe
1346  *  overlapped: Optional OVERLAPPED struct
1347  *
1348  *  Return values
1349  *  TRUE: Success
1350  *  FALSE: Failure, GetLastError can be called for further details
1351  */
1352 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1353 {
1354     NTSTATUS status;
1355     IO_STATUS_BLOCK status_block;
1356     LPVOID   cvalue = NULL;
1357
1358     TRACE("(%p,%p)\n", hPipe, overlapped);
1359
1360     if(overlapped)
1361     {
1362         overlapped->Internal = STATUS_PENDING;
1363         overlapped->InternalHigh = 0;
1364         if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
1365     }
1366
1367     status = NtFsControlFile(hPipe, overlapped ? overlapped->hEvent : NULL, NULL, cvalue,
1368                              overlapped ? (IO_STATUS_BLOCK *)overlapped : &status_block,
1369                              FSCTL_PIPE_LISTEN, NULL, 0, NULL, 0);
1370
1371     if (status == STATUS_SUCCESS) return TRUE;
1372     SetLastError( RtlNtStatusToDosError(status) );
1373     return FALSE;
1374 }
1375
1376 /***********************************************************************
1377  *           DisconnectNamedPipe   (KERNEL32.@)
1378  *
1379  *  Disconnects from a named pipe
1380  *
1381  *  Parameters
1382  *  hPipe: A handle to a named pipe returned by CreateNamedPipe
1383  *
1384  *  Return values
1385  *  TRUE: Success
1386  *  FALSE: Failure, GetLastError can be called for further details
1387  */
1388 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
1389 {
1390     NTSTATUS status;
1391     IO_STATUS_BLOCK io_block;
1392
1393     TRACE("(%p)\n",hPipe);
1394
1395     status = NtFsControlFile(hPipe, 0, NULL, NULL, &io_block, FSCTL_PIPE_DISCONNECT,
1396                              NULL, 0, NULL, 0);
1397     if (status == STATUS_SUCCESS) return TRUE;
1398     SetLastError( RtlNtStatusToDosError(status) );
1399     return FALSE;
1400 }
1401
1402 /***********************************************************************
1403  *           TransactNamedPipe   (KERNEL32.@)
1404  *
1405  * BUGS
1406  *  should be done as a single operation in the wineserver or kernel
1407  */
1408 BOOL WINAPI TransactNamedPipe(
1409     HANDLE handle, LPVOID write_buf, DWORD write_size, LPVOID read_buf,
1410     DWORD read_size, LPDWORD bytes_read, LPOVERLAPPED overlapped)
1411 {
1412     BOOL r;
1413     DWORD count;
1414
1415     TRACE("%p %p %d %p %d %p %p\n",
1416           handle, write_buf, write_size, read_buf,
1417           read_size, bytes_read, overlapped);
1418
1419     if (overlapped)
1420     {
1421         FIXME("Doesn't support overlapped operation as yet\n");
1422         return FALSE;
1423     }
1424
1425     r = WriteFile(handle, write_buf, write_size, &count, NULL);
1426     if (r)
1427         r = ReadFile(handle, read_buf, read_size, bytes_read, NULL);
1428
1429     return r;
1430 }
1431
1432 /***********************************************************************
1433  *           GetNamedPipeInfo   (KERNEL32.@)
1434  */
1435 BOOL WINAPI GetNamedPipeInfo(
1436     HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
1437     LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
1438 {
1439     FILE_PIPE_LOCAL_INFORMATION fpli;
1440     IO_STATUS_BLOCK iosb;
1441     NTSTATUS status;
1442
1443     status = NtQueryInformationFile(hNamedPipe, &iosb, &fpli, sizeof(fpli),
1444                                     FilePipeLocalInformation);
1445     if (status)
1446     {
1447         SetLastError( RtlNtStatusToDosError(status) );
1448         return FALSE;
1449     }
1450
1451     if (lpFlags)
1452     {
1453         *lpFlags = (fpli.NamedPipeEnd & FILE_PIPE_SERVER_END) ?
1454             PIPE_SERVER_END : PIPE_CLIENT_END;
1455         *lpFlags |= (fpli.NamedPipeType & FILE_PIPE_TYPE_MESSAGE) ?
1456             PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
1457     }
1458
1459     if (lpOutputBufferSize) *lpOutputBufferSize = fpli.OutboundQuota;
1460     if (lpInputBufferSize) *lpInputBufferSize = fpli.InboundQuota;
1461     if (lpMaxInstances) *lpMaxInstances = fpli.MaximumInstances;
1462
1463     return TRUE;
1464 }
1465
1466 /***********************************************************************
1467  *           GetNamedPipeHandleStateA  (KERNEL32.@)
1468  */
1469 BOOL WINAPI GetNamedPipeHandleStateA(
1470     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1471     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1472     LPSTR lpUsername, DWORD nUsernameMaxSize)
1473 {
1474     FIXME("%p %p %p %p %p %p %d\n",
1475           hNamedPipe, lpState, lpCurInstances,
1476           lpMaxCollectionCount, lpCollectDataTimeout,
1477           lpUsername, nUsernameMaxSize);
1478
1479     return FALSE;
1480 }
1481
1482 /***********************************************************************
1483  *           GetNamedPipeHandleStateW  (KERNEL32.@)
1484  */
1485 BOOL WINAPI GetNamedPipeHandleStateW(
1486     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1487     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1488     LPWSTR lpUsername, DWORD nUsernameMaxSize)
1489 {
1490     FIXME("%p %p %p %p %p %p %d\n",
1491           hNamedPipe, lpState, lpCurInstances,
1492           lpMaxCollectionCount, lpCollectDataTimeout,
1493           lpUsername, nUsernameMaxSize);
1494
1495     return FALSE;
1496 }
1497
1498 /***********************************************************************
1499  *           SetNamedPipeHandleState  (KERNEL32.@)
1500  */
1501 BOOL WINAPI SetNamedPipeHandleState(
1502     HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1503     LPDWORD lpCollectDataTimeout)
1504 {
1505     /* should be a fixme, but this function is called a lot by the RPC
1506      * runtime, and it slows down InstallShield a fair bit. */
1507     WARN("stub: %p %p/%d %p %p\n",
1508           hNamedPipe, lpMode, lpMode ? *lpMode : 0, lpMaxCollectionCount, lpCollectDataTimeout);
1509     return FALSE;
1510 }
1511
1512 /***********************************************************************
1513  *           CallNamedPipeA  (KERNEL32.@)
1514  */
1515 BOOL WINAPI CallNamedPipeA(
1516     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
1517     LPVOID lpOutput, DWORD dwOutputSize,
1518     LPDWORD lpBytesRead, DWORD nTimeout)
1519 {
1520     DWORD len;
1521     LPWSTR str = NULL;
1522     BOOL ret;
1523
1524     TRACE("%s %p %d %p %d %p %d\n",
1525            debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
1526            lpOutput, dwOutputSize, lpBytesRead, nTimeout);
1527
1528     if( lpNamedPipeName )
1529     {
1530         len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
1531         str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1532         MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
1533     }
1534     ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
1535                           dwOutputSize, lpBytesRead, nTimeout );
1536     if( lpNamedPipeName )
1537         HeapFree( GetProcessHeap(), 0, str );
1538
1539     return ret;
1540 }
1541
1542 /***********************************************************************
1543  *           CallNamedPipeW  (KERNEL32.@)
1544  */
1545 BOOL WINAPI CallNamedPipeW(
1546     LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1547     LPVOID lpOutput, DWORD lpOutputSize,
1548     LPDWORD lpBytesRead, DWORD nTimeout)
1549 {
1550     HANDLE pipe;
1551     BOOL ret;
1552     DWORD mode;
1553
1554     TRACE("%s %p %d %p %d %p %d\n",
1555           debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1556           lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1557
1558     pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1559     if (pipe == INVALID_HANDLE_VALUE)
1560     {
1561         ret = WaitNamedPipeW(lpNamedPipeName, nTimeout);
1562         if (!ret)
1563             return FALSE;
1564         pipe = CreateFileW(lpNamedPipeName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
1565         if (pipe == INVALID_HANDLE_VALUE)
1566             return FALSE;
1567     }
1568
1569     mode = PIPE_READMODE_MESSAGE;
1570     ret = SetNamedPipeHandleState(pipe, &mode, NULL, NULL);
1571
1572     /* Currently SetNamedPipeHandleState() is a stub returning FALSE */
1573     if (ret) FIXME("Now that SetNamedPipeHandleState() is more than a stub, please update CallNamedPipeW\n");
1574     /*
1575     if (!ret)
1576     {
1577         CloseHandle(pipe);
1578         return FALSE;
1579     }*/
1580
1581     ret = TransactNamedPipe(pipe, lpInput, lpInputSize, lpOutput, lpOutputSize, lpBytesRead, NULL);
1582     CloseHandle(pipe);
1583     if (!ret)
1584         return FALSE;
1585
1586     return TRUE;
1587 }
1588
1589 /******************************************************************
1590  *              CreatePipe (KERNEL32.@)
1591  *
1592  */
1593 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1594                         LPSECURITY_ATTRIBUTES sa, DWORD size )
1595 {
1596     static unsigned     index /* = 0 */;
1597     WCHAR               name[64];
1598     HANDLE              hr, hw;
1599     unsigned            in_index = index;
1600     UNICODE_STRING      nt_name;
1601     OBJECT_ATTRIBUTES   attr;
1602     NTSTATUS            status;
1603     IO_STATUS_BLOCK     iosb;
1604     LARGE_INTEGER       timeout;
1605
1606     *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1607
1608     attr.Length                   = sizeof(attr);
1609     attr.RootDirectory            = 0;
1610     attr.ObjectName               = &nt_name;
1611     attr.Attributes               = OBJ_CASE_INSENSITIVE |
1612                                     ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
1613     attr.SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
1614     attr.SecurityQualityOfService = NULL;
1615
1616     timeout.QuadPart = (ULONGLONG)NMPWAIT_USE_DEFAULT_WAIT * -10000;
1617     /* generate a unique pipe name (system wide) */
1618     do
1619     {
1620         static const WCHAR nameFmt[] = { '\\','?','?','\\','p','i','p','e',
1621          '\\','W','i','n','3','2','.','P','i','p','e','s','.','%','0','8','l',
1622          'u','.','%','0','8','u','\0' };
1623
1624         snprintfW(name, sizeof(name) / sizeof(name[0]), nameFmt,
1625                   GetCurrentProcessId(), ++index);
1626         RtlInitUnicodeString(&nt_name, name);
1627         status = NtCreateNamedPipeFile(&hr, GENERIC_READ | SYNCHRONIZE, &attr, &iosb,
1628                                        0, FILE_OVERWRITE_IF,
1629                                        FILE_SYNCHRONOUS_IO_ALERT | FILE_PIPE_INBOUND,
1630                                        FALSE, FALSE, FALSE,
1631                                        1, size, size, &timeout);
1632         if (status)
1633         {
1634             SetLastError( RtlNtStatusToDosError(status) );
1635             hr = INVALID_HANDLE_VALUE;
1636         }
1637     } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1638     /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1639     if (hr == INVALID_HANDLE_VALUE) return FALSE;
1640
1641     status = NtOpenFile(&hw, GENERIC_WRITE | SYNCHRONIZE, &attr, &iosb, 0,
1642                         FILE_SYNCHRONOUS_IO_ALERT | FILE_NON_DIRECTORY_FILE);
1643
1644     if (status)
1645     {
1646         SetLastError( RtlNtStatusToDosError(status) );
1647         NtClose(hr);
1648         return FALSE;
1649     }
1650
1651     *hReadPipe = hr;
1652     *hWritePipe = hw;
1653     return TRUE;
1654 }
1655
1656
1657 /******************************************************************************
1658  * CreateMailslotA [KERNEL32.@]
1659  *
1660  * See CreateMailslotW.
1661  */
1662 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1663                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1664 {
1665     DWORD len;
1666     HANDLE handle;
1667     LPWSTR name = NULL;
1668
1669     TRACE("%s %d %d %p\n", debugstr_a(lpName),
1670           nMaxMessageSize, lReadTimeout, sa);
1671
1672     if( lpName )
1673     {
1674         len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1675         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1676         MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1677     }
1678
1679     handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1680
1681     HeapFree( GetProcessHeap(), 0, name );
1682
1683     return handle;
1684 }
1685
1686
1687 /******************************************************************************
1688  * CreateMailslotW [KERNEL32.@]
1689  *
1690  * Create a mailslot with specified name.
1691  *
1692  * PARAMS
1693  *    lpName          [I] Pointer to string for mailslot name
1694  *    nMaxMessageSize [I] Maximum message size
1695  *    lReadTimeout    [I] Milliseconds before read time-out
1696  *    sa              [I] Pointer to security structure
1697  *
1698  * RETURNS
1699  *    Success: Handle to mailslot
1700  *    Failure: INVALID_HANDLE_VALUE
1701  */
1702 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
1703                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1704 {
1705     HANDLE handle = INVALID_HANDLE_VALUE;
1706     OBJECT_ATTRIBUTES attr;
1707     UNICODE_STRING nameW;
1708     LARGE_INTEGER timeout;
1709     IO_STATUS_BLOCK iosb;
1710     NTSTATUS status;
1711
1712     TRACE("%s %d %d %p\n", debugstr_w(lpName),
1713           nMaxMessageSize, lReadTimeout, sa);
1714
1715     if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
1716     {
1717         SetLastError( ERROR_PATH_NOT_FOUND );
1718         return INVALID_HANDLE_VALUE;
1719     }
1720
1721     if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
1722     {
1723         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1724         RtlFreeUnicodeString( &nameW );
1725         return INVALID_HANDLE_VALUE;
1726     }
1727
1728     attr.Length = sizeof(attr);
1729     attr.RootDirectory = 0;
1730     attr.Attributes = OBJ_CASE_INSENSITIVE;
1731     attr.ObjectName = &nameW;
1732     attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
1733     attr.SecurityQualityOfService = NULL;
1734
1735     if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
1736         timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
1737     else
1738         timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1739
1740     status = NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
1741                                    &iosb, 0, 0, nMaxMessageSize, &timeout );
1742     if (status)
1743     {
1744         SetLastError( RtlNtStatusToDosError(status) );
1745         handle = INVALID_HANDLE_VALUE;
1746     }
1747
1748     RtlFreeUnicodeString( &nameW );
1749     return handle;
1750 }
1751
1752
1753 /******************************************************************************
1754  * GetMailslotInfo [KERNEL32.@]
1755  *
1756  * Retrieve information about a mailslot.
1757  *
1758  * PARAMS
1759  *    hMailslot        [I] Mailslot handle
1760  *    lpMaxMessageSize [O] Address of maximum message size
1761  *    lpNextSize       [O] Address of size of next message
1762  *    lpMessageCount   [O] Address of number of messages
1763  *    lpReadTimeout    [O] Address of read time-out
1764  *
1765  * RETURNS
1766  *    Success: TRUE
1767  *    Failure: FALSE
1768  */
1769 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
1770                                LPDWORD lpNextSize, LPDWORD lpMessageCount,
1771                                LPDWORD lpReadTimeout )
1772 {
1773     FILE_MAILSLOT_QUERY_INFORMATION info;
1774     IO_STATUS_BLOCK iosb;
1775     NTSTATUS status;
1776
1777     TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
1778           lpNextSize, lpMessageCount, lpReadTimeout);
1779
1780     status = NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
1781                                      FileMailslotQueryInformation );
1782
1783     if( status != STATUS_SUCCESS )
1784     {
1785         SetLastError( RtlNtStatusToDosError(status) );
1786         return FALSE;
1787     }
1788
1789     if( lpMaxMessageSize )
1790         *lpMaxMessageSize = info.MaximumMessageSize;
1791     if( lpNextSize )
1792         *lpNextSize = info.NextMessageSize;
1793     if( lpMessageCount )
1794         *lpMessageCount = info.MessagesAvailable;
1795     if( lpReadTimeout )
1796     {
1797         if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
1798             *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
1799         else
1800             *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
1801     }
1802     return TRUE;
1803 }
1804
1805
1806 /******************************************************************************
1807  * SetMailslotInfo [KERNEL32.@]
1808  *
1809  * Set the read timeout of a mailslot.
1810  *
1811  * PARAMS
1812  *  hMailslot     [I] Mailslot handle
1813  *  dwReadTimeout [I] Timeout in milliseconds.
1814  *
1815  * RETURNS
1816  *    Success: TRUE
1817  *    Failure: FALSE
1818  */
1819 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
1820 {
1821     FILE_MAILSLOT_SET_INFORMATION info;
1822     IO_STATUS_BLOCK iosb;
1823     NTSTATUS status;
1824
1825     TRACE("%p %d\n", hMailslot, dwReadTimeout);
1826
1827     if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
1828         info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
1829     else
1830         info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
1831     status = NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
1832                                    FileMailslotSetInformation );
1833     if( status != STATUS_SUCCESS )
1834     {
1835         SetLastError( RtlNtStatusToDosError(status) );
1836         return FALSE;
1837     }
1838     return TRUE;
1839 }
1840
1841
1842 /******************************************************************************
1843  *              CreateIoCompletionPort (KERNEL32.@)
1844  */
1845 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
1846                                      ULONG_PTR CompletionKey, DWORD dwNumberOfConcurrentThreads)
1847 {
1848     NTSTATUS status;
1849     HANDLE ret = 0;
1850
1851     TRACE("(%p, %p, %08lx, %08x)\n",
1852           hFileHandle, hExistingCompletionPort, CompletionKey, dwNumberOfConcurrentThreads);
1853
1854     if (hExistingCompletionPort && hFileHandle == INVALID_HANDLE_VALUE)
1855     {
1856         SetLastError( ERROR_INVALID_PARAMETER);
1857         return NULL;
1858     }
1859
1860     if (hExistingCompletionPort)
1861         ret = hExistingCompletionPort;
1862     else
1863     {
1864         status = NtCreateIoCompletion( &ret, IO_COMPLETION_ALL_ACCESS, NULL, dwNumberOfConcurrentThreads );
1865         if (status != STATUS_SUCCESS) goto fail;
1866     }
1867
1868     if (hFileHandle != INVALID_HANDLE_VALUE)
1869     {
1870         FILE_COMPLETION_INFORMATION info;
1871         IO_STATUS_BLOCK iosb;
1872
1873         info.CompletionPort = ret;
1874         info.CompletionKey = CompletionKey;
1875         status = NtSetInformationFile( hFileHandle, &iosb, &info, sizeof(info), FileCompletionInformation );
1876         if (status != STATUS_SUCCESS) goto fail;
1877     }
1878
1879     return ret;
1880
1881 fail:
1882     if (ret && !hExistingCompletionPort)
1883         CloseHandle( ret );
1884     SetLastError( RtlNtStatusToDosError(status) );
1885     return 0;
1886 }
1887
1888 /******************************************************************************
1889  *              GetQueuedCompletionStatus (KERNEL32.@)
1890  */
1891 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
1892                                        PULONG_PTR pCompletionKey, LPOVERLAPPED *lpOverlapped,
1893                                        DWORD dwMilliseconds )
1894 {
1895     NTSTATUS status;
1896     IO_STATUS_BLOCK iosb;
1897     LARGE_INTEGER wait_time;
1898
1899     TRACE("(%p,%p,%p,%p,%d)\n",
1900           CompletionPort,lpNumberOfBytesTransferred,pCompletionKey,lpOverlapped,dwMilliseconds);
1901
1902     *lpOverlapped = NULL;
1903
1904     status = NtRemoveIoCompletion( CompletionPort, pCompletionKey, (PULONG_PTR)lpOverlapped,
1905                                    &iosb, get_nt_timeout( &wait_time, dwMilliseconds ) );
1906     if (status == STATUS_SUCCESS)
1907     {
1908         *lpNumberOfBytesTransferred = iosb.Information;
1909         return TRUE;
1910     }
1911
1912     SetLastError( RtlNtStatusToDosError(status) );
1913     return FALSE;
1914 }
1915
1916
1917 /******************************************************************************
1918  *              PostQueuedCompletionStatus (KERNEL32.@)
1919  */
1920 BOOL WINAPI PostQueuedCompletionStatus( HANDLE CompletionPort, DWORD dwNumberOfBytes,
1921                                         ULONG_PTR dwCompletionKey, LPOVERLAPPED lpOverlapped)
1922 {
1923     NTSTATUS status;
1924
1925     TRACE("%p %d %08lx %p\n", CompletionPort, dwNumberOfBytes, dwCompletionKey, lpOverlapped );
1926
1927     status = NtSetIoCompletion( CompletionPort, dwCompletionKey, (ULONG_PTR)lpOverlapped,
1928                                 STATUS_SUCCESS, dwNumberOfBytes );
1929
1930     if (status == STATUS_SUCCESS) return TRUE;
1931     SetLastError( RtlNtStatusToDosError(status) );
1932     return FALSE;
1933 }
1934
1935 /******************************************************************************
1936  *              BindIoCompletionCallback (KERNEL32.@)
1937  */
1938 BOOL WINAPI BindIoCompletionCallback( HANDLE FileHandle, LPOVERLAPPED_COMPLETION_ROUTINE Function, ULONG Flags)
1939 {
1940     NTSTATUS status;
1941
1942     TRACE("(%p, %p, %d)\n", FileHandle, Function, Flags);
1943
1944     status = RtlSetIoCompletionCallback( FileHandle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)Function, Flags );
1945     if (status == STATUS_SUCCESS) return TRUE;
1946     SetLastError( RtlNtStatusToDosError(status) );
1947     return FALSE;
1948 }
1949
1950 /******************************************************************************
1951  *              CreateJobObjectW (KERNEL32.@)
1952  */
1953 HANDLE WINAPI CreateJobObjectW( LPSECURITY_ATTRIBUTES attr, LPCWSTR name )
1954 {
1955     FIXME("%p %s\n", attr, debugstr_w(name) );
1956     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1957     return 0;
1958 }
1959
1960 /******************************************************************************
1961  *              CreateJobObjectA (KERNEL32.@)
1962  */
1963 HANDLE WINAPI CreateJobObjectA( LPSECURITY_ATTRIBUTES attr, LPCSTR name )
1964 {
1965     LPWSTR str = NULL;
1966     UINT len;
1967     HANDLE r;
1968
1969     TRACE("%p %s\n", attr, debugstr_a(name) );
1970
1971     if( name )
1972     {
1973         len = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
1974         str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1975         if( !str )
1976         {
1977             SetLastError( ERROR_OUTOFMEMORY );
1978             return 0;
1979         }
1980         len = MultiByteToWideChar( CP_ACP, 0, name, -1, str, len );
1981     }
1982
1983     r = CreateJobObjectW( attr, str );
1984
1985     HeapFree( GetProcessHeap(), 0, str );
1986
1987     return r;
1988 }
1989
1990 /******************************************************************************
1991  *              AssignProcessToJobObject (KERNEL32.@)
1992  */
1993 BOOL WINAPI AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess )
1994 {
1995     FIXME("%p %p\n", hJob, hProcess);
1996     return TRUE;
1997 }
1998
1999 #ifdef __i386__
2000
2001 /***********************************************************************
2002  *              InterlockedCompareExchange (KERNEL32.@)
2003  */
2004 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
2005 __ASM_GLOBAL_FUNC(InterlockedCompareExchange,
2006                   "movl 12(%esp),%eax\n\t"
2007                   "movl 8(%esp),%ecx\n\t"
2008                   "movl 4(%esp),%edx\n\t"
2009                   "lock; cmpxchgl %ecx,(%edx)\n\t"
2010                   "ret $12")
2011
2012 /***********************************************************************
2013  *              InterlockedExchange (KERNEL32.@)
2014  */
2015 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
2016 __ASM_GLOBAL_FUNC(InterlockedExchange,
2017                   "movl 8(%esp),%eax\n\t"
2018                   "movl 4(%esp),%edx\n\t"
2019                   "lock; xchgl %eax,(%edx)\n\t"
2020                   "ret $8")
2021
2022 /***********************************************************************
2023  *              InterlockedExchangeAdd (KERNEL32.@)
2024  */
2025 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
2026 __ASM_GLOBAL_FUNC(InterlockedExchangeAdd,
2027                   "movl 8(%esp),%eax\n\t"
2028                   "movl 4(%esp),%edx\n\t"
2029                   "lock; xaddl %eax,(%edx)\n\t"
2030                   "ret $8")
2031
2032 /***********************************************************************
2033  *              InterlockedIncrement (KERNEL32.@)
2034  */
2035 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
2036 __ASM_GLOBAL_FUNC(InterlockedIncrement,
2037                   "movl 4(%esp),%edx\n\t"
2038                   "movl $1,%eax\n\t"
2039                   "lock; xaddl %eax,(%edx)\n\t"
2040                   "incl %eax\n\t"
2041                   "ret $4")
2042
2043 /***********************************************************************
2044  *              InterlockedDecrement (KERNEL32.@)
2045  */
2046 __ASM_GLOBAL_FUNC(InterlockedDecrement,
2047                   "movl 4(%esp),%edx\n\t"
2048                   "movl $-1,%eax\n\t"
2049                   "lock; xaddl %eax,(%edx)\n\t"
2050                   "decl %eax\n\t"
2051                   "ret $4")
2052
2053 #else  /* __i386__ */
2054
2055 /***********************************************************************
2056  *              InterlockedCompareExchange (KERNEL32.@)
2057  *
2058  * Atomically swap one value with another.
2059  *
2060  * PARAMS
2061  *  dest    [I/O] The value to replace
2062  *  xchq    [I]   The value to be swapped
2063  *  compare [I]   The value to compare to dest
2064  *
2065  * RETURNS
2066  *  The resulting value of dest.
2067  *
2068  * NOTES
2069  *  dest is updated only if it is equal to compare, otherwise no swap is done.
2070  */
2071 LONG WINAPI InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
2072 {
2073     return interlocked_cmpxchg( (int *)dest, xchg, compare );
2074 }
2075
2076 /***********************************************************************
2077  *              InterlockedExchange (KERNEL32.@)
2078  *
2079  * Atomically swap one value with another.
2080  *
2081  * PARAMS
2082  *  dest [I/O] The value to replace
2083  *  val  [I]   The value to be swapped
2084  *
2085  * RETURNS
2086  *  The resulting value of dest.
2087  */
2088 LONG WINAPI InterlockedExchange( LONG volatile *dest, LONG val )
2089 {
2090     return interlocked_xchg( (int *)dest, val );
2091 }
2092
2093 /***********************************************************************
2094  *              InterlockedExchangeAdd (KERNEL32.@)
2095  *
2096  * Atomically add one value to another.
2097  *
2098  * PARAMS
2099  *  dest [I/O] The value to add to
2100  *  incr [I]   The value to be added
2101  *
2102  * RETURNS
2103  *  The resulting value of dest.
2104  */
2105 LONG WINAPI InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
2106 {
2107     return interlocked_xchg_add( (int *)dest, incr );
2108 }
2109
2110 /***********************************************************************
2111  *              InterlockedIncrement (KERNEL32.@)
2112  *
2113  * Atomically increment a value.
2114  *
2115  * PARAMS
2116  *  dest [I/O] The value to increment
2117  *
2118  * RETURNS
2119  *  The resulting value of dest.
2120  */
2121 LONG WINAPI InterlockedIncrement( LONG volatile *dest )
2122 {
2123     return interlocked_xchg_add( (int *)dest, 1 ) + 1;
2124 }
2125
2126 /***********************************************************************
2127  *              InterlockedDecrement (KERNEL32.@)
2128  *
2129  * Atomically decrement a value.
2130  *
2131  * PARAMS
2132  *  dest [I/O] The value to decrement
2133  *
2134  * RETURNS
2135  *  The resulting value of dest.
2136  */
2137 LONG WINAPI InterlockedDecrement( LONG volatile *dest )
2138 {
2139     return interlocked_xchg_add( (int *)dest, -1 ) - 1;
2140 }
2141
2142 #endif  /* __i386__ */