sal/osl/os2/pipe.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: pipe.cxx,v $
  10  * $Revision: 1.5 $
  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 //#define INCL_DOSERRORS
  32 #include "system.h"
  33
  34 #include <osl/pipe.h>
  35 #include <osl/diagnose.h>
  36 #include <osl/thread.h>
  37 #include <osl/mutex.h>
  38 #include <osl/semaphor.h>
  39 #include <osl/conditn.h>
  40 #include <osl/interlck.h>
  41 #include <osl/process.h>
  42 #include <rtl/ustring.hxx>
  43
  44 #define PIPENAMEMASK    "OSL_PIPE_%s"
  45 #define SECPIPENAMEMASK "OSL_PIPE_%s_%s"
  46
  47 typedef enum {
  48     MSG_SYN,
  49     MSG_FIN,
  50     MSG_DATA,
  51     MSG_UNKNOWN
  52 } MessageType;
  53
  54 struct oslPipeImpl {
  55     oslInterlockedCount m_Reference;
  56     HPIPE                               hPipe;
  57     HMTX                                m_NamedObject;
  58     APIRET                              nLastError;
  59     //oslSecurity               m_Security;
  60     sal_Bool            m_bClosed;
  61 };
  62
  63 /* default size for input/output buffer */
  64 static const ULONG ulBufSize = 4096;
  65
  66 /* OS/2 path for pipes */
  67 static const CHAR  pszPipePath[] = "\\PIPE\\";
  68 static const UCHAR nPipePathLen  = sizeof (pszPipePath) - 1;
  69
  70 /* global last error value to be returned from oslGetLastPipeError */
  71 static APIRET ngLastError;
  72
  73 using rtl::OString;
  74 using rtl::OUString;
  75 using rtl::OUStringToOString;
  76
  77 /*****************************************************************************/
  78 /* osl_create/destroy-PipeImpl */
  79 /*****************************************************************************/
  80
  81 static oslInterlockedCount nPipes = 0;
  82
  83 oslPipe __osl_createPipeImpl(void)
  84 {
  85     oslPipe pPipe;
  86
  87     pPipe = (oslPipe) calloc(1,sizeof(struct oslPipeImpl));
  88
  89     pPipe->m_bClosed = sal_False;
  90     pPipe->m_Reference = 1;
  91     pPipe->hPipe = NULL;
  92     pPipe->m_NamedObject = NULL;
  93
  94     return pPipe;
  95 }
  96
  97 void __osl_destroyPipeImpl(oslPipe pPipe)
  98 {
  99     if (pPipe != NULL)
 100     {
 101         DosCloseMutexSem( pPipe->m_NamedObject);
 102         free(pPipe);
 103     }
 104 }
 105
 106
 107 /*****************************************************************************/
 108 /* osl_createPipe  */
 109 /*****************************************************************************/
 110 oslPipe SAL_CALL osl_createPipe(rtl_uString *ustrPipeName, oslPipeOptions Options,
 111                        oslSecurity Security)
 112 {
 113     oslPipe pPipe;
 114
 115     ULONG  ulAction;
 116     CHAR   strPipeNameBuffer [CCHMAXPATHCOMP];
 117     rtl_String* strPipeName=0;
 118     sal_Char* pszPipeName=0;
 119
 120     /* check parameters */
 121     OSL_ASSERT( ustrPipeName );
 122     //YD 17/04/06 OSL_ASSERT( Security == 0 );
 123
 124     /* allocate impl-structure */
 125     pPipe = __osl_createPipeImpl();
 126     if (!pPipe)
 127     {
 128         OSL_TRACE( "osl_createPipe failed allocating memory.\n" );
 129         return NULL;
 130     }
 131
 132     /* create pipe name */
 133     OString sPipe = OUStringToOString(ustrPipeName, RTL_TEXTENCODING_ASCII_US);
 134 #if OSL_DEBUG_LEVEL>0
 135     debug_printf("osl_createPipe options 0x%x\n", Options);
 136 #endif
 137
 138     switch( Options )
 139     {
 140     case osl_Pipe_OPEN:
 141         {
 142             APIRET      fPipeAvailable;
 143
 144             sprintf (strPipeNameBuffer, "\\PIPE\\OSL_PIPE_%s", sPipe.getStr());
 145 #if OSL_DEBUG_LEVEL>0
 146             debug_printf("osl_createPipe %s\n", strPipeNameBuffer);
 147 #endif
 148             ngLastError = DosOpen( (PCSZ)strPipeNameBuffer,
 149                                 &(pPipe->hPipe), &ulAction,
 150                                 0, FILE_NORMAL, FILE_OPEN,
 151                                 OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE,
 152                                 (PEAOP2) NULL);
 153             // if pipe is busy, wait for it
 154             if (ngLastError == ERROR_PIPE_BUSY)
 155                 do
 156                 {
 157                     /* free instance should be available first */
 158                     fPipeAvailable = DosWaitNPipe( (PCSZ)strPipeNameBuffer, -1);
 159                     /* first try to open system pipe */
 160                     if ( fPipeAvailable == NO_ERROR )
 161                     {
 162                         // We got it !
 163                         ngLastError = NO_ERROR;
 164                         break;
 165                     }
 166                     // Pipe instance maybe catched by another client -> try again
 167                     printf("osl_createPipe wait for Pipe available\n");
 168                 } while ( fPipeAvailable );
 169         }
 170         break;
 171     case osl_Pipe_CREATE:
 172         {
 173             sprintf (strPipeNameBuffer, "\\SEM32\\OSL_SEM_%s", sPipe.getStr());
 174             // check if semaphore exists (pipe create must fail for existig pipes)
 175             ngLastError = DosCreateMutexSem( (PCSZ)strPipeNameBuffer, &(pPipe->m_NamedObject), 0, TRUE );
 176             if (ngLastError)
 177                 break;
 178
 179             sprintf (strPipeNameBuffer, "\\PIPE\\OSL_PIPE_%s", sPipe.getStr());
 180 #if OSL_DEBUG_LEVEL>0
 181             debug_printf("osl_createPipe %s\n", strPipeNameBuffer);
 182 #endif
 183             ngLastError = DosCreateNPipe( (PCSZ)strPipeNameBuffer,
 184                             &(pPipe->hPipe),
 185                             NP_ACCESS_DUPLEX,    /* open pipe for read and write access */
 186                             0xFF,                /* allow unlimited number of instances */
 187                             ulBufSize,           /* output buffer size */
 188                             ulBufSize,           /* input buffer size */
 189                             0L                   /* use default time-out time */
 190                           );
 191         }
 192         break;
 193     default:
 194         ngLastError = ERROR_INVALID_PARAMETER;
 195     }
 196
 197     /* if failed, release allocated memory */
 198     if (ngLastError)
 199     {
 200         OSL_TRACE( "osl_createPipe failed %s the pipe %s, Error Code %d.\n",
 201                    Options == osl_Pipe_OPEN ? "opening" : "creating",
 202                    strPipeNameBuffer,
 203                    ngLastError );
 204         __osl_destroyPipeImpl(pPipe);
 205         return NULL;
 206     }
 207
 208     pPipe->m_Reference= 1;
 209     pPipe->m_bClosed  = sal_False;
 210     //pPipe->m_Security = Security;
 211     pPipe->nLastError = NO_ERROR;
 212     return (oslPipe)pPipe;
 213 }
 214
 215 /*****************************************************************************/
 216 /* osl_copyPipe  */
 217 /*****************************************************************************/
 218 oslPipe SAL_CALL osl_copyPipe(oslPipe pPipe)
 219 {
 220     //oslPipe* pPipe = (oslPipe*) Pipe;
 221     oslPipe pNewPipe;
 222
 223
 224     /* check parameter */
 225     OSL_ASSERT (pPipe);
 226
 227     /* allocate impl-structure */
 228     pNewPipe = __osl_createPipeImpl();
 229     if (!pNewPipe) return NULL;
 230
 231     /* create new handle */
 232     pNewPipe->hPipe = (HPIPE) -1;
 233     ngLastError  = DosDupHandle( pPipe->hPipe, &(pNewPipe->hPipe) );
 234
 235     /* if failed, release allocated memory */
 236     if (ngLastError)
 237     {
 238         OSL_TRACE( "osl_copyPipe failed duplicating pipe handle, Error-Code: %d.\n",
 239                    ngLastError );
 240         free (pNewPipe);
 241         return NULL;
 242     }
 243
 244     pNewPipe->nLastError = NO_ERROR;
 245     return (oslPipe)pNewPipe;
 246 }
 247
 248 void SAL_CALL osl_acquirePipe( oslPipe pPipe )
 249 {
 250     osl_incrementInterlockedCount( &(pPipe->m_Reference) );
 251 }
 252
 253 void SAL_CALL osl_releasePipe( oslPipe pPipe )
 254 {
 255 //      OSL_ASSERT( pPipe );
 256
 257     if( 0 == pPipe )
 258         return;
 259
 260     if( 0 == osl_decrementInterlockedCount( &(pPipe->m_Reference) ) )
 261     {
 262         if( ! pPipe->m_bClosed )
 263             osl_closePipe( pPipe );
 264
 265         __osl_destroyPipeImpl( pPipe );
 266     }
 267 }
 268
 269 /*****************************************************************************/
 270 /* osl_destroyPipe  */
 271 /*************close****************************************************************/
 272 void SAL_CALL osl_closePipe(oslPipe pPipe)
 273 {
 274     //oslPipe* pPipe = (oslPipe*) Pipe;
 275     /* check parameter */
 276     OSL_ASSERT (pPipe);
 277
 278     if( pPipe && ! pPipe->m_bClosed )
 279     {
 280         pPipe->m_bClosed = sal_True;
 281         /* if we have a system pipe close it */
 282         if (pPipe->hPipe != 0)
 283         {
 284             /* disconnect client */
 285             DosDisConnectNPipe (pPipe->hPipe);
 286
 287             /* close the pipe */
 288             DosClose (pPipe->hPipe);
 289         }
 290     }
 291 }
 292
 293 /*****************************************************************************/
 294 /* osl_acceptPipe  */
 295 /*****************************************************************************/
 296 oslPipe SAL_CALL osl_acceptPipe(oslPipe pPipe)
 297 {
 298
 299 #define PINFO ((PIPEINFO *) &PipeInfoBuffer)
 300
 301     ///oslPipe* pPipe = (oslPipe*) Pipe;
 302     oslPipe pNewPipe;
 303     BYTE     PipeInfoBuffer[sizeof(PIPEINFO) + CCHMAXPATHCOMP];
 304
 305     /* check parameter */
 306     OSL_ASSERT (pPipe);
 307
 308     /* get pipe information */
 309     pPipe->nLastError = DosQueryNPipeInfo(pPipe->hPipe,
 310                                          1,
 311                                          (PVOID) &PipeInfoBuffer,
 312                                          sizeof(PipeInfoBuffer));
 313
 314     if (pPipe->nLastError)
 315     {
 316         OSL_TRACE( "osl_acceptPipe failed for requesting pipe information.\n",
 317                    pPipe->nLastError );
 318         return NULL;
 319     }
 320
 321     /* create a new instance of the pipe if possible */
 322     if (PINFO->cbMaxInst == -1 ||                   /* unlimited instances */
 323         PINFO->cbMaxInst > PINFO->cbCurInst)
 324     {
 325         HPIPE hPipe;
 326
 327         pNewPipe = __osl_createPipeImpl();
 328
 329         if (!pNewPipe)
 330         {
 331             OSL_TRACE( "osl_acceptPipe failed creating new instance.\n", ngLastError );
 332             free(pNewPipe);
 333             return NULL;
 334         }
 335
 336         //pNewPipe->m_Security = pPipe->m_Security;
 337
 338         pNewPipe->nLastError =
 339             DosCreateNPipe( (PCSZ)PINFO->szName,
 340                             &(pNewPipe->hPipe),
 341                             NP_ACCESS_DUPLEX,    /* open pipe for read and write access */
 342                             0xFF,                /* allow unlimited number of instances */
 343                             ulBufSize,           /* output buffer size */
 344                             ulBufSize,           /* input buffer size */
 345                             0L                   /* use default time-out time */
 346                           );
 347
 348         if (pNewPipe->nLastError)
 349         {
 350             OSL_TRACE( "osl_acceptPipe failed creating new named pipe, Error-Code: %d.\n",
 351                        pNewPipe->nLastError );
 352             free(pNewPipe);
 353             return NULL;
 354         }
 355
 356         /* switch pipe handles */
 357         hPipe = pPipe->hPipe;
 358         pPipe->hPipe  = pNewPipe->hPipe;
 359         pNewPipe->hPipe = hPipe;
 360
 361         /* connect new handle to client */
 362         pNewPipe->nLastError = DosConnectNPipe( pNewPipe->hPipe );
 363
 364         /* if failed, release allocated memory */
 365         if (pNewPipe->nLastError)
 366         {
 367             OSL_TRACE( "osl_acceptPipe failed connecting pipe to client, Error-Code: %d.\n",
 368                        pNewPipe->nLastError );
 369
 370             osl_closePipe((oslPipe)pNewPipe);
 371             return NULL;
 372         }
 373         return (oslPipe)pNewPipe;
 374     }
 375     else
 376     {
 377         /* connect original handle to client */
 378         pPipe->nLastError = DosConnectNPipe( pPipe->hPipe );
 379
 380         if (pPipe->nLastError)
 381         {
 382             OSL_TRACE( "osl_acceptPipe failed connecting pipe to client, Error-Code: %d.\n",
 383                        pPipe->nLastError );
 384             return NULL;
 385         }
 386
 387         return (oslPipe)pPipe;
 388     }
 389 }
 390
 391 /*****************************************************************************/
 392 /* osl_receivePipe  */
 393 /*****************************************************************************/
 394 sal_Int32 SAL_CALL osl_receivePipe(oslPipe pPipe,
 395                         void* pBuffer,
 396                         sal_Int32 BytesToRead)
 397 {
 398     //oslPipe* pPipe = (oslPipe*) Pipe;
 399     ULONG  ulActual;
 400
 401     /* check parameter */
 402     OSL_ASSERT (pPipe);
 403
 404     /* read data from pipe */
 405     pPipe->nLastError = DosRead( pPipe->hPipe, pBuffer, BytesToRead, &ulActual );
 406
 407     /* return -1 if failed */
 408     if( pPipe->nLastError )
 409     {
 410         OSL_TRACE( "osl_receivePipe failed receiving from Pipe, Error-Code: %d.\n",
 411                    pPipe->nLastError );
 412         return -1;
 413     }
 414
 415     return ulActual;
 416 }
 417
 418
 419 /*****************************************************************************/
 420 /* osl_sendPipe  */
 421 /*****************************************************************************/
 422 sal_Int32 SAL_CALL osl_sendPipe(oslPipe pPipe,
 423                        const void* pBuffer,
 424                        sal_Int32 BytesToSend)
 425 {
 426     //oslPipe* pPipe = (oslPipe*) Pipe;
 427     ULONG  ulActual;
 428
 429     /* check parameter */
 430     OSL_ASSERT (pPipe);
 431
 432     /* read data from pipe */
 433     pPipe->nLastError = DosWrite( pPipe->hPipe, (PVOID) pBuffer, BytesToSend, &ulActual );
 434
 435     /* return -1 if failed */
 436     if( pPipe->nLastError )
 437     {
 438         OSL_TRACE( "osl_receivePipe failed writing to Pipe, Error-Code: %d.\n",
 439                    pPipe->nLastError );
 440         return -1;
 441     }
 442
 443     return ulActual;
 444 }
 445
 446
 447 /*****************************************************************************/
 448 /* osl_getLastPipeError  */
 449 /*****************************************************************************/
 450
 451 oslPipeError SAL_CALL osl_getLastPipeError(oslPipe pPipe)
 452 {
 453     //oslPipe* pPipe = (oslPipe*) Pipe;
 454     APIRET rc;
 455
 456     /* return local error value if possible */
 457     if (pPipe)
 458     {
 459         rc = pPipe->nLastError;
 460         pPipe->nLastError = NO_ERROR;
 461     } else
 462         rc = ngLastError;
 463
 464     /* map OS/2 error values */
 465     switch (rc)
 466     {
 467     case NO_ERROR:                return osl_Pipe_E_None;
 468     case ERROR_PATH_NOT_FOUND:    return osl_Pipe_E_NotFound;
 469     case ERROR_NOT_ENOUGH_MEMORY: return osl_Pipe_E_NoBufferSpace;
 470     default:                      return osl_Pipe_E_invalidError;
 471     }
 472 }
 473
 474 /*****************************************************************************/
 475
 476 sal_Int32 SAL_CALL osl_writePipe( oslPipe pPipe, const void *pBuffer , sal_Int32 n )
 477 {
 478     /* loop until all desired bytes were send or an error occured */
 479     sal_Int32 BytesSend= 0;
 480     sal_Int32 BytesToSend= n;
 481
 482     OSL_ASSERT(pPipe);
 483     while (BytesToSend > 0)
 484     {
 485         sal_Int32 RetVal;
 486
 487         RetVal= osl_sendPipe(pPipe, pBuffer, BytesToSend);
 488
 489         /* error occured? */
 490         if(RetVal <= 0)
 491         {
 492             break;
 493         }
 494
 495         BytesToSend -= RetVal;
 496         BytesSend += RetVal;
 497         pBuffer= (sal_Char*)pBuffer + RetVal;
 498     }
 499
 500     return BytesSend;
 501 }
 502
 503 sal_Int32 SAL_CALL osl_readPipe( oslPipe pPipe, void *pBuffer , sal_Int32 n )
 504 {
 505     /* loop until all desired bytes were read or an error occured */
 506     sal_Int32 BytesRead= 0;
 507     sal_Int32 BytesToRead= n;
 508
 509     OSL_ASSERT( pPipe );
 510     while (BytesToRead > 0)
 511     {
 512         sal_Int32 RetVal;
 513         RetVal= osl_receivePipe(pPipe, pBuffer, BytesToRead);
 514
 515         /* error occured? */
 516         if(RetVal <= 0)
 517         {
 518             break;
 519         }
 520
 521         BytesToRead -= RetVal;
 522         BytesRead += RetVal;
 523         pBuffer= (sal_Char*)pBuffer + RetVal;
 524     }
 525     return BytesRead;
 526 }
 527
 528
 529 /******************************************************************************
 530  *
 531  *                  New io resource transfer functions
 532  *
 533  *****************************************************************************/
 534
 535
 536 /**********************************************
 537  osl_sendResourcePipe
 538  *********************************************/
 539
 540 sal_Bool osl_sendResourcePipe(oslPipe pPipe, oslSocket pSocket)
 541 {
 542     sal_Bool bRet = sal_False;
 543
 544     return bRet;
 545 }
 546
 547 /**********************************************
 548  osl_receiveResourcePipe
 549  *********************************************/
 550
 551 oslSocket osl_receiveResourcePipe(oslPipe pPipe)
 552 {
 553     oslSocket pSocket=0;
 554
 555     return (oslSocket) pSocket;
 556 }
 557
 558