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 <string.h>
  22 #include <errno.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #define NONAMELESSUNION
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wincon.h"
  32 #include "winerror.h"
  33 #include "winnls.h"
  34 #include "winternl.h"
  35 #include "winioctl.h"
  36 #include "ddk/wdm.h"
  37
  38 #include "wine/asm.h"
  39 #include "kernel_private.h"
  40
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(sync);
  44
  45 static const struct _KUSER_SHARED_DATA *user_shared_data = (struct _KUSER_SHARED_DATA *)0x7ffe0000;
  46
  47
  48 static void get_create_object_attributes( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *nameW,
  49                                           SECURITY_ATTRIBUTES *sa, const WCHAR *name )
  50 {
  51     attr->Length                   = sizeof(*attr);
  52     attr->RootDirectory            = 0;
  53     attr->ObjectName               = NULL;
  54     attr->Attributes               = OBJ_OPENIF | ((sa && sa->bInheritHandle) ? OBJ_INHERIT : 0);
  55     attr->SecurityDescriptor       = sa ? sa->lpSecurityDescriptor : NULL;
  56     attr->SecurityQualityOfService = NULL;
  57     if (name)
  58     {
  59         RtlInitUnicodeString( nameW, name );
  60         attr->ObjectName = nameW;
  61         BaseGetNamedObjectDirectory( &attr->RootDirectory );
  62     }
  63 }
  64
  65 static BOOL get_open_object_attributes( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *nameW,
  66                                         BOOL inherit, const WCHAR *name )
  67 {
  68     HANDLE dir;
  69
  70     if (!name)
  71     {
  72         SetLastError( ERROR_INVALID_PARAMETER );
  73         return FALSE;
  74     }
  75     RtlInitUnicodeString( nameW, name );
  76     BaseGetNamedObjectDirectory( &dir );
  77     InitializeObjectAttributes( attr, nameW, inherit ? OBJ_INHERIT : 0, dir, NULL );
  78     return TRUE;
  79 }
  80
  81 /******************************************************************************
  82  *           GetTickCount64       (KERNEL32.@)
  83  */
  84 ULONGLONG WINAPI DECLSPEC_HOTPATCH GetTickCount64(void)
  85 {
  86     ULONG high, low;
  87
  88     do
  89     {
  90         high = user_shared_data->u.TickCount.High1Time;
  91         low = user_shared_data->u.TickCount.LowPart;
  92     }
  93     while (high != user_shared_data->u.TickCount.High2Time);
  94     /* note: we ignore TickCountMultiplier */
  95     return (ULONGLONG)high << 32 | low;
  96 }
  97
  98 /***********************************************************************
  99  *           GetTickCount       (KERNEL32.@)
 100  */
 101 DWORD WINAPI DECLSPEC_HOTPATCH GetTickCount(void)
 102 {
 103     /* note: we ignore TickCountMultiplier */
 104     return user_shared_data->u.TickCount.LowPart;
 105 }
 106
 107 /***********************************************************************
 108  *           RegisterWaitForSingleObject   (KERNEL32.@)
 109  */
 110 BOOL WINAPI RegisterWaitForSingleObject( HANDLE *wait, HANDLE object, WAITORTIMERCALLBACK callback,
 111                                          void *context, ULONG timeout, ULONG flags )
 112 {
 113     if (!set_ntstatus( RtlRegisterWait( wait, object, callback, context, timeout, flags ))) return FALSE;
 114     return TRUE;
 115 }
 116
 117 /***********************************************************************
 118  *           UnregisterWait   (KERNEL32.@)
 119  */
 120 BOOL WINAPI UnregisterWait( HANDLE handle )
 121 {
 122     return set_ntstatus( RtlDeregisterWait( handle ));
 123 }
 124
 125 /***********************************************************************
 126  *           MakeCriticalSectionGlobal   (KERNEL32.@)
 127  */
 128 void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *crit )
 129 {
 130     /* let's assume that only one thread at a time will try to do this */
 131     HANDLE sem = crit->LockSemaphore;
 132     if (!sem) NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 );
 133     crit->LockSemaphore = ConvertToGlobalHandle( sem );
 134     if (crit->DebugInfo != (void *)(ULONG_PTR)-1)
 135         RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 136     crit->DebugInfo = NULL;
 137 }
 138
 139
 140 /***********************************************************************
 141  *           ReinitializeCriticalSection   (KERNEL32.@)
 142  *
 143  * Initialise an already used critical section.
 144  *
 145  * PARAMS
 146  *  crit [O] Critical section to initialise.
 147  *
 148  * RETURNS
 149  *  Nothing.
 150  */
 151 void WINAPI ReinitializeCriticalSection( CRITICAL_SECTION *crit )
 152 {
 153     if ( !crit->LockSemaphore )
 154         RtlInitializeCriticalSection( crit );
 155 }
 156
 157
 158 /***********************************************************************
 159  *           UninitializeCriticalSection   (KERNEL32.@)
 160  *
 161  * UnInitialise a critical section after use.
 162  *
 163  * PARAMS
 164  *  crit [O] Critical section to uninitialise (destroy).
 165  *
 166  * RETURNS
 167  *  Nothing.
 168  */
 169 void WINAPI UninitializeCriticalSection( CRITICAL_SECTION *crit )
 170 {
 171     RtlDeleteCriticalSection( crit );
 172 }
 173
 174
 175 /***********************************************************************
 176  *           OpenMutexA   (KERNEL32.@)
 177  */
 178 HANDLE WINAPI DECLSPEC_HOTPATCH OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
 179 {
 180     WCHAR buffer[MAX_PATH];
 181
 182     if (!name) return OpenMutexW( access, inherit, NULL );
 183
 184     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 185     {
 186         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 187         return 0;
 188     }
 189     return OpenMutexW( access, inherit, buffer );
 190 }
 191
 192
 193
 194
 195 /*
 196  * Semaphores
 197  */
 198
 199
 200 /***********************************************************************
 201  *           CreateSemaphoreA   (KERNEL32.@)
 202  */
 203 HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
 204 {
 205     return CreateSemaphoreExA( sa, initial, max, name, 0, SEMAPHORE_ALL_ACCESS );
 206 }
 207
 208
 209 /***********************************************************************
 210  *           CreateSemaphoreExA   (KERNEL32.@)
 211  */
 212 HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreExA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max,
 213                                                     LPCSTR name, DWORD flags, DWORD access )
 214 {
 215     WCHAR buffer[MAX_PATH];
 216
 217     if (!name) return CreateSemaphoreExW( sa, initial, max, NULL, flags, access );
 218
 219     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 220     {
 221         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 222         return 0;
 223     }
 224     return CreateSemaphoreExW( sa, initial, max, buffer, flags, access );
 225 }
 226
 227
 228 /***********************************************************************
 229  *           OpenSemaphoreA   (KERNEL32.@)
 230  */
 231 HANDLE WINAPI DECLSPEC_HOTPATCH OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 232 {
 233     WCHAR buffer[MAX_PATH];
 234
 235     if (!name) return OpenSemaphoreW( access, inherit, NULL );
 236
 237     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 238     {
 239         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 240         return 0;
 241     }
 242     return OpenSemaphoreW( access, inherit, buffer );
 243 }
 244
 245
 246 /*
 247  * Jobs
 248  */
 249
 250 /******************************************************************************
 251  *              CreateJobObjectW (KERNEL32.@)
 252  */
 253 HANDLE WINAPI CreateJobObjectW( LPSECURITY_ATTRIBUTES sa, LPCWSTR name )
 254 {
 255     HANDLE ret = 0;
 256     UNICODE_STRING nameW;
 257     OBJECT_ATTRIBUTES attr;
 258     NTSTATUS status;
 259
 260     get_create_object_attributes( &attr, &nameW, sa, name );
 261
 262     status = NtCreateJobObject( &ret, JOB_OBJECT_ALL_ACCESS, &attr );
 263     if (status == STATUS_OBJECT_NAME_EXISTS)
 264         SetLastError( ERROR_ALREADY_EXISTS );
 265     else
 266         SetLastError( RtlNtStatusToDosError(status) );
 267     return ret;
 268 }
 269
 270 /******************************************************************************
 271  *              CreateJobObjectA (KERNEL32.@)
 272  */
 273 HANDLE WINAPI CreateJobObjectA( LPSECURITY_ATTRIBUTES attr, LPCSTR name )
 274 {
 275     WCHAR buffer[MAX_PATH];
 276
 277     if (!name) return CreateJobObjectW( attr, NULL );
 278
 279     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 280     {
 281         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 282         return 0;
 283     }
 284     return CreateJobObjectW( attr, buffer );
 285 }
 286
 287 /******************************************************************************
 288  *              OpenJobObjectW (KERNEL32.@)
 289  */
 290 HANDLE WINAPI OpenJobObjectW( DWORD access, BOOL inherit, LPCWSTR name )
 291 {
 292     HANDLE ret;
 293     UNICODE_STRING nameW;
 294     OBJECT_ATTRIBUTES attr;
 295
 296     if (!get_open_object_attributes( &attr, &nameW, inherit, name )) return 0;
 297
 298     if (!set_ntstatus( NtOpenJobObject( &ret, access, &attr ))) return 0;
 299     return ret;
 300 }
 301
 302 /******************************************************************************
 303  *              OpenJobObjectA (KERNEL32.@)
 304  */
 305 HANDLE WINAPI OpenJobObjectA( DWORD access, BOOL inherit, LPCSTR name )
 306 {
 307     WCHAR buffer[MAX_PATH];
 308
 309     if (!name) return OpenJobObjectW( access, inherit, NULL );
 310
 311     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 312     {
 313         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 314         return 0;
 315     }
 316     return OpenJobObjectW( access, inherit, buffer );
 317 }
 318
 319 /******************************************************************************
 320  *              TerminateJobObject (KERNEL32.@)
 321  */
 322 BOOL WINAPI TerminateJobObject( HANDLE job, UINT exit_code )
 323 {
 324     return set_ntstatus( NtTerminateJobObject( job, exit_code ));
 325 }
 326
 327 /******************************************************************************
 328  *              QueryInformationJobObject (KERNEL32.@)
 329  */
 330 BOOL WINAPI QueryInformationJobObject( HANDLE job, JOBOBJECTINFOCLASS class, LPVOID info,
 331                                        DWORD len, DWORD *ret_len )
 332 {
 333     return set_ntstatus( NtQueryInformationJobObject( job, class, info, len, ret_len ));
 334 }
 335
 336 /******************************************************************************
 337  *              SetInformationJobObject (KERNEL32.@)
 338  */
 339 BOOL WINAPI SetInformationJobObject( HANDLE job, JOBOBJECTINFOCLASS class, LPVOID info, DWORD len )
 340 {
 341     return set_ntstatus( NtSetInformationJobObject( job, class, info, len ));
 342 }
 343
 344 /******************************************************************************
 345  *              AssignProcessToJobObject (KERNEL32.@)
 346  */
 347 BOOL WINAPI AssignProcessToJobObject( HANDLE job, HANDLE process )
 348 {
 349     return set_ntstatus( NtAssignProcessToJobObject( job, process ));
 350 }
 351
 352
 353 /*
 354  * Timers
 355  */
 356
 357
 358 /***********************************************************************
 359  *           CreateWaitableTimerA    (KERNEL32.@)
 360  */
 361 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
 362 {
 363     return CreateWaitableTimerExA( sa, name, manual ? CREATE_WAITABLE_TIMER_MANUAL_RESET : 0,
 364                                    TIMER_ALL_ACCESS );
 365 }
 366
 367
 368 /***********************************************************************
 369  *           CreateWaitableTimerExA    (KERNEL32.@)
 370  */
 371 HANDLE WINAPI CreateWaitableTimerExA( SECURITY_ATTRIBUTES *sa, LPCSTR name, DWORD flags, DWORD access )
 372 {
 373     WCHAR buffer[MAX_PATH];
 374
 375     if (!name) return CreateWaitableTimerExW( sa, NULL, flags, access );
 376
 377     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 378     {
 379         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 380         return 0;
 381     }
 382     return CreateWaitableTimerExW( sa, buffer, flags, access );
 383 }
 384
 385
 386 /***********************************************************************
 387  *           OpenWaitableTimerA    (KERNEL32.@)
 388  */
 389 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
 390 {
 391     WCHAR buffer[MAX_PATH];
 392
 393     if (!name) return OpenWaitableTimerW( access, inherit, NULL );
 394
 395     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 396     {
 397         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 398         return 0;
 399     }
 400     return OpenWaitableTimerW( access, inherit, buffer );
 401 }
 402
 403
 404 /***********************************************************************
 405  *           DeleteTimerQueue  (KERNEL32.@)
 406  */
 407 BOOL WINAPI DeleteTimerQueue(HANDLE TimerQueue)
 408 {
 409     return DeleteTimerQueueEx(TimerQueue, NULL);
 410 }
 411
 412 /***********************************************************************
 413  *           CancelTimerQueueTimer    (KERNEL32.@)
 414  */
 415 BOOL WINAPI CancelTimerQueueTimer(HANDLE queue, HANDLE timer)
 416 {
 417     return DeleteTimerQueueTimer( queue, timer, NULL );
 418 }
 419
 420
 421
 422 /*
 423  * Mappings
 424  */
 425
 426
 427 /***********************************************************************
 428  *             CreateFileMappingA   (KERNEL32.@)
 429  */
 430 HANDLE WINAPI CreateFileMappingA( HANDLE file, SECURITY_ATTRIBUTES *sa, DWORD protect,
 431                                   DWORD size_high, DWORD size_low, LPCSTR name )
 432 {
 433     WCHAR buffer[MAX_PATH];
 434
 435     if (!name) return CreateFileMappingW( file, sa, protect, size_high, size_low, NULL );
 436
 437     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 438     {
 439         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 440         return 0;
 441     }
 442     return CreateFileMappingW( file, sa, protect, size_high, size_low, buffer );
 443 }
 444
 445
 446 /***********************************************************************
 447  *             OpenFileMappingA   (KERNEL32.@)
 448  */
 449 HANDLE WINAPI OpenFileMappingA( DWORD access, BOOL inherit, LPCSTR name )
 450 {
 451     WCHAR buffer[MAX_PATH];
 452
 453     if (!name) return OpenFileMappingW( access, inherit, NULL );
 454
 455     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 456     {
 457         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 458         return 0;
 459     }
 460     return OpenFileMappingW( access, inherit, buffer );
 461 }
 462
 463
 464 /*
 465  * Pipes
 466  */
 467
 468
 469 /***********************************************************************
 470  *           CreateNamedPipeA   (KERNEL32.@)
 471  */
 472 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
 473                                 DWORD dwPipeMode, DWORD nMaxInstances,
 474                                 DWORD nOutBufferSize, DWORD nInBufferSize,
 475                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
 476 {
 477     WCHAR buffer[MAX_PATH];
 478
 479     if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
 480                                         nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 481
 482     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 483     {
 484         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 485         return INVALID_HANDLE_VALUE;
 486     }
 487     return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
 488                              nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 489 }
 490
 491
 492 /***********************************************************************
 493  *           WaitNamedPipeA   (KERNEL32.@)
 494  */
 495 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
 496 {
 497     WCHAR buffer[MAX_PATH];
 498
 499     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
 500
 501     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 502     {
 503         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 504         return FALSE;
 505     }
 506     return WaitNamedPipeW( buffer, nTimeOut );
 507 }
 508
 509
 510 /***********************************************************************
 511  *           GetNamedPipeClientProcessId  (KERNEL32.@)
 512  */
 513 BOOL WINAPI GetNamedPipeClientProcessId( HANDLE pipe, ULONG *id )
 514 {
 515     IO_STATUS_BLOCK iosb;
 516
 517     return set_ntstatus( NtFsControlFile( pipe, NULL, NULL, NULL, &iosb,
 518                                           FSCTL_PIPE_GET_CONNECTION_ATTRIBUTE, (void *)"ClientProcessId",
 519                                           sizeof("ClientProcessId"), id, sizeof(*id) ));
 520 }
 521
 522 /***********************************************************************
 523  *           GetNamedPipeServerProcessId  (KERNEL32.@)
 524  */
 525 BOOL WINAPI GetNamedPipeServerProcessId( HANDLE pipe, ULONG *id )
 526 {
 527     IO_STATUS_BLOCK iosb;
 528
 529     return set_ntstatus( NtFsControlFile( pipe, NULL, NULL, NULL, &iosb,
 530                                           FSCTL_PIPE_GET_CONNECTION_ATTRIBUTE, (void *)"ServerProcessId",
 531                                           sizeof("ServerProcessId"), id, sizeof(*id) ));
 532 }
 533
 534 /***********************************************************************
 535  *           GetNamedPipeClientSessionId  (KERNEL32.@)
 536  */
 537 BOOL WINAPI GetNamedPipeClientSessionId( HANDLE pipe, ULONG *id )
 538 {
 539     FIXME( "%p, %p\n", pipe, id );
 540
 541     if (!id) return FALSE;
 542     *id = NtCurrentTeb()->Peb->SessionId;
 543     return TRUE;
 544 }
 545
 546 /***********************************************************************
 547  *           GetNamedPipeServerSessionId  (KERNEL32.@)
 548  */
 549 BOOL WINAPI GetNamedPipeServerSessionId( HANDLE pipe, ULONG *id )
 550 {
 551     FIXME( "%p, %p\n", pipe, id );
 552
 553     if (!id) return FALSE;
 554     *id = NtCurrentTeb()->Peb->SessionId;
 555     return TRUE;
 556 }
 557
 558 /***********************************************************************
 559  *           GetNamedPipeHandleStateA  (KERNEL32.@)
 560  */
 561 BOOL WINAPI GetNamedPipeHandleStateA(
 562     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
 563     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
 564     LPSTR lpUsername, DWORD nUsernameMaxSize)
 565 {
 566     WCHAR *username = NULL;
 567     BOOL ret;
 568
 569     WARN("%p %p %p %p %p %p %ld: semi-stub\n", hNamedPipe, lpState, lpCurInstances,
 570          lpMaxCollectionCount, lpCollectDataTimeout, lpUsername, nUsernameMaxSize);
 571
 572     if (lpUsername && nUsernameMaxSize &&
 573         !(username = HeapAlloc(GetProcessHeap(), 0, nUsernameMaxSize * sizeof(WCHAR)))) return FALSE;
 574
 575     ret = GetNamedPipeHandleStateW(hNamedPipe, lpState, lpCurInstances, lpMaxCollectionCount,
 576                                    lpCollectDataTimeout, username, nUsernameMaxSize);
 577     if (ret && username)
 578         WideCharToMultiByte(CP_ACP, 0, username, -1, lpUsername, nUsernameMaxSize, NULL, NULL);
 579
 580     HeapFree(GetProcessHeap(), 0, username);
 581     return ret;
 582 }
 583
 584 /***********************************************************************
 585  *           CallNamedPipeA  (KERNEL32.@)
 586  */
 587 BOOL WINAPI CallNamedPipeA(
 588     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD dwInputSize,
 589     LPVOID lpOutput, DWORD dwOutputSize,
 590     LPDWORD lpBytesRead, DWORD nTimeout)
 591 {
 592     DWORD len;
 593     LPWSTR str = NULL;
 594     BOOL ret;
 595
 596     TRACE("%s %p %ld %p %ld %p %ld\n",
 597            debugstr_a(lpNamedPipeName), lpInput, dwInputSize,
 598            lpOutput, dwOutputSize, lpBytesRead, nTimeout);
 599
 600     if( lpNamedPipeName )
 601     {
 602         len = MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, NULL, 0 );
 603         str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 604         MultiByteToWideChar( CP_ACP, 0, lpNamedPipeName, -1, str, len );
 605     }
 606     ret = CallNamedPipeW( str, lpInput, dwInputSize, lpOutput,
 607                           dwOutputSize, lpBytesRead, nTimeout );
 608     if( lpNamedPipeName )
 609         HeapFree( GetProcessHeap(), 0, str );
 610
 611     return ret;
 612 }
 613
 614 /******************************************************************************
 615  * CreateMailslotA [KERNEL32.@]
 616  *
 617  * See CreateMailslotW.
 618  */
 619 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
 620                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
 621 {
 622     DWORD len;
 623     HANDLE handle;
 624     LPWSTR name = NULL;
 625
 626     TRACE("%s %ld %ld %p\n", debugstr_a(lpName),
 627           nMaxMessageSize, lReadTimeout, sa);
 628
 629     if( lpName )
 630     {
 631         len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
 632         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 633         MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
 634     }
 635
 636     handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
 637
 638     HeapFree( GetProcessHeap(), 0, name );
 639
 640     return handle;
 641 }
 642
 643
 644 /******************************************************************************
 645  * CreateMailslotW [KERNEL32.@]
 646  *
 647  * Create a mailslot with specified name.
 648  *
 649  * PARAMS
 650  *    lpName          [I] Pointer to string for mailslot name
 651  *    nMaxMessageSize [I] Maximum message size
 652  *    lReadTimeout    [I] Milliseconds before read time-out
 653  *    sa              [I] Pointer to security structure
 654  *
 655  * RETURNS
 656  *    Success: Handle to mailslot
 657  *    Failure: INVALID_HANDLE_VALUE
 658  */
 659 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
 660                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
 661 {
 662     HANDLE handle = INVALID_HANDLE_VALUE;
 663     OBJECT_ATTRIBUTES attr;
 664     UNICODE_STRING nameW;
 665     LARGE_INTEGER timeout;
 666     IO_STATUS_BLOCK iosb;
 667
 668     TRACE("%s %ld %ld %p\n", debugstr_w(lpName),
 669           nMaxMessageSize, lReadTimeout, sa);
 670
 671     if (!RtlDosPathNameToNtPathName_U( lpName, &nameW, NULL, NULL ))
 672     {
 673         SetLastError( ERROR_PATH_NOT_FOUND );
 674         return INVALID_HANDLE_VALUE;
 675     }
 676
 677     if (nameW.Length >= MAX_PATH * sizeof(WCHAR) )
 678     {
 679         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 680         RtlFreeUnicodeString( &nameW );
 681         return INVALID_HANDLE_VALUE;
 682     }
 683
 684     attr.Length = sizeof(attr);
 685     attr.RootDirectory = 0;
 686     attr.Attributes = OBJ_CASE_INSENSITIVE;
 687     attr.ObjectName = &nameW;
 688     attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
 689     attr.SecurityQualityOfService = NULL;
 690
 691     if (lReadTimeout != MAILSLOT_WAIT_FOREVER)
 692         timeout.QuadPart = (ULONGLONG) lReadTimeout * -10000;
 693     else
 694         timeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
 695
 696     if (!set_ntstatus( NtCreateMailslotFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr,
 697                                              &iosb, 0, 0, nMaxMessageSize, &timeout )))
 698         handle = INVALID_HANDLE_VALUE;
 699
 700     RtlFreeUnicodeString( &nameW );
 701     return handle;
 702 }
 703
 704
 705 /******************************************************************************
 706  * GetMailslotInfo [KERNEL32.@]
 707  *
 708  * Retrieve information about a mailslot.
 709  *
 710  * PARAMS
 711  *    hMailslot        [I] Mailslot handle
 712  *    lpMaxMessageSize [O] Address of maximum message size
 713  *    lpNextSize       [O] Address of size of next message
 714  *    lpMessageCount   [O] Address of number of messages
 715  *    lpReadTimeout    [O] Address of read time-out
 716  *
 717  * RETURNS
 718  *    Success: TRUE
 719  *    Failure: FALSE
 720  */
 721 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
 722                                LPDWORD lpNextSize, LPDWORD lpMessageCount,
 723                                LPDWORD lpReadTimeout )
 724 {
 725     FILE_MAILSLOT_QUERY_INFORMATION info;
 726     IO_STATUS_BLOCK iosb;
 727
 728     TRACE("%p %p %p %p %p\n",hMailslot, lpMaxMessageSize,
 729           lpNextSize, lpMessageCount, lpReadTimeout);
 730
 731     if (!set_ntstatus( NtQueryInformationFile( hMailslot, &iosb, &info, sizeof info,
 732                                                FileMailslotQueryInformation )))
 733         return FALSE;
 734
 735     if( lpMaxMessageSize )
 736         *lpMaxMessageSize = info.MaximumMessageSize;
 737     if( lpNextSize )
 738         *lpNextSize = info.NextMessageSize;
 739     if( lpMessageCount )
 740         *lpMessageCount = info.MessagesAvailable;
 741     if( lpReadTimeout )
 742     {
 743         if (info.ReadTimeout.QuadPart == (((LONGLONG)0x7fffffff << 32) | 0xffffffff))
 744             *lpReadTimeout = MAILSLOT_WAIT_FOREVER;
 745         else
 746             *lpReadTimeout = info.ReadTimeout.QuadPart / -10000;
 747     }
 748     return TRUE;
 749 }
 750
 751
 752 /******************************************************************************
 753  * SetMailslotInfo [KERNEL32.@]
 754  *
 755  * Set the read timeout of a mailslot.
 756  *
 757  * PARAMS
 758  *  hMailslot     [I] Mailslot handle
 759  *  dwReadTimeout [I] Timeout in milliseconds.
 760  *
 761  * RETURNS
 762  *    Success: TRUE
 763  *    Failure: FALSE
 764  */
 765 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
 766 {
 767     FILE_MAILSLOT_SET_INFORMATION info;
 768     IO_STATUS_BLOCK iosb;
 769
 770     TRACE("%p %ld\n", hMailslot, dwReadTimeout);
 771
 772     if (dwReadTimeout != MAILSLOT_WAIT_FOREVER)
 773         info.ReadTimeout.QuadPart = (ULONGLONG)dwReadTimeout * -10000;
 774     else
 775         info.ReadTimeout.QuadPart = ((LONGLONG)0x7fffffff << 32) | 0xffffffff;
 776     return set_ntstatus( NtSetInformationFile( hMailslot, &iosb, &info, sizeof info,
 777                                                FileMailslotSetInformation ));
 778 }
 779
 780
 781 /******************************************************************************
 782  *              BindIoCompletionCallback (KERNEL32.@)
 783  */
 784 BOOL WINAPI BindIoCompletionCallback( HANDLE handle, LPOVERLAPPED_COMPLETION_ROUTINE func, ULONG flags )
 785 {
 786     return set_ntstatus( RtlSetIoCompletionCallback( handle, (PRTL_OVERLAPPED_COMPLETION_ROUTINE)func, flags ));
 787 }
 788
 789
 790 #ifdef __i386__
 791
 792 /***********************************************************************
 793  *              InterlockedCompareExchange (KERNEL32.@)
 794  */
 795 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
 796 __ASM_STDCALL_FUNC(InterlockedCompareExchange, 12,
 797                   "movl 12(%esp),%eax\n\t"
 798                   "movl 8(%esp),%ecx\n\t"
 799                   "movl 4(%esp),%edx\n\t"
 800                   "lock; cmpxchgl %ecx,(%edx)\n\t"
 801                   "ret $12")
 802
 803 /***********************************************************************
 804  *              InterlockedExchange (KERNEL32.@)
 805  */
 806 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
 807 __ASM_STDCALL_FUNC(InterlockedExchange, 8,
 808                   "movl 8(%esp),%eax\n\t"
 809                   "movl 4(%esp),%edx\n\t"
 810                   "lock; xchgl %eax,(%edx)\n\t"
 811                   "ret $8")
 812
 813 /***********************************************************************
 814  *              InterlockedExchangeAdd (KERNEL32.@)
 815  */
 816 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
 817 __ASM_STDCALL_FUNC(InterlockedExchangeAdd, 8,
 818                   "movl 8(%esp),%eax\n\t"
 819                   "movl 4(%esp),%edx\n\t"
 820                   "lock; xaddl %eax,(%edx)\n\t"
 821                   "ret $8")
 822
 823 /***********************************************************************
 824  *              InterlockedIncrement (KERNEL32.@)
 825  */
 826 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
 827 __ASM_STDCALL_FUNC(InterlockedIncrement, 4,
 828                   "movl 4(%esp),%edx\n\t"
 829                   "movl $1,%eax\n\t"
 830                   "lock; xaddl %eax,(%edx)\n\t"
 831                   "incl %eax\n\t"
 832                   "ret $4")
 833
 834 /***********************************************************************
 835  *              InterlockedDecrement (KERNEL32.@)
 836  */
 837 __ASM_STDCALL_FUNC(InterlockedDecrement, 4,
 838                   "movl 4(%esp),%edx\n\t"
 839                   "movl $-1,%eax\n\t"
 840                   "lock; xaddl %eax,(%edx)\n\t"
 841                   "decl %eax\n\t"
 842                   "ret $4")
 843
 844 #endif  /* __i386__ */