vos/source/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.7 $
  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 #include <vos/pipe.hxx>
  33 #include <vos/diagnose.hxx>
  34
  35 using namespace vos;
  36
  37 ///////////////////////////////////////////////////////////////////////////////
  38 // Pipe
  39
  40
  41 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OPipe, vos),
  42                         VOS_NAMESPACE(OPipe, vos),
  43                         VOS_NAMESPACE(OObject, vos), 0);
  44
  45 /*****************************************************************************/
  46 // OPipe()
  47 /*****************************************************************************/
  48 OPipe::OPipe()
  49 {
  50     m_pPipeRef= 0;
  51 }
  52
  53 /*****************************************************************************/
  54 // OPipe()
  55 /*****************************************************************************/
  56
  57 OPipe::OPipe( const rtl::OUString& strName, TPipeOption Options)
  58 {
  59     m_pPipeRef =
  60         new PipeRef( osl_createPipe(strName.pData,
  61                                     (oslPipeOptions)Options,
  62                                     NULL) );
  63
  64     VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n");
  65     VOS_POSTCOND((*m_pPipeRef)(), "OPipe(): creation of pipe failed!\n");
  66 }
  67
  68 /*****************************************************************************/
  69 // OPipe()
  70 /*****************************************************************************/
  71
  72 OPipe::OPipe( const rtl::OUString& strName,
  73               TPipeOption Options,
  74               const OSecurity& rSecurity)
  75 {
  76     m_pPipeRef=
  77         new PipeRef(osl_createPipe(strName.pData,
  78                                    (oslPipeOptions)Options,
  79                                    (oslSecurity)rSecurity));
  80
  81     VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n");
  82     VOS_POSTCOND((*m_pPipeRef)(), "OPipe(): creation of pipe failed!\n");
  83 }
  84
  85 /*****************************************************************************/
  86 // OPipe()
  87 /*****************************************************************************/
  88 OPipe::OPipe(const OPipe& pipe) :
  89 OReference(), OObject()
  90 {
  91
  92     VOS_ASSERT(pipe.m_pPipeRef != 0);
  93
  94     m_pPipeRef= pipe.m_pPipeRef;
  95
  96     m_pPipeRef->acquire();
  97 }
  98
  99 /*****************************************************************************/
 100 // OPipe()
 101 /*****************************************************************************/
 102 OPipe::OPipe(oslPipe Pipe)
 103 {
 104     m_pPipeRef = new PipeRef(Pipe);
 105 }
 106
 107
 108 /*****************************************************************************/
 109 // ~OPipe()
 110 /*****************************************************************************/
 111 OPipe::~OPipe()
 112 {
 113     close();
 114 }
 115
 116 /*****************************************************************************/
 117 // create
 118 /*****************************************************************************/
 119 sal_Bool OPipe::create( const rtl::OUString& strName, TPipeOption Options )
 120 {
 121     // if this was a valid pipe, decrease reference
 122     if ((m_pPipeRef) && (m_pPipeRef->release() == 0))
 123     {
 124         osl_releasePipe((*m_pPipeRef)());
 125         delete m_pPipeRef;
 126         m_pPipeRef= 0;
 127     }
 128
 129     m_pPipeRef=
 130         new PipeRef(osl_createPipe(strName.pData,
 131                                    (oslPipeOptions)Options,
 132                                    NULL));
 133
 134     VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n");
 135
 136     return (*m_pPipeRef)() != 0;
 137 }
 138
 139 /*****************************************************************************/
 140 // create
 141 /*****************************************************************************/
 142 sal_Bool OPipe::create( const rtl::OUString& strName,
 143                         TPipeOption Options,
 144                         const NAMESPACE_VOS(OSecurity)& rSecurity )
 145 {
 146     // if this was a valid pipe, decrease reference
 147     if ((m_pPipeRef) && (m_pPipeRef->release() == 0))
 148     {
 149         osl_releasePipe((*m_pPipeRef)());
 150         delete m_pPipeRef;
 151         m_pPipeRef= 0;
 152     }
 153
 154     m_pPipeRef=
 155         new PipeRef(osl_createPipe(strName.pData,
 156                                    (oslPipeOptions)Options,
 157                                    (oslSecurity)rSecurity));
 158
 159     VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n");
 160
 161     return (*m_pPipeRef)() != 0;
 162 }
 163
 164 /*****************************************************************************/
 165 // operator=
 166 /*****************************************************************************/
 167 OPipe& OPipe::operator= (const OPipe& pipe)
 168 {
 169     VOS_PRECOND(pipe.m_pPipeRef != 0, "OPipe::operator=: tried to assign an empty/invalid pipe\n");
 170
 171     if (m_pPipeRef == pipe.m_pPipeRef)
 172         return *this;
 173
 174     // if this was a valid pipe, decrease reference
 175     if ((m_pPipeRef) && (m_pPipeRef->release() == 0))
 176     {
 177         osl_releasePipe((*m_pPipeRef)());
 178         delete m_pPipeRef;
 179         m_pPipeRef= 0;
 180     }
 181
 182     m_pPipeRef= pipe.m_pPipeRef;
 183
 184     m_pPipeRef->acquire();
 185
 186     return *this;
 187 }
 188
 189 /*****************************************************************************/
 190 // operator oslPipe()
 191 /*****************************************************************************/
 192 OPipe::operator oslPipe() const
 193 {
 194     VOS_ASSERT(m_pPipeRef);
 195     return (*m_pPipeRef)();
 196 }
 197
 198 /*****************************************************************************/
 199 // isValid()
 200 /*****************************************************************************/
 201 sal_Bool OPipe::isValid() const
 202 {
 203     return m_pPipeRef != 0 && (*m_pPipeRef)() != 0;
 204 }
 205
 206
 207 /*****************************************************************************/
 208 // close
 209 /*****************************************************************************/
 210 void OPipe::close()
 211 {
 212     if (m_pPipeRef && (m_pPipeRef->release() == 0))
 213     {
 214         osl_releasePipe((*m_pPipeRef)());
 215         delete m_pPipeRef;
 216     }
 217     m_pPipeRef= 0;
 218 }
 219
 220 /*****************************************************************************/
 221 // accept
 222 /*****************************************************************************/
 223 OPipe::TPipeError OPipe::accept(OStreamPipe& Connection)
 224 {
 225     if ( isValid() )
 226     {
 227         Connection = osl_acceptPipe((*m_pPipeRef)());
 228
 229         if(Connection.isValid())
 230             return E_None;
 231     }
 232
 233     return getError();
 234 }
 235
 236 /*****************************************************************************/
 237 // recv
 238 /*****************************************************************************/
 239 sal_Int32 OPipe::recv(void* pBuffer, sal_uInt32 BytesToRead)
 240 {
 241     if ( isValid() )
 242         return osl_receivePipe((*m_pPipeRef)(),
 243                              pBuffer,
 244                             BytesToRead);
 245     else
 246         return -1;
 247
 248 }
 249
 250 /*****************************************************************************/
 251 // send
 252 /*****************************************************************************/
 253 sal_Int32 OPipe::send(const void* pBuffer, sal_uInt32 BytesToSend)
 254 {
 255     if ( isValid() )
 256         return osl_sendPipe((*m_pPipeRef)(),
 257                             pBuffer,
 258                             BytesToSend);
 259     else
 260         return -1;
 261 }
 262
 263 /*****************************************************************************/
 264 // getError
 265 /*****************************************************************************/
 266 OPipe::TPipeError OPipe::getError() const
 267 {
 268     if (m_pPipeRef)
 269         return (TPipeError)osl_getLastPipeError((*m_pPipeRef)());
 270     else
 271         return (TPipeError)osl_getLastPipeError(NULL);
 272 }
 273
 274
 275
 276 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OStreamPipe, vos),
 277                         VOS_NAMESPACE(OStreamPipe, vos),
 278                         VOS_NAMESPACE(OPipe, vos), 0);
 279
 280
 281
 282 /*****************************************************************************/
 283 // OStreamPipe
 284 /*****************************************************************************/
 285 OStreamPipe::OStreamPipe()
 286 {
 287 }
 288
 289 /*****************************************************************************/
 290 // OStreamPipe
 291 /*****************************************************************************/
 292 OStreamPipe::OStreamPipe(oslPipe Pipe) :
 293     OPipe(Pipe)
 294 {
 295 }
 296
 297 /*****************************************************************************/
 298 // OStreamPipe
 299 // copy constructor
 300 /*****************************************************************************/
 301 OStreamPipe::OStreamPipe(const OStreamPipe& pipe) :
 302 OPipe(), IStream()
 303 {
 304     VOS_ASSERT(pipe.m_pPipeRef != 0);
 305
 306     m_pPipeRef= pipe.m_pPipeRef;
 307
 308     m_pPipeRef->acquire();
 309 }
 310
 311 /*****************************************************************************/
 312 // ~OStreamPipe
 313 /*****************************************************************************/
 314 OStreamPipe::~OStreamPipe()
 315 {
 316 }
 317
 318 /*****************************************************************************/
 319 // operator=(oslPipe)
 320 /*****************************************************************************/
 321 OStreamPipe& OStreamPipe::operator=(oslPipe Pipe)
 322 {
 323
 324     // if this was a valid pipe, decrease reference
 325     if (m_pPipeRef && (m_pPipeRef->release() == 0))
 326     {
 327         osl_releasePipe((*m_pPipeRef)());
 328         delete m_pPipeRef;
 329         m_pPipeRef= 0;
 330     }
 331
 332     m_pPipeRef= new PipeRef(Pipe);
 333
 334     VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n");
 335
 336     return *this;
 337 }
 338
 339 /*****************************************************************************/
 340 // operator=OPipe
 341 /*****************************************************************************/
 342
 343 OStreamPipe& OStreamPipe::operator= (const OPipe& pipe)
 344 {
 345     OPipe::operator= ( pipe );
 346     return *this;
 347 }
 348
 349 /*****************************************************************************/
 350 // read
 351 /*****************************************************************************/
 352 sal_Int32 OStreamPipe::read(void* pBuffer, sal_uInt32 n) const
 353 {
 354     VOS_ASSERT(m_pPipeRef && (*m_pPipeRef)());
 355
 356     /* loop until all desired bytes were read or an error occured */
 357     sal_Int32 BytesRead= 0;
 358     sal_Int32 BytesToRead= n;
 359     while (BytesToRead > 0)
 360     {
 361         sal_Int32 RetVal;
 362         RetVal= osl_receivePipe((*m_pPipeRef)(),
 363                                  pBuffer,
 364                                 BytesToRead);
 365
 366         /* error occured? */
 367         if(RetVal <= 0)
 368         {
 369             break;
 370         }
 371
 372         BytesToRead -= RetVal;
 373         BytesRead += RetVal;
 374         pBuffer= (sal_Char*)pBuffer + RetVal;
 375     }
 376
 377     return BytesRead;
 378 }
 379
 380 /*****************************************************************************/
 381 // write
 382 /*****************************************************************************/
 383 sal_Int32 OStreamPipe::write(const void* pBuffer, sal_uInt32 n)
 384 {
 385     VOS_ASSERT(m_pPipeRef && (*m_pPipeRef)());
 386
 387     /* loop until all desired bytes were send or an error occured */
 388     sal_Int32 BytesSend= 0;
 389     sal_Int32 BytesToSend= n;
 390     while (BytesToSend > 0)
 391     {
 392         sal_Int32 RetVal;
 393
 394         RetVal= osl_sendPipe((*m_pPipeRef)(),
 395                                 pBuffer,
 396                                 BytesToSend);
 397
 398         /* error occured? */
 399         if(RetVal <= 0)
 400         {
 401             break;
 402         }
 403
 404         BytesToSend -= RetVal;
 405         BytesSend += RetVal;
 406         pBuffer= (sal_Char*)pBuffer + RetVal;
 407     }
 408
 409     return BytesSend;
 410 }
 411
 412 sal_Bool OStreamPipe::isEof() const
 413 {
 414     return isValid();
 415 }
 416
 417
 418
 419