LCOV - code coverage report
Current view: top level - libreoffice/sal/osl/unx - pipe.c (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 196 0.0 %
Date: 2012-12-27 Functions: 0 15 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "system.h"
      21             : 
      22             : #include <osl/pipe.h>
      23             : #include <osl/diagnose.h>
      24             : #include <osl/thread.h>
      25             : #include <osl/interlck.h>
      26             : #include <rtl/string.h>
      27             : #include <rtl/ustring.h>
      28             : #include <rtl/bootstrap.h>
      29             : 
      30             : #include "sockimpl.h"
      31             : 
      32             : #define PIPEDEFAULTPATH     "/tmp"
      33             : #define PIPEALTERNATEPATH   "/var/tmp"
      34             : 
      35             : #define PIPENAMEMASK    "OSL_PIPE_%s"
      36             : #define SECPIPENAMEMASK "OSL_PIPE_%s_%s"
      37             : 
      38             : sal_Bool SAL_CALL osl_psz_getUserIdent(oslSecurity Security, sal_Char *pszIdent, sal_uInt32 nMax);
      39             : oslPipe SAL_CALL osl_psz_createPipe(const sal_Char *pszPipeName, oslPipeOptions Options, oslSecurity Security);
      40             : 
      41             : 
      42             : /*****************************************************************************/
      43             : /* enum oslPipeError */
      44             : /*****************************************************************************/
      45             : 
      46             : static struct
      47             : {
      48             :     int            errcode;
      49             :     oslPipeError   error;
      50             : } PipeError[]= {
      51             :     { 0,               osl_Pipe_E_None              },  /* no error */
      52             :     { EPROTOTYPE,      osl_Pipe_E_NoProtocol        },  /* Protocol wrong type for socket */
      53             :     { ENOPROTOOPT,     osl_Pipe_E_NoProtocol        },  /* Protocol not available */
      54             :     { EPROTONOSUPPORT, osl_Pipe_E_NoProtocol        },  /* Protocol not supported */
      55             :     { ESOCKTNOSUPPORT, osl_Pipe_E_NoProtocol        },  /* Socket type not supported */
      56             :     { EPFNOSUPPORT,    osl_Pipe_E_NoProtocol        },  /* Protocol family not supported */
      57             :     { EAFNOSUPPORT,    osl_Pipe_E_NoProtocol        },  /* Address family not supported by */
      58             :                                                         /* protocol family */
      59             :     { ENETRESET,       osl_Pipe_E_NetworkReset      },  /* Network dropped connection because */
      60             :                                                          /* of reset */
      61             :     { ECONNABORTED,    osl_Pipe_E_ConnectionAbort   },  /* Software caused connection abort */
      62             :     { ECONNRESET,      osl_Pipe_E_ConnectionReset   },  /* Connection reset by peer */
      63             :     { ENOBUFS,         osl_Pipe_E_NoBufferSpace     },  /* No buffer space available */
      64             :     { ETIMEDOUT,       osl_Pipe_E_TimedOut          },  /* Connection timed out */
      65             :     { ECONNREFUSED,    osl_Pipe_E_ConnectionRefused },  /* Connection refused */
      66             :     { -1,              osl_Pipe_E_invalidError      }
      67             : };
      68             : 
      69             : 
      70             : /* map */
      71             : /* mfe: NOT USED
      72             :    static int osl_NativeFromPipeError(oslPipeError errorCode)
      73             :    {
      74             :    int i = 0;
      75             : 
      76             :    while ((PipeError[i].error != osl_Pipe_E_invalidError) &&
      77             :    (PipeError[i].error != errorCode)) i++;
      78             : 
      79             :    return PipeError[i].errcode;
      80             : 
      81             :    }
      82             : */
      83             : 
      84             : /* reverse map */
      85           0 : static oslPipeError osl_PipeErrorFromNative(int nativeType)
      86             : {
      87           0 :     int i = 0;
      88             : 
      89           0 :     while ((PipeError[i].error != osl_Pipe_E_invalidError) &&
      90           0 :            (PipeError[i].errcode != nativeType)) i++;
      91             : 
      92           0 :     return PipeError[i].error;
      93             : }
      94             : 
      95             : 
      96             : /* macros */
      97             : #define ERROR_TO_NATIVE(x)      osl_NativeFromPipeError(x)
      98             : #define ERROR_FROM_NATIVE(y)    osl_PipeErrorFromNative(y)
      99             : 
     100             : 
     101             : /*****************************************************************************/
     102             : /* osl_create/destroy-PipeImpl */
     103             : /*****************************************************************************/
     104             : 
     105           0 : oslPipe __osl_createPipeImpl()
     106             : {
     107             :     oslPipe pPipeImpl;
     108             : 
     109           0 :     pPipeImpl = (oslPipe)calloc(1, sizeof(struct oslPipeImpl));
     110           0 :     pPipeImpl->m_nRefCount =1;
     111           0 :     pPipeImpl->m_bClosed = sal_False;
     112             : #if defined(LINUX)
     113           0 :     pPipeImpl->m_bIsInShutdown = sal_False;
     114           0 :     pPipeImpl->m_bIsAccepting = sal_False;
     115             : #endif
     116           0 :     return pPipeImpl;
     117             : }
     118             : 
     119           0 : void __osl_destroyPipeImpl(oslPipe pImpl)
     120             : {
     121           0 :     if (pImpl != NULL)
     122           0 :         free(pImpl);
     123           0 : }
     124             : 
     125             : 
     126             : /*****************************************************************************/
     127             : /* osl_createPipe  */
     128             : /*****************************************************************************/
     129           0 : oslPipe SAL_CALL osl_createPipe(rtl_uString *ustrPipeName, oslPipeOptions Options, oslSecurity Security)
     130             : {
     131           0 :     oslPipe pPipe=0;
     132           0 :     rtl_String* strPipeName=0;
     133           0 :     sal_Char* pszPipeName=0;
     134             : 
     135           0 :     if ( ustrPipeName != 0 )
     136             :     {
     137           0 :         rtl_uString2String( &strPipeName,
     138           0 :                             rtl_uString_getStr(ustrPipeName),
     139             :                             rtl_uString_getLength(ustrPipeName),
     140           0 :                             osl_getThreadTextEncoding(),
     141             :                             OUSTRING_TO_OSTRING_CVTFLAGS );
     142           0 :         pszPipeName = rtl_string_getStr(strPipeName);
     143           0 :         pPipe = osl_psz_createPipe(pszPipeName, Options, Security);
     144             : 
     145           0 :         if ( strPipeName != 0 )
     146             :         {
     147           0 :             rtl_string_release(strPipeName);
     148             :         }
     149             :     }
     150             : 
     151           0 :     return pPipe;
     152             : 
     153             : }
     154             : 
     155             : static sal_Bool
     156           0 : cpyBootstrapSocketPath(sal_Char *name, size_t len)
     157             : {
     158           0 :     sal_Bool bRet = sal_False;
     159           0 :     rtl_uString *pName = 0, *pValue = 0;
     160             : 
     161           0 :     rtl_uString_newFromAscii(&pName, "OSL_SOCKET_PATH");
     162             : 
     163           0 :     if (rtl_bootstrap_get(pName, &pValue, NULL))
     164             :     {
     165           0 :         rtl_String *pStrValue = 0;
     166           0 :         if (pValue && pValue->length > 0)
     167             :         {
     168           0 :             rtl_uString2String(&pStrValue, pValue->buffer,
     169           0 :                                pValue->length, RTL_TEXTENCODING_UTF8,
     170             :                                OUSTRING_TO_OSTRING_CVTFLAGS);
     171           0 :             if (pStrValue && pStrValue->length > 0)
     172             :             {
     173           0 :                 size_t nCopy = (len-1 < (size_t)pStrValue->length) ? len-1 : (size_t)pStrValue->length;
     174           0 :                 strncpy (name, pStrValue->buffer, nCopy);
     175           0 :                 name[nCopy] = '\0';
     176           0 :                 bRet = (size_t)pStrValue->length < len;
     177             :             }
     178           0 :             rtl_string_release(pStrValue);
     179             :         }
     180           0 :         rtl_uString_release(pName);
     181             :     }
     182           0 :     return bRet;
     183             : }
     184             : 
     185           0 : oslPipe SAL_CALL osl_psz_createPipe(const sal_Char *pszPipeName, oslPipeOptions Options,
     186             :                                     oslSecurity Security)
     187             : {
     188             :     int    Flags;
     189             :     size_t     len;
     190             :     struct sockaddr_un addr;
     191             : 
     192             :     sal_Char     name[PATH_MAX + 1];
     193           0 :     size_t nNameLength = 0;
     194           0 :     int bNameTooLong = 0;
     195             :     oslPipe  pPipe;
     196             : 
     197           0 :     if (access(PIPEDEFAULTPATH, R_OK|W_OK) == 0)
     198             :     {
     199           0 :         strncpy(name, PIPEDEFAULTPATH, sizeof(name));
     200             :     }
     201           0 :     else if (access(PIPEALTERNATEPATH, R_OK|W_OK) == 0)
     202             :     {
     203           0 :         strncpy(name, PIPEALTERNATEPATH, sizeof(name));
     204             :     }
     205           0 :     else if (!cpyBootstrapSocketPath (name, sizeof (name)))
     206             :     {
     207           0 :         return NULL;
     208             :     }
     209           0 :     name[sizeof(name) - 1] = '\0';  // ensure the string is NULL-terminated
     210           0 :     nNameLength = strlen(name);
     211           0 :     bNameTooLong = nNameLength > sizeof(name) - 2;
     212             : 
     213           0 :     if (!bNameTooLong)
     214             :     {
     215           0 :         size_t nRealLength = 0;
     216             : 
     217           0 :         strcat(name, "/");
     218           0 :         ++nNameLength;
     219             : 
     220           0 :         if (Security)
     221             :         {
     222             :             sal_Char Ident[256];
     223             : 
     224           0 :             Ident[0] = '\0';
     225             : 
     226           0 :             OSL_VERIFY(osl_psz_getUserIdent(Security, Ident, sizeof(Ident)));
     227             : 
     228           0 :             nRealLength = snprintf(&name[nNameLength], sizeof(name) - nNameLength, SECPIPENAMEMASK, Ident, pszPipeName);
     229             :         }
     230             :         else
     231             :         {
     232           0 :             nRealLength = snprintf(&name[nNameLength], sizeof(name) - nNameLength, PIPENAMEMASK, pszPipeName);
     233             :         }
     234             : 
     235           0 :         bNameTooLong = nRealLength > sizeof(name) - nNameLength - 1;
     236             :     }
     237             : 
     238           0 :     if (bNameTooLong)
     239             :     {
     240             :         OSL_TRACE("osl_createPipe: pipe name too long");
     241           0 :         return NULL;
     242             :     }
     243             : 
     244             :     /* alloc memory */
     245           0 :     pPipe= __osl_createPipeImpl();
     246             : 
     247             :     /* create socket */
     248           0 :     pPipe->m_Socket = socket(AF_UNIX, SOCK_STREAM, 0);
     249           0 :     if ( pPipe->m_Socket < 0 )
     250             :     {
     251             :         OSL_TRACE("osl_createPipe socket failed. Errno: %d; %s",errno, strerror(errno));
     252           0 :         __osl_destroyPipeImpl(pPipe);
     253           0 :         return NULL;
     254             :     }
     255             : 
     256             : /*    OSL_TRACE("osl_createPipe : new Pipe on fd %i\n",pPipe->m_Socket);*/
     257             : 
     258             :     /* set close-on-exec flag */
     259           0 :     if ((Flags = fcntl(pPipe->m_Socket, F_GETFD, 0)) != -1)
     260             :     {
     261           0 :         Flags |= FD_CLOEXEC;
     262           0 :         if (fcntl(pPipe->m_Socket, F_SETFD, Flags) == -1)
     263             :         {
     264             :             OSL_TRACE("osl_createPipe failed changing socket flags. Errno: %d; %s",errno,strerror(errno));
     265             :         }
     266             :     }
     267             : 
     268           0 :     memset(&addr, 0, sizeof(addr));
     269             : 
     270             :     OSL_TRACE("osl_createPipe : Pipe Name '%s'",name);
     271             : 
     272           0 :     addr.sun_family = AF_UNIX;
     273           0 :     strncpy(addr.sun_path, name, sizeof(addr.sun_path) - 1);
     274             : #if defined(FREEBSD)
     275             :     len = SUN_LEN(&addr);
     276             : #else
     277           0 :     len = sizeof(addr);
     278             : #endif
     279             : 
     280           0 :     if ( Options & osl_Pipe_CREATE )
     281             :     {
     282             :         struct stat status;
     283             : 
     284             :         /* check if there exists an orphan filesystem entry */
     285           0 :         if ( ( stat(name, &status) == 0) &&
     286           0 :              ( S_ISSOCK(status.st_mode) || S_ISFIFO(status.st_mode) ) )
     287             :         {
     288           0 :             if ( connect(pPipe->m_Socket,(struct sockaddr *)&addr,len) >= 0 )
     289             :             {
     290             :                 OSL_TRACE("osl_createPipe : Pipe already in use. Errno: %d; %s",errno,strerror(errno));
     291           0 :                 close (pPipe->m_Socket);
     292           0 :                 __osl_destroyPipeImpl(pPipe);
     293           0 :                 return NULL;
     294             :             }
     295             : 
     296           0 :             unlink(name);
     297             :         }
     298             : 
     299             :         /* ok, fs clean */
     300           0 :         if ( bind(pPipe->m_Socket, (struct sockaddr *)&addr, len) < 0 )
     301             :         {
     302             :             OSL_TRACE("osl_createPipe : failed to bind socket. Errno: %d; %s",errno,strerror(errno));
     303           0 :             close (pPipe->m_Socket);
     304           0 :             __osl_destroyPipeImpl(pPipe);
     305           0 :             return NULL;
     306             :         }
     307             : 
     308             :         /*  Only give access to all if no security handle was specified, otherwise security
     309             :             depends on umask */
     310             : 
     311           0 :         if ( !Security )
     312           0 :             chmod(name,S_IRWXU | S_IRWXG |S_IRWXO);
     313             : 
     314             : 
     315           0 :         strncpy(pPipe->m_Name, name, sizeof(pPipe->m_Name) - 1);
     316             : 
     317           0 :         if ( listen(pPipe->m_Socket, 5) < 0 )
     318             :         {
     319             :             OSL_TRACE("osl_createPipe failed to listen. Errno: %d; %s",errno,strerror(errno));
     320           0 :             unlink(name);   /* remove filesystem entry */
     321           0 :             close (pPipe->m_Socket);
     322           0 :             __osl_destroyPipeImpl(pPipe);
     323           0 :             return NULL;
     324             :         }
     325             : 
     326           0 :         return (pPipe);
     327             :     }
     328             :     else
     329             :     {   /* osl_pipe_OPEN */
     330           0 :         if ( access(name, F_OK) != -1 )
     331             :         {
     332           0 :             if ( connect( pPipe->m_Socket, (struct sockaddr *)&addr, len) >= 0 )
     333             :             {
     334           0 :                 return (pPipe);
     335             :             }
     336             : 
     337             :             OSL_TRACE("osl_createPipe failed to connect. Errno: %d; %s",errno,strerror(errno));
     338             :         }
     339             : 
     340           0 :         close (pPipe->m_Socket);
     341           0 :         __osl_destroyPipeImpl(pPipe);
     342           0 :         return NULL;
     343             :     }
     344             : }
     345             : 
     346           0 : void SAL_CALL osl_acquirePipe( oslPipe pPipe )
     347             : {
     348           0 :     osl_atomic_increment( &(pPipe->m_nRefCount) );
     349           0 : }
     350             : 
     351           0 : void SAL_CALL osl_releasePipe( oslPipe pPipe )
     352             : {
     353             : 
     354           0 :     if( 0 == pPipe )
     355           0 :         return;
     356             : 
     357           0 :     if( 0 == osl_atomic_decrement( &(pPipe->m_nRefCount) ) )
     358             :     {
     359           0 :         if( ! pPipe->m_bClosed )
     360           0 :             osl_closePipe( pPipe );
     361             : 
     362           0 :         __osl_destroyPipeImpl( pPipe );
     363             :     }
     364             : }
     365             : 
     366           0 : void SAL_CALL osl_closePipe( oslPipe pPipe )
     367             : {
     368             :     int nRet;
     369             : #if defined(LINUX)
     370             :     size_t     len;
     371             :     struct sockaddr_un addr;
     372             :     int fd;
     373             : #endif
     374             :     int ConnFD;
     375             : 
     376           0 :     if( ! pPipe )
     377             :     {
     378             :         return;
     379             :     }
     380             : 
     381           0 :     if( pPipe->m_bClosed )
     382             :     {
     383             :         return;
     384             :     }
     385             : 
     386           0 :     ConnFD = pPipe->m_Socket;
     387             : 
     388             :     /*
     389             :       Thread does not return from accept on linux, so
     390             :       connect to the accepting pipe
     391             :      */
     392             : #if defined(LINUX)
     393           0 :     if ( pPipe->m_bIsAccepting )
     394             :     {
     395           0 :         pPipe->m_bIsInShutdown = sal_True;
     396           0 :         pPipe->m_Socket = -1;
     397           0 :         fd = socket(AF_UNIX, SOCK_STREAM, 0);
     398           0 :         memset(&addr, 0, sizeof(addr));
     399             : 
     400             :         OSL_TRACE("osl_destroyPipe : Pipe Name '%s'",pPipe->m_Name);
     401             : 
     402           0 :         addr.sun_family = AF_UNIX;
     403           0 :         strncpy(addr.sun_path, pPipe->m_Name, sizeof(addr.sun_path) - 1);
     404           0 :         len = sizeof(addr);
     405             : 
     406           0 :         nRet = connect( fd, (struct sockaddr *)&addr, len);
     407             :         if ( nRet < 0 )
     408             :         {
     409             :             OSL_TRACE("connect in osl_destroyPipe failed with error: %s", strerror(errno));
     410             :         }
     411           0 :         close(fd);
     412             :     }
     413             : #endif /* LINUX */
     414             : 
     415             : 
     416           0 :     nRet = shutdown(ConnFD, 2);
     417             :     if ( nRet < 0 )
     418             :     {
     419             :         OSL_TRACE("shutdown in destroyPipe failed : '%s'",strerror(errno));
     420             :     }
     421             : 
     422           0 :     nRet = close(ConnFD);
     423             :     if ( nRet < 0 )
     424             :     {
     425             :         OSL_TRACE("close in destroyPipe failed : '%s'",strerror(errno));
     426             :     }
     427             :     /* remove filesystem entry */
     428           0 :     if ( strlen(pPipe->m_Name) > 0 )
     429             :     {
     430           0 :         unlink(pPipe->m_Name);
     431             :     }
     432           0 :     pPipe->m_bClosed = sal_True;
     433             : 
     434             : /*      OSL_TRACE("Out osl_destroyPipe");     */
     435             : }
     436             : 
     437             : 
     438             : /*****************************************************************************/
     439             : /* osl_acceptPipe  */
     440             : /*****************************************************************************/
     441           0 : oslPipe SAL_CALL osl_acceptPipe(oslPipe pPipe)
     442             : {
     443             :     int     s, flags;
     444             :     oslPipe pAcceptedPipe;
     445             : 
     446             :     OSL_ASSERT(pPipe);
     447           0 :     if ( pPipe == 0 )
     448             :     {
     449           0 :         return NULL;
     450             :     }
     451             : 
     452             :     OSL_ASSERT(strlen(pPipe->m_Name) > 0);
     453             : 
     454             : #if defined(LINUX)
     455           0 :     pPipe->m_bIsAccepting = sal_True;
     456             : #endif
     457             : 
     458           0 :     s = accept(pPipe->m_Socket, NULL, NULL);
     459             : 
     460             : #if defined(LINUX)
     461           0 :     pPipe->m_bIsAccepting = sal_False;
     462             : #endif
     463             : 
     464           0 :     if (s < 0)
     465             :     {
     466             :         OSL_TRACE("osl_acceptPipe : accept error '%s'", strerror(errno));
     467           0 :         return NULL;
     468             :     }
     469             : 
     470             : #if defined(LINUX)
     471           0 :     if ( pPipe->m_bIsInShutdown  )
     472             :     {
     473           0 :         close(s);
     474           0 :         return NULL;
     475             :     }
     476             : #endif /* LINUX */
     477             :     else
     478             :     {
     479             :         /* alloc memory */
     480           0 :         pAcceptedPipe= __osl_createPipeImpl();
     481             : 
     482             :         OSL_ASSERT(pAcceptedPipe);
     483           0 :         if(pAcceptedPipe==NULL)
     484             :         {
     485           0 :             close(s);
     486           0 :             return NULL;
     487             :         }
     488             : 
     489             :         /* set close-on-exec flag */
     490           0 :         if (!((flags = fcntl(s, F_GETFD, 0)) < 0))
     491             :         {
     492           0 :             flags |= FD_CLOEXEC;
     493           0 :             if (fcntl(s, F_SETFD, flags) < 0)
     494             :             {
     495             :                 OSL_TRACE("osl_acceptPipe: error changing socket flags. "
     496             :                           "Errno: %d; %s",errno,strerror(errno));
     497             :             }
     498             :         }
     499             : 
     500           0 :         pAcceptedPipe->m_Socket = s;
     501             :     }
     502             : 
     503           0 :     return pAcceptedPipe;
     504             : }
     505             : 
     506             : /*****************************************************************************/
     507             : /* osl_receivePipe  */
     508             : /*****************************************************************************/
     509           0 : sal_Int32 SAL_CALL osl_receivePipe(oslPipe pPipe,
     510             :                         void* pBuffer,
     511             :                         sal_Int32 BytesToRead)
     512             : {
     513           0 :     int nRet = 0;
     514             : 
     515             :     OSL_ASSERT(pPipe);
     516             : 
     517           0 :     if ( pPipe == 0 )
     518             :     {
     519             :         OSL_TRACE("osl_receivePipe : Invalid socket");
     520           0 :         errno=EINVAL;
     521           0 :         return -1;
     522             :     }
     523             : 
     524           0 :     nRet = recv(pPipe->m_Socket,
     525             :                   (sal_Char*)pBuffer,
     526             :                   BytesToRead, 0);
     527             : 
     528             :     if ( nRet < 0 )
     529             :     {
     530             :         OSL_TRACE("osl_receivePipe failed : %i '%s'",nRet,strerror(errno));
     531             :     }
     532             : 
     533           0 :       return nRet;
     534             : }
     535             : 
     536             : 
     537             : /*****************************************************************************/
     538             : /* osl_sendPipe  */
     539             : /*****************************************************************************/
     540           0 : sal_Int32 SAL_CALL osl_sendPipe(oslPipe pPipe,
     541             :                        const void* pBuffer,
     542             :                        sal_Int32 BytesToSend)
     543             : {
     544           0 :     int nRet=0;
     545             : 
     546             :     OSL_ASSERT(pPipe);
     547             : 
     548           0 :     if ( pPipe == 0 )
     549             :     {
     550             :         OSL_TRACE("osl_sendPipe : Invalid socket");
     551           0 :         errno=EINVAL;
     552           0 :         return -1;
     553             :     }
     554             : 
     555           0 :     nRet = send(pPipe->m_Socket,
     556             :                   (sal_Char*)pBuffer,
     557             :                   BytesToSend, 0);
     558             : 
     559             : 
     560             :     if ( nRet <= 0 )
     561             :     {
     562             :         OSL_TRACE("osl_sendPipe failed : %i '%s'",nRet,strerror(errno));
     563             :     }
     564             : 
     565           0 :      return nRet;
     566             : }
     567             : 
     568             : 
     569             : /*****************************************************************************/
     570             : /* osl_getLastPipeError  */
     571             : /*****************************************************************************/
     572           0 : oslPipeError SAL_CALL osl_getLastPipeError(oslPipe pPipe)
     573             : {
     574             :     (void) pPipe; /* unused */
     575           0 :     return ERROR_FROM_NATIVE(errno);
     576             : }
     577             : 
     578             : 
     579           0 : sal_Int32 SAL_CALL osl_writePipe( oslPipe pPipe, const void *pBuffer , sal_Int32 n )
     580             : {
     581             :     /* loop until all desired bytes were send or an error occurred */
     582           0 :     sal_Int32 BytesSend= 0;
     583           0 :     sal_Int32 BytesToSend= n;
     584             : 
     585             :     OSL_ASSERT(pPipe);
     586           0 :     while (BytesToSend > 0)
     587             :     {
     588             :         sal_Int32 RetVal;
     589             : 
     590           0 :         RetVal= osl_sendPipe(pPipe, pBuffer, BytesToSend);
     591             : 
     592             :         /* error occurred? */
     593           0 :         if(RetVal <= 0)
     594             :         {
     595           0 :             break;
     596             :         }
     597             : 
     598           0 :         BytesToSend -= RetVal;
     599           0 :         BytesSend += RetVal;
     600           0 :         pBuffer= (sal_Char*)pBuffer + RetVal;
     601             :     }
     602             : 
     603           0 :     return BytesSend;
     604             : }
     605             : 
     606           0 : sal_Int32 SAL_CALL osl_readPipe( oslPipe pPipe, void *pBuffer , sal_Int32 n )
     607             : {
     608             :     /* loop until all desired bytes were read or an error occurred */
     609           0 :     sal_Int32 BytesRead= 0;
     610           0 :     sal_Int32 BytesToRead= n;
     611             : 
     612             :     OSL_ASSERT( pPipe );
     613           0 :     while (BytesToRead > 0)
     614             :     {
     615             :         sal_Int32 RetVal;
     616           0 :         RetVal= osl_receivePipe(pPipe, pBuffer, BytesToRead);
     617             : 
     618             :         /* error occurred? */
     619           0 :         if(RetVal <= 0)
     620             :         {
     621           0 :             break;
     622             :         }
     623             : 
     624           0 :         BytesToRead -= RetVal;
     625           0 :         BytesRead += RetVal;
     626           0 :         pBuffer= (sal_Char*)pBuffer + RetVal;
     627             :     }
     628           0 :     return BytesRead;
     629             : }
     630             : 
     631             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10