git.oblomov.eu Git - wine/blob - dlls/kernel/sync.c

   1 /*
   2  * Kernel synchronization objects
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <string.h>
  10
  11 #include "winbase.h"
  12 #include "winerror.h"
  13 #include "winnls.h"
  14
  15 #include "wine/server.h"
  16 #include "wine/unicode.h"
  17
  18 #include "debugtools.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(win32);
  21
  22 /*
  23  * Events
  24  */
  25
  26
  27 /***********************************************************************
  28  *           CreateEventA    (KERNEL32.@)
  29  */
  30 HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
  31                             BOOL initial_state, LPCSTR name )
  32 {
  33     WCHAR buffer[MAX_PATH];
  34
  35     if (!name) return CreateEventW( sa, manual_reset, initial_state, NULL );
  36
  37     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
  38     {
  39         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  40         return 0;
  41     }
  42     return CreateEventW( sa, manual_reset, initial_state, buffer );
  43 }
  44
  45
  46 /***********************************************************************
  47  *           CreateEventW    (KERNEL32.@)
  48  */
  49 HANDLE WINAPI CreateEventW( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
  50                             BOOL initial_state, LPCWSTR name )
  51 {
  52     HANDLE ret;
  53     DWORD len = name ? strlenW(name) : 0;
  54     if (len >= MAX_PATH)
  55     {
  56         SetLastError( ERROR_FILENAME_EXCED_RANGE );
  57         return 0;
  58     }
  59     /* one buggy program needs this
  60      * ("Van Dale Groot woordenboek der Nederlandse taal")
  61      */
  62     if (sa && IsBadReadPtr(sa,sizeof(SECURITY_ATTRIBUTES)))
  63     {
  64         ERR("Bad security attributes pointer %p\n",sa);
  65         SetLastError( ERROR_INVALID_PARAMETER);
  66         return 0;
  67     }
  68     SERVER_START_REQ( create_event )
  69     {
  70         req->manual_reset = manual_reset;
  71         req->initial_state = initial_state;
  72         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
  73         wine_server_add_data( req, name, len * sizeof(WCHAR) );
  74         SetLastError(0);
  75         wine_server_call_err( req );
  76         ret = reply->handle;
  77     }
  78     SERVER_END_REQ;
  79     return ret;
  80 }
  81
  82
  83 /***********************************************************************
  84  *           CreateW32Event    (KERNEL.457)
  85  */
  86 HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
  87 {
  88     return CreateEventA( NULL, manual_reset, initial_state, NULL );
  89 }
  90
  91
  92 /***********************************************************************
  93  *           OpenEventA    (KERNEL32.@)
  94  */
  95 HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
  96 {
  97     WCHAR buffer[MAX_PATH];
  98
  99     if (!name) return OpenEventW( access, inherit, NULL );
 100
 101     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 102     {
 103         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 104         return 0;
 105     }
 106     return OpenEventW( access, inherit, buffer );
 107 }
 108
 109
 110 /***********************************************************************
 111  *           OpenEventW    (KERNEL32.@)
 112  */
 113 HANDLE WINAPI OpenEventW( DWORD access, BOOL inherit, LPCWSTR name )
 114 {
 115     HANDLE ret;
 116     DWORD len = name ? strlenW(name) : 0;
 117     if (len >= MAX_PATH)
 118     {
 119         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 120         return 0;
 121     }
 122     SERVER_START_REQ( open_event )
 123     {
 124         req->access  = access;
 125         req->inherit = inherit;
 126         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 127         wine_server_call_err( req );
 128         ret = reply->handle;
 129     }
 130     SERVER_END_REQ;
 131     return ret;
 132 }
 133
 134
 135 /***********************************************************************
 136  *           EVENT_Operation
 137  *
 138  * Execute an event operation (set,reset,pulse).
 139  */
 140 static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
 141 {
 142     BOOL ret;
 143     SERVER_START_REQ( event_op )
 144     {
 145         req->handle = handle;
 146         req->op     = op;
 147         ret = !wine_server_call_err( req );
 148     }
 149     SERVER_END_REQ;
 150     return ret;
 151 }
 152
 153
 154 /***********************************************************************
 155  *           PulseEvent    (KERNEL32.@)
 156  */
 157 BOOL WINAPI PulseEvent( HANDLE handle )
 158 {
 159     return EVENT_Operation( handle, PULSE_EVENT );
 160 }
 161
 162
 163 /***********************************************************************
 164  *           SetW32Event (KERNEL.458)
 165  *           SetEvent    (KERNEL32.@)
 166  */
 167 BOOL WINAPI SetEvent( HANDLE handle )
 168 {
 169     return EVENT_Operation( handle, SET_EVENT );
 170 }
 171
 172
 173 /***********************************************************************
 174  *           ResetW32Event (KERNEL.459)
 175  *           ResetEvent    (KERNEL32.@)
 176  */
 177 BOOL WINAPI ResetEvent( HANDLE handle )
 178 {
 179     return EVENT_Operation( handle, RESET_EVENT );
 180 }
 181
 182
 183 /***********************************************************************
 184  * NOTE: The Win95 VWin32_Event routines given below are really low-level
 185  *       routines implemented directly by VWin32. The user-mode libraries
 186  *       implement Win32 synchronisation routines on top of these low-level
 187  *       primitives. We do it the other way around here :-)
 188  */
 189
 190 /***********************************************************************
 191  *       VWin32_EventCreate     (KERNEL.442)
 192  */
 193 HANDLE WINAPI VWin32_EventCreate(VOID)
 194 {
 195     HANDLE hEvent = CreateEventA( NULL, FALSE, 0, NULL );
 196     return ConvertToGlobalHandle( hEvent );
 197 }
 198
 199 /***********************************************************************
 200  *       VWin32_EventDestroy    (KERNEL.443)
 201  */
 202 VOID WINAPI VWin32_EventDestroy(HANDLE event)
 203 {
 204     CloseHandle( event );
 205 }
 206
 207 /***********************************************************************
 208  *       VWin32_EventWait       (KERNEL.450)
 209  */
 210 VOID WINAPI VWin32_EventWait(HANDLE event)
 211 {
 212     DWORD mutex_count;
 213
 214     ReleaseThunkLock( &mutex_count );
 215     WaitForSingleObject( event, INFINITE );
 216     RestoreThunkLock( mutex_count );
 217 }
 218
 219 /***********************************************************************
 220  *       VWin32_EventSet        (KERNEL.451)
 221  *       KERNEL_479             (KERNEL.479)
 222  */
 223 VOID WINAPI VWin32_EventSet(HANDLE event)
 224 {
 225     SetEvent( event );
 226 }
 227
 228
 229
 230 /***********************************************************************
 231  *           CreateMutexA   (KERNEL32.@)
 232  */
 233 HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCSTR name )
 234 {
 235     WCHAR buffer[MAX_PATH];
 236
 237     if (!name) return CreateMutexW( sa, owner, NULL );
 238
 239     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 240     {
 241         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 242         return 0;
 243     }
 244     return CreateMutexW( sa, owner, buffer );
 245 }
 246
 247
 248 /***********************************************************************
 249  *           CreateMutexW   (KERNEL32.@)
 250  */
 251 HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner, LPCWSTR name )
 252 {
 253     HANDLE ret;
 254     DWORD len = name ? strlenW(name) : 0;
 255     if (len >= MAX_PATH)
 256     {
 257         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 258         return 0;
 259     }
 260     SERVER_START_REQ( create_mutex )
 261     {
 262         req->owned   = owner;
 263         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 264         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 265         SetLastError(0);
 266         wine_server_call_err( req );
 267         ret = reply->handle;
 268     }
 269     SERVER_END_REQ;
 270     return ret;
 271 }
 272
 273
 274 /***********************************************************************
 275  *           OpenMutexA   (KERNEL32.@)
 276  */
 277 HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
 278 {
 279     WCHAR buffer[MAX_PATH];
 280
 281     if (!name) return OpenMutexW( access, inherit, NULL );
 282
 283     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 284     {
 285         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 286         return 0;
 287     }
 288     return OpenMutexW( access, inherit, buffer );
 289 }
 290
 291
 292 /***********************************************************************
 293  *           OpenMutexW   (KERNEL32.@)
 294  */
 295 HANDLE WINAPI OpenMutexW( DWORD access, BOOL inherit, LPCWSTR name )
 296 {
 297     HANDLE ret;
 298     DWORD len = name ? strlenW(name) : 0;
 299     if (len >= MAX_PATH)
 300     {
 301         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 302         return 0;
 303     }
 304     SERVER_START_REQ( open_mutex )
 305     {
 306         req->access  = access;
 307         req->inherit = inherit;
 308         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 309         wine_server_call_err( req );
 310         ret = reply->handle;
 311     }
 312     SERVER_END_REQ;
 313     return ret;
 314 }
 315
 316
 317 /***********************************************************************
 318  *           ReleaseMutex   (KERNEL32.@)
 319  */
 320 BOOL WINAPI ReleaseMutex( HANDLE handle )
 321 {
 322     BOOL ret;
 323     SERVER_START_REQ( release_mutex )
 324     {
 325         req->handle = handle;
 326         ret = !wine_server_call_err( req );
 327     }
 328     SERVER_END_REQ;
 329     return ret;
 330 }
 331
 332
 333 /*
 334  * Semaphores
 335  */
 336
 337
 338 /***********************************************************************
 339  *           CreateSemaphoreA   (KERNEL32.@)
 340  */
 341 HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial, LONG max, LPCSTR name )
 342 {
 343     WCHAR buffer[MAX_PATH];
 344
 345     if (!name) return CreateSemaphoreW( sa, initial, max, NULL );
 346
 347     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 348     {
 349         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 350         return 0;
 351     }
 352     return CreateSemaphoreW( sa, initial, max, buffer );
 353 }
 354
 355
 356 /***********************************************************************
 357  *           CreateSemaphoreW   (KERNEL32.@)
 358  */
 359 HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
 360                                     LONG max, LPCWSTR name )
 361 {
 362     HANDLE ret;
 363     DWORD len = name ? strlenW(name) : 0;
 364
 365     /* Check parameters */
 366
 367     if ((max <= 0) || (initial < 0) || (initial > max))
 368     {
 369         SetLastError( ERROR_INVALID_PARAMETER );
 370         return 0;
 371     }
 372     if (len >= MAX_PATH)
 373     {
 374         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 375         return 0;
 376     }
 377
 378     SERVER_START_REQ( create_semaphore )
 379     {
 380         req->initial = (unsigned int)initial;
 381         req->max     = (unsigned int)max;
 382         req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
 383         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 384         SetLastError(0);
 385         wine_server_call_err( req );
 386         ret = reply->handle;
 387     }
 388     SERVER_END_REQ;
 389     return ret;
 390 }
 391
 392
 393 /***********************************************************************
 394  *           OpenSemaphoreA   (KERNEL32.@)
 395  */
 396 HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
 397 {
 398     WCHAR buffer[MAX_PATH];
 399
 400     if (!name) return OpenSemaphoreW( access, inherit, NULL );
 401
 402     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 403     {
 404         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 405         return 0;
 406     }
 407     return OpenSemaphoreW( access, inherit, buffer );
 408 }
 409
 410
 411 /***********************************************************************
 412  *           OpenSemaphoreW   (KERNEL32.@)
 413  */
 414 HANDLE WINAPI OpenSemaphoreW( DWORD access, BOOL inherit, LPCWSTR name )
 415 {
 416     HANDLE ret;
 417     DWORD len = name ? strlenW(name) : 0;
 418     if (len >= MAX_PATH)
 419     {
 420         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 421         return 0;
 422     }
 423     SERVER_START_REQ( open_semaphore )
 424     {
 425         req->access  = access;
 426         req->inherit = inherit;
 427         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 428         wine_server_call_err( req );
 429         ret = reply->handle;
 430     }
 431     SERVER_END_REQ;
 432     return ret;
 433 }
 434
 435
 436 /***********************************************************************
 437  *           ReleaseSemaphore   (KERNEL32.@)
 438  */
 439 BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
 440 {
 441     NTSTATUS status = NtReleaseSemaphore( handle, count, previous );
 442     if (status) SetLastError( RtlNtStatusToDosError(status) );
 443     return !status;
 444 }
 445
 446
 447 /*
 448  * Pipes
 449  */
 450
 451
 452 /***********************************************************************
 453  *           CreateNamedPipeA   (KERNEL32.@)
 454  */
 455 HANDLE WINAPI CreateNamedPipeA( LPCSTR name, DWORD dwOpenMode,
 456                                 DWORD dwPipeMode, DWORD nMaxInstances,
 457                                 DWORD nOutBufferSize, DWORD nInBufferSize,
 458                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
 459 {
 460     WCHAR buffer[MAX_PATH];
 461
 462     if (!name) return CreateNamedPipeW( NULL, dwOpenMode, dwPipeMode, nMaxInstances,
 463                                         nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 464
 465     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 466     {
 467         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 468         return 0;
 469     }
 470     return CreateNamedPipeW( buffer, dwOpenMode, dwPipeMode, nMaxInstances,
 471                              nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 472 }
 473
 474
 475 /***********************************************************************
 476  *           CreateNamedPipeW   (KERNEL32.@)
 477  */
 478 HANDLE WINAPI CreateNamedPipeW( LPCWSTR name, DWORD dwOpenMode,
 479                                 DWORD dwPipeMode, DWORD nMaxInstances,
 480                                 DWORD nOutBufferSize, DWORD nInBufferSize,
 481                                 DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES attr )
 482 {
 483     HANDLE ret;
 484     DWORD len = name ? strlenW(name) : 0;
 485
 486     TRACE("(%s, %#08lx, %#08lx, %ld, %ld, %ld, %ld, %p)\n",
 487           debugstr_w(name), dwOpenMode, dwPipeMode, nMaxInstances,
 488           nOutBufferSize, nInBufferSize, nDefaultTimeOut, attr );
 489
 490     if (len >= MAX_PATH)
 491     {
 492         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 493         return 0;
 494     }
 495     SERVER_START_REQ( create_named_pipe )
 496     {
 497         req->openmode = dwOpenMode;
 498         req->pipemode = dwPipeMode;
 499         req->maxinstances = nMaxInstances;
 500         req->outsize = nOutBufferSize;
 501         req->insize = nInBufferSize;
 502         req->timeout = nDefaultTimeOut;
 503         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 504         SetLastError(0);
 505         wine_server_call_err( req );
 506         ret = reply->handle;
 507     }
 508     SERVER_END_REQ;
 509     return ret;
 510 }
 511
 512
 513 /***********************************************************************
 514  *           PeekNamedPipe   (KERNEL32.@)
 515  */
 516 BOOL WINAPI PeekNamedPipe( HANDLE hPipe, LPVOID lpvBuffer, DWORD cbBuffer,
 517                            LPDWORD lpcbRead, LPDWORD lpcbAvail, LPDWORD lpcbMessage )
 518 {
 519     FIXME("(%08x, %p, %08lx, %p, %p, %p): stub\n",
 520           hPipe, lpvBuffer, cbBuffer, lpcbRead, lpcbAvail, lpcbMessage);
 521     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 522     return FALSE;
 523 }
 524
 525 /***********************************************************************
 526  *           SYNC_CompletePipeOverlapped   (Internal)
 527  */
 528 static void SYNC_CompletePipeOverlapped (LPOVERLAPPED overlapped, DWORD result)
 529 {
 530     TRACE("for %p result %08lx\n",overlapped,result);
 531     if(!overlapped)
 532         return;
 533     overlapped->Internal = result;
 534     SetEvent(overlapped->hEvent);
 535 }
 536
 537
 538 /***********************************************************************
 539  *           WaitNamedPipeA   (KERNEL32.@)
 540  */
 541 BOOL WINAPI WaitNamedPipeA (LPCSTR name, DWORD nTimeOut)
 542 {
 543     WCHAR buffer[MAX_PATH];
 544
 545     if (!name) return WaitNamedPipeW( NULL, nTimeOut );
 546
 547     if (!MultiByteToWideChar( CP_ACP, 0, name, -1, buffer, MAX_PATH ))
 548     {
 549         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 550         return 0;
 551     }
 552     return WaitNamedPipeW( buffer, nTimeOut );
 553 }
 554
 555
 556 /***********************************************************************
 557  *           WaitNamedPipeW   (KERNEL32.@)
 558  */
 559 BOOL WINAPI WaitNamedPipeW (LPCWSTR name, DWORD nTimeOut)
 560 {
 561     DWORD len = name ? strlenW(name) : 0;
 562     BOOL ret;
 563     OVERLAPPED ov;
 564
 565     if (len >= MAX_PATH)
 566     {
 567         SetLastError( ERROR_FILENAME_EXCED_RANGE );
 568         return FALSE;
 569     }
 570
 571     TRACE("%s 0x%08lx\n",debugstr_w(name),nTimeOut);
 572
 573     memset(&ov,0,sizeof ov);
 574     ov.hEvent = CreateEventA( NULL, 0, 0, NULL );
 575     if (!ov.hEvent)
 576         return FALSE;
 577
 578     SERVER_START_REQ( wait_named_pipe )
 579     {
 580         req->timeout = nTimeOut;
 581         req->overlapped = &ov;
 582         req->func = SYNC_CompletePipeOverlapped;
 583         wine_server_add_data( req, name, len * sizeof(WCHAR) );
 584         ret = !wine_server_call_err( req );
 585     }
 586     SERVER_END_REQ;
 587
 588     if(ret)
 589     {
 590         if (WAIT_OBJECT_0==WaitForSingleObject(ov.hEvent,INFINITE))
 591         {
 592             SetLastError(ov.Internal);
 593             ret = (ov.Internal==STATUS_SUCCESS);
 594         }
 595     }
 596     CloseHandle(ov.hEvent);
 597     return ret;
 598 }
 599
 600
 601 /***********************************************************************
 602  *           SYNC_ConnectNamedPipe   (Internal)
 603  */
 604 static BOOL SYNC_ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
 605 {
 606     BOOL ret;
 607
 608     if(!overlapped)
 609         return FALSE;
 610
 611     overlapped->Internal = STATUS_PENDING;
 612
 613     SERVER_START_REQ( connect_named_pipe )
 614     {
 615         req->handle = hPipe;
 616         req->overlapped = overlapped;
 617         req->func = SYNC_CompletePipeOverlapped;
 618         ret = !wine_server_call_err( req );
 619     }
 620     SERVER_END_REQ;
 621
 622     return ret;
 623 }
 624
 625 /***********************************************************************
 626  *           ConnectNamedPipe   (KERNEL32.@)
 627  */
 628 BOOL WINAPI ConnectNamedPipe(HANDLE hPipe, LPOVERLAPPED overlapped)
 629 {
 630     OVERLAPPED ov;
 631     BOOL ret;
 632
 633     TRACE("(%d,%p)\n",hPipe, overlapped);
 634
 635     if(overlapped)
 636         return SYNC_ConnectNamedPipe(hPipe,overlapped);
 637
 638     memset(&ov,0,sizeof ov);
 639     ov.hEvent = CreateEventA(NULL,0,0,NULL);
 640     if (!ov.hEvent)
 641         return FALSE;
 642
 643     ret=SYNC_ConnectNamedPipe(hPipe, &ov);
 644     if(ret)
 645     {
 646         if (WAIT_OBJECT_0==WaitForSingleObject(ov.hEvent,INFINITE))
 647         {
 648             SetLastError(ov.Internal);
 649             ret = (ov.Internal==STATUS_SUCCESS);
 650         }
 651     }
 652
 653     CloseHandle(ov.hEvent);
 654
 655     return ret;
 656 }
 657
 658 /***********************************************************************
 659  *           DisconnectNamedPipe   (KERNEL32.@)
 660  */
 661 BOOL WINAPI DisconnectNamedPipe(HANDLE hPipe)
 662 {
 663     BOOL ret;
 664
 665     TRACE("(%d)\n",hPipe);
 666
 667     SERVER_START_REQ( disconnect_named_pipe )
 668     {
 669         req->handle = hPipe;
 670         ret = !wine_server_call_err( req );
 671     }
 672     SERVER_END_REQ;
 673
 674     return ret;
 675 }
 676
 677 /***********************************************************************
 678  *           TransactNamedPipe   (KERNEL32.@)
 679  */
 680 BOOL WINAPI TransactNamedPipe(
 681     HANDLE hPipe, LPVOID lpInput, DWORD dwInputSize, LPVOID lpOutput,
 682     DWORD dwOutputSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped)
 683 {
 684     FIXME("%d %p %ld %p %ld %p %p\n",
 685           hPipe, lpInput, dwInputSize, lpOutput,
 686           dwOutputSize, lpBytesRead, lpOverlapped);
 687     if(lpBytesRead)
 688         *lpBytesRead=0;
 689     return FALSE;
 690 }
 691
 692 /***********************************************************************
 693  *           GetNamedPipeInfo   (KERNEL32.@)
 694  */
 695 BOOL WINAPI GetNamedPipeInfo(
 696     HANDLE hNamedPipe, LPDWORD lpFlags, LPDWORD lpOutputBufferSize,
 697     LPDWORD lpInputBufferSize, LPDWORD lpMaxInstances)
 698 {
 699     BOOL ret;
 700
 701     TRACE("%d %p %p %p %p\n", hNamedPipe, lpFlags,
 702           lpOutputBufferSize, lpInputBufferSize, lpMaxInstances);
 703
 704     SERVER_START_REQ( get_named_pipe_info )
 705     {
 706         req->handle = hNamedPipe;
 707         ret = !wine_server_call_err( req );
 708         if(lpFlags) *lpFlags = reply->flags;
 709         if(lpOutputBufferSize) *lpOutputBufferSize = reply->outsize;
 710         if(lpInputBufferSize) *lpInputBufferSize = reply->outsize;
 711         if(lpMaxInstances) *lpMaxInstances = reply->maxinstances;
 712     }
 713     SERVER_END_REQ;
 714
 715     return ret;
 716 }
 717
 718 /***********************************************************************
 719  *           GetNamedPipeHandleStateA  (KERNEL32.@)
 720  */
 721 BOOL WINAPI GetNamedPipeHandleStateA(
 722     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
 723     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
 724     LPSTR lpUsername, DWORD nUsernameMaxSize)
 725 {
 726     FIXME("%d %p %p %p %p %p %ld\n",
 727           hNamedPipe, lpState, lpCurInstances,
 728           lpMaxCollectionCount, lpCollectDataTimeout,
 729           lpUsername, nUsernameMaxSize);
 730
 731     return FALSE;
 732 }
 733
 734 /***********************************************************************
 735  *           GetNamedPipeHandleStateW  (KERNEL32.@)
 736  */
 737 BOOL WINAPI GetNamedPipeHandleStateW(
 738     HANDLE hNamedPipe, LPDWORD lpState, LPDWORD lpCurInstances,
 739     LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout,
 740     LPWSTR lpUsername, DWORD nUsernameMaxSize)
 741 {
 742     FIXME("%d %p %p %p %p %p %ld\n",
 743           hNamedPipe, lpState, lpCurInstances,
 744           lpMaxCollectionCount, lpCollectDataTimeout,
 745           lpUsername, nUsernameMaxSize);
 746
 747     return FALSE;
 748 }
 749
 750 /***********************************************************************
 751  *           SetNamedPipeHandleState  (KERNEL32.@)
 752  */
 753 BOOL WINAPI SetNamedPipeHandleState(
 754     HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
 755     LPDWORD lpCollectDataTimeout)
 756 {
 757     FIXME("%d %p %p %p\n",
 758           hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout);
 759     return FALSE;
 760 }
 761
 762 /***********************************************************************
 763  *           CallNamedPipeA  (KERNEL32.@)
 764  */
 765 BOOL WINAPI CallNamedPipeA(
 766     LPCSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
 767     LPVOID lpOutput, DWORD lpOutputSize,
 768     LPDWORD lpBytesRead, DWORD nTimeout)
 769 {
 770     FIXME("%s %p %ld %p %ld %p %ld\n",
 771            debugstr_a(lpNamedPipeName), lpInput, lpInputSize,
 772            lpOutput, lpOutputSize, lpBytesRead, nTimeout);
 773     return FALSE;
 774 }
 775
 776 /***********************************************************************
 777  *           CallNamedPipeW  (KERNEL32.@)
 778  */
 779 BOOL WINAPI CallNamedPipeW(
 780     LPCWSTR lpNamedPipeName, LPVOID lpInput, DWORD lpInputSize,
 781     LPVOID lpOutput, DWORD lpOutputSize,
 782     LPDWORD lpBytesRead, DWORD nTimeout)
 783 {
 784     FIXME("%s %p %ld %p %ld %p %ld\n",
 785            debugstr_w(lpNamedPipeName), lpInput, lpInputSize,
 786            lpOutput, lpOutputSize, lpBytesRead, nTimeout);
 787     return FALSE;
 788 }
 789