sal/inc/osl/pipe_decl.hxx

   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_decl.hxx,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 #ifndef _OSL_PIPE_DECL_HXX_
  31 #define _OSL_PIPE_DECL_HXX_
  32
  33 #include <osl/pipe.h>
  34 #       include <osl/security.hxx>
  35 #include <rtl/ustring.hxx>
  36
  37 namespace osl {
  38
  39 class StreamPipe;
  40
  41 /** Represents a pipe.
  42 */
  43 class Pipe
  44 {
  45 protected:
  46     oslPipe m_handle;
  47
  48 public:
  49
  50     /** Does not create a pipe. Use assignment operator to
  51         make this a useable pipe.
  52     */
  53     inline Pipe();
  54
  55     /** Creates an insecure pipe that is accessible for all users.
  56         @param strName
  57         @param Options
  58     */
  59     inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options);
  60
  61     /** Creates a secure pipe that access depends on the umask settings.
  62         @param strName
  63         @param Options
  64         @param Security
  65     */
  66     inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options,const Security & rSecurity);
  67
  68     /** Copy constructor.
  69     */
  70     inline Pipe(const Pipe& pipe);
  71
  72     /** Constructs a Pipe reference without acquiring the handle
  73     */
  74     inline Pipe( oslPipe pipe, __sal_NoAcquire noacquire );
  75
  76     /** Creates pipe as wrapper around the underlying oslPipe.
  77         @param Pipe
  78     */
  79     inline Pipe(oslPipe Pipe);
  80
  81     /** Destructor. Destroys the underlying oslPipe.
  82     */
  83     inline ~Pipe();
  84
  85     inline sal_Bool SAL_CALL is() const;
  86
  87     /** Creates an insecure pipe that is accessible for all users
  88         with the given attributes.
  89         If the pipe was already created, the old one will be discarded.
  90         @param strName
  91         @param Options
  92         @param Security
  93         @return True if socket was successfully created.
  94     */
  95     inline sal_Bool create( const ::rtl::OUString & strName,
  96                             oslPipeOptions Options, const Security &rSec );
  97
  98     /** Creates a secure that access rights depend on the umask settings
  99         with the given attributes.
 100
 101         If socket was already created, the old one will be discarded.
 102         @param strName
 103         @param Options
 104         @return True if socket was successfully created.
 105     */
 106     inline sal_Bool create( const ::rtl::OUString & strName, oslPipeOptions Options = osl_Pipe_OPEN );
 107
 108     /** releases the underlying handle
 109      */
 110     inline void SAL_CALL clear();
 111
 112     /** Assignment operator. If pipe was already created, the old one will
 113         be discarded.
 114     */
 115     inline Pipe& SAL_CALL operator= (const Pipe& pipe);
 116
 117     /** Assignment operator. If pipe was already created, the old one will
 118         be discarded.
 119     */
 120     inline Pipe& SAL_CALL operator= (const oslPipe pipe );
 121
 122     /** Checks if the pipe is valid.
 123         @return True if the object represents a valid pipe.
 124     */
 125     inline sal_Bool SAL_CALL isValid() const;
 126
 127     inline sal_Bool SAL_CALL operator==( const Pipe& rPipe ) const;
 128
 129     /** Closes the pipe.
 130     */
 131     inline void SAL_CALL close();
 132
 133     /** Accept connection on an existing pipe
 134     */
 135     inline oslPipeError SAL_CALL accept(StreamPipe& Connection);
 136
 137
 138     /** Delivers a constant decribing the last error for the pipe system.
 139         @return ENONE if no error occured, invalid_PipeError if
 140         an unknown (unmapped) error occured, otherwise an enum describing the
 141         error.
 142     */
 143     inline oslPipeError SAL_CALL getError() const;
 144
 145     inline oslPipe SAL_CALL getHandle() const;
 146 };
 147
 148 /** A pipe to send or receive a stream of data.
 149 */
 150 class StreamPipe : public Pipe
 151 {
 152 public:
 153
 154     /** Creates an unattached pipe. You must attach the pipe to an oslPipe
 155         e.g. by using the operator=(oslPipe), before you can use the stream-
 156         functionality of the object.
 157     */
 158     inline StreamPipe();
 159
 160     /** Creates pipe as wrapper around the underlying oslPipe.
 161         @param Pipe
 162     */
 163     inline StreamPipe(oslPipe Pipe);
 164
 165     /** Copy constructor.
 166         @param Pipe
 167     */
 168     inline StreamPipe(const StreamPipe& Pipe);
 169
 170     /** Creates a pipe.
 171         @param strName
 172         @param Options
 173     */
 174     inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options = osl_Pipe_OPEN);
 175
 176     /** Creates a pipe.
 177         @param strName
 178         @param Options
 179         @param rSec
 180     */
 181     inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options, const Security &rSec );
 182
 183     /** Constructs a Pipe reference without acquiring the handle
 184     */
 185     inline StreamPipe( oslPipe pipe, __sal_NoAcquire noacquire );
 186
 187     /** Attaches the oslPipe to this object. If the object
 188         already was attached to an oslPipe, the old one will
 189         be closed and destroyed.
 190         @param Pipe.
 191     */
 192     inline StreamPipe & SAL_CALL operator=(oslPipe Pipe);
 193
 194     /** Assignment operator
 195     */
 196     inline StreamPipe& SAL_CALL operator=(const Pipe& pipe);
 197
 198     /** Tries to receives BytesToRead data from the connected pipe,
 199
 200         @param pBuffer [out] Points to a buffer that will be filled with the received
 201         data.
 202         @param BytesToRead [in] The number of bytes to read. pBuffer must have at least
 203         this size.
 204         @return the number of received bytes.
 205     */
 206     inline sal_Int32 SAL_CALL recv(void* pBuffer, sal_Int32 BytesToRead) const;
 207
 208     /** Tries to sends BytesToSend data from the connected pipe.
 209
 210         @param pBuffer [in] Points to a buffer that contains the send-data.
 211         @param BytesToSend [in] The number of bytes to send. pBuffer must have at least
 212         this size.
 213         @return the number of transfered bytes.
 214     */
 215     inline sal_Int32 SAL_CALL send(const void* pBuffer, sal_Int32 BytesToSend) const;
 216
 217     /** Retrieves n bytes from the stream and copies them into pBuffer.
 218         The method avoids incomplete reads due to packet boundaries.
 219         @param pBuffer receives the read data.
 220         @param n the number of bytes to read. pBuffer must be large enough
 221         to hold the n bytes!
 222         @return the number of read bytes. The number will only be smaller than
 223         n if an exceptional condition (e.g. connection closed) occurs.
 224     */
 225     inline sal_Int32 SAL_CALL read(void* pBuffer, sal_Int32 n) const;
 226
 227     /** Writes n bytes from pBuffer to the stream. The method avoids
 228         incomplete writes due to packet boundaries.
 229         @param pBuffer contains the data to be written.
 230         @param n the number of bytes to write.
 231         @return the number of written bytes. The number will only be smaller than
 232         n if an exceptional condition (e.g. connection closed) occurs.
 233     */
 234     sal_Int32 SAL_CALL write(const void* pBuffer, sal_Int32 n) const;
 235 };
 236
 237 }
 238 #endif