sal/osl/w32/pipe.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <string.h>
  21
  22 #include "system.h"
  23
  24 #include <osl/pipe.h>
  25 #include <osl/diagnose.h>
  26 #include <osl/thread.h>
  27 #include <osl/mutex.h>
  28 #include <osl/conditn.h>
  29 #include <osl/interlck.h>
  30 #include <osl/process.h>
  31
  32 #include <rtl/alloc.h>
  33
  34 #define PIPESYSTEM      "\\\\.\\pipe\\"
  35 #define PIPEPREFIX    "OSL_PIPE_"
  36
  37 typedef struct
  38 {
  39     sal_uInt32 m_Size;
  40     sal_uInt32 m_ReadPos;
  41     sal_uInt32 m_WritePos;
  42     BYTE   m_Data[1];
  43
  44 } oslPipeBuffer;
  45
  46 /*****************************************************************************/
  47 /* oslPipeImpl */
  48 /*****************************************************************************/
  49
  50 struct oslPipeImpl {
  51     oslInterlockedCount  m_Reference;
  52     HANDLE               m_File;
  53     HANDLE               m_NamedObject;
  54     PSECURITY_ATTRIBUTES m_Security;
  55     HANDLE               m_ReadEvent;
  56     HANDLE               m_WriteEvent;
  57     HANDLE               m_AcceptEvent;
  58     rtl_uString*         m_Name;
  59     oslPipeError         m_Error;
  60     sal_Bool             m_bClosed;
  61 };
  62
  63
  64 /*****************************************************************************/
  65 /* osl_create/destroy-PipeImpl */
  66 /*****************************************************************************/
  67
  68 oslPipe __osl_createPipeImpl(void)
  69 {
  70     oslPipe pPipe;
  71
  72     pPipe = (oslPipe) rtl_allocateZeroMemory(sizeof(struct oslPipeImpl));
  73
  74     pPipe->m_bClosed = sal_False;
  75     pPipe->m_Reference = 0;
  76     pPipe->m_Name = NULL;
  77     pPipe->m_File = INVALID_HANDLE_VALUE;
  78     pPipe->m_NamedObject = INVALID_HANDLE_VALUE;
  79
  80     pPipe->m_ReadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  81     pPipe->m_WriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  82     pPipe->m_AcceptEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  83
  84     return pPipe;
  85 }
  86
  87 void __osl_destroyPipeImpl(oslPipe pPipe)
  88 {
  89     if (pPipe != NULL)
  90     {
  91         if ( pPipe->m_NamedObject != INVALID_HANDLE_VALUE && pPipe->m_NamedObject != NULL )
  92             CloseHandle( pPipe->m_NamedObject );
  93
  94         if (pPipe->m_Security != NULL)
  95         {
  96             rtl_freeMemory(pPipe->m_Security->lpSecurityDescriptor);
  97             rtl_freeMemory(pPipe->m_Security);
  98         }
  99
 100         CloseHandle(pPipe->m_ReadEvent);
 101         CloseHandle(pPipe->m_WriteEvent);
 102         CloseHandle(pPipe->m_AcceptEvent);
 103
 104         if (pPipe->m_Name)
 105             rtl_uString_release(pPipe->m_Name);
 106
 107         rtl_freeMemory(pPipe);
 108     }
 109 }
 110
 111
 112
 113 /*****************************************************************************/
 114 /* osl_createPipe  */
 115 /*****************************************************************************/
 116 oslPipe SAL_CALL osl_createPipe(rtl_uString *strPipeName, oslPipeOptions Options,
 117                        oslSecurity Security)
 118 {
 119     rtl_uString* name = NULL;
 120     rtl_uString* path = NULL;
 121     rtl_uString* temp = NULL;
 122     oslPipe pPipe;
 123
 124        PSECURITY_ATTRIBUTES  pSecAttr = NULL;
 125
 126     rtl_uString_newFromAscii(&path, PIPESYSTEM);
 127     rtl_uString_newFromAscii(&name, PIPEPREFIX);
 128
 129     if ( Security)
 130     {
 131         rtl_uString *Ident = NULL;
 132         rtl_uString *Delim = NULL;
 133
 134         OSL_VERIFY(osl_getUserIdent(Security, &Ident));
 135         rtl_uString_newFromAscii(&Delim, "_");
 136
 137         rtl_uString_newConcat(&temp, name, Ident);
 138         rtl_uString_newConcat(&name, temp, Delim);
 139
 140         rtl_uString_release(Ident);
 141         rtl_uString_release(Delim);
 142     }
 143     else
 144     {
 145         if (Options & osl_Pipe_CREATE)
 146         {
 147             PSECURITY_DESCRIPTOR pSecDesc;
 148
 149             pSecDesc = (PSECURITY_DESCRIPTOR) rtl_allocateMemory(SECURITY_DESCRIPTOR_MIN_LENGTH);
 150
 151             /* add a NULL disc. ACL to the security descriptor */
 152             OSL_VERIFY(InitializeSecurityDescriptor(pSecDesc, SECURITY_DESCRIPTOR_REVISION));
 153             OSL_VERIFY(SetSecurityDescriptorDacl(pSecDesc, TRUE, (PACL) NULL, FALSE));
 154
 155             pSecAttr = rtl_allocateMemory(sizeof(SECURITY_ATTRIBUTES));
 156             pSecAttr->nLength = sizeof(SECURITY_ATTRIBUTES);
 157             pSecAttr->lpSecurityDescriptor = pSecDesc;
 158             pSecAttr->bInheritHandle = TRUE;
 159         }
 160     }
 161
 162     rtl_uString_assign(&temp, name);
 163     rtl_uString_newConcat(&name, temp, strPipeName);
 164
 165     /* alloc memory */
 166     pPipe= __osl_createPipeImpl();
 167     osl_atomic_increment(&(pPipe->m_Reference));
 168
 169     /* build system pipe name */
 170     rtl_uString_assign(&temp, path);
 171     rtl_uString_newConcat(&path, temp, name);
 172     rtl_uString_release(temp);
 173     temp = NULL;
 174
 175     if (Options & osl_Pipe_CREATE)
 176     {
 177         SetLastError( ERROR_SUCCESS );
 178
 179         pPipe->m_NamedObject = CreateMutexW( NULL, FALSE, name->buffer );
 180
 181         if ( pPipe->m_NamedObject != INVALID_HANDLE_VALUE && pPipe->m_NamedObject != NULL )
 182         {
 183             if ( GetLastError() != ERROR_ALREADY_EXISTS )
 184             {
 185                 pPipe->m_Security = pSecAttr;
 186                 rtl_uString_assign(&pPipe->m_Name, name);
 187
 188                 /* try to open system pipe */
 189                 pPipe->m_File = CreateNamedPipeW(
 190                     path->buffer,
 191                     PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
 192                     PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
 193                     PIPE_UNLIMITED_INSTANCES,
 194                     4096, 4096,
 195                     NMPWAIT_WAIT_FOREVER,
 196                     pPipe->m_Security);
 197
 198                 if (pPipe->m_File != INVALID_HANDLE_VALUE)
 199                 {
 200                     rtl_uString_release( name );
 201                     rtl_uString_release( path );
 202
 203                     return pPipe;
 204                 }
 205             }
 206             else
 207             {
 208                 CloseHandle( pPipe->m_NamedObject );
 209                 pPipe->m_NamedObject = INVALID_HANDLE_VALUE;
 210             }
 211         }
 212     }
 213     else
 214     {
 215         BOOL    fPipeAvailable;
 216
 217         do
 218         {
 219             /* free instance should be available first */
 220             fPipeAvailable = WaitNamedPipeW(path->buffer, NMPWAIT_WAIT_FOREVER);
 221
 222             /* first try to open system pipe */
 223             if ( fPipeAvailable )
 224             {
 225                 pPipe->m_File = CreateFileW(
 226                     path->buffer,
 227                     GENERIC_READ|GENERIC_WRITE,
 228                     FILE_SHARE_READ | FILE_SHARE_WRITE,
 229                     NULL,
 230                     OPEN_EXISTING,
 231                     FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
 232                     NULL);
 233
 234                 if ( pPipe->m_File != INVALID_HANDLE_VALUE )
 235                 {
 236                     // We got it !
 237                     rtl_uString_release( name );
 238                     rtl_uString_release( path );
 239
 240                     return (pPipe);
 241                 }
 242                 else
 243                 {
 244                     // Pipe instance maybe catched by another client -> try again
 245                 }
 246             }
 247         } while ( fPipeAvailable );
 248     }
 249
 250     /* if we reach here something went wrong */
 251     __osl_destroyPipeImpl(pPipe);
 252
 253     return NULL;
 254 }
 255
 256 void SAL_CALL osl_acquirePipe( oslPipe pPipe )
 257 {
 258     osl_atomic_increment( &(pPipe->m_Reference) );
 259 }
 260
 261 void SAL_CALL osl_releasePipe( oslPipe pPipe )
 262 {
 263 //      OSL_ASSERT( pPipe );
 264
 265     if( 0 == pPipe )
 266         return;
 267
 268     if( 0 == osl_atomic_decrement( &(pPipe->m_Reference) ) )
 269     {
 270         if( ! pPipe->m_bClosed )
 271             osl_closePipe( pPipe );
 272
 273         __osl_destroyPipeImpl( pPipe );
 274     }
 275 }
 276
 277 void SAL_CALL osl_closePipe( oslPipe pPipe )
 278 {
 279     if( pPipe && ! pPipe->m_bClosed )
 280     {
 281         pPipe->m_bClosed = sal_True;
 282         /* if we have a system pipe close it */
 283         if (pPipe->m_File != INVALID_HANDLE_VALUE)
 284         {
 285             /*          FlushFileBuffers(pPipe->m_File); */
 286             DisconnectNamedPipe(pPipe->m_File);
 287             CloseHandle(pPipe->m_File);
 288         }
 289     }
 290 }
 291
 292 /*****************************************************************************/
 293 /* osl_acceptPipe  */
 294 /*****************************************************************************/
 295 oslPipe SAL_CALL osl_acceptPipe(oslPipe pPipe)
 296 {
 297     oslPipe  pAcceptedPipe = NULL;
 298
 299     OVERLAPPED   os;
 300
 301     DWORD nBytesTransfered;
 302     rtl_uString* path = NULL;
 303     rtl_uString* temp = NULL;
 304
 305     OSL_ASSERT(pPipe);
 306     OSL_ASSERT(pPipe->m_File != INVALID_HANDLE_VALUE);
 307
 308     memset(&os, 0, sizeof(OVERLAPPED));
 309     os.hEvent = pPipe->m_AcceptEvent;
 310     ResetEvent(pPipe->m_AcceptEvent);
 311
 312     if ( !ConnectNamedPipe(pPipe->m_File, &os))
 313     {
 314         switch ( GetLastError() )
 315         {
 316             case ERROR_PIPE_CONNECTED:  // Client already connected to pipe
 317             case ERROR_NO_DATA:         // Client was connected but has already closed pipe end
 318                                         // should only appear in nonblocking mode but in fact does
 319                                         // in blocking asynchronous mode.
 320                 break;
 321             case ERROR_PIPE_LISTENING:  // Only for nonblocking mode but see ERROR_NO_DATA
 322             case ERROR_IO_PENDING:      // This is normal if not client is connected yet
 323             case ERROR_MORE_DATA:       // Should not happen
 324                 // blocking call to accept
 325                 if( !GetOverlappedResult( pPipe->m_File, &os, &nBytesTransfered, TRUE ) )
 326                 {
 327                     // Possible error could be that between ConnectNamedPipe and GetOverlappedResult a connect
 328                     // took place.
 329
 330                     switch ( GetLastError() )
 331                     {
 332                     case ERROR_PIPE_CONNECTED:  // Pipe was already connected
 333                     case ERROR_NO_DATA:         // Pipe was connected but client has already closed -> ver fast client ;-)
 334                         break;                  // Everything's fine !!!
 335                     default:
 336                         // Something went wrong
 337                         return 0;
 338                     }
 339                 }
 340                 break;
 341             default:                    // All other error say that somethings going wrong.
 342                 return 0;
 343         }
 344     }
 345
 346     pAcceptedPipe = __osl_createPipeImpl();
 347     OSL_ASSERT(pAcceptedPipe);
 348
 349     osl_atomic_increment(&(pAcceptedPipe->m_Reference));
 350     rtl_uString_assign(&pAcceptedPipe->m_Name, pPipe->m_Name);
 351     pAcceptedPipe->m_File = pPipe->m_File;
 352
 353     rtl_uString_newFromAscii(&temp, PIPESYSTEM);
 354     rtl_uString_newConcat(&path, temp, pPipe->m_Name);
 355     rtl_uString_release(temp);
 356
 357     // prepare for next accept
 358     pPipe->m_File =
 359         CreateNamedPipeW(path->buffer,
 360             PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
 361             PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
 362             PIPE_UNLIMITED_INSTANCES,
 363             4096, 4096,
 364             NMPWAIT_WAIT_FOREVER,
 365             pAcceptedPipe->m_Security);
 366     rtl_uString_release( path );
 367
 368     return pAcceptedPipe;
 369 }
 370
 371 /*****************************************************************************/
 372 /* osl_receivePipe  */
 373 /*****************************************************************************/
 374 sal_Int32 SAL_CALL osl_receivePipe(oslPipe pPipe,
 375                         void* pBuffer,
 376                         sal_Int32 BytesToRead)
 377 {
 378     DWORD nBytes;
 379     OVERLAPPED   os;
 380
 381     OSL_ASSERT(pPipe);
 382
 383     memset(&os, 0, sizeof(OVERLAPPED));
 384     os.hEvent = pPipe->m_ReadEvent;
 385
 386     ResetEvent(pPipe->m_ReadEvent);
 387
 388     if (! ReadFile(pPipe->m_File, pBuffer, BytesToRead, &nBytes, &os) &&
 389         ((GetLastError() != ERROR_IO_PENDING) ||
 390          ! GetOverlappedResult(pPipe->m_File, &os, &nBytes, TRUE)))
 391     {
 392         DWORD lastError = GetLastError();
 393
 394         if (lastError == ERROR_MORE_DATA)
 395             nBytes = BytesToRead;
 396           else
 397           {
 398               if (lastError == ERROR_PIPE_NOT_CONNECTED)
 399                 nBytes = 0;
 400             else
 401                 nBytes = (DWORD) -1;
 402
 403              pPipe->m_Error = osl_Pipe_E_ConnectionAbort;
 404         }
 405     }
 406
 407     return (nBytes);
 408 }
 409
 410 /*****************************************************************************/
 411 /* osl_sendPipe  */
 412 /*****************************************************************************/
 413 sal_Int32 SAL_CALL osl_sendPipe(oslPipe pPipe,
 414                        const void* pBuffer,
 415                        sal_Int32 BytesToSend)
 416 {
 417     DWORD nBytes;
 418     OVERLAPPED   os;
 419
 420     OSL_ASSERT(pPipe);
 421
 422     memset(&os, 0, sizeof(OVERLAPPED));
 423     os.hEvent = pPipe->m_WriteEvent;
 424     ResetEvent(pPipe->m_WriteEvent);
 425
 426     if (! WriteFile(pPipe->m_File, pBuffer, BytesToSend, &nBytes, &os) &&
 427         ((GetLastError() != ERROR_IO_PENDING) ||
 428           ! GetOverlappedResult(pPipe->m_File, &os, &nBytes, TRUE)))
 429     {
 430           if (GetLastError() == ERROR_PIPE_NOT_CONNECTED)
 431             nBytes = 0;
 432         else
 433             nBytes = (DWORD) -1;
 434
 435          pPipe->m_Error = osl_Pipe_E_ConnectionAbort;
 436     }
 437
 438     return (nBytes);
 439 }
 440
 441 sal_Int32 SAL_CALL osl_writePipe( oslPipe pPipe, const void *pBuffer , sal_Int32 n )
 442 {
 443     /* loop until all desired bytes were send or an error occurred */
 444     sal_Int32 BytesSend= 0;
 445     sal_Int32 BytesToSend= n;
 446
 447     OSL_ASSERT(pPipe);
 448     while (BytesToSend > 0)
 449     {
 450         sal_Int32 RetVal;
 451
 452         RetVal= osl_sendPipe(pPipe, pBuffer, BytesToSend);
 453
 454         /* error occurred? */
 455         if(RetVal <= 0)
 456         {
 457             break;
 458         }
 459
 460         BytesToSend -= RetVal;
 461         BytesSend += RetVal;
 462         pBuffer= (sal_Char*)pBuffer + RetVal;
 463     }
 464
 465     return BytesSend;
 466 }
 467
 468 sal_Int32 SAL_CALL osl_readPipe( oslPipe pPipe, void *pBuffer , sal_Int32 n )
 469 {
 470     /* loop until all desired bytes were read or an error occurred */
 471     sal_Int32 BytesRead= 0;
 472     sal_Int32 BytesToRead= n;
 473
 474     OSL_ASSERT( pPipe );
 475     while (BytesToRead > 0)
 476     {
 477         sal_Int32 RetVal;
 478         RetVal= osl_receivePipe(pPipe, pBuffer, BytesToRead);
 479
 480         /* error occurred? */
 481         if(RetVal <= 0)
 482         {
 483             break;
 484         }
 485
 486         BytesToRead -= RetVal;
 487         BytesRead += RetVal;
 488         pBuffer= (sal_Char*)pBuffer + RetVal;
 489     }
 490     return BytesRead;
 491 }
 492
 493
 494 /*****************************************************************************/
 495 /* osl_getLastPipeError  */
 496 /*****************************************************************************/
 497 oslPipeError SAL_CALL osl_getLastPipeError(oslPipe pPipe)
 498 {
 499     oslPipeError Error;
 500
 501     if (pPipe != NULL)
 502     {
 503         Error = pPipe->m_Error;
 504         pPipe->m_Error = osl_Pipe_E_None;
 505     }
 506     else
 507         Error = osl_Pipe_E_NotFound;
 508
 509     return (Error);
 510 }
 511
 512 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */