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

Generated by: LCOV version 1.10