git.oblomov.eu Git - wine/blob - dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #ifdef HAVE_SYS_IOCTL_H
  30 #include <sys/ioctl.h>
  31 #endif
  32 #ifdef HAVE_SYS_POLL_H
  33 #include <sys/poll.h>
  34 #endif
  35 #ifdef HAVE_SYS_SOCKET_H
  36 #include <sys/socket.h>
  37 #endif
  38 #include <stdarg.h>
  39 #include <stdio.h>
  40
  41 #include "ntstatus.h"
  42 #include "windef.h"
  43 #include "winbase.h"
  44 #include "winerror.h"
  45 #include "winnls.h"
  46
  47 #include "wine/server.h"
  48 #include "wine/unicode.h"
  49 #include "wine/winbase16.h"
  50 #include "kernel_private.h"
  51 #include "file.h"
  52
  53 #include "wine/debug.h"
  54
  55 WINE_DEFAULT_DEBUG_CHANNEL(sync);
  56
  57 /* check if current version is NT or Win95 */
  58 inline static int is_version_nt(void)
  59 {
  60     return !(GetVersion() & 0x80000000);
  61 }
  62
  63
  64 /***********************************************************************
  65  *              Sleep  (KERNEL32.@)
  66  */
  67 VOID WINAPI Sleep( DWORD timeout )
  68 {
  69     SleepEx( timeout, FALSE );
  70 }
  71
  72 /******************************************************************************
  73  *              SleepEx   (KERNEL32.@)
  74  */
  75 DWORD WINAPI SleepEx( DWORD timeout, BOOL alertable )
  76 {
  77     NTSTATUS status;
  78
  79     if (timeout == INFINITE) status = NtDelayExecution( alertable, NULL );
  80     else
  81     {
  82         LARGE_INTEGER time;
  83
  84         time.QuadPart = timeout * (ULONGLONG)10000;
  85         time.QuadPart = -time.QuadPart;
  86         status = NtDelayExecution( alertable, &time );
  87     }
  88     if (status != STATUS_USER_APC) status = STATUS_SUCCESS;
  89     return status;
  90 }
  91
  92
  93 /***********************************************************************
  94  *           WaitForSingleObject   (KERNEL32.@)
  95  */
  96 DWORD WINAPI WaitForSingleObject( HANDLE handle, DWORD timeout )
  97 {
  98     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, FALSE );
  99 }
 100
 101
 102 /***********************************************************************
 103  *           WaitForSingleObjectEx   (KERNEL32.@)
 104  */
 105 DWORD WINAPI WaitForSingleObjectEx( HANDLE handle, DWORD timeout,
 106                                     BOOL alertable )
 107 {
 108     return WaitForMultipleObjectsEx( 1, &handle, FALSE, timeout, alertable );
 109 }
 110
 111
 112 /***********************************************************************
 113  *           WaitForMultipleObjects   (KERNEL32.@)
 114  */
 115 DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles,
 116                                      BOOL wait_all, DWORD timeout )
 117 {
 118     return WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
 119 }
 120
 121
 122 /***********************************************************************
 123  *           WaitForMultipleObjectsEx   (KERNEL32.@)
 124  */
 125 DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
 126                                        BOOL wait_all, DWORD timeout,
 127                                        BOOL alertable )
 128 {
 129     NTSTATUS status;
 130     HANDLE hloc[MAXIMUM_WAIT_OBJECTS];
 131     int i;
 132
 133     if (count >= MAXIMUM_WAIT_OBJECTS)
 134     {
 135         SetLastError(ERROR_INVALID_PARAMETER);
 136         return WAIT_FAILED;
 137     }
 138     for (i = 0; i < count; i++)
 139     {
 140         if ((handles[i] == (HANDLE)STD_INPUT_HANDLE) ||
 141             (handles[i] == (HANDLE)STD_OUTPUT_HANDLE) ||
 142             (handles[i] == (HANDLE)STD_ERROR_HANDLE))
 143             hloc[i] = GetStdHandle( (DWORD)handles[i] );
 144         else
 145             hloc[i] = handles[i];
 146
 147         /* yes, even screen buffer console handles are waitable, and are
 148          * handled as a handle to the console itself !!
 149          */
 150         if (is_console_handle(hloc[i]))
 151         {
 152             if (!VerifyConsoleIoHandle(hloc[i]))
 153             {
 154                 return FALSE;
 155             }
 156             hloc[i] = GetConsoleInputWaitHandle();
 157         }
 158     }
 159
 160     if (timeout == INFINITE)
 161     {
 162         status = NtWaitForMultipleObjects( count, hloc, wait_all, alertable, NULL );
 163     }
 164     else
 165     {
 166         LARGE_INTEGER time;
 167
 168         time.QuadPart = timeout * (ULONGLONG)10000;
 169         time.QuadPart = -time.QuadPart;
 170         status = NtWaitForMultipleObjects( count, hloc, wait_all, alertable, &time );
 171     }
 172
 173     if (HIWORD(status))  /* is it an error code? */
 174     {
 175         SetLastError( RtlNtStatusToDosError(status) );
 176         status = WAIT_FAILED;
 177     }
 178     return status;
 179 }
 180
 181
 182 /***********************************************************************
 183  *           WaitForSingleObject   (KERNEL.460)
 184  */
 185 DWORD WINAPI WaitForSingleObject16( HANDLE handle, DWORD timeout )
 186 {
 187     DWORD retval, mutex_count;
 188
 189     ReleaseThunkLock( &mutex_count );
 190     retval = WaitForSingleObject( handle, timeout );
 191     RestoreThunkLock( mutex_count );
 192     return retval;
 193 }
 194
 195 /***********************************************************************
 196  *           WaitForMultipleObjects   (KERNEL.461)
 197  */
 198 DWORD WINAPI WaitForMultipleObjects16( DWORD count, const HANDLE *handles,
 199                                        BOOL wait_all, DWORD timeout )
 200 {
 201     DWORD retval, mutex_count;
 202
 203     ReleaseThunkLock( &mutex_count );
 204     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, FALSE );
 205     RestoreThunkLock( mutex_count );
 206     return retval;
 207 }
 208
 209 /***********************************************************************
 210  *           WaitForMultipleObjectsEx   (KERNEL.495)
 211  */
 212 DWORD WINAPI WaitForMultipleObjectsEx16( DWORD count, const HANDLE *handles,
 213                                          BOOL wait_all, DWORD timeout, BOOL alertable )
 214 {
 215     DWORD retval, mutex_count;
 216
 217     ReleaseThunkLock( &mutex_count );
 218     retval = WaitForMultipleObjectsEx( count, handles, wait_all, timeout, alertable );
 219     RestoreThunkLock( mutex_count );
 220     return retval;
 221 }
 222
 223 /***********************************************************************
 224  *           RegisterWaitForSingleObject   (KERNEL32.@)
 225  */
 226 BOOL WINAPI RegisterWaitForSingleObject(PHANDLE phNewWaitObject, HANDLE hObject,
 227                 WAITORTIMERCALLBACK Callback, PVOID Context,
 228                 ULONG dwMilliseconds, ULONG dwFlags)
 229 {
 230     FIXME("%p %p %p %p %ld %ld\n",
 231           phNewWaitObject,hObject,Callback,Context,dwMilliseconds,dwFlags);
 232     return FALSE;
 233 }
 234
 235 /***********************************************************************
 236  *           RegisterWaitForSingleObjectEx   (KERNEL32.@)
 237  */
 238 BOOL WINAPI RegisterWaitForSingleObjectEx( HANDLE hObject,
 239                 WAITORTIMERCALLBACK Callback, PVOID Context,
 240                 ULONG dwMilliseconds, ULONG dwFlags )
 241 {
 242     FIXME("%p %p %p %ld %ld\n",
 243           hObject,Callback,Context,dwMilliseconds,dwFlags);
 244     return FALSE;
 245 }
 246
 247 /***********************************************************************
 248  *           UnregisterWait   (KERNEL32.@)
 249  */
 250 BOOL WINAPI UnregisterWait( HANDLE WaitHandle )
 251 {
 252     FIXME("%p\n",WaitHandle);
 253     return FALSE;
 254 }
 255
 256 /***********************************************************************
 257  *           UnregisterWaitEx   (KERNEL32.@)
 258  */
 259 BOOL WINAPI UnregisterWaitEx( HANDLE WaitHandle, HANDLE CompletionEvent )
 260 {
 261     FIXME("%p %p\n",WaitHandle, CompletionEvent);
 262     return FALSE;
 263 }
 264
 265 /***********************************************************************
 266  *           InitializeCriticalSection   (KERNEL32.@)
 267  *
 268  * Initialise a critical section before use.
 269  *
 270  * PARAMS
 271  *  crit [O] Critical section to initialise.
 272  *
 273  * RETURNS
 274  *  Nothing. If the function fails an exception is raised.
 275  */
 276 void WINAPI InitializeCriticalSection( CRITICAL_SECTION *crit )
 277 {
 278     NTSTATUS ret = RtlInitializeCriticalSection( crit );
 279     if (ret) RtlRaiseStatus( ret );
 280 }
 281
 282 /***********************************************************************
 283  *           InitializeCriticalSectionAndSpinCount   (KERNEL32.@)
 284  *
 285  * Initialise a critical section with a spin count.
 286  *
 287  * PARAMS
 288  *  crit      [O] Critical section to initialise.
 289  *  spincount [I] Number of times to spin upon contention.
 290  *
 291  * RETURNS
 292  *  Success: TRUE.
 293  *  Failure: Nothing. If the function fails an exception is raised.
 294  *
 295  * NOTES
 296  *  spincount is ignored on uni-processor systems.
 297  */
 298 BOOL WINAPI InitializeCriticalSectionAndSpinCount( CRITICAL_SECTION *crit, DWORD spincount )
 299 {
 300     NTSTATUS ret = RtlInitializeCriticalSectionAndSpinCount( crit, spincount );
 301     if (ret) RtlRaiseStatus( ret );
 302     return !ret;
 303 }
 304
 305 /***********************************************************************
 306  *           SetCriticalSectionSpinCount   (KERNEL32.@)
 307  *
 308  * Set the spin count for a critical section.
 309  *
 310  * PARAMS
 311  *  crit      [O] Critical section to set the spin count for.
 312  *  spincount [I] Number of times to spin upon contention.
 313  *
 314  * RETURNS
 315  *  The previous spin count value of crit.
 316  *
 317  * NOTES
 318  *  This function is available on NT4SP3 or later, but not Win98.
 319  */
 320 DWORD WINAPI SetCriticalSectionSpinCount( CRITICAL_SECTION *crit, DWORD spincount )
 321 {
 322     ULONG_PTR oldspincount = crit->SpinCount;
 323     if(spincount) FIXME("critsection=%p: spincount=%ld not supported\n", crit, spincount);
 324     crit->SpinCount = spincount;
 325     return oldspincount;
 326 }
 327
 328 /***********************************************************************
 329  *           MakeCriticalSectionGlobal   (KERNEL32.@)
 330  */
 331 void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *crit )
 332 {
 333     /* let's assume that only one thread at a time will try to do this */
 334     HANDLE sem = crit->LockSemaphore;
 335     if (!sem) NtCreateSemaphore( &sem, SEMAPHORE_ALL_ACCESS, NULL, 0, 1 );
 336     crit->LockSemaphore = ConvertToGlobalHandle( sem );
 337     if (crit->DebugInfo)
 338     {
 339         RtlFreeHeap( GetProcessHeap(), 0, crit->DebugInfo );
 340         crit->DebugInfo = NULL;
 341     }
 342 }
 343
 344
 345 /***********************************************************************
 346  *           ReinitializeCriticalSection   (KERNEL32.@)
 347  *
 348  * Initialise an already used critical section.
 349  *
 350  * PARAMS
 351  *  crit [O] Critical section to initialise.
 352  *
 353  * RETURNS
 354  *  Nothing.
 355  */
 356 void WINAPI ReinitializeCriticalSection( CRITICAL_SECTION *crit )
 357 {
 358     if ( !crit->LockSemaphore )
 359         RtlInitializeCriticalSection( crit );
 360 }
 361
 362
 363 /***********************************************************************
 364  *           UninitializeCriticalSection   (KERNEL32.@)
 365  *
 366  * UnInitialise a critical section after use.
 367  *
 368  * PARAMS
 369  *  crit [O] Critical section to uninitialise (destroy).
 370  *
 371  * RETURNS
 372  *  Nothing.
 373  */
 374 void WINAPI UninitializeCriticalSection( CRITICAL_SECTION *crit )
 375 {
 376     RtlDeleteCriticalSection( crit );
 377 }
 378
 379
 380 /***********************************************************************
 381  *           CreateEventA    (KERNEL32.@)
 382  */
 383 HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
 384                             BOOL initial_state, LPCSTR name )
 385 {
 386     WCHAR buffer[MAX_PATH];
 387
 388     if (!name) return CreateEventW( sa, manual_reset, initial_state, NULL );
 389
 390     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 391     {
 392         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 393         return 0;
 394     }
 395     return CreateEventW( sa, manual_reset, initial_state, buffer );
 396 }
 397
 398
 399 /***********************************************************************
 400  *           CreateEventW    (KERNEL32.@)
 401  */
 402 HANDLE WINAPI CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
 403                             BOOL initial_state, LPCWSTR name )
 404 {
 405     HANDLE ret;
 406     DWORD len = name ? strlenW(name) : 0;
 407     if (len >= MAX_PATH)
 408     {
 409         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 410         return 0;
 411     }
 412     /* one buggy program needs this
 413      * ("Van Dale Groot woordenboek der Nederlandse taal")
 414      */
 415     if (sa && IsBadReadPtr(sa,sizeof(SECURITY_ATTRIBUTES)))
 416     {
 417         ERR("Bad security attributes pointer %p\n",sa);
 418         SetLastError( ERROR_INVALID_PARAMETER);
 419         return 0;
 420     }
 421     SERVER_START_REQ( create_event )
 422     {
 423         req->manual_reset = manual_reset;
 424         req->initial_state = initial_state;
 425         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 426         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 427         SetLastError(0);
 428         wine_server_call_err( req );
 429         ret = reply->handle;
 430     }
 431     SERVER_END_REQ;
 432     return ret;
 433 }
 434
 435
 436 /***********************************************************************
 437  *           CreateW32Event    (KERNEL.457)
 438  */
 439 HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
 440 {
 441     return CreateEventA( NULL, manual_reset, initial_state, NULL );
 442 }
 443
 444
 445 /***********************************************************************
 446  *           OpenEventA    (KERNEL32.@)
 447  */
 448 HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
 449 {
 450     WCHAR buffer[MAX_PATH];
 451
 452     if (!name) return OpenEventW( 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 OpenEventW( access, inherit, buffer );
 460 }
 461
 462
 463 /***********************************************************************
 464  *           OpenEventW    (KERNEL32.@)
 465  */
 466 HANDLE WINAPI OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
 467 {
 468     HANDLE ret;
 469     DWORD len = name ? strlenW(name) : 0;
 470     if (len >= MAX_PATH)
 471     {
 472         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 473         return 0;
 474     }
 475     if (!is_version_nt()) access = EVENT_ALL_ACCESS;
 476
 477     SERVER_START_REQ( open_event )
 478     {
 479         req->access  = access;
 480         req->inherit = inherit;
 481         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 482         wine_server_call_err( req );
 483         ret = reply->handle;
 484     }
 485     SERVER_END_REQ;
 486     return ret;
 487 }
 488
 489
 490 /***********************************************************************
 491  *           EVENT_Operation
 492  *
 493  * Execute an event operation (set,reset,pulse).
 494  */
 495 static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
 496 {
 497     BOOL ret;
 498     SERVER_START_REQ( event_op )
 499     {
 500         req->handle = handle;
 501         req->op     = op;
 502         ret = !wine_server_call_err( req );
 503     }
 504     SERVER_END_REQ;
 505     return ret;
 506 }
 507
 508
 509 /***********************************************************************
 510  *           PulseEvent    (KERNEL32.@)
 511  */
 512 BOOL WINAPI PulseEvent( HANDLE handle )
 513 {
 514     return EVENT_Operation( handle, PULSE_EVENT );
 515 }
 516
 517
 518 /***********************************************************************
 519  *           SetW32Event (KERNEL.458)
 520  *           SetEvent    (KERNEL32.@)
 521  */
 522 BOOL WINAPI SetEvent( HANDLE handle )
 523 {
 524     return EVENT_Operation( handle, SET_EVENT );
 525 }
 526
 527
 528 /***********************************************************************
 529  *           ResetW32Event (KERNEL.459)
 530  *           ResetEvent    (KERNEL32.@)
 531  */
 532 BOOL WINAPI ResetEvent( HANDLE handle )
 533 {
 534     return EVENT_Operation( handle, RESET_EVENT );
 535 }
 536
 537
 538 /***********************************************************************
 539  * NOTE: The Win95 VWin32_Event routines given below are really low-level
 540  *       routines implemented directly by VWin32. The user-mode libraries
 541  *       implement Win32 synchronisation routines on top of these low-level
 542  *       primitives. We do it the other way around here :-)
 543  */
 544
 545 /***********************************************************************
 546  *       VWin32_EventCreate     (KERNEL.442)
 547  */
 548 HANDLE WINAPI VWin32_EventCreate(VOID)
 549 {
 550     HANDLE hEvent = CreateEventA( NULL, FALSE, 0, NULL );
 551     return ConvertToGlobalHandle( hEvent );
 552 }
 553
 554 /***********************************************************************
 555  *       VWin32_EventDestroy    (KERNEL.443)
 556  */
 557 VOID WINAPI VWin32_EventDestroy(HANDLE event)
 558 {
 559     CloseHandle( event );
 560 }
 561
 562 /***********************************************************************
 563  *       VWin32_EventWait       (KERNEL.450)
 564  */
 565 VOID WINAPI VWin32_EventWait(HANDLE event)
 566 {
 567     DWORD mutex_count;
 568
 569     ReleaseThunkLock( &mutex_count );
 570     WaitForSingleObject( event, INFINITE );
 571     RestoreThunkLock( mutex_count );
 572 }
 573
 574 /***********************************************************************
 575  *       VWin32_EventSet        (KERNEL.451)
 576  *       KERNEL_479             (KERNEL.479)
 577  */
 578 VOID WINAPI VWin32_EventSet(HANDLE event)
 579 {
 580     SetEvent( event );
 581 }
 582
 583
 584
 585 /***********************************************************************
 586  *           CreateMutexA   (KERNEL32.@)
 587  */
 588 HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
 589 {
 590     WCHAR buffer[MAX_PATH];
 591
 592     if (!name) return CreateMutexW( sa, owner, NULL );
 593
 594     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 595     {
 596         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 597         return 0;
 598     }
 599     return CreateMutexW( sa, owner, buffer );
 600 }
 601
 602
 603 /***********************************************************************
 604  *           CreateMutexW   (KERNEL32.@)
 605  */
 606 HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
 607 {
 608     HANDLE ret;
 609     DWORD len = name ? strlenW(name) : 0;
 610     if (len >= MAX_PATH)
 611     {
 612         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 613         return 0;
 614     }
 615     SERVER_START_REQ( create_mutex )
 616     {
 617         req->owned   = owner;
 618         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 619         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 620         SetLastError(0);
 621         wine_server_call_err( req );
 622         ret = reply->handle;
 623     }
 624     SERVER_END_REQ;
 625     return ret;
 626 }
 627
 628
 629 /***********************************************************************
 630  *           OpenMutexA   (KERNEL32.@)
 631  */
 632 HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
 633 {
 634     WCHAR buffer[MAX_PATH];
 635
 636     if (!name) return OpenMutexW( access, inherit, NULL );
 637
 638     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 639     {
 640         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 641         return 0;
 642     }
 643     return OpenMutexW( access, inherit, buffer );
 644 }
 645
 646
 647 /***********************************************************************
 648  *           OpenMutexW   (KERNEL32.@)
 649  */
 650 HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
 651 {
 652     HANDLE ret;
 653     DWORD len = name ? strlenW(name) : 0;
 654     if (len >= MAX_PATH)
 655     {
 656         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 657         return 0;
 658     }
 659     if (!is_version_nt()) access = MUTEX_ALL_ACCESS;
 660
 661     SERVER_START_REQ( open_mutex )
 662     {
 663         req->access  = access;
 664         req->inherit = inherit;
 665         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 666         wine_server_call_err( req );
 667         ret = reply->handle;
 668     }
 669     SERVER_END_REQ;
 670     return ret;
 671 }
 672
 673
 674 /***********************************************************************
 675  *           ReleaseMutex   (KERNEL32.@)
 676  */
 677 BOOL WINAPI ReleaseMutex( HANDLE handle )
 678 {
 679     BOOL ret;
 680     SERVER_START_REQ( release_mutex )
 681     {
 682         req->handle = handle;
 683         ret = !wine_server_call_err( req );
 684     }
 685     SERVER_END_REQ;
 686     return ret;
 687 }
 688
 689
 690 /*
 691  * Semaphores
 692  */
 693
 694
 695 /***********************************************************************
 696  *           CreateSemaphoreA   (KERNEL32.@)
 697  */
 698 HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
 699 {
 700     WCHAR buffer[MAX_PATH];
 701
 702     if (!name) return CreateSemaphoreW( sa, initial, max, NULL );
 703
 704     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 705     {
 706         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 707         return 0;
 708     }
 709     return CreateSemaphoreW( sa, initial, max, buffer );
 710 }
 711
 712
 713 /***********************************************************************
 714  *           CreateSemaphoreW   (KERNEL32.@)
 715  */
 716 HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
 717                                     LONG max, LPCWSTR name )
 718 {
 719     HANDLE ret;
 720     DWORD len = name ? strlenW(name) : 0;
 721
 722     /* Check parameters */
 723
 724     if ((max <= 0) || (initial < 0) || (initial > max))
 725     {
 726         SetLastError( ERROR_INVALID_PARAMETER );
 727         return 0;
 728     }
 729     if (len >= MAX_PATH)
 730     {
 731         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 732         return 0;
 733     }
 734
 735     SERVER_START_REQ( create_semaphore )
 736     {
 737         req->initial = (unsigned int)initial;
 738         req->max     = (unsigned int)max;
 739         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 740         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 741         SetLastError(0);
 742         wine_server_call_err( req );
 743         ret = reply->handle;
 744     }
 745     SERVER_END_REQ;
 746     return ret;
 747 }
 748
 749
 750 /***********************************************************************
 751  *           OpenSemaphoreA   (KERNEL32.@)
 752  */
 753 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 754 {
 755     WCHAR buffer[MAX_PATH];
 756
 757     if (!name) return OpenSemaphoreW( access, inherit, NULL );
 758
 759     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 760     {
 761         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 762         return 0;
 763     }
 764     return OpenSemaphoreW( access, inherit, buffer );
 765 }
 766
 767
 768 /***********************************************************************
 769  *           OpenSemaphoreW   (KERNEL32.@)
 770  */
 771 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 772 {
 773     HANDLE ret;
 774     DWORD len = name ? strlenW(name) : 0;
 775     if (len >= MAX_PATH)
 776     {
 777         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 778         return 0;
 779     }
 780     if (!is_version_nt()) access = SEMAPHORE_ALL_ACCESS;
 781
 782     SERVER_START_REQ( open_semaphore )
 783     {
 784         req->access  = access;
 785         req->inherit = inherit;
 786         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 787         wine_server_call_err( req );
 788         ret = reply->handle;
 789     }
 790     SERVER_END_REQ;
 791     return ret;
 792 }
 793
 794
 795 /***********************************************************************
 796  *           ReleaseSemaphore   (KERNEL32.@)
 797  */
 798 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 799 {
 800     NTSTATUS status = NtReleaseSemaphore( handle, count, previous );
 801     if (status) SetLastError( RtlNtStatusToDosError(status) );
 802     return !status;
 803 }
 804
 805
 806 /*
 807  * Timers
 808  */
 809
 810
 811 /***********************************************************************
 812  *           CreateWaitableTimerA    (KERNEL32.@)
 813  */
 814 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
 815 {
 816     WCHAR buffer[MAX_PATH];
 817
 818     if (!name) return CreateWaitableTimerW( sa, manual, NULL );
 819
 820     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 821     {
 822         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 823         return 0;
 824     }
 825     return CreateWaitableTimerW( sa, manual, buffer );
 826 }
 827
 828
 829 /***********************************************************************
 830  *           CreateWaitableTimerW    (KERNEL32.@)
 831  */
 832 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
 833 {
 834     HANDLE              handle;
 835     NTSTATUS            status;
 836     UNICODE_STRING      us;
 837     DWORD               attr = 0;
 838     OBJECT_ATTRIBUTES   oa;
 839
 840     if (name) RtlInitUnicodeString(&us, name);
 841     if (sa && (sa->nLength >= sizeof(*sa)) && sa->bInheritHandle)
 842         attr |= OBJ_INHERIT;
 843     InitializeObjectAttributes(&oa, name ? &us : NULL, attr,
 844                                NULL /* FIXME */, NULL /* FIXME */);
 845     status = NtCreateTimer(&handle, TIMER_ALL_ACCESS, &oa,
 846                            manual ? NotificationTimer : SynchronizationTimer);
 847
 848     if (status != STATUS_SUCCESS)
 849     {
 850         SetLastError( RtlNtStatusToDosError(status) );
 851         return 0;
 852     }
 853     return handle;
 854 }
 855
 856
 857 /***********************************************************************
 858  *           OpenWaitableTimerA    (KERNEL32.@)
 859  */
 860 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
 861 {
 862     WCHAR buffer[MAX_PATH];
 863
 864     if (!name) return OpenWaitableTimerW( access, inherit, NULL );
 865
 866     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 867     {
 868         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 869         return 0;
 870     }
 871     return OpenWaitableTimerW( access, inherit, buffer );
 872 }
 873
 874
 875 /***********************************************************************
 876  *           OpenWaitableTimerW    (KERNEL32.@)
 877  */
 878 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 879 {
 880     NTSTATUS            status;
 881     ULONG               attr = 0;
 882     UNICODE_STRING      us;
 883     HANDLE              handle;
 884     OBJECT_ATTRIBUTES   oa;
 885
 886     if (inherit) attr |= OBJ_INHERIT;
 887
 888     if (name) RtlInitUnicodeString(&us, name);
 889     InitializeObjectAttributes(&oa, name ? &us : NULL, attr, NULL /* FIXME */, NULL /* FIXME */);
 890     status = NtOpenTimer(&handle, access, &oa);
 891     if (status != STATUS_SUCCESS)
 892     {
 893         SetLastError( RtlNtStatusToDosError(status) );
 894         return 0;
 895     }
 896     return handle;
 897 }
 898
 899
 900 /***********************************************************************
 901  *           SetWaitableTimer    (KERNEL32.@)
 902  */
 903 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
 904                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
 905 {
 906     NTSTATUS status = NtSetTimer(handle, when, callback, arg, resume, period, NULL);
 907
 908     if (status != STATUS_SUCCESS)
 909     {
 910         SetLastError( RtlNtStatusToDosError(status) );
 911         if (status != STATUS_TIMER_RESUME_IGNORED) return FALSE;
 912     }
 913     return TRUE;
 914 }
 915
 916
 917 /***********************************************************************
 918  *           CancelWaitableTimer    (KERNEL32.@)
 919  */
 920 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
 921 {
 922     NTSTATUS status;
 923
 924     status = NtCancelTimer(handle, NULL);
 925     if (status != STATUS_SUCCESS)
 926     {
 927         SetLastError( RtlNtStatusToDosError(status) );
 928         return FALSE;
 929     }
 930     return TRUE;
 931 }
 932
 933
 934 /***********************************************************************
 935  *           CreateTimerQueue  (KERNEL32.@)
 936  */
 937 HANDLE WINAPI CreateTimerQueue(void)
 938 {
 939     FIXME("stub\n");
 940     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 941     return NULL;
 942 }
 943
 944
 945 /***********************************************************************
 946  *           DeleteTimerQueueEx  (KERNEL32.@)
 947  */
 948 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
 949 {
 950     FIXME("(%p, %p): stub\n", TimerQueue, CompletionEvent);
 951     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 952     return 0;
 953 }
 954
 955 /***********************************************************************
 956  *           CreateTimerQueueTimer  (KERNEL32.@)
 957  *
 958  * Creates a timer-queue timer. This timer expires at the specified due
 959  * time (in ms), then after every specified period (in ms). When the timer
 960  * expires, the callback function is called.
 961  *
 962  * RETURNS
 963  *   nonzero on success or zero on faillure
 964  *
 965  * BUGS
 966  *   Unimplemented
 967  */
 968 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
 969                                    WAITORTIMERCALLBACK Callback, PVOID Parameter,
 970                                    DWORD DueTime, DWORD Period, ULONG Flags )
 971 {
 972     FIXME("stub\n");
 973     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 974     return TRUE;
 975 }
 976
 977 /***********************************************************************
 978  *           DeleteTimerQueueTimer  (KERNEL32.@)
 979  *
 980  * Cancels a timer-queue timer.
 981  *
 982  * RETURNS
 983  *   nonzero on success or zero on faillure
 984  *
 985  * BUGS
 986  *   Unimplemented
 987  */
 988 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
 989                                    HANDLE CompletionEvent )
 990 {
 991     FIXME("stub\n");
 992     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 993     return TRUE;
 994 }
 995
 996
 997 /*
 998  * Pipes
 999  */
1000
1001
1002 /***********************************************************************
1003  *           CreateNamedPipeA   (KERNEL32.@)
1004  */
1005 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
1006                                 DWORD dwPipeMode, DWORD nMaxInstances,
1007                                 DWORD nOutBufferSize, DWORD nInBufferSize,
1008                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
1009 {
1010     WCHAR buffer[MAX_PATH];
1011
1012     if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
1013                                         nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1014
1015     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1016     {
1017         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1018         return INVALID_HANDLE_VALUE;
1019     }
1020     return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
1021                              nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1022 }
1023
1024
1025 /***********************************************************************
1026  *           CreateNamedPipeW   (KERNEL32.@)
1027  */
1028 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
1029                                 DWORD dwPipeMode, DWORD nMaxInstances,
1030                                 DWORD nOutBufferSize, DWORD nInBufferSize,
1031                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
1032 {
1033     HANDLE ret;
1034     DWORD len;
1035     static const WCHAR leadin[] = {'\\','\\','.','\\','P','I','P','E','\\'};
1036
1037     TRACE("(%s, %#08lx, %#08lx, %ld, %ld, %ld, %ld, %p)\n",
1038           debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
1039           nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
1040
1041     if (!name)
1042     {
1043         SetLastError( ERROR_PATH_NOT_FOUND );
1044         return INVALID_HANDLE_VALUE;
1045     }
1046     len = strlenW(name);
1047     if (len >= MAX_PATH)
1048     {
1049         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1050         return INVALID_HANDLE_VALUE;
1051     }
1052     if (strncmpiW(name, leadin, sizeof(leadin)/sizeof(leadin[0])))
1053     {
1054         SetLastError( ERROR_INVALID_NAME );
1055         return INVALID_HANDLE_VALUE;
1056     }
1057     SERVER_START_REQ( create_named_pipe )
1058     {
1059         req->openmode = dwOpenMode;
1060         req->pipemode = dwPipeMode;
1061         req->maxinstances = nMaxInstances;
1062         req->outsize = nOutBufferSize;
1063         req->insize = nInBufferSize;
1064         req->timeout = nDefaultTimeOut;
1065         req->inherit = (attr && (attr->nLength>=sizeof(*attr)) && attr->bInheritHandle);
1066         wine_server_add_data( req, name, len * sizeof(WCHAR) );
1067         SetLastError(0);
1068         if (!wine_server_call_err( req )) ret = reply->handle;
1069         else ret = INVALID_HANDLE_VALUE;
1070     }
1071     SERVER_END_REQ;
1072     return ret;
1073 }
1074
1075
1076 /***********************************************************************
1077  *           PeekNamedPipe   (KERNEL32.@)
1078  */
1079 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
1080                            LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
1081 {
1082 #ifdef FIONREAD
1083     int avail=0, fd, ret, flags;
1084
1085     ret = wine_server_handle_to_fd( hPipe, GENERIC_READ, &fd, NULL, &flags );
1086     if (ret)
1087     {
1088         SetLastError( RtlNtStatusToDosError(ret) );
1089         return FALSE;
1090     }
1091     if (flags & FD_FLAG_RECV_SHUTDOWN)
1092     {
1093         wine_server_release_fd( hPipe, fd );
1094         SetLastError ( ERROR_PIPE_NOT_CONNECTED );
1095         return FALSE;
1096     }
1097
1098     if (ioctl(fd,FIONREAD, &avail ) != 0)
1099     {
1100         TRACE("FIONREAD failed reason: %s\n",strerror(errno));
1101         wine_server_release_fd( hPipe, fd );
1102         return FALSE;
1103     }
1104     if (!avail)  /* check for closed pipe */
1105     {
1106         struct pollfd pollfd;
1107         pollfd.fd = fd;
1108         pollfd.events = POLLIN;
1109         pollfd.revents = 0;
1110         switch (poll( &pollfd, 1, 0 ))
1111         {
1112         case 0:
1113             break;
1114         case 1:  /* got something */
1115             if (!(pollfd.revents & (POLLHUP | POLLERR))) break;
1116             TRACE("POLLHUP | POLLERR\n");
1117             /* fall through */
1118         case -1:
1119             wine_server_release_fd( hPipe, fd );
1120             SetLastError(ERROR_BROKEN_PIPE);
1121             return FALSE;
1122         }
1123     }
1124     TRACE(" 0x%08x bytes available\n", avail );
1125     ret = TRUE;
1126     if (lpcbAvail)
1127         *lpcbAvail = avail;
1128     if (lpcbRead)
1129         *lpcbRead = 0;
1130     if (avail && lpvBuffer)
1131     {
1132         int readbytes = (avail < cbBuffer) ? avail : cbBuffer;
1133         readbytes = recv(fd, lpvBuffer, readbytes, MSG_PEEK);
1134         if (readbytes < 0)
1135         {
1136             WARN("failed to peek socket (%d)\n", errno);
1137             ret = FALSE;
1138         }
1139         else if (lpcbRead)
1140             *lpcbRead = readbytes;
1141     }
1142     wine_server_release_fd( hPipe, fd );
1143     return ret;
1144 #endif /* defined(FIONREAD) */
1145
1146     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1147     FIXME("function not implemented\n");
1148     return FALSE;
1149 }
1150
1151 /***********************************************************************
1152  *           SYNC_CompletePipeOverlapped   (Internal)
1153  */
1154 static void SYNC_CompletePipeOverlapped (LPOVERLAPPED overlapped, DWORD result)
1155 {
1156     TRACE("for %p result %08lx\n",overlapped,result);
1157     if(!overlapped)
1158         return;
1159     overlapped->Internal = result;
1160     SetEvent(overlapped->hEvent);
1161 }
1162
1163
1164 /***********************************************************************
1165  *           WaitNamedPipeA   (KERNEL32.@)
1166  */
1167 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
1168 {
1169     WCHAR buffer[MAX_PATH];
1170
1171     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
1172
1173     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
1174     {
1175         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1176         return 0;
1177     }
1178     return WaitNamedPipeW( buffer, nTimeOut );
1179 }
1180
1181
1182 /***********************************************************************
1183  *           WaitNamedPipeW   (KERNEL32.@)
1184  */
1185 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
1186 {
1187     DWORD len = name ? strlenW(name) : 0;
1188     BOOL ret;
1189     OVERLAPPED ov;
1190
1191     if (len >= MAX_PATH)
1192     {
1193         SetLastError( ERROR_FILENAME_EXCED_RANGE );
1194         return FALSE;
1195     }
1196
1197     TRACE("%s 0x%08lx\n",debugstr_w(name),nTimeOut);
1198
1199     memset(&ov,0,sizeof(ov));
1200     ov.hEvent = CreateEventA( NULL, 0, 0, NULL );
1201     if (!ov.hEvent)
1202         return FALSE;
1203
1204     SERVER_START_REQ( wait_named_pipe )
1205     {
1206         req->timeout = nTimeOut;
1207         req->overlapped = &ov;
1208         req->func = SYNC_CompletePipeOverlapped;
1209         wine_server_add_data( req, name, len * sizeof(WCHAR) );
1210         ret = !wine_server_call_err( req );
1211     }
1212     SERVER_END_REQ;
1213
1214     if(ret)
1215     {
1216         if (WAIT_OBJECT_0==WaitForSingleObject(ov.hEvent,INFINITE))
1217         {
1218             SetLastError(ov.Internal);
1219             ret = (ov.Internal==STATUS_SUCCESS);
1220         }
1221     }
1222     CloseHandle(ov.hEvent);
1223     return ret;
1224 }
1225
1226
1227 /***********************************************************************
1228  *           SYNC_ConnectNamedPipe   (Internal)
1229  */
1230 static BOOL SYNC_ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1231 {
1232     BOOL ret;
1233
1234     if(!overlapped)
1235         return FALSE;
1236
1237     overlapped->Internal = STATUS_PENDING;
1238
1239     SERVER_START_REQ( connect_named_pipe )
1240     {
1241         req->handle = hPipe;
1242         req->overlapped = overlapped;
1243         req->func = SYNC_CompletePipeOverlapped;
1244         ret = !wine_server_call_err( req );
1245     }
1246     SERVER_END_REQ;
1247
1248     return ret;
1249 }
1250
1251 /***********************************************************************
1252  *           ConnectNamedPipe   (KERNEL32.@)
1253  */
1254 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
1255 {
1256     OVERLAPPED ov;
1257     BOOL ret;
1258
1259     TRACE("(%p,%p)\n",hPipe, overlapped);
1260
1261     if(overlapped)
1262     {
1263         if(SYNC_ConnectNamedPipe(hPipe,overlapped))
1264             SetLastError( ERROR_IO_PENDING );
1265         return FALSE;
1266     }
1267
1268     memset(&ov,0,sizeof(ov));
1269     ov.hEvent = CreateEventA(NULL,0,0,NULL);
1270     if (!ov.hEvent)
1271         return FALSE;
1272
1273     ret=SYNC_ConnectNamedPipe(hPipe, &ov);
1274     if(ret)
1275     {
1276         if (WAIT_OBJECT_0==WaitForSingleObject(ov.hEvent,INFINITE))
1277         {
1278             SetLastError(ov.Internal);
1279             ret = (ov.Internal==STATUS_SUCCESS);
1280         }
1281     }
1282
1283     CloseHandle(ov.hEvent);
1284
1285     return ret;
1286 }
1287
1288 /***********************************************************************
1289  *           DisconnectNamedPipe   (KERNEL32.@)
1290  */
1291 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
1292 {
1293     BOOL ret;
1294
1295     TRACE("(%p)\n",hPipe);
1296
1297     SERVER_START_REQ( disconnect_named_pipe )
1298     {
1299         req->handle = hPipe;
1300         ret = !wine_server_call_err( req );
1301         if (ret && reply->fd != -1) close( reply->fd );
1302     }
1303     SERVER_END_REQ;
1304
1305     return ret;
1306 }
1307
1308 /***********************************************************************
1309  *           TransactNamedPipe   (KERNEL32.@)
1310  */
1311 BOOL WINAPI TransactNamedPipe(
1312     HANDLE hPipe, LPVOID lpInput, DWORD dwInputSize, LPVOID lpOutput,
1313     DWORD dwOutputSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped)
1314 {
1315     FIXME("%p %p %ld %p %ld %p %p\n",
1316           hPipe, lpInput, dwInputSize, lpOutput,
1317           dwOutputSize, lpBytesRead, lpOverlapped);
1318     if(lpBytesRead)
1319         *lpBytesRead=0;
1320     return FALSE;
1321 }
1322
1323 /***********************************************************************
1324  *           GetNamedPipeInfo   (KERNEL32.@)
1325  */
1326 BOOL WINAPI GetNamedPipeInfo(
1327     HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
1328     LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
1329 {
1330     BOOL ret;
1331
1332     TRACE("%p %p %p %p %p\n", hNamedPipe, lpFlags,
1333           lpOutputBufferSize, lpInputBufferSize, lpMaxInstances);
1334
1335     SERVER_START_REQ( get_named_pipe_info )
1336     {
1337         req->handle = hNamedPipe;
1338         ret = !wine_server_call_err( req );
1339         if(lpFlags) *lpFlags = reply->flags;
1340         if(lpOutputBufferSize) *lpOutputBufferSize = reply->outsize;
1341         if(lpInputBufferSize) *lpInputBufferSize = reply->outsize;
1342         if(lpMaxInstances) *lpMaxInstances = reply->maxinstances;
1343     }
1344     SERVER_END_REQ;
1345
1346     return ret;
1347 }
1348
1349 /***********************************************************************
1350  *           GetNamedPipeHandleStateA  (KERNEL32.@)
1351  */
1352 BOOL WINAPI GetNamedPipeHandleStateA(
1353     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1354     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1355     LPSTR lpUsername, DWORD nUsernameMaxSize)
1356 {
1357     FIXME("%p %p %p %p %p %p %ld\n",
1358           hNamedPipe, lpState, lpCurInstances,
1359           lpMaxCollectionCount, lpCollectDataTimeout,
1360           lpUsername, nUsernameMaxSize);
1361
1362     return FALSE;
1363 }
1364
1365 /***********************************************************************
1366  *           GetNamedPipeHandleStateW  (KERNEL32.@)
1367  */
1368 BOOL WINAPI GetNamedPipeHandleStateW(
1369     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1370     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1371     LPWSTR lpUsername, DWORD nUsernameMaxSize)
1372 {
1373     FIXME("%p %p %p %p %p %p %ld\n",
1374           hNamedPipe, lpState, lpCurInstances,
1375           lpMaxCollectionCount, lpCollectDataTimeout,
1376           lpUsername, nUsernameMaxSize);
1377
1378     return FALSE;
1379 }
1380
1381 /***********************************************************************
1382  *           SetNamedPipeHandleState  (KERNEL32.@)
1383  */
1384 BOOL WINAPI SetNamedPipeHandleState(
1385     HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1386     LPDWORD lpCollectDataTimeout)
1387 {
1388     FIXME("%p %p %p %p\n",
1389           hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout);
1390     return FALSE;
1391 }
1392
1393 /***********************************************************************
1394  *           CallNamedPipeA  (KERNEL32.@)
1395  */
1396 BOOL WINAPI CallNamedPipeA(
1397     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1398     LPVOID lpOutput, DWORD lpOutputSize,
1399     LPDWORD lpBytesRead, DWORD nTimeout)
1400 {
1401     FIXME("%s %p %ld %p %ld %p %ld\n",
1402            debugstr_a(lpNamedPipeName), lpInput, lpInputSize,
1403            lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1404     return FALSE;
1405 }
1406
1407 /***********************************************************************
1408  *           CallNamedPipeW  (KERNEL32.@)
1409  */
1410 BOOL WINAPI CallNamedPipeW(
1411     LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1412     LPVOID lpOutput, DWORD lpOutputSize,
1413     LPDWORD lpBytesRead, DWORD nTimeout)
1414 {
1415     FIXME("%s %p %ld %p %ld %p %ld\n",
1416            debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1417            lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1418     return FALSE;
1419 }
1420
1421 /******************************************************************
1422  *              CreatePipe (KERNEL32.@)
1423  *
1424  */
1425 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1426                         LPSECURITY_ATTRIBUTES sa, DWORD size )
1427 {
1428     static unsigned  index = 0;
1429     char        name[64];
1430     HANDLE      hr, hw;
1431     unsigned    in_index = index;
1432
1433     *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1434     /* generate a unique pipe name (system wide) */
1435     do
1436     {
1437         sprintf(name, "\\\\.\\pipe\\Win32.Pipes.%08lu.%08u", GetCurrentProcessId(), ++index);
1438         hr = CreateNamedPipeA(name, PIPE_ACCESS_INBOUND,
1439                               PIPE_TYPE_BYTE | PIPE_WAIT, 1, size, size,
1440                               NMPWAIT_USE_DEFAULT_WAIT, sa);
1441     } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1442     /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1443     if (hr == INVALID_HANDLE_VALUE) return FALSE;
1444
1445     hw = CreateFileA(name, GENERIC_WRITE, 0, sa, OPEN_EXISTING, 0, 0);
1446     if (hw == INVALID_HANDLE_VALUE)
1447     {
1448         CloseHandle(hr);
1449         return FALSE;
1450     }
1451
1452     *hReadPipe = hr;
1453     *hWritePipe = hw;
1454     return TRUE;
1455 }
1456
1457
1458 /******************************************************************************
1459  * CreateMailslotA [KERNEL32.@]
1460  */
1461 HANDLE WINAPI CreateMailslotA( LPCSTR lpName, DWORD nMaxMessageSize,
1462                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1463 {
1464     DWORD len;
1465     HANDLE handle;
1466     LPWSTR name = NULL;
1467
1468     TRACE("%s %ld %ld %p\n", debugstr_a(lpName),
1469           nMaxMessageSize, lReadTimeout, sa);
1470
1471     if( lpName )
1472     {
1473         len = MultiByteToWideChar( CP_ACP, 0, lpName, -1, NULL, 0 );
1474         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1475         MultiByteToWideChar( CP_ACP, 0, lpName, -1, name, len );
1476     }
1477
1478     handle = CreateMailslotW( name, nMaxMessageSize, lReadTimeout, sa );
1479
1480     if( name )
1481         HeapFree( GetProcessHeap(), 0, name );
1482
1483     return handle;
1484 }
1485
1486
1487 /******************************************************************************
1488  * CreateMailslotW [KERNEL32.@]
1489  *
1490  * Create a mailslot with specified name.
1491  *
1492  * PARAMS
1493  *    lpName          [I] Pointer to string for mailslot name
1494  *    nMaxMessageSize [I] Maximum message size
1495  *    lReadTimeout    [I] Milliseconds before read time-out
1496  *    sa              [I] Pointer to security structure
1497  *
1498  * RETURNS
1499  *    Success: Handle to mailslot
1500  *    Failure: INVALID_HANDLE_VALUE
1501  */
1502 HANDLE WINAPI CreateMailslotW( LPCWSTR lpName, DWORD nMaxMessageSize,
1503                                DWORD lReadTimeout, LPSECURITY_ATTRIBUTES sa )
1504 {
1505     FIXME("(%s,%ld,%ld,%p): stub\n", debugstr_w(lpName),
1506           nMaxMessageSize, lReadTimeout, sa);
1507     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1508     return INVALID_HANDLE_VALUE;
1509 }
1510
1511
1512 /******************************************************************************
1513  * GetMailslotInfo [KERNEL32.@]
1514  *
1515  * Retrieve information about a mailslot.
1516  *
1517  * PARAMS
1518  *    hMailslot        [I] Mailslot handle
1519  *    lpMaxMessageSize [O] Address of maximum message size
1520  *    lpNextSize       [O] Address of size of next message
1521  *    lpMessageCount   [O] Address of number of messages
1522  *    lpReadTimeout    [O] Address of read time-out
1523  *
1524  * RETURNS
1525  *    Success: TRUE
1526  *    Failure: FALSE
1527  */
1528 BOOL WINAPI GetMailslotInfo( HANDLE hMailslot, LPDWORD lpMaxMessageSize,
1529                                LPDWORD lpNextSize, LPDWORD lpMessageCount,
1530                                LPDWORD lpReadTimeout )
1531 {
1532     FIXME("(%p): stub\n",hMailslot);
1533     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1534     return FALSE;
1535 }
1536
1537
1538 /******************************************************************************
1539  * SetMailslotInfo [KERNEL32.@]
1540  *
1541  * Set the read timeout of a mailslot.
1542  *
1543  * PARAMS
1544  *  hMailslot     [I] Mailslot handle
1545  *  dwReadTimeout [I] Timeout in milliseconds.
1546  *
1547  * RETURNS
1548  *    Success: TRUE
1549  *    Failure: FALSE
1550  */
1551 BOOL WINAPI SetMailslotInfo( HANDLE hMailslot, DWORD dwReadTimeout)
1552 {
1553     FIXME("%p %ld: stub\n", hMailslot, dwReadTimeout);
1554     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1555     return FALSE;
1556 }
1557
1558
1559 /******************************************************************************
1560  *              CreateIoCompletionPort (KERNEL32.@)
1561  */
1562 HANDLE WINAPI CreateIoCompletionPort(HANDLE hFileHandle, HANDLE hExistingCompletionPort,
1563                                      DWORD dwCompletionKey, DWORD dwNumberOfConcurrentThreads)
1564 {
1565     FIXME("(%p, %p, %08lx, %08lx): stub.\n",
1566           hFileHandle, hExistingCompletionPort, dwCompletionKey, dwNumberOfConcurrentThreads);
1567     return NULL;
1568 }
1569
1570
1571 /******************************************************************************
1572  *              GetQueuedCompletionStatus (KERNEL32.@)
1573  */
1574 BOOL WINAPI GetQueuedCompletionStatus( HANDLE CompletionPort, LPDWORD lpNumberOfBytesTransferred,
1575                                        LPDWORD lpCompletionKey, LPOVERLAPPED *lpOverlapped,
1576                                        DWORD dwMilliseconds )
1577 {
1578     FIXME("(%p,%p,%p,%p,%ld), stub!\n",
1579           CompletionPort,lpNumberOfBytesTransferred,lpCompletionKey,lpOverlapped,dwMilliseconds);
1580     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1581     return FALSE;
1582 }
1583
1584 /******************************************************************************
1585  *              CreateJobObjectW (KERNEL32.@)
1586  */
1587 HANDLE WINAPI CreateJobObjectW( LPSECURITY_ATTRIBUTES attr, LPCWSTR name )
1588 {
1589     FIXME("%p %s\n", attr, debugstr_w(name) );
1590     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1591     return 0;
1592 }
1593
1594 /******************************************************************************
1595  *              CreateJobObjectA (KERNEL32.@)
1596  */
1597 HANDLE WINAPI CreateJobObjectA( LPSECURITY_ATTRIBUTES attr, LPCSTR name )
1598 {
1599     LPWSTR str = NULL;
1600     UINT len;
1601     HANDLE r;
1602
1603     TRACE("%p %s\n", attr, debugstr_a(name) );
1604
1605     if( name )
1606     {
1607         len = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
1608         str = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1609         if( !str )
1610         {
1611             SetLastError( ERROR_OUTOFMEMORY );
1612             return 0;
1613         }
1614         len = MultiByteToWideChar( CP_ACP, 0, name, -1, str, len );
1615     }
1616
1617     r = CreateJobObjectW( attr, str );
1618
1619     if( str )
1620         HeapFree( GetProcessHeap(), 0, str );
1621
1622     return r;
1623 }
1624
1625 /******************************************************************************
1626  *              AssignProcessToJobObject (KERNEL32.@)
1627  */
1628 BOOL WINAPI AssignProcessToJobObject( HANDLE hJob, HANDLE hProcess )
1629 {
1630     FIXME("%p %p\n", hJob, hProcess);
1631     return TRUE;
1632 }
1633
1634 #ifdef __i386__
1635
1636 /***********************************************************************
1637  *              InterlockedCompareExchange (KERNEL32.@)
1638  */
1639 /* LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare ); */
1640 __ASM_GLOBAL_FUNC(InterlockedCompareExchange,
1641                   "movl 12(%esp),%eax\n\t"
1642                   "movl 8(%esp),%ecx\n\t"
1643                   "movl 4(%esp),%edx\n\t"
1644                   "lock; cmpxchgl %ecx,(%edx)\n\t"
1645                   "ret $12");
1646
1647 /***********************************************************************
1648  *              InterlockedExchange (KERNEL32.@)
1649  */
1650 /* LONG WINAPI InterlockedExchange( PLONG dest, LONG val ); */
1651 __ASM_GLOBAL_FUNC(InterlockedExchange,
1652                   "movl 8(%esp),%eax\n\t"
1653                   "movl 4(%esp),%edx\n\t"
1654                   "lock; xchgl %eax,(%edx)\n\t"
1655                   "ret $8");
1656
1657 /***********************************************************************
1658  *              InterlockedExchangeAdd (KERNEL32.@)
1659  */
1660 /* LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr ); */
1661 __ASM_GLOBAL_FUNC(InterlockedExchangeAdd,
1662                   "movl 8(%esp),%eax\n\t"
1663                   "movl 4(%esp),%edx\n\t"
1664                   "lock; xaddl %eax,(%edx)\n\t"
1665                   "ret $8");
1666
1667 /***********************************************************************
1668  *              InterlockedIncrement (KERNEL32.@)
1669  */
1670 /* LONG WINAPI InterlockedIncrement( PLONG dest ); */
1671 __ASM_GLOBAL_FUNC(InterlockedIncrement,
1672                   "movl 4(%esp),%edx\n\t"
1673                   "movl $1,%eax\n\t"
1674                   "lock; xaddl %eax,(%edx)\n\t"
1675                   "incl %eax\n\t"
1676                   "ret $4");
1677
1678 /***********************************************************************
1679  *              InterlockedDecrement (KERNEL32.@)
1680  */
1681 __ASM_GLOBAL_FUNC(InterlockedDecrement,
1682                   "movl 4(%esp),%edx\n\t"
1683                   "movl $-1,%eax\n\t"
1684                   "lock; xaddl %eax,(%edx)\n\t"
1685                   "decl %eax\n\t"
1686                   "ret $4");
1687
1688 #else  /* __i386__ */
1689
1690 /***********************************************************************
1691  *              InterlockedCompareExchange (KERNEL32.@)
1692  *
1693  * Atomically swap one value with another.
1694  *
1695  * PARAMS
1696  *  dest    [I/O] The value to replace
1697  *  xchq    [I]   The value to be swapped
1698  *  compare [I]   The value to compare to dest
1699  *
1700  * RETURNS
1701  *  The resulting value of dest.
1702  *
1703  * NOTES
1704  *  dest is updated only if it is equal to compare, otherwise no swap is done.
1705  */
1706 LONG WINAPI InterlockedCompareExchange( PLONG dest, LONG xchg, LONG compare )
1707 {
1708     return interlocked_cmpxchg( dest, xchg, compare );
1709 }
1710
1711 /***********************************************************************
1712  *              InterlockedExchange (KERNEL32.@)
1713  *
1714  * Atomically swap one value with another.
1715  *
1716  * PARAMS
1717  *  dest [I/O] The value to replace
1718  *  val  [I]   The value to be swapped
1719  *
1720  * RETURNS
1721  *  The resulting value of dest.
1722  */
1723 LONG WINAPI InterlockedExchange( PLONG dest, LONG val )
1724 {
1725     return interlocked_xchg( dest, val );
1726 }
1727
1728 /***********************************************************************
1729  *              InterlockedExchangeAdd (KERNEL32.@)
1730  *
1731  * Atomically add one value to another.
1732  *
1733  * PARAMS
1734  *  dest [I/O] The value to add to
1735  *  incr [I]   The value to be added
1736  *
1737  * RETURNS
1738  *  The resulting value of dest.
1739  */
1740 LONG WINAPI InterlockedExchangeAdd( PLONG dest, LONG incr )
1741 {
1742     return interlocked_xchg_add( dest, incr );
1743 }
1744
1745 /***********************************************************************
1746  *              InterlockedIncrement (KERNEL32.@)
1747  *
1748  * Atomically increment a value.
1749  *
1750  * PARAMS
1751  *  dest [I/O] The value to increment
1752  *
1753  * RETURNS
1754  *  The resulting value of dest.
1755  */
1756 LONG WINAPI InterlockedIncrement( PLONG dest )
1757 {
1758     return interlocked_xchg_add( dest, 1 ) + 1;
1759 }
1760
1761 /***********************************************************************
1762  *              InterlockedDecrement (KERNEL32.@)
1763  *
1764  * Atomically decrement a value.
1765  *
1766  * PARAMS
1767  *  dest [I/O] The value to decrement
1768  *
1769  * RETURNS
1770  *  The resulting value of dest.
1771  */
1772 LONG WINAPI InterlockedDecrement( PLONG dest )
1773 {
1774     return interlocked_xchg_add( dest, -1 ) - 1;
1775 }
1776
1777 #endif  /* __i386__ */