/builddir/build/BUILD/libutil++-1.4.0/src/sella/net/Pipe.cpp

/*
** libutil++
** $Id: Pipe.cpp 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Pipe.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "Pipe.h"

#include <unistd.h>
#include <fcntl.h>

using namespace sella::net;

Pipe::Pipe(bool nonBlock) throw (SocketException) {
        if (::pipe(fd) != 0) {
                THROW2(SocketException, "pipe()");
        }

        if (nonBlock) {
                fcntl(fd[0], F_SETFL, O_NONBLOCK);
        }
}

Pipe::~Pipe() {
        close(fd[0]);
        close(fd[1]);
}

ssize_t Pipe::write(const void *data, size_t len) throw (SocketException) {
        ssize_t c, r = len;
        int flg;

        do {
                if ((c = ::write(fd[1], data, len)) < 0) {
                        switch (errno) {
                                case EINTR:
                                case EMSGSIZE:
                                case ENOBUFS:
                                        break;

#if ((EAGAIN) != (EWOULDBLOCK)) /* Same value in Linux, but both are checked for completeness. */
                                case EAGAIN:
#endif
                                case EWOULDBLOCK:
                                        if ((flg = fcntl(fd[1], F_GETFL)) != -1 && (flg & O_NONBLOCK)) {
                                                THROW_CODE(SocketException, EWOULDBLOCK, "Nonblocking socket would have blocked");
                                        }

                                        THROW_CODE(SocketException, EWOULDBLOCK, "Send timed out");
                        }

                        THROW2(SocketException, "write()");
                } else if (c == 0) { /* Orderly socket shutdown detected */
                        break;
                }
        } while ((r -= c) > 0);

        return len;
}

ssize_t Pipe::write(const std::string &data) throw (SocketException) {
        return write((const void*) data.c_str(), data.size());
}

ssize_t Pipe::write(const std::vector<uint8_t> &data) throw (SocketException) {
        return write((const void*) data.data(), data.size());
}

ssize_t Pipe::read(void *data, size_t len) throw (SocketException) {
        ssize_t c;
        int flg;

        if ((c = ::read(fd[0], data, len)) < 0) {
                switch (errno) {
                        case EINTR:
                                break;

#if ((EAGAIN) != (EWOULDBLOCK)) /* Same value in Linux, but both are checked for completeness. */
                        case EAGAIN:
#endif
                        case EWOULDBLOCK:
                                if ((flg = fcntl(fd[0], F_GETFL)) != -1 && (flg & O_NONBLOCK)) {
                                        THROW_CODE(SocketException, EWOULDBLOCK, "Nonblocking socket would have blocked");
                                }

                                THROW_CODE(SocketException, EWOULDBLOCK, "Receive timed out");
                }

                THROW2(SocketException, "read()");
        }

        return c;
}

ssize_t Pipe::read(std::string &data, size_t len) throw (SocketException) {
        uint8_t buf[len];
        ssize_t size = read(buf, len);

        std::string(buf, buf + len).swap(data);

        return size;
}

ssize_t Pipe::read(std::vector<uint8_t> &data, size_t len) throw (SocketException) {
        uint8_t buf[len];
        ssize_t size = read(buf, len);

        std::vector<uint8_t>(buf, buf + len).swap(data);

        return size;
}

int Pipe::getWriteFD(void) {
        return fd[1];
}

int Pipe::getReadFD(void) {
        return fd[0];
}

const Pipe::shared Pipe::shared_ptr(bool nonBlock) throw (SocketException) {
        return std::make_shared<Pipe>(nonBlock);
}

/*
** vim: noet ts=3 sw=3
*/

---