path: root/libs/utils/Pipe.cpp

/*
 * Copyright (C) 2005 The Android Open Source Project
 *
 * Licensed 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.
 */

//
// Unidirectional pipe.
//

#include <utils/Pipe.h>
#include <utils/Log.h>

#if defined(HAVE_WIN32_IPC)
# include <windows.h>
#else
# include <fcntl.h>
# include <unistd.h>
# include <errno.h>
#endif

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>

using namespace android;

const unsigned long kInvalidHandle = (unsigned long) -1;


/*
 * Constructor.  Do little.
 */
Pipe::Pipe(void)
    : mReadNonBlocking(false), mReadHandle(kInvalidHandle),
      mWriteHandle(kInvalidHandle)
{
}

/*
 * Destructor.  Use the system-appropriate close call.
 */
Pipe::~Pipe(void)
{
#if defined(HAVE_WIN32_IPC)
    if (mReadHandle != kInvalidHandle) {
        if (!CloseHandle((HANDLE)mReadHandle))
            LOG(LOG_WARN, "pipe", "failed closing read handle (%ld)\n",
                mReadHandle);
    }
    if (mWriteHandle != kInvalidHandle) {
        FlushFileBuffers((HANDLE)mWriteHandle);
        if (!CloseHandle((HANDLE)mWriteHandle))
            LOG(LOG_WARN, "pipe", "failed closing write handle (%ld)\n",
                mWriteHandle);
    }
#else
    if (mReadHandle != kInvalidHandle) {
        if (close((int) mReadHandle) != 0)
            LOG(LOG_WARN, "pipe", "failed closing read fd (%d)\n",
                (int) mReadHandle);
    }
    if (mWriteHandle != kInvalidHandle) {
        if (close((int) mWriteHandle) != 0)
            LOG(LOG_WARN, "pipe", "failed closing write fd (%d)\n",
                (int) mWriteHandle);
    }
#endif
}

/*
 * Create the pipe.
 *
 * Use the POSIX stuff for everything but Windows.
 */
bool Pipe::create(void)
{
    assert(mReadHandle == kInvalidHandle);
    assert(mWriteHandle == kInvalidHandle);

#if defined(HAVE_WIN32_IPC)
    /* we use this across processes, so they need to be inheritable */
    HANDLE handles[2];
    SECURITY_ATTRIBUTES saAttr;

    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    saAttr.bInheritHandle = TRUE;
    saAttr.lpSecurityDescriptor = NULL;

    if (!CreatePipe(&handles[0], &handles[1], &saAttr, 0)) {
        LOG(LOG_ERROR, "pipe", "unable to create pipe\n");
        return false;
    }
    mReadHandle = (unsigned long) handles[0];
    mWriteHandle = (unsigned long) handles[1];
    return true;
#else
    int fds[2];

    if (pipe(fds) != 0) {
        LOG(LOG_ERROR, "pipe", "unable to create pipe\n");
        return false;
    }
    mReadHandle = fds[0];
    mWriteHandle = fds[1];
    return true;
#endif
}

/*
 * Create a "half pipe".  Please, no Segway riding.
 */
bool Pipe::createReader(unsigned long handle)
{
    mReadHandle = handle;
    assert(mWriteHandle == kInvalidHandle);
    return true;
}

/*
 * Create a "half pipe" for writing.
 */
bool Pipe::createWriter(unsigned long handle)
{
    mWriteHandle = handle;
    assert(mReadHandle == kInvalidHandle);
    return true;
}

/*
 * Return "true" if create() has been called successfully.
 */
bool Pipe::isCreated(void)
{
    // one or the other should be open
    return (mReadHandle != kInvalidHandle || mWriteHandle != kInvalidHandle);
}


/*
 * Read data from the pipe.
 *
 * For Linux and Darwin, just call read().  For Windows, implement
 * non-blocking reads by calling PeekNamedPipe first.
 */
int Pipe::read(void* buf, int count)
{
    assert(mReadHandle != kInvalidHandle);

#if defined(HAVE_WIN32_IPC)
    DWORD totalBytesAvail = count;
    DWORD bytesRead;

    if (mReadNonBlocking) {
        // use PeekNamedPipe to adjust read count expectations
        if (!PeekNamedPipe((HANDLE) mReadHandle, NULL, 0, NULL,
                &totalBytesAvail, NULL))
        {
            LOG(LOG_ERROR, "pipe", "PeekNamedPipe failed\n");
            return -1;
        }

        if (totalBytesAvail == 0)
            return 0;
    }

    if (!ReadFile((HANDLE) mReadHandle, buf, totalBytesAvail, &bytesRead,
            NULL))
    {
        DWORD err = GetLastError();
        if (err == ERROR_HANDLE_EOF || err == ERROR_BROKEN_PIPE)
            return 0;
        LOG(LOG_ERROR, "pipe", "ReadFile failed (err=%ld)\n", err);
        return -1;
    }

    return (int) bytesRead;
#else
    int cc;
    cc = ::read(mReadHandle, buf, count);
    if (cc < 0 && errno == EAGAIN)
        return 0;
    return cc;
#endif
}

/*
 * Write data to the pipe.
 *
 * POSIX systems are trivial, Windows uses a different call and doesn't
 * handle non-blocking writes.
 *
 * If we add non-blocking support here, we probably want to make it an
 * all-or-nothing write.
 *
 * DO NOT use LOG() here, we could be writing a log message.
 */
int Pipe::write(const void* buf, int count)
{
    assert(mWriteHandle != kInvalidHandle);

#if defined(HAVE_WIN32_IPC)
    DWORD bytesWritten;

    if (mWriteNonBlocking) {
        // BUG: can't use PeekNamedPipe() to get the amount of space
        // left.  Looks like we need to use "overlapped I/O" functions.
        // I just don't care that much.
    }

    if (!WriteFile((HANDLE) mWriteHandle, buf, count, &bytesWritten, NULL)) {
        // can't LOG, use stderr
        fprintf(stderr, "WriteFile failed (err=%ld)\n", GetLastError());
        return -1;
    }

    return (int) bytesWritten;
#else
    int cc;
    cc = ::write(mWriteHandle, buf, count);
    if (cc < 0 && errno == EAGAIN)
        return 0;
    return cc;
#endif
}

/*
 * Figure out if there is data available on the read fd.
 *
 * We return "true" on error because we want the caller to try to read
 * from the pipe.  They'll notice the read failure and do something
 * appropriate.
 */
bool Pipe::readReady(void)
{
    assert(mReadHandle != kInvalidHandle);

#if defined(HAVE_WIN32_IPC)
    DWORD totalBytesAvail;

    if (!PeekNamedPipe((HANDLE) mReadHandle, NULL, 0, NULL,
            &totalBytesAvail, NULL))
    {
        LOG(LOG_ERROR, "pipe", "PeekNamedPipe failed\n");
        return true;
    }

    return (totalBytesAvail != 0);
#else
    errno = 0;
    fd_set readfds;
    struct timeval tv = { 0, 0 };
    int cc;

    FD_ZERO(&readfds);
    FD_SET(mReadHandle, &readfds);

    cc = select(mReadHandle+1, &readfds, NULL, NULL, &tv);
    if (cc < 0) {
        LOG(LOG_ERROR, "pipe", "select() failed\n");
        return true;
    } else if (cc == 0) {
        /* timed out, nothing available */
        return false;
    } else if (cc == 1) {
        /* our fd is ready */
        return true;
    } else {
        LOG(LOG_ERROR, "pipe", "HUH? select() returned > 1\n");
        return true;
    }
#endif
}

/*
 * Enable or disable non-blocking mode for the read descriptor.
 *
 * NOTE: the calls succeed under Mac OS X, but the pipe doesn't appear to
 * actually be in non-blocking mode.  If this matters -- i.e. you're not
 * using a select() call -- put a call to readReady() in front of the
 * ::read() call, with a PIPE_NONBLOCK_BROKEN #ifdef in the Makefile for
 * Darwin.
 */
bool Pipe::setReadNonBlocking(bool val)
{
    assert(mReadHandle != kInvalidHandle);

#if defined(HAVE_WIN32_IPC)
    // nothing to do
#else
    int flags;

    if (fcntl(mReadHandle, F_GETFL, &flags) == -1) {
        LOG(LOG_ERROR, "pipe", "couldn't get flags for pipe read fd\n");
        return false;
    }
    if (val)
        flags |= O_NONBLOCK;
    else
        flags &= ~(O_NONBLOCK);
    if (fcntl(mReadHandle, F_SETFL, &flags) == -1) {
        LOG(LOG_ERROR, "pipe", "couldn't set flags for pipe read fd\n");
        return false;
    }
#endif

    mReadNonBlocking = val;
    return true;
}

/*
 * Enable or disable non-blocking mode for the write descriptor.
 *
 * As with setReadNonBlocking(), this does not work on the Mac.
 */
bool Pipe::setWriteNonBlocking(bool val)
{
    assert(mWriteHandle != kInvalidHandle);

#if defined(HAVE_WIN32_IPC)
    // nothing to do
#else
    int flags;

    if (fcntl(mWriteHandle, F_GETFL, &flags) == -1) {
        LOG(LOG_WARN, "pipe",
            "Warning: couldn't get flags for pipe write fd (errno=%d)\n",
            errno);
        return false;
    }
    if (val)
        flags |= O_NONBLOCK;
    else
        flags &= ~(O_NONBLOCK);
    if (fcntl(mWriteHandle, F_SETFL, &flags) == -1) {
        LOG(LOG_WARN, "pipe",
            "Warning: couldn't set flags for pipe write fd (errno=%d)\n",
            errno);
        return false;
    }
#endif

    mWriteNonBlocking = val;
    return true;
}

/*
 * Specify whether a file descriptor can be inherited by a child process.
 * Under Linux this means setting the close-on-exec flag, under Windows
 * this is SetHandleInformation(HANDLE_FLAG_INHERIT).
 */
bool Pipe::disallowReadInherit(void)
{
    if (mReadHandle == kInvalidHandle)
        return false;

#if defined(HAVE_WIN32_IPC)
    if (SetHandleInformation((HANDLE) mReadHandle, HANDLE_FLAG_INHERIT, 0) == 0)
        return false;
#else
    if (fcntl((int) mReadHandle, F_SETFD, FD_CLOEXEC) != 0)
        return false;
#endif
    return true;
}
bool Pipe::disallowWriteInherit(void)
{
    if (mWriteHandle == kInvalidHandle)
        return false;

#if defined(HAVE_WIN32_IPC)
    if (SetHandleInformation((HANDLE) mWriteHandle, HANDLE_FLAG_INHERIT, 0) == 0)
        return false;
#else
    if (fcntl((int) mWriteHandle, F_SETFD, FD_CLOEXEC) != 0)
        return false;
#endif
    return true;
}

/*
 * Close read descriptor.
 */
bool Pipe::closeRead(void)
{
    if (mReadHandle == kInvalidHandle)
        return false;

#if defined(HAVE_WIN32_IPC)
    if (mReadHandle != kInvalidHandle) {
        if (!CloseHandle((HANDLE)mReadHandle)) {
            LOG(LOG_WARN, "pipe", "failed closing read handle\n");
            return false;
        }
    }
#else
    if (mReadHandle != kInvalidHandle) {
        if (close((int) mReadHandle) != 0) {
            LOG(LOG_WARN, "pipe", "failed closing read fd\n");
            return false;
        }
    }
#endif
    mReadHandle = kInvalidHandle;
    return true;
}

/*
 * Close write descriptor.
 */
bool Pipe::closeWrite(void)
{
    if (mWriteHandle == kInvalidHandle)
        return false;

#if defined(HAVE_WIN32_IPC)
    if (mWriteHandle != kInvalidHandle) {
        if (!CloseHandle((HANDLE)mWriteHandle)) {
            LOG(LOG_WARN, "pipe", "failed closing write handle\n");
            return false;
        }
    }
#else
    if (mWriteHandle != kInvalidHandle) {
        if (close((int) mWriteHandle) != 0) {
            LOG(LOG_WARN, "pipe", "failed closing write fd\n");
            return false;
        }
    }
#endif
    mWriteHandle = kInvalidHandle;
    return true;
}

/*
 * Get the read handle.
 */
unsigned long Pipe::getReadHandle(void)
{
    assert(mReadHandle != kInvalidHandle);

    return mReadHandle;
}

/*
 * Get the write handle.
 */
unsigned long Pipe::getWriteHandle(void)
{
    assert(mWriteHandle != kInvalidHandle);

    return mWriteHandle;
}