| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| |
| #include <vos/pipe.hxx> |
| #include <vos/diagnose.hxx> |
| |
| using namespace vos; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Pipe |
| |
| |
| VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OPipe, vos), |
| VOS_NAMESPACE(OPipe, vos), |
| VOS_NAMESPACE(OObject, vos), 0); |
| |
| /*****************************************************************************/ |
| // OPipe() |
| /*****************************************************************************/ |
| OPipe::OPipe() |
| { |
| m_pPipeRef= 0; |
| } |
| |
| /*****************************************************************************/ |
| // OPipe() |
| /*****************************************************************************/ |
| |
| OPipe::OPipe( const rtl::OUString& strName, TPipeOption Options) |
| { |
| m_pPipeRef = |
| new PipeRef( osl_createPipe(strName.pData, |
| (oslPipeOptions)Options, |
| NULL) ); |
| |
| VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n"); |
| VOS_POSTCOND((*m_pPipeRef)(), "OPipe(): creation of pipe failed!\n"); |
| } |
| |
| /*****************************************************************************/ |
| // OPipe() |
| /*****************************************************************************/ |
| |
| OPipe::OPipe( const rtl::OUString& strName, |
| TPipeOption Options, |
| const OSecurity& rSecurity) |
| { |
| m_pPipeRef= |
| new PipeRef(osl_createPipe(strName.pData, |
| (oslPipeOptions)Options, |
| (oslSecurity)rSecurity)); |
| |
| VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n"); |
| VOS_POSTCOND((*m_pPipeRef)(), "OPipe(): creation of pipe failed!\n"); |
| } |
| |
| /*****************************************************************************/ |
| // OPipe() |
| /*****************************************************************************/ |
| OPipe::OPipe(const OPipe& pipe) : |
| OReference(), OObject() |
| { |
| |
| VOS_ASSERT(pipe.m_pPipeRef != 0); |
| |
| m_pPipeRef= pipe.m_pPipeRef; |
| |
| m_pPipeRef->acquire(); |
| } |
| |
| /*****************************************************************************/ |
| // OPipe() |
| /*****************************************************************************/ |
| OPipe::OPipe(oslPipe Pipe) |
| { |
| m_pPipeRef = new PipeRef(Pipe); |
| } |
| |
| |
| /*****************************************************************************/ |
| // ~OPipe() |
| /*****************************************************************************/ |
| OPipe::~OPipe() |
| { |
| close(); |
| } |
| |
| /*****************************************************************************/ |
| // create |
| /*****************************************************************************/ |
| sal_Bool OPipe::create( const rtl::OUString& strName, TPipeOption Options ) |
| { |
| // if this was a valid pipe, decrease reference |
| if ((m_pPipeRef) && (m_pPipeRef->release() == 0)) |
| { |
| osl_releasePipe((*m_pPipeRef)()); |
| delete m_pPipeRef; |
| m_pPipeRef= 0; |
| } |
| |
| m_pPipeRef= |
| new PipeRef(osl_createPipe(strName.pData, |
| (oslPipeOptions)Options, |
| NULL)); |
| |
| VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n"); |
| |
| return (*m_pPipeRef)() != 0; |
| } |
| |
| /*****************************************************************************/ |
| // create |
| /*****************************************************************************/ |
| sal_Bool OPipe::create( const rtl::OUString& strName, |
| TPipeOption Options, |
| const vos::OSecurity& rSecurity ) |
| { |
| // if this was a valid pipe, decrease reference |
| if ((m_pPipeRef) && (m_pPipeRef->release() == 0)) |
| { |
| osl_releasePipe((*m_pPipeRef)()); |
| delete m_pPipeRef; |
| m_pPipeRef= 0; |
| } |
| |
| m_pPipeRef= |
| new PipeRef(osl_createPipe(strName.pData, |
| (oslPipeOptions)Options, |
| (oslSecurity)rSecurity)); |
| |
| VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n"); |
| |
| return (*m_pPipeRef)() != 0; |
| } |
| |
| /*****************************************************************************/ |
| // operator= |
| /*****************************************************************************/ |
| OPipe& OPipe::operator= (const OPipe& pipe) |
| { |
| VOS_PRECOND(pipe.m_pPipeRef != 0, "OPipe::operator=: tried to assign an empty/invalid pipe\n"); |
| |
| if (m_pPipeRef == pipe.m_pPipeRef) |
| return *this; |
| |
| // if this was a valid pipe, decrease reference |
| if ((m_pPipeRef) && (m_pPipeRef->release() == 0)) |
| { |
| osl_releasePipe((*m_pPipeRef)()); |
| delete m_pPipeRef; |
| m_pPipeRef= 0; |
| } |
| |
| m_pPipeRef= pipe.m_pPipeRef; |
| |
| m_pPipeRef->acquire(); |
| |
| return *this; |
| } |
| |
| /*****************************************************************************/ |
| // operator oslPipe() |
| /*****************************************************************************/ |
| OPipe::operator oslPipe() const |
| { |
| VOS_ASSERT(m_pPipeRef); |
| return (*m_pPipeRef)(); |
| } |
| |
| /*****************************************************************************/ |
| // isValid() |
| /*****************************************************************************/ |
| sal_Bool OPipe::isValid() const |
| { |
| return m_pPipeRef != 0 && (*m_pPipeRef)() != 0; |
| } |
| |
| |
| /*****************************************************************************/ |
| // close |
| /*****************************************************************************/ |
| void OPipe::close() |
| { |
| if (m_pPipeRef && (m_pPipeRef->release() == 0)) |
| { |
| osl_releasePipe((*m_pPipeRef)()); |
| delete m_pPipeRef; |
| } |
| m_pPipeRef= 0; |
| } |
| |
| /*****************************************************************************/ |
| // accept |
| /*****************************************************************************/ |
| OPipe::TPipeError OPipe::accept(OStreamPipe& Connection) |
| { |
| if ( isValid() ) |
| { |
| Connection = osl_acceptPipe((*m_pPipeRef)()); |
| |
| if(Connection.isValid()) |
| return E_None; |
| } |
| |
| return getError(); |
| } |
| |
| /*****************************************************************************/ |
| // recv |
| /*****************************************************************************/ |
| sal_Int32 OPipe::recv(void* pBuffer, sal_uInt32 BytesToRead) |
| { |
| if ( isValid() ) |
| return osl_receivePipe((*m_pPipeRef)(), |
| pBuffer, |
| BytesToRead); |
| else |
| return -1; |
| |
| } |
| |
| /*****************************************************************************/ |
| // send |
| /*****************************************************************************/ |
| sal_Int32 OPipe::send(const void* pBuffer, sal_uInt32 BytesToSend) |
| { |
| if ( isValid() ) |
| return osl_sendPipe((*m_pPipeRef)(), |
| pBuffer, |
| BytesToSend); |
| else |
| return -1; |
| } |
| |
| /*****************************************************************************/ |
| // getError |
| /*****************************************************************************/ |
| OPipe::TPipeError OPipe::getError() const |
| { |
| if (m_pPipeRef) |
| return (TPipeError)osl_getLastPipeError((*m_pPipeRef)()); |
| else |
| return (TPipeError)osl_getLastPipeError(NULL); |
| } |
| |
| |
| |
| VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OStreamPipe, vos), |
| VOS_NAMESPACE(OStreamPipe, vos), |
| VOS_NAMESPACE(OPipe, vos), 0); |
| |
| |
| |
| /*****************************************************************************/ |
| // OStreamPipe |
| /*****************************************************************************/ |
| OStreamPipe::OStreamPipe() |
| { |
| } |
| |
| /*****************************************************************************/ |
| // OStreamPipe |
| /*****************************************************************************/ |
| OStreamPipe::OStreamPipe(oslPipe Pipe) : |
| OPipe(Pipe) |
| { |
| } |
| |
| /*****************************************************************************/ |
| // OStreamPipe |
| // copy constructor |
| /*****************************************************************************/ |
| OStreamPipe::OStreamPipe(const OStreamPipe& pipe) : |
| OPipe(), IStream() |
| { |
| VOS_ASSERT(pipe.m_pPipeRef != 0); |
| |
| m_pPipeRef= pipe.m_pPipeRef; |
| |
| m_pPipeRef->acquire(); |
| } |
| |
| /*****************************************************************************/ |
| // ~OStreamPipe |
| /*****************************************************************************/ |
| OStreamPipe::~OStreamPipe() |
| { |
| } |
| |
| /*****************************************************************************/ |
| // operator=(oslPipe) |
| /*****************************************************************************/ |
| OStreamPipe& OStreamPipe::operator=(oslPipe Pipe) |
| { |
| |
| // if this was a valid pipe, decrease reference |
| if (m_pPipeRef && (m_pPipeRef->release() == 0)) |
| { |
| osl_releasePipe((*m_pPipeRef)()); |
| delete m_pPipeRef; |
| m_pPipeRef= 0; |
| } |
| |
| m_pPipeRef= new PipeRef(Pipe); |
| |
| VOS_POSTCOND(m_pPipeRef != 0, "OPipe(): new failed.\n"); |
| |
| return *this; |
| } |
| |
| /*****************************************************************************/ |
| // operator=OPipe |
| /*****************************************************************************/ |
| |
| OStreamPipe& OStreamPipe::operator= (const OPipe& pipe) |
| { |
| OPipe::operator= ( pipe ); |
| return *this; |
| } |
| |
| /*****************************************************************************/ |
| // read |
| /*****************************************************************************/ |
| sal_Int32 OStreamPipe::read(void* pBuffer, sal_uInt32 n) const |
| { |
| VOS_ASSERT(m_pPipeRef && (*m_pPipeRef)()); |
| |
| /* loop until all desired bytes were read or an error occured */ |
| sal_Int32 BytesRead= 0; |
| sal_Int32 BytesToRead= n; |
| while (BytesToRead > 0) |
| { |
| sal_Int32 RetVal; |
| RetVal= osl_receivePipe((*m_pPipeRef)(), |
| pBuffer, |
| BytesToRead); |
| |
| /* error occured? */ |
| if(RetVal <= 0) |
| { |
| break; |
| } |
| |
| BytesToRead -= RetVal; |
| BytesRead += RetVal; |
| pBuffer= (sal_Char*)pBuffer + RetVal; |
| } |
| |
| return BytesRead; |
| } |
| |
| /*****************************************************************************/ |
| // write |
| /*****************************************************************************/ |
| sal_Int32 OStreamPipe::write(const void* pBuffer, sal_uInt32 n) |
| { |
| VOS_ASSERT(m_pPipeRef && (*m_pPipeRef)()); |
| |
| /* loop until all desired bytes were send or an error occured */ |
| sal_Int32 BytesSend= 0; |
| sal_Int32 BytesToSend= n; |
| while (BytesToSend > 0) |
| { |
| sal_Int32 RetVal; |
| |
| RetVal= osl_sendPipe((*m_pPipeRef)(), |
| pBuffer, |
| BytesToSend); |
| |
| /* error occured? */ |
| if(RetVal <= 0) |
| { |
| break; |
| } |
| |
| BytesToSend -= RetVal; |
| BytesSend += RetVal; |
| pBuffer= (sal_Char*)pBuffer + RetVal; |
| } |
| |
| return BytesSend; |
| } |
| |
| sal_Bool OStreamPipe::isEof() const |
| { |
| return isValid(); |
| } |
| |
| |
| |
| |