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 #include <stdio.h>
  36
  37 #include "winbase.h"
  38 #include "winerror.h"
  39 #include "winnls.h"
  40
  41 #include "wine/server.h"
  42 #include "wine/unicode.h"
  43 #include "file.h"
  44
  45 #include "wine/debug.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(win32);
  48
  49 /* check if current version is NT or Win95 */
  50 inline static int is_version_nt(void)
  51 {
  52     return !(GetVersion() & 0x80000000);
  53 }
  54
  55
  56 /***********************************************************************
  57  *           CreateEventA    (KERNEL32.@)
  58  */
  59 HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
  60                             BOOL initial_state, LPCSTR name )
  61 {
  62     WCHAR buffer[MAX_PATH];
  63
  64     if (!name) return CreateEventW( sa, manual_reset, initial_state, NULL );
  65
  66     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
  67     {
  68         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  69         return 0;
  70     }
  71     return CreateEventW( sa, manual_reset, initial_state, buffer );
  72 }
  73
  74
  75 /***********************************************************************
  76  *           CreateEventW    (KERNEL32.@)
  77  */
  78 HANDLE WINAPI CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
  79                             BOOL initial_state, LPCWSTR name )
  80 {
  81     HANDLE ret;
  82     DWORD len = name ? strlenW(name) : 0;
  83     if (len >= MAX_PATH)
  84     {
  85         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  86         return 0;
  87     }
  88     /* one buggy program needs this
  89      * ("Van Dale Groot woordenboek der Nederlandse taal")
  90      */
  91     if (sa && IsBadReadPtr(sa,sizeof(SECURITY_ATTRIBUTES)))
  92     {
  93         ERR("Bad security attributes pointer %p\n",sa);
  94         SetLastError( ERROR_INVALID_PARAMETER);
  95         return 0;
  96     }
  97     SERVER_START_REQ( create_event )
  98     {
  99         req->manual_reset = manual_reset;
 100         req->initial_state = initial_state;
 101         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 102         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 103         SetLastError(0);
 104         wine_server_call_err( req );
 105         ret = reply->handle;
 106     }
 107     SERVER_END_REQ;
 108     return ret;
 109 }
 110
 111
 112 /***********************************************************************
 113  *           CreateW32Event    (KERNEL.457)
 114  */
 115 HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
 116 {
 117     return CreateEventA( NULL, manual_reset, initial_state, NULL );
 118 }
 119
 120
 121 /***********************************************************************
 122  *           OpenEventA    (KERNEL32.@)
 123  */
 124 HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
 125 {
 126     WCHAR buffer[MAX_PATH];
 127
 128     if (!name) return OpenEventW( access, inherit, NULL );
 129
 130     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 131     {
 132         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 133         return 0;
 134     }
 135     return OpenEventW( access, inherit, buffer );
 136 }
 137
 138
 139 /***********************************************************************
 140  *           OpenEventW    (KERNEL32.@)
 141  */
 142 HANDLE WINAPI OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
 143 {
 144     HANDLE ret;
 145     DWORD len = name ? strlenW(name) : 0;
 146     if (len >= MAX_PATH)
 147     {
 148         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 149         return 0;
 150     }
 151     if (!is_version_nt()) access = EVENT_ALL_ACCESS;
 152
 153     SERVER_START_REQ( open_event )
 154     {
 155         req->access  = access;
 156         req->inherit = inherit;
 157         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 158         wine_server_call_err( req );
 159         ret = reply->handle;
 160     }
 161     SERVER_END_REQ;
 162     return ret;
 163 }
 164
 165
 166 /***********************************************************************
 167  *           EVENT_Operation
 168  *
 169  * Execute an event operation (set,reset,pulse).
 170  */
 171 static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
 172 {
 173     BOOL ret;
 174     SERVER_START_REQ( event_op )
 175     {
 176         req->handle = handle;
 177         req->op     = op;
 178         ret = !wine_server_call_err( req );
 179     }
 180     SERVER_END_REQ;
 181     return ret;
 182 }
 183
 184
 185 /***********************************************************************
 186  *           PulseEvent    (KERNEL32.@)
 187  */
 188 BOOL WINAPI PulseEvent( HANDLE handle )
 189 {
 190     return EVENT_Operation( handle, PULSE_EVENT );
 191 }
 192
 193
 194 /***********************************************************************
 195  *           SetW32Event (KERNEL.458)
 196  *           SetEvent    (KERNEL32.@)
 197  */
 198 BOOL WINAPI SetEvent( HANDLE handle )
 199 {
 200     return EVENT_Operation( handle, SET_EVENT );
 201 }
 202
 203
 204 /***********************************************************************
 205  *           ResetW32Event (KERNEL.459)
 206  *           ResetEvent    (KERNEL32.@)
 207  */
 208 BOOL WINAPI ResetEvent( HANDLE handle )
 209 {
 210     return EVENT_Operation( handle, RESET_EVENT );
 211 }
 212
 213
 214 /***********************************************************************
 215  * NOTE: The Win95 VWin32_Event routines given below are really low-level
 216  *       routines implemented directly by VWin32. The user-mode libraries
 217  *       implement Win32 synchronisation routines on top of these low-level
 218  *       primitives. We do it the other way around here :-)
 219  */
 220
 221 /***********************************************************************
 222  *       VWin32_EventCreate     (KERNEL.442)
 223  */
 224 HANDLE WINAPI VWin32_EventCreate(VOID)
 225 {
 226     HANDLE hEvent = CreateEventA( NULL, FALSE, 0, NULL );
 227     return ConvertToGlobalHandle( hEvent );
 228 }
 229
 230 /***********************************************************************
 231  *       VWin32_EventDestroy    (KERNEL.443)
 232  */
 233 VOID WINAPI VWin32_EventDestroy(HANDLE event)
 234 {
 235     CloseHandle( event );
 236 }
 237
 238 /***********************************************************************
 239  *       VWin32_EventWait       (KERNEL.450)
 240  */
 241 VOID WINAPI VWin32_EventWait(HANDLE event)
 242 {
 243     DWORD mutex_count;
 244
 245     ReleaseThunkLock( &mutex_count );
 246     WaitForSingleObject( event, INFINITE );
 247     RestoreThunkLock( mutex_count );
 248 }
 249
 250 /***********************************************************************
 251  *       VWin32_EventSet        (KERNEL.451)
 252  *       KERNEL_479             (KERNEL.479)
 253  */
 254 VOID WINAPI VWin32_EventSet(HANDLE event)
 255 {
 256     SetEvent( event );
 257 }
 258
 259
 260
 261 /***********************************************************************
 262  *           CreateMutexA   (KERNEL32.@)
 263  */
 264 HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
 265 {
 266     WCHAR buffer[MAX_PATH];
 267
 268     if (!name) return CreateMutexW( sa, owner, NULL );
 269
 270     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 271     {
 272         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 273         return 0;
 274     }
 275     return CreateMutexW( sa, owner, buffer );
 276 }
 277
 278
 279 /***********************************************************************
 280  *           CreateMutexW   (KERNEL32.@)
 281  */
 282 HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
 283 {
 284     HANDLE ret;
 285     DWORD len = name ? strlenW(name) : 0;
 286     if (len >= MAX_PATH)
 287     {
 288         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 289         return 0;
 290     }
 291     SERVER_START_REQ( create_mutex )
 292     {
 293         req->owned   = owner;
 294         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 295         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 296         SetLastError(0);
 297         wine_server_call_err( req );
 298         ret = reply->handle;
 299     }
 300     SERVER_END_REQ;
 301     return ret;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           OpenMutexA   (KERNEL32.@)
 307  */
 308 HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
 309 {
 310     WCHAR buffer[MAX_PATH];
 311
 312     if (!name) return OpenMutexW( access, inherit, NULL );
 313
 314     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 315     {
 316         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 317         return 0;
 318     }
 319     return OpenMutexW( access, inherit, buffer );
 320 }
 321
 322
 323 /***********************************************************************
 324  *           OpenMutexW   (KERNEL32.@)
 325  */
 326 HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
 327 {
 328     HANDLE ret;
 329     DWORD len = name ? strlenW(name) : 0;
 330     if (len >= MAX_PATH)
 331     {
 332         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 333         return 0;
 334     }
 335     if (!is_version_nt()) access = MUTEX_ALL_ACCESS;
 336
 337     SERVER_START_REQ( open_mutex )
 338     {
 339         req->access  = access;
 340         req->inherit = inherit;
 341         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 342         wine_server_call_err( req );
 343         ret = reply->handle;
 344     }
 345     SERVER_END_REQ;
 346     return ret;
 347 }
 348
 349
 350 /***********************************************************************
 351  *           ReleaseMutex   (KERNEL32.@)
 352  */
 353 BOOL WINAPI ReleaseMutex( HANDLE handle )
 354 {
 355     BOOL ret;
 356     SERVER_START_REQ( release_mutex )
 357     {
 358         req->handle = handle;
 359         ret = !wine_server_call_err( req );
 360     }
 361     SERVER_END_REQ;
 362     return ret;
 363 }
 364
 365
 366 /*
 367  * Semaphores
 368  */
 369
 370
 371 /***********************************************************************
 372  *           CreateSemaphoreA   (KERNEL32.@)
 373  */
 374 HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
 375 {
 376     WCHAR buffer[MAX_PATH];
 377
 378     if (!name) return CreateSemaphoreW( sa, initial, max, NULL );
 379
 380     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 381     {
 382         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 383         return 0;
 384     }
 385     return CreateSemaphoreW( sa, initial, max, buffer );
 386 }
 387
 388
 389 /***********************************************************************
 390  *           CreateSemaphoreW   (KERNEL32.@)
 391  */
 392 HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
 393                                     LONG max, LPCWSTR name )
 394 {
 395     HANDLE ret;
 396     DWORD len = name ? strlenW(name) : 0;
 397
 398     /* Check parameters */
 399
 400     if ((max <= 0) || (initial < 0) || (initial > max))
 401     {
 402         SetLastError( ERROR_INVALID_PARAMETER );
 403         return 0;
 404     }
 405     if (len >= MAX_PATH)
 406     {
 407         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 408         return 0;
 409     }
 410
 411     SERVER_START_REQ( create_semaphore )
 412     {
 413         req->initial = (unsigned int)initial;
 414         req->max     = (unsigned int)max;
 415         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 416         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 417         SetLastError(0);
 418         wine_server_call_err( req );
 419         ret = reply->handle;
 420     }
 421     SERVER_END_REQ;
 422     return ret;
 423 }
 424
 425
 426 /***********************************************************************
 427  *           OpenSemaphoreA   (KERNEL32.@)
 428  */
 429 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 430 {
 431     WCHAR buffer[MAX_PATH];
 432
 433     if (!name) return OpenSemaphoreW( access, inherit, NULL );
 434
 435     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 436     {
 437         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 438         return 0;
 439     }
 440     return OpenSemaphoreW( access, inherit, buffer );
 441 }
 442
 443
 444 /***********************************************************************
 445  *           OpenSemaphoreW   (KERNEL32.@)
 446  */
 447 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 448 {
 449     HANDLE ret;
 450     DWORD len = name ? strlenW(name) : 0;
 451     if (len >= MAX_PATH)
 452     {
 453         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 454         return 0;
 455     }
 456     if (!is_version_nt()) access = SEMAPHORE_ALL_ACCESS;
 457
 458     SERVER_START_REQ( open_semaphore )
 459     {
 460         req->access  = access;
 461         req->inherit = inherit;
 462         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 463         wine_server_call_err( req );
 464         ret = reply->handle;
 465     }
 466     SERVER_END_REQ;
 467     return ret;
 468 }
 469
 470
 471 /***********************************************************************
 472  *           ReleaseSemaphore   (KERNEL32.@)
 473  */
 474 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 475 {
 476     NTSTATUS status = NtReleaseSemaphore( handle, count, previous );
 477     if (status) SetLastError( RtlNtStatusToDosError(status) );
 478     return !status;
 479 }
 480
 481
 482 /*
 483  * Timers
 484  */
 485
 486
 487 /***********************************************************************
 488  *           CreateWaitableTimerA    (KERNEL32.@)
 489  */
 490 HANDLE WINAPI CreateWaitableTimerA( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCSTR name )
 491 {
 492     WCHAR buffer[MAX_PATH];
 493
 494     if (!name) return CreateWaitableTimerW( sa, manual, NULL );
 495
 496     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 497     {
 498         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 499         return 0;
 500     }
 501     return CreateWaitableTimerW( sa, manual, buffer );
 502 }
 503
 504
 505 /***********************************************************************
 506  *           CreateWaitableTimerW    (KERNEL32.@)
 507  */
 508 HANDLE WINAPI CreateWaitableTimerW( SECURITY_ATTRIBUTES *sa, BOOL manual, LPCWSTR name )
 509 {
 510     HANDLE              handle;
 511     NTSTATUS            status;
 512     UNICODE_STRING      us;
 513     DWORD               attr = 0;
 514     OBJECT_ATTRIBUTES   oa;
 515
 516     if (name) RtlInitUnicodeString(&us, name);
 517     if (sa && (sa->nLength >= sizeof(*sa)) && sa->bInheritHandle)
 518         attr |= OBJ_INHERIT;
 519     InitializeObjectAttributes(&oa, name ? &us : NULL, attr,
 520                                NULL /* FIXME */, NULL /* FIXME */);
 521     status = NtCreateTimer(&handle, TIMER_ALL_ACCESS, &oa,
 522                            manual ? NotificationTimer : SynchronizationTimer);
 523
 524     if (status != STATUS_SUCCESS)
 525     {
 526         SetLastError( RtlNtStatusToDosError(status) );
 527         return 0;
 528     }
 529     return handle;
 530 }
 531
 532
 533 /***********************************************************************
 534  *           OpenWaitableTimerA    (KERNEL32.@)
 535  */
 536 HANDLE WINAPI OpenWaitableTimerA( DWORD access, BOOL inherit, LPCSTR name )
 537 {
 538     WCHAR buffer[MAX_PATH];
 539
 540     if (!name) return OpenWaitableTimerW( access, inherit, NULL );
 541
 542     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 543     {
 544         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 545         return 0;
 546     }
 547     return OpenWaitableTimerW( access, inherit, buffer );
 548 }
 549
 550
 551 /***********************************************************************
 552  *           OpenWaitableTimerW    (KERNEL32.@)
 553  */
 554 HANDLE WINAPI OpenWaitableTimerW( DWORD access, BOOL inherit, LPCWSTR name )
 555 {
 556     NTSTATUS            status;
 557     ULONG               attr = 0;
 558     UNICODE_STRING      us;
 559     HANDLE              handle;
 560     OBJECT_ATTRIBUTES   oa;
 561
 562     if (inherit) attr |= OBJ_INHERIT;
 563
 564     if (name) RtlInitUnicodeString(&us, name);
 565     InitializeObjectAttributes(&oa, name ? &us : NULL, attr, NULL /* FIXME */, NULL /* FIXME */);
 566     status = NtOpenTimer(&handle, access, &oa);
 567     if (status != STATUS_SUCCESS)
 568     {
 569         SetLastError( RtlNtStatusToDosError(status) );
 570         return 0;
 571     }
 572     return handle;
 573 }
 574
 575
 576 /***********************************************************************
 577  *           SetWaitableTimer    (KERNEL32.@)
 578  */
 579 BOOL WINAPI SetWaitableTimer( HANDLE handle, const LARGE_INTEGER *when, LONG period,
 580                               PTIMERAPCROUTINE callback, LPVOID arg, BOOL resume )
 581 {
 582     NTSTATUS status = NtSetTimer(handle, when, callback, arg, resume, period, NULL);
 583
 584     if (status != STATUS_SUCCESS)
 585     {
 586         SetLastError( RtlNtStatusToDosError(status) );
 587         if (status != STATUS_TIMER_RESUME_IGNORED) return FALSE;
 588     }
 589     return TRUE;
 590 }
 591
 592
 593 /***********************************************************************
 594  *           CancelWaitableTimer    (KERNEL32.@)
 595  */
 596 BOOL WINAPI CancelWaitableTimer( HANDLE handle )
 597 {
 598     NTSTATUS status;
 599
 600     status = NtCancelTimer(handle, NULL);
 601     if (status != STATUS_SUCCESS)
 602     {
 603         SetLastError( RtlNtStatusToDosError(status) );
 604         return FALSE;
 605     }
 606     return TRUE;
 607 }
 608
 609
 610 /***********************************************************************
 611  *           CreateTimerQueue  (KERNEL32.@)
 612  */
 613 HANDLE WINAPI CreateTimerQueue(void)
 614 {
 615     FIXME("stub\n");
 616     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 617     return NULL;
 618 }
 619
 620
 621 /***********************************************************************
 622  *           DeleteTimerQueueEx  (KERNEL32.@)
 623  */
 624 BOOL WINAPI DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent)
 625 {
 626     FIXME("(%p, %p): stub\n", TimerQueue, CompletionEvent);
 627     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 628     return 0;
 629 }
 630
 631 /***********************************************************************
 632  *           CreateTimerQueueTimer  (KERNEL32.@)
 633  *
 634  * Creates a timer-queue timer. This timer expires at the specified due
 635  * time (in ms), then after every specified period (in ms). When the timer
 636  * expires, the callback function is called.
 637  *
 638  * RETURNS
 639  *   nonzero on success or zero on faillure
 640  *
 641  * BUGS
 642  *   Unimplemented
 643  */
 644 BOOL WINAPI CreateTimerQueueTimer( PHANDLE phNewTimer, HANDLE TimerQueue,
 645                                    WAITORTIMERCALLBACK Callback, PVOID Parameter,
 646                                    DWORD DueTime, DWORD Period, ULONG Flags )
 647 {
 648     FIXME("stub\n");
 649     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 650     return TRUE;
 651 }
 652
 653 /***********************************************************************
 654  *           DeleteTimerQueueTimer  (KERNEL32.@)
 655  *
 656  * Cancels a timer-queue timer.
 657  *
 658  * RETURNS
 659  *   nonzero on success or zero on faillure
 660  *
 661  * BUGS
 662  *   Unimplemented
 663  */
 664 BOOL WINAPI DeleteTimerQueueTimer( HANDLE TimerQueue, HANDLE Timer,
 665                                    HANDLE CompletionEvent )
 666 {
 667     FIXME("stub\n");
 668     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 669     return TRUE;
 670 }
 671
 672
 673 /*
 674  * Pipes
 675  */
 676
 677
 678 /***********************************************************************
 679  *           CreateNamedPipeA   (KERNEL32.@)
 680  */
 681 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
 682                                 DWORD dwPipeMode, DWORD nMaxInstances,
 683                                 DWORD nOutBufferSize, DWORD nInBufferSize,
 684                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
 685 {
 686     WCHAR buffer[MAX_PATH];
 687
 688     if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
 689                                         nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 690
 691     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 692     {
 693         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 694         return INVALID_HANDLE_VALUE;
 695     }
 696     return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
 697                              nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 698 }
 699
 700
 701 /***********************************************************************
 702  *           CreateNamedPipeW   (KERNEL32.@)
 703  */
 704 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
 705                                 DWORD dwPipeMode, DWORD nMaxInstances,
 706                                 DWORD nOutBufferSize, DWORD nInBufferSize,
 707                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
 708 {
 709     HANDLE ret;
 710     DWORD len;
 711     static const WCHAR leadin[] = {'\\','\\','.','\\','P','I','P','E','\\'};
 712
 713     TRACE("(%s, %#08lx, %#08lx, %ld, %ld, %ld, %ld, %p)\n",
 714           debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
 715           nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 716
 717     if (!name)
 718     {
 719         SetLastError( ERROR_PATH_NOT_FOUND );
 720         return INVALID_HANDLE_VALUE;
 721     }
 722     len = strlenW(name);
 723     if (len >= MAX_PATH)
 724     {
 725         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 726         return INVALID_HANDLE_VALUE;
 727     }
 728     if (strncmpiW(name, leadin, sizeof(leadin)/sizeof(leadin[0])))
 729     {
 730         SetLastError( ERROR_INVALID_NAME );
 731         return INVALID_HANDLE_VALUE;
 732     }
 733     SERVER_START_REQ( create_named_pipe )
 734     {
 735         req->openmode = dwOpenMode;
 736         req->pipemode = dwPipeMode;
 737         req->maxinstances = nMaxInstances;
 738         req->outsize = nOutBufferSize;
 739         req->insize = nInBufferSize;
 740         req->timeout = nDefaultTimeOut;
 741         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 742         SetLastError(0);
 743         if (!wine_server_call_err( req )) ret = reply->handle;
 744         else ret = INVALID_HANDLE_VALUE;
 745     }
 746     SERVER_END_REQ;
 747     return ret;
 748 }
 749
 750
 751 /***********************************************************************
 752  *           PeekNamedPipe   (KERNEL32.@)
 753  */
 754 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
 755                            LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
 756 {
 757 #ifdef FIONREAD
 758     int avail=0,fd;
 759
 760     fd = FILE_GetUnixHandle(hPipe, GENERIC_READ);
 761     if (fd == -1) return FALSE;
 762
 763     if (ioctl(fd,FIONREAD, &avail ) != 0)
 764     {
 765         TRACE("FIONREAD failed reason: %s\n",strerror(errno));
 766         close(fd);
 767         return FALSE;
 768     }
 769     if (!avail)  /* check for closed pipe */
 770     {
 771         struct pollfd pollfd;
 772         pollfd.fd = fd;
 773         pollfd.events = POLLIN;
 774         pollfd.revents = 0;
 775         switch (poll( &pollfd, 1, 0 ))
 776         {
 777         case 0:
 778             break;
 779         case 1:  /* got something */
 780             if (!(pollfd.revents & (POLLHUP | POLLERR))) break;
 781             TRACE("POLLHUP | POLLERR\n");
 782             /* fall through */
 783         case -1:
 784             close(fd);
 785             SetLastError(ERROR_BROKEN_PIPE);
 786             return FALSE;
 787         }
 788     }
 789     close(fd);
 790     TRACE(" 0x%08x bytes available\n", avail );
 791     if (!lpvBuffer && lpcbAvail)
 792       {
 793         *lpcbAvail= avail;
 794         return TRUE;
 795       }
 796 #endif /* defined(FIONREAD) */
 797
 798     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 799     FIXME("function not implemented\n");
 800     return FALSE;
 801 }
 802
 803 /***********************************************************************
 804  *           SYNC_CompletePipeOverlapped   (Internal)
 805  */
 806 static void SYNC_CompletePipeOverlapped (LPOVERLAPPED overlapped, DWORD result)
 807 {
 808     TRACE("for %p result %08lx\n",overlapped,result);
 809     if(!overlapped)
 810         return;
 811     overlapped->Internal = result;
 812     SetEvent(overlapped->hEvent);
 813 }
 814
 815
 816 /***********************************************************************
 817  *           WaitNamedPipeA   (KERNEL32.@)
 818  */
 819 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
 820 {
 821     WCHAR buffer[MAX_PATH];
 822
 823     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
 824
 825     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 826     {
 827         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 828         return 0;
 829     }
 830     return WaitNamedPipeW( buffer, nTimeOut );
 831 }
 832
 833
 834 /***********************************************************************
 835  *           WaitNamedPipeW   (KERNEL32.@)
 836  */
 837 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
 838 {
 839     DWORD len = name ? strlenW(name) : 0;
 840     BOOL ret;
 841     OVERLAPPED ov;
 842
 843     if (len >= MAX_PATH)
 844     {
 845         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 846         return FALSE;
 847     }
 848
 849     TRACE("%s 0x%08lx\n",debugstr_w(name),nTimeOut);
 850
 851     memset(&ov,0,sizeof ov);
 852     ov.hEvent = CreateEventA( NULL, 0, 0, NULL );
 853     if (!ov.hEvent)
 854         return FALSE;
 855
 856     SERVER_START_REQ( wait_named_pipe )
 857     {
 858         req->timeout = nTimeOut;
 859         req->overlapped = &ov;
 860         req->func = SYNC_CompletePipeOverlapped;
 861         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 862         ret = !wine_server_call_err( req );
 863     }
 864     SERVER_END_REQ;
 865
 866     if(ret)
 867     {
 868         if (WAIT_OBJECT_0==WaitForSingleObject(ov.hEvent,INFINITE))
 869         {
 870             SetLastError(ov.Internal);
 871             ret = (ov.Internal==STATUS_SUCCESS);
 872         }
 873     }
 874     CloseHandle(ov.hEvent);
 875     return ret;
 876 }
 877
 878
 879 /***********************************************************************
 880  *           SYNC_ConnectNamedPipe   (Internal)
 881  */
 882 static BOOL SYNC_ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
 883 {
 884     BOOL ret;
 885
 886     if(!overlapped)
 887         return FALSE;
 888
 889     overlapped->Internal = STATUS_PENDING;
 890
 891     SERVER_START_REQ( connect_named_pipe )
 892     {
 893         req->handle = hPipe;
 894         req->overlapped = overlapped;
 895         req->func = SYNC_CompletePipeOverlapped;
 896         ret = !wine_server_call_err( req );
 897     }
 898     SERVER_END_REQ;
 899
 900     return ret;
 901 }
 902
 903 /***********************************************************************
 904  *           ConnectNamedPipe   (KERNEL32.@)
 905  */
 906 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
 907 {
 908     OVERLAPPED ov;
 909     BOOL ret;
 910
 911     TRACE("(%p,%p)\n",hPipe, overlapped);
 912
 913     if(overlapped)
 914         return SYNC_ConnectNamedPipe(hPipe,overlapped);
 915
 916     memset(&ov,0,sizeof ov);
 917     ov.hEvent = CreateEventA(NULL,0,0,NULL);
 918     if (!ov.hEvent)
 919         return FALSE;
 920
 921     ret=SYNC_ConnectNamedPipe(hPipe, &ov);
 922     if(ret)
 923     {
 924         if (WAIT_OBJECT_0==WaitForSingleObject(ov.hEvent,INFINITE))
 925         {
 926             SetLastError(ov.Internal);
 927             ret = (ov.Internal==STATUS_SUCCESS);
 928         }
 929     }
 930
 931     CloseHandle(ov.hEvent);
 932
 933     return ret;
 934 }
 935
 936 /***********************************************************************
 937  *           DisconnectNamedPipe   (KERNEL32.@)
 938  */
 939 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
 940 {
 941     BOOL ret;
 942
 943     TRACE("(%p)\n",hPipe);
 944
 945     SERVER_START_REQ( disconnect_named_pipe )
 946     {
 947         req->handle = hPipe;
 948         ret = !wine_server_call_err( req );
 949         if (ret && reply->fd != -1) close( reply->fd );
 950     }
 951     SERVER_END_REQ;
 952
 953     return ret;
 954 }
 955
 956 /***********************************************************************
 957  *           TransactNamedPipe   (KERNEL32.@)
 958  */
 959 BOOL WINAPI TransactNamedPipe(
 960     HANDLE hPipe, LPVOID lpInput, DWORD dwInputSize, LPVOID lpOutput,
 961     DWORD dwOutputSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped)
 962 {
 963     FIXME("%p %p %ld %p %ld %p %p\n",
 964           hPipe, lpInput, dwInputSize, lpOutput,
 965           dwOutputSize, lpBytesRead, lpOverlapped);
 966     if(lpBytesRead)
 967         *lpBytesRead=0;
 968     return FALSE;
 969 }
 970
 971 /***********************************************************************
 972  *           GetNamedPipeInfo   (KERNEL32.@)
 973  */
 974 BOOL WINAPI GetNamedPipeInfo(
 975     HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
 976     LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
 977 {
 978     BOOL ret;
 979
 980     TRACE("%p %p %p %p %p\n", hNamedPipe, lpFlags,
 981           lpOutputBufferSize, lpInputBufferSize, lpMaxInstances);
 982
 983     SERVER_START_REQ( get_named_pipe_info )
 984     {
 985         req->handle = hNamedPipe;
 986         ret = !wine_server_call_err( req );
 987         if(lpFlags) *lpFlags = reply->flags;
 988         if(lpOutputBufferSize) *lpOutputBufferSize = reply->outsize;
 989         if(lpInputBufferSize) *lpInputBufferSize = reply->outsize;
 990         if(lpMaxInstances) *lpMaxInstances = reply->maxinstances;
 991     }
 992     SERVER_END_REQ;
 993
 994     return ret;
 995 }
 996
 997 /***********************************************************************
 998  *           GetNamedPipeHandleStateA  (KERNEL32.@)
 999  */
1000 BOOL WINAPI GetNamedPipeHandleStateA(
1001     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1002     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1003     LPSTR lpUsername, DWORD nUsernameMaxSize)
1004 {
1005     FIXME("%p %p %p %p %p %p %ld\n",
1006           hNamedPipe, lpState, lpCurInstances,
1007           lpMaxCollectionCount, lpCollectDataTimeout,
1008           lpUsername, nUsernameMaxSize);
1009
1010     return FALSE;
1011 }
1012
1013 /***********************************************************************
1014  *           GetNamedPipeHandleStateW  (KERNEL32.@)
1015  */
1016 BOOL WINAPI GetNamedPipeHandleStateW(
1017     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
1018     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
1019     LPWSTR lpUsername, DWORD nUsernameMaxSize)
1020 {
1021     FIXME("%p %p %p %p %p %p %ld\n",
1022           hNamedPipe, lpState, lpCurInstances,
1023           lpMaxCollectionCount, lpCollectDataTimeout,
1024           lpUsername, nUsernameMaxSize);
1025
1026     return FALSE;
1027 }
1028
1029 /***********************************************************************
1030  *           SetNamedPipeHandleState  (KERNEL32.@)
1031  */
1032 BOOL WINAPI SetNamedPipeHandleState(
1033     HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
1034     LPDWORD lpCollectDataTimeout)
1035 {
1036     FIXME("%p %p %p %p\n",
1037           hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout);
1038     return FALSE;
1039 }
1040
1041 /***********************************************************************
1042  *           CallNamedPipeA  (KERNEL32.@)
1043  */
1044 BOOL WINAPI CallNamedPipeA(
1045     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1046     LPVOID lpOutput, DWORD lpOutputSize,
1047     LPDWORD lpBytesRead, DWORD nTimeout)
1048 {
1049     FIXME("%s %p %ld %p %ld %p %ld\n",
1050            debugstr_a(lpNamedPipeName), lpInput, lpInputSize,
1051            lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1052     return FALSE;
1053 }
1054
1055 /***********************************************************************
1056  *           CallNamedPipeW  (KERNEL32.@)
1057  */
1058 BOOL WINAPI CallNamedPipeW(
1059     LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
1060     LPVOID lpOutput, DWORD lpOutputSize,
1061     LPDWORD lpBytesRead, DWORD nTimeout)
1062 {
1063     FIXME("%s %p %ld %p %ld %p %ld\n",
1064            debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
1065            lpOutput, lpOutputSize, lpBytesRead, nTimeout);
1066     return FALSE;
1067 }
1068
1069 /******************************************************************
1070  *              CreatePipe (KERNEL32.@)
1071  *
1072  */
1073 BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
1074                         LPSECURITY_ATTRIBUTES sa, DWORD size )
1075 {
1076     static unsigned  index = 0;
1077     char        name[64];
1078     HANDLE      hr, hw;
1079     unsigned    in_index = index;
1080
1081     *hReadPipe = *hWritePipe = INVALID_HANDLE_VALUE;
1082     /* generate a unique pipe name (system wide) */
1083     do
1084     {
1085         sprintf(name, "\\\\.\\pipe\\Win32.Pipes.%08lu.%08u", GetCurrentProcessId(), ++index);
1086         hr = CreateNamedPipeA(name, PIPE_ACCESS_INBOUND,
1087                               PIPE_TYPE_BYTE | PIPE_WAIT, 1, size, size,
1088                               NMPWAIT_USE_DEFAULT_WAIT, sa);
1089     } while (hr == INVALID_HANDLE_VALUE && index != in_index);
1090     /* from completion sakeness, I think system resources might be exhausted before this happens !! */
1091     if (hr == INVALID_HANDLE_VALUE) return FALSE;
1092
1093     hw = CreateFileA(name, GENERIC_WRITE, 0, sa, OPEN_EXISTING, 0, 0);
1094     if (hw == INVALID_HANDLE_VALUE)
1095     {
1096         CloseHandle(hr);
1097         return FALSE;
1098     }
1099
1100     *hReadPipe = hr;
1101     *hWritePipe = hw;
1102     return TRUE;
1103 }