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