sal/osl/w32/pipeimpl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: pipeimpl.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sal.hxx"
  34 #       include "pipeimpl.h"
  35
  36 #ifndef _INC_MALLOC
  37 #       include <malloc.h>
  38 #endif
  39
  40 #ifndef _INC_TCHAR
  41 #       ifdef UNICODE
  42 #               define _UNICODE
  43 #       endif
  44 #       include <tchar.h>
  45 #endif
  46
  47 const TCHAR PIPE_NAME_PREFIX_MAPPING[] = TEXT("PIPE_FILE_MAPPING_");
  48 const TCHAR PIPE_NAME_PREFIX_SYNCHRONIZE[] = TEXT("PIPE_SYNCHRONIZE_MUTEX_");
  49 const TCHAR PIPE_NAME_PREFIX_CONNECTION[] = TEXT("PIPE_CONNECTION_SEMAPHORE_");
  50
  51 const DWORD PIPE_BUFFER_SIZE = 4096;
  52
  53
  54 //============================================================================
  55 //      PipeData
  56 //============================================================================
  57
  58 struct PipeData
  59 {
  60     DWORD       dwProcessId;
  61     HANDLE      hReadPipe;
  62     HANDLE      hWritePipe;
  63 };
  64
  65 //============================================================================
  66 //      Pipe
  67 //============================================================================
  68
  69 #ifdef UNICODE
  70 #define Pipe            PipeW
  71 #define ClientPipe      ClientPipeW
  72 #define ServerPipe      ServerPipeW
  73 #else
  74 #define Pipe            PipeA
  75 #define ClientPipe      ClientPipeA
  76 #define ServerPipe      ServerPipeA
  77 #endif
  78
  79 class Pipe
  80 {
  81 protected:
  82     HANDLE      m_hReadPipe;    // Handle to use for reading
  83     HANDLE      m_hWritePipe;   // Handle to use for writing
  84
  85     Pipe( HANDLE hReadPipe, HANDLE hWritePipe );
  86
  87     static HANDLE CreatePipeDataMutex( LPCTSTR lpName, BOOL bInitialOwner );
  88     static HANDLE CreatePipeDataMapping( LPCTSTR lpName );
  89     static HANDLE OpenPipeDataMapping( LPCTSTR lpName );
  90     static HANDLE CreatePipeConnectionSemaphore( LPCTSTR lpName, LONG lInitialCount, LONG lMaximumcount );
  91
  92 public:
  93     Pipe( const Pipe& );
  94     const Pipe& operator = ( const Pipe& );
  95     virtual ~Pipe();
  96
  97     virtual bool Close();
  98     virtual bool Write( LPCVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpBytesWritten, bool bWait = true );
  99     virtual bool Read( LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpBytesRead, bool bWait = true );
 100
 101     virtual Pipe *AcceptConnection()
 102     {
 103         SetLastError( ERROR_INVALID_HANDLE );
 104         return NULL;
 105     }
 106
 107     void * operator new( size_t nBytes )
 108     {
 109         return HeapAlloc( GetProcessHeap(), 0, nBytes );
 110     }
 111
 112     void operator delete( void *ptr )
 113     {
 114         HeapFree( GetProcessHeap(), 0, ptr );
 115     }
 116
 117     bool is() const
 118     {
 119         return (FALSE != HeapValidate( GetProcessHeap(), 0, this ));
 120     }
 121
 122 };
 123
 124 //============================================================================
 125 //      ClientPipe
 126 //============================================================================
 127
 128 class ClientPipe : public Pipe
 129 {
 130 protected:
 131     ClientPipe( HANDLE hReadPipe, HANDLE hWritePipe );
 132 public:
 133     static ClientPipe* Create( LPCTSTR lpName );
 134 };
 135
 136 //============================================================================
 137 //      ServerPipe
 138 //============================================================================
 139
 140 class ServerPipe : public Pipe
 141 {
 142 protected:
 143     HANDLE      m_hMapping;
 144     HANDLE      m_hSynchronize;
 145     LPTSTR      m_lpName;
 146
 147     ServerPipe( LPCTSTR lpName, HANDLE hMapping, HANDLE hSynchronize, HANDLE hReadPipe, HANDLE hWritePipe );
 148 public:
 149     virtual ~ServerPipe();
 150
 151     static ServerPipe *Create( LPCTSTR lpName );
 152
 153     virtual Pipe *AcceptConnection();
 154 };
 155
 156 //----------------------------------------------------------------------------
 157 //
 158 //----------------------------------------------------------------------------
 159
 160 HANDLE  Pipe::CreatePipeDataMapping( LPCTSTR lpName )
 161 {
 162     HANDLE      hMapping = NULL;
 163     LPTSTR      lpMappingName = (LPTSTR)alloca( _tcslen(lpName) * sizeof(TCHAR) + sizeof(PIPE_NAME_PREFIX_MAPPING) );
 164
 165     if ( lpMappingName )
 166     {
 167         _tcscpy( lpMappingName, PIPE_NAME_PREFIX_MAPPING );
 168         _tcscat( lpMappingName, lpName );
 169
 170         LPTSTR  lpMappingFileName = (LPTSTR)alloca( MAX_PATH * sizeof(TCHAR) );
 171
 172         if ( lpMappingFileName )
 173         {
 174             DWORD       nChars = GetTempPath( MAX_PATH, lpMappingFileName );
 175
 176             if ( MAX_PATH + _tcslen(lpName) < nChars + 1 )
 177             {
 178                 lpMappingFileName = (LPTSTR)alloca( (nChars + 1 + _tcslen(lpName)) * sizeof(TCHAR) );
 179                 if ( lpMappingFileName )
 180                     nChars = GetTempPath( nChars, lpMappingFileName );
 181                 else
 182                 {
 183                     nChars = 0;
 184                     SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 185                 }
 186             }
 187
 188             if ( nChars )
 189             {
 190                 _tcscat( lpMappingFileName, lpMappingName );
 191
 192                 HANDLE hFile = CreateFile(
 193                     lpMappingFileName,
 194                     GENERIC_READ | GENERIC_WRITE,
 195                     FILE_SHARE_READ | FILE_SHARE_WRITE,
 196                     NULL,
 197                     OPEN_ALWAYS,
 198                     FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
 199                     NULL );
 200
 201                 if ( IsValidHandle(hFile) )
 202                 {
 203                     hMapping = CreateFileMapping(
 204                         (HANDLE)hFile,
 205                         (LPSECURITY_ATTRIBUTES)NULL,
 206                         PAGE_READWRITE,
 207                         0,
 208                         sizeof(PipeData),
 209                         lpMappingName );
 210
 211                     CloseHandle( hFile );
 212                 }
 213             }
 214         }
 215         else
 216             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 217     }
 218
 219     return hMapping;
 220 }
 221
 222 //----------------------------------------------------------------------------
 223 //
 224 //----------------------------------------------------------------------------
 225
 226 HANDLE  Pipe::OpenPipeDataMapping( LPCTSTR lpName )
 227 {
 228     HANDLE      hMapping = NULL;
 229     LPTSTR      lpMappingName = (LPTSTR)alloca( _tcslen(lpName) * sizeof(TCHAR) + sizeof(PIPE_NAME_PREFIX_MAPPING) );
 230
 231     if ( lpMappingName )
 232     {
 233         _tcscpy( lpMappingName, PIPE_NAME_PREFIX_MAPPING );
 234         _tcscat( lpMappingName, lpName );
 235
 236         hMapping = OpenFileMapping( FILE_MAP_ALL_ACCESS, FALSE, lpMappingName );
 237     }
 238
 239     return hMapping;
 240 }
 241
 242 //----------------------------------------------------------------------------
 243 //
 244 //----------------------------------------------------------------------------
 245
 246 HANDLE  Pipe::CreatePipeDataMutex( LPCTSTR lpName, BOOL bInitialOwner )
 247 {
 248     HANDLE      hMutex = NULL;
 249     LPTSTR      lpMutexName = (LPTSTR)alloca( _tcslen(lpName) * sizeof(TCHAR) + sizeof(PIPE_NAME_PREFIX_SYNCHRONIZE) );
 250
 251     if ( lpMutexName )
 252     {
 253         _tcscpy( lpMutexName, PIPE_NAME_PREFIX_SYNCHRONIZE );
 254         _tcscat( lpMutexName, lpName );
 255
 256         hMutex = CreateMutex( NULL, bInitialOwner, lpMutexName );
 257     }
 258
 259     return hMutex;
 260 }
 261
 262 //----------------------------------------------------------------------------
 263 //
 264 //----------------------------------------------------------------------------
 265
 266 HANDLE Pipe::CreatePipeConnectionSemaphore( LPCTSTR lpName, LONG lInitialCount, LONG lMaximumCount )
 267 {
 268     HANDLE      hSemaphore = NULL;
 269     LPTSTR      lpSemaphoreName = (LPTSTR)alloca( _tcslen(lpName) * sizeof(TCHAR) + sizeof(PIPE_NAME_PREFIX_CONNECTION) );
 270
 271     if ( lpSemaphoreName )
 272     {
 273         _tcscpy( lpSemaphoreName, PIPE_NAME_PREFIX_CONNECTION );
 274         _tcscat( lpSemaphoreName, lpName );
 275
 276         hSemaphore = CreateSemaphore( NULL, lInitialCount, lMaximumCount, lpSemaphoreName );
 277     }
 278
 279     return hSemaphore;
 280 }
 281
 282
 283 //----------------------------------------------------------------------------
 284 //      Pipe copy ctor
 285 //----------------------------------------------------------------------------
 286
 287 Pipe::Pipe( const Pipe& rPipe ) :
 288 m_hReadPipe( INVALID_HANDLE_VALUE ),
 289 m_hWritePipe( INVALID_HANDLE_VALUE )
 290 {
 291     DuplicateHandle(
 292         GetCurrentProcess(),
 293         rPipe.m_hReadPipe,
 294         GetCurrentProcess(),
 295         &m_hReadPipe,
 296         0,
 297         FALSE,
 298         DUPLICATE_SAME_ACCESS );
 299
 300     DuplicateHandle(
 301         GetCurrentProcess(),
 302         rPipe.m_hWritePipe,
 303         GetCurrentProcess(),
 304         &m_hWritePipe,
 305         0,
 306         FALSE,
 307         DUPLICATE_SAME_ACCESS );
 308 }
 309
 310 //----------------------------------------------------------------------------
 311 //      Pipe assignment operator
 312 //----------------------------------------------------------------------------
 313
 314 const Pipe& Pipe::operator = ( const Pipe& rPipe )
 315 {
 316     Close();
 317
 318     DuplicateHandle(
 319         GetCurrentProcess(),
 320         rPipe.m_hReadPipe,
 321         GetCurrentProcess(),
 322         &m_hReadPipe,
 323         0,
 324         FALSE,
 325         DUPLICATE_SAME_ACCESS );
 326
 327     DuplicateHandle(
 328         GetCurrentProcess(),
 329         rPipe.m_hWritePipe,
 330         GetCurrentProcess(),
 331         &m_hWritePipe,
 332         0,
 333         FALSE,
 334         DUPLICATE_SAME_ACCESS );
 335
 336     return *this;
 337 }
 338
 339 //----------------------------------------------------------------------------
 340 //      Pipe ctor
 341 //----------------------------------------------------------------------------
 342
 343 Pipe::Pipe( HANDLE hReadPipe, HANDLE hWritePipe ) :
 344 m_hReadPipe( INVALID_HANDLE_VALUE ),
 345 m_hWritePipe( INVALID_HANDLE_VALUE )
 346 {
 347     DuplicateHandle(
 348         GetCurrentProcess(),
 349         hReadPipe,
 350         GetCurrentProcess(),
 351         &m_hReadPipe,
 352         0,
 353         FALSE,
 354         DUPLICATE_SAME_ACCESS );
 355
 356     DuplicateHandle(
 357         GetCurrentProcess(),
 358         hWritePipe,
 359         GetCurrentProcess(),
 360         &m_hWritePipe,
 361         0,
 362         FALSE,
 363         DUPLICATE_SAME_ACCESS );
 364 }
 365
 366 //----------------------------------------------------------------------------
 367 //      Pipe dtor
 368 //----------------------------------------------------------------------------
 369
 370 Pipe::~Pipe()
 371 {
 372     Close();
 373 }
 374
 375 //----------------------------------------------------------------------------
 376 //      Pipe Close
 377 //----------------------------------------------------------------------------
 378
 379 bool Pipe::Close()
 380 {
 381     bool        fSuccess = false;       // Assume failure
 382
 383     if ( IsValidHandle(m_hReadPipe) )
 384     {
 385         CloseHandle( m_hReadPipe );
 386         m_hReadPipe = INVALID_HANDLE_VALUE;
 387     }
 388
 389     if ( IsValidHandle(m_hWritePipe) )
 390     {
 391         CloseHandle( m_hWritePipe );
 392         m_hWritePipe = INVALID_HANDLE_VALUE;
 393     }
 394
 395     return fSuccess;
 396 }
 397
 398 //----------------------------------------------------------------------------
 399 //      Pipe Write
 400 //----------------------------------------------------------------------------
 401
 402 bool Pipe::Write( LPCVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpBytesWritten, bool bWait )
 403 {
 404     DWORD       dwBytesAvailable = 0;
 405     BOOL        fSuccess = TRUE;
 406
 407     if ( !bWait )
 408         fSuccess = PeekNamedPipe( m_hReadPipe, NULL, 0, NULL, &dwBytesAvailable, NULL );
 409
 410     if ( fSuccess )
 411     {
 412         if ( !bWait && dwBytesToWrite > PIPE_BUFFER_SIZE - dwBytesAvailable )
 413             dwBytesToWrite = PIPE_BUFFER_SIZE - dwBytesAvailable ;
 414
 415         return !!WriteFile( m_hWritePipe, lpBuffer, dwBytesToWrite, lpBytesWritten, NULL );
 416     }
 417
 418     return false;
 419 }
 420
 421 //----------------------------------------------------------------------------
 422 //      Pipe Read
 423 //----------------------------------------------------------------------------
 424
 425 bool Pipe::Read( LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpBytesRead, bool bWait )
 426 {
 427     DWORD       dwBytesAvailable = 0;
 428     BOOL        fSuccess = TRUE;
 429
 430     if ( !bWait )
 431         fSuccess = PeekNamedPipe( m_hReadPipe, NULL, 0, NULL, &dwBytesAvailable, NULL );
 432
 433     if ( fSuccess )
 434     {
 435         if ( bWait || dwBytesAvailable )
 436             return !!ReadFile( m_hReadPipe, lpBuffer, dwBytesToRead, lpBytesRead, NULL );
 437         else
 438         {
 439             *lpBytesRead = 0;
 440             return true;
 441         }
 442     }
 443
 444     return false;
 445 }
 446
 447
 448
 449 //----------------------------------------------------------------------------
 450 //      Client pipe dtor
 451 //----------------------------------------------------------------------------
 452
 453 ClientPipe::ClientPipe( HANDLE hReadPipe, HANDLE hWritePipe ) : Pipe( hReadPipe, hWritePipe )
 454 {
 455 }
 456
 457 //----------------------------------------------------------------------------
 458 //      Client pipe creation
 459 //----------------------------------------------------------------------------
 460
 461 ClientPipe *ClientPipe::Create( LPCTSTR lpName )
 462 {
 463     ClientPipe  *pPipe = NULL;  // Assume failure
 464
 465     HANDLE      hMapping = OpenPipeDataMapping( lpName );
 466
 467     if ( IsValidHandle(hMapping) )
 468     {
 469         PipeData        *pData = (PipeData*)MapViewOfFile( hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
 470
 471         if ( pData )
 472         {
 473             HANDLE      hSourceProcess = OpenProcess( PROCESS_DUP_HANDLE, FALSE, pData->dwProcessId );
 474
 475             if ( IsValidHandle(hSourceProcess) )
 476             {
 477                 BOOL fSuccess;
 478                 HANDLE  hReadPipe = INVALID_HANDLE_VALUE, hWritePipe = INVALID_HANDLE_VALUE;
 479
 480                 fSuccess = DuplicateHandle(
 481                     hSourceProcess,
 482                     pData->hReadPipe,
 483                     GetCurrentProcess(),
 484                     &hReadPipe,
 485                     0,
 486                     FALSE,
 487                     DUPLICATE_SAME_ACCESS );
 488
 489                 fSuccess = fSuccess && DuplicateHandle(
 490                     hSourceProcess,
 491                     pData->hWritePipe,
 492                     GetCurrentProcess(),
 493                     &hWritePipe,
 494                     0,
 495                     FALSE,
 496                     DUPLICATE_SAME_ACCESS );
 497
 498                 if ( fSuccess )
 499                     pPipe = new ClientPipe( hReadPipe, hWritePipe );
 500
 501                 if ( IsValidHandle(hWritePipe) )
 502                     CloseHandle( hWritePipe );
 503
 504                 if ( IsValidHandle(hReadPipe) )
 505                     CloseHandle( hReadPipe );
 506
 507                 HANDLE  hConnectionRequest = CreatePipeConnectionSemaphore( lpName, 0, 1 );
 508
 509                 ReleaseSemaphore( hConnectionRequest, 1, NULL );
 510
 511                 CloseHandle( hConnectionRequest );
 512
 513                 CloseHandle( hSourceProcess );
 514             }
 515
 516             UnmapViewOfFile( pData );
 517         }
 518
 519         CloseHandle( hMapping );
 520     }
 521
 522     return pPipe;
 523 }
 524
 525
 526
 527 //----------------------------------------------------------------------------
 528 //      ServerPipe ctor
 529 //----------------------------------------------------------------------------
 530
 531 ServerPipe::ServerPipe( LPCTSTR lpName, HANDLE hMapping, HANDLE hSynchronize, HANDLE hReadPipe, HANDLE hWritePipe ) : Pipe( hReadPipe, hWritePipe ),
 532 m_hMapping( NULL ),
 533 m_hSynchronize( NULL ),
 534 m_lpName( NULL )
 535 {
 536     DuplicateHandle(
 537         GetCurrentProcess(),
 538         hMapping,
 539         GetCurrentProcess(),
 540         &m_hMapping,
 541         0,
 542         FALSE,
 543         DUPLICATE_SAME_ACCESS );
 544
 545     DuplicateHandle(
 546         GetCurrentProcess(),
 547         hSynchronize,
 548         GetCurrentProcess(),
 549         &m_hSynchronize,
 550         0,
 551         FALSE,
 552         DUPLICATE_SAME_ACCESS
 553         );
 554     m_lpName = new TCHAR[_tcslen(lpName) + 1];
 555     if ( m_lpName )
 556         _tcscpy( m_lpName, lpName );
 557 }
 558
 559 //----------------------------------------------------------------------------
 560 //      ServerPipe dtor
 561 //----------------------------------------------------------------------------
 562
 563 ServerPipe::~ServerPipe()
 564 {
 565     if ( IsValidHandle(m_hMapping) )
 566         CloseHandle( m_hMapping );
 567     if ( m_lpName )
 568         delete[]m_lpName;
 569 }
 570
 571 //----------------------------------------------------------------------------
 572 //      ServerPipe AcceptConnection
 573 //----------------------------------------------------------------------------
 574
 575 Pipe *ServerPipe::AcceptConnection()
 576 {
 577     Pipe        *pPipe = NULL;  // Assume failure;
 578
 579     HANDLE      hConnectionRequest = CreatePipeConnectionSemaphore( m_lpName, 0, 1 );
 580
 581     if ( WAIT_OBJECT_0 == WaitForSingleObject( hConnectionRequest, INFINITE ) )
 582     {
 583         pPipe = new Pipe( *this );
 584         Close();
 585
 586         // Create new inbound Pipe
 587
 588         HANDLE  hClientWritePipe = NULL, hServerReadPipe = NULL;
 589
 590         BOOL    fSuccess = CreatePipe( &hServerReadPipe, &hClientWritePipe, NULL, PIPE_BUFFER_SIZE );
 591
 592
 593         if ( fSuccess )
 594         {
 595             // Create outbound pipe
 596
 597             HANDLE      hClientReadPipe = NULL, hServerWritePipe = NULL;
 598
 599             if ( CreatePipe( &hClientReadPipe, &hServerWritePipe, NULL, PIPE_BUFFER_SIZE ) )
 600             {
 601                 m_hReadPipe = hServerReadPipe;
 602                 m_hWritePipe = hServerWritePipe;
 603
 604                 PipeData        *pData = (PipeData *)MapViewOfFile( m_hMapping, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(PipeData) );
 605
 606                 HANDLE  hSynchronize = CreatePipeDataMutex( m_lpName, TRUE );
 607
 608                 CloseHandle( pData->hReadPipe );
 609                 CloseHandle( pData->hWritePipe );
 610
 611                 pData->hReadPipe = hClientReadPipe;
 612                 pData->hWritePipe = hClientWritePipe;
 613
 614                 ReleaseMutex( hSynchronize );
 615
 616                 CloseHandle( hSynchronize );
 617
 618             }
 619             else
 620             {
 621                 CloseHandle( hClientWritePipe );
 622                 CloseHandle( hServerWritePipe );
 623             }
 624         }
 625
 626         ReleaseMutex( hConnectionRequest );
 627     }
 628
 629     CloseHandle( hConnectionRequest );
 630
 631     return pPipe;
 632 }
 633
 634 //----------------------------------------------------------------------------
 635 //      Pipe creation
 636 //----------------------------------------------------------------------------
 637
 638 ServerPipe *ServerPipe::Create( LPCTSTR lpName )
 639 {
 640     ServerPipe  *pPipe = NULL;
 641
 642     HANDLE      hMapping = CreatePipeDataMapping( lpName );
 643
 644     if ( IsValidHandle(hMapping) )
 645     {
 646         if ( ERROR_FILE_EXISTS != GetLastError() )
 647         {
 648             HANDLE      hSynchronize = CreatePipeDataMutex( lpName, FALSE);
 649
 650             WaitForSingleObject( hSynchronize, INFINITE );
 651
 652             PipeData    *pData = (PipeData*)MapViewOfFile( hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
 653
 654             if ( pData )
 655             {
 656
 657                 // Initialize pipe data
 658
 659                 pData->dwProcessId = 0;
 660                 pData->hReadPipe = NULL;
 661                 pData->hWritePipe = NULL;
 662
 663                 // Create inbound pipe
 664
 665                 HANDLE  hServerReadPipe = NULL, hClientWritePipe = NULL;
 666
 667                 BOOL    fSuccess = CreatePipe( &hServerReadPipe, &hClientWritePipe, NULL, PIPE_BUFFER_SIZE );
 668
 669                 if ( fSuccess )
 670                 {
 671                     // Create outbound pipe
 672
 673                     HANDLE      hServerWritePipe = NULL, hClientReadPipe = NULL;
 674
 675                     fSuccess = CreatePipe( &hClientReadPipe, &hServerWritePipe, NULL, PIPE_BUFFER_SIZE );
 676
 677                     if ( fSuccess )
 678                     {
 679                         pData->dwProcessId = GetCurrentProcessId();
 680                         pData->hReadPipe = hClientReadPipe;
 681                         pData->hWritePipe = hClientWritePipe;
 682                         pPipe = new ServerPipe( lpName, hMapping, hSynchronize, hServerReadPipe, hServerWritePipe );
 683
 684                         CloseHandle( hServerWritePipe );
 685                         CloseHandle( hServerReadPipe );
 686                     }
 687                     else
 688                     {
 689                         CloseHandle( hServerReadPipe );
 690                         CloseHandle( hClientWritePipe );
 691                     }
 692                 }
 693
 694                 UnmapViewOfFile( pData );
 695             }
 696
 697             ReleaseMutex( hSynchronize );
 698             CloseHandle( hSynchronize );
 699         }
 700
 701         CloseHandle( hMapping );
 702     }
 703
 704     return pPipe;
 705 }
 706
 707
 708 //----------------------------------------------------------------------------
 709 //      C style API
 710 //----------------------------------------------------------------------------
 711
 712 const TCHAR     LOCAL_PIPE_PREFIX[] = TEXT("\\\\.\\PIPE\\" );
 713
 714 extern "C" HANDLE WINAPI CreateSimplePipe( LPCTSTR lpName )
 715 {
 716     int nPrefixLen = _tcslen( LOCAL_PIPE_PREFIX );
 717     if ( 0 == _tcsnicmp( lpName, LOCAL_PIPE_PREFIX, nPrefixLen ) )
 718         lpName += nPrefixLen;
 719     return (HANDLE)ServerPipe::Create( lpName );
 720 }
 721
 722 extern "C" HANDLE WINAPI OpenSimplePipe( LPCTSTR lpName )
 723 {
 724     int nPrefixLen = _tcslen( LOCAL_PIPE_PREFIX );
 725     if ( 0 == _tcsnicmp( lpName, LOCAL_PIPE_PREFIX, nPrefixLen ) )
 726         lpName += nPrefixLen;
 727     return (HANDLE)ClientPipe::Create( lpName );
 728 }
 729
 730 extern "C" HANDLE WINAPI AcceptSimplePipeConnection( HANDLE hPipe )
 731 {
 732     Pipe        *pPipe = (Pipe *)hPipe;
 733
 734     if ( pPipe->is() )
 735         return (HANDLE)pPipe->AcceptConnection();
 736     else
 737     {
 738         SetLastError( ERROR_INVALID_HANDLE );
 739         return NULL;
 740     }
 741 }
 742
 743 extern "C" BOOL WINAPI WaitForSimplePipe( LPCTSTR /*lpName*/, DWORD /*dwTimeOut*/ )
 744 {
 745     return FALSE;
 746 }
 747
 748 extern "C" BOOL WINAPI WriteSimplePipe( HANDLE hPipe, LPCVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpBytesWritten, BOOL bWait )
 749 {
 750     Pipe        *pPipe = (Pipe *)hPipe;
 751
 752     if ( pPipe->is() )
 753         return pPipe->Write( lpBuffer, dwBytesToWrite, lpBytesWritten, bWait );
 754     else
 755     {
 756         SetLastError( ERROR_INVALID_HANDLE );
 757         return FALSE;
 758     }
 759 }
 760
 761 extern "C" BOOL WINAPI ReadSimplePipe( HANDLE hPipe, LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpBytesRead, BOOL bWait )
 762 {
 763     Pipe        *pPipe = (Pipe *)hPipe;
 764
 765     if ( pPipe->is() )
 766         return pPipe->Read( lpBuffer, dwBytesToRead, lpBytesRead, bWait );
 767     else
 768     {
 769         SetLastError( ERROR_INVALID_HANDLE );
 770         return FALSE;
 771     }
 772 }
 773
 774 extern "C" BOOL WINAPI CloseSimplePipe( HANDLE hPipe )
 775 {
 776     Pipe        *pPipe = (Pipe *)hPipe;
 777
 778     if ( pPipe->is() )
 779     {
 780         delete pPipe;
 781         return TRUE;
 782     }
 783     else
 784     {
 785         SetLastError( ERROR_INVALID_HANDLE );
 786         return FALSE;
 787     }
 788 }