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