path: root/src/gui/embedded/qunixsocket.cpp

/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qunixsocket_p.h"

// #define QUNIXSOCKET_DEBUG 1

#include <QtCore/qsocketnotifier.h>
#include <QtCore/qqueue.h>
#include <QtCore/qdatetime.h>
#include "private/qcore_unix_p.h" // overrides QT_OPEN

#ifdef QUNIXSOCKET_DEBUG
#include <QtCore/qdebug.h>
#endif

extern "C" {
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/un.h>
};

#define UNIX_PATH_MAX 108 // From unix(7)

#ifdef QT_LINUXBASE
// LSB doesn't declare ucred
struct ucred
{
    pid_t pid;                    /* PID of sending process.  */
    uid_t uid;                    /* UID of sending process.  */
    gid_t gid;                    /* GID of sending process.  */
};

// LSB doesn't define the ones below
#ifndef SO_PASSCRED
#  define SO_PASSCRED   16
#endif
#ifndef SCM_CREDENTIALS
#  define SCM_CREDENTIALS 0x02
#endif
#ifndef MSG_DONTWAIT
#  define MSG_DONTWAIT 0x40
#endif
#ifndef MSG_NOSIGNAL
#  define MSG_NOSIGNAL 0x4000
#endif

#endif // QT_LINUXBASE

QT_BEGIN_NAMESPACE

///////////////////////////////////////////////////////////////////////////////
// class QUnixSocketRights
///////////////////////////////////////////////////////////////////////////////
/*!
  \class QUnixSocketRights
  \internal

  \brief The QUnixSocketRights class encapsulates QUnixSocket rights data.
  \omit
  \ingroup Platform::DeviceSpecific
  \ingroup Platform::OS
  \ingroup Platform::Communications
  \endomit
  \ingroup qws

  \l QUnixSocket allows you to transfer Unix file descriptors between processes.
  A file descriptor is referred to as "rights data" as it allows one process to
  transfer its right to access a resource to another.

  The Unix system verifies resource permissions only when the resource is first
  opened.  For example, consider a file on disk readable only by the user "qt".
  A process running as user "qt" will be able to open this file for reading.
  If, while the process was still reading from the file, the ownership was
  changed from user "qt" to user "root", the process would be allowed to
  continue reading from the file, even though attempting to reopen the file
  would be denied.  Permissions are associated with special descriptors called
  file descriptors which are returned to a process after it initially opens a
  resource.

  File descriptors can be duplicated within a process through the dup(2) system
  call.  File descriptors can be passed between processes using the
  \l QUnixSocket class in the same way.  Even though the receiving process never
  opened the resource directly, it has the same permissions to access it as the
  process that did.

  \sa QUnixSocket
 */
struct QUnixSocketRightsPrivate : public QSharedData
{
    virtual ~QUnixSocketRightsPrivate() {
#ifdef QUNIXSOCKET_DEBUG
        int closerv =
#endif
            QT_CLOSE(fd);
#ifdef QUNIXSOCKET_DEBUG
        if(0 != closerv) {
            qDebug() << "QUnixSocketRightsPrivate: Unable to close managed"
                        " file descriptor (" << ::strerror(errno) << ')';
        }
#endif
    }

    int fd;
};

/*!
  Create a new QUnixSocketRights instance containing the file descriptor \a fd.
  \a fd will be dup(2)'d internally, so the application is free to close \a fd
  following this call.

  If the dup(2) fails, or you pass an invalid \a fd, an
  \l {QUnixSocketRights::isValid()}{invalid } object will be
  constructed.

  QUnixSocketRights instances are immutable and the internal file descriptor
  will be shared between any copies made of this object.  The system will
  close(2) the file descriptor once it is no longer needed.
  */
QUnixSocketRights::QUnixSocketRights(int fd)
{
    d = new QUnixSocketRightsPrivate();
    if(-1 == fd) {
        d->fd = -1;
    } else {
        d->fd = qt_safe_dup(fd);
#ifdef QUNIXSOCKET_DEBUG
        if(-1 == d->fd) {
            qDebug() << "QUnixSocketRights: Unable to duplicate fd "
                     << fd << " (" << ::strerror(errno) << ')';
        }
#endif
    }
}

/*!
  \internal

  Construct a QUnixSocketRights instance on \a fd without dup(2)'ing the file
  descriptor.
  */
QUnixSocketRights::QUnixSocketRights(int fd,int)
{
    Q_ASSERT(-1 != fd);
    d = new QUnixSocketRightsPrivate();
    d->fd = fd;
}

/*!
  Destroys the QUnixSocketRights instance.
  */
QUnixSocketRights::~QUnixSocketRights()
{
}

/*!
  Create a copy of \a other.
  */
QUnixSocketRights &
QUnixSocketRights::operator=(const QUnixSocketRights & other)
{
    d = other.d;
    return *this;
}

/*!
  Create a copy of \a other.
  */
QUnixSocketRights::QUnixSocketRights(const QUnixSocketRights & other)
: d(other.d)
{
}

/*!
  Returns true if this QUnixSocketRights instance is managing a valid file
  descriptor.  This method is equivalent to (-1 != peekFd()).

  \sa QUnixSocketRights::peekFd()
  */
bool QUnixSocketRights::isValid() const
{
    return d->fd != -1;
}

/*!
  Return a duplicate of the file descriptor contained in this object.  If this
  is an \l {QUnixSocketRights::isValid()}{invalid } object, or the
  dup(2) call fails, an invalid file descriptor (-1) will be returned.

  \sa QUnixSocketRights::peekFd()
  */
int QUnixSocketRights::dupFd() const
{
    if(-1 == d->fd) return -1;

    int rv = qt_safe_dup(d->fd);

#ifdef QUNIXSOCKET_DEBUG
    if(-1 == rv)
        qDebug() << "QUnixSocketRights: Unable to duplicate managed file "
                    "descriptor (" << ::strerror(errno) << ')';
#endif

    return rv;
}

/*!
  Returns the file descriptor contained in this object.  If this
  is an \l {QUnixSocketRights::isValid()}{invalid } object an invalid
  file descriptor (-1) will be returned.

  The lifetime of this file descriptor is tied to the lifetime of the
  QUnixSocketRights instance.  The file descriptor returned by this method
  \e may be close(2)'d when the QUnixSocketRights instance is destroyed.  If
  you want to continue to use the file descriptor use
  \l QUnixSocketRights::dupFd() instead.

  \sa QUnixSocketRights::dupFd()
  */
int QUnixSocketRights::peekFd() const
{
    return d->fd;
}

///////////////////////////////////////////////////////////////////////////////
// class QUnixSocketMessage
///////////////////////////////////////////////////////////////////////////////
struct QUnixSocketMessagePrivate : public QSharedData
{
    QUnixSocketMessagePrivate()
    : state(Default), vec(0), iovecLen(0), dataSize(0) {}
    QUnixSocketMessagePrivate(const QByteArray & b)
    : bytes(b), state(Default), vec(0), iovecLen(0), dataSize(0) {}
    QUnixSocketMessagePrivate(const QByteArray & b,
                              const QList<QUnixSocketRights> & r)
    : bytes(b), rights(r), state(Default), vec(0), iovecLen(0), dataSize(0) {}

    int size() const { return vec ? dataSize : bytes.size(); }
    void removeBytes( unsigned int );

    QByteArray bytes;
    QList<QUnixSocketRights> rights;

    enum AncillaryDataState {
        Default = 0x00,
        Truncated = 0x01,
        Credential = 0x02
    };
    AncillaryDataState state;

    pid_t pid;
    gid_t gid;
    uid_t uid;

    ::iovec *vec;
    int iovecLen;  // number of vectors in array
    int dataSize;  // total size of vectors = payload
};

/*!
  \internal
  Remove \a bytesToDequeue bytes from the front of this message
*/
void QUnixSocketMessagePrivate::removeBytes( unsigned int bytesToDequeue )
{
    if ( vec )
    {
        ::iovec *vecPtr = vec;
        if ( bytesToDequeue > (unsigned int)dataSize ) bytesToDequeue = dataSize;
        while ( bytesToDequeue > 0 && iovecLen > 0 )
        {
            if ( vecPtr->iov_len > bytesToDequeue )
            {
                // dequeue the bytes by taking them off the front of the
                // current vector.  since we don't own the iovec, its okay
                // to "leak" this away by pointing past it
                char **base = reinterpret_cast<char**>(&(vecPtr->iov_base));
                *base += bytesToDequeue;
                vecPtr->iov_len -= bytesToDequeue;
                bytesToDequeue = 0;
            }
            else
            {
                // dequeue bytes by skipping a whole vector.  again, its ok
                // to lose the pointers to this data
                bytesToDequeue -= vecPtr->iov_len;
                iovecLen--;
                vecPtr++;
            }
        }
        dataSize -= bytesToDequeue;
        if ( iovecLen == 0 ) vec = 0;
    }
    else
    {
        bytes.remove(0, bytesToDequeue );
    }
}


/*!
  \class QUnixSocketMessage
  \internal

  \brief The QUnixSocketMessage class encapsulates a message sent or received
  through the QUnixSocket class.
  \omit
  \ingroup Platform::DeviceSpecific
  \ingroup Platform::OS
  \ingroup Platform::Communications
  \endomit
  \ingroup qws

  In addition to transmitting regular byte stream data, messages sent over Unix
  domain sockets may have special ancillary properties.  QUnixSocketMessage
  instances allow programmers to retrieve and control these properties.

  Every QUnixSocketMessage sent has an associated set of credentials.  A
  message's credentials consist of the process id, the user id and the group id
  of the sending process.  Normally these credentials are set automatically for
  you by the QUnixSocketMessage class and can be queried by the receiving
  process using the \l QUnixSocketMessage::processId(),
  \l QUnixSocketMessage::userId() and \l QUnixSocketMessage::groupId() methods
  respectively.

  Advanced applications may wish to change the credentials that their message
  is sent with, and may do so though the \l QUnixSocketMessage::setProcessId(),
  \l QUnixSocketMessage::setUserId() and \l QUnixSocketMessage::setGroupId()
  methods.  The validity of these credentials is verified by the system kernel.
  Only the root user can send messages with credentials that are not his own.
  Sending of the message will fail for any non-root user who attempts to
  fabricate credentials.  Note that this failure is enforced by the system
  kernel - receivers can trust the accuracy of credential data!

  Unix domain socket messages may also be used to transmit Unix file descriptors
  between processes.  In this context, file descriptors are known as rights data
  and are encapsulated by the \l QUnixSocketRights class.  Senders can set the
  file descriptors to transmit using the \l QUnixSocketMessage::setRights() and
  receivers can retrieve this data through a call to
  \l QUnixSocketMessage::rights().  \l QUnixSocket and \l QUnixSocketRights
  discuss the specific copy and ordering semantic associated with rights data.

  QUnixSocketMessage messages are sent by the \l QUnixSocket::write() method.
  Like any normal network message, attempting to transmit an empty
  QUnixSocketMessage will succeed, but result in a no-op.  Limitations in the
  Unix domain protocol semantic will cause a transmission of a
  QUnixSocketMessage with rights data, but no byte data portion, to fail.

  \sa QUnixSocket QUnixSocketRights
  */

/*!
  Construct an empty QUnixSocketMessage.  This instance will have not data and
  no rights information.  The message's credentials will be set to the
  application's default credentials.
  */
QUnixSocketMessage::QUnixSocketMessage()
: d(new QUnixSocketMessagePrivate())
{
}

/*!
  Construct a QUnixSocketMessage with an initial data payload of \a bytes.  The
  message's credentials will be set to the application's default credentials.
  */
QUnixSocketMessage::QUnixSocketMessage(const QByteArray & bytes)
: d(new QUnixSocketMessagePrivate(bytes))
{
}

/*!
  Construct a QUnixSocketMessage with an initial data payload of \a bytes and
  an initial rights payload of \a rights.  The message's credentials will be set
  to the application's default credentials.

  A message with rights data but an empty data payload cannot be transmitted
  by the system.
  */
QUnixSocketMessage::QUnixSocketMessage(const QByteArray & bytes,
                                       const QList<QUnixSocketRights> & rights)
: d(new QUnixSocketMessagePrivate(bytes, rights))
{
}

/*!
  Create a copy of \a other.
  */
QUnixSocketMessage::QUnixSocketMessage(const QUnixSocketMessage & other)
: d(other.d)
{
}

/*!
  \fn  QUnixSocketMessage::QUnixSocketMessage(const iovec* data, int vecLen)

  Construct a QUnixSocketMessage with an initial data payload of \a
  data which points to an array of \a vecLen iovec structures.  The
  message's credentials will be set to the application's default
  credentials.

  This method can be used to avoid the overhead of copying buffers of data
  and will directly send the data pointed to by \a data on the socket.  It also
  avoids the syscall overhead of making a number of small socket write calls,
  if a number of data items can be delivered with one write.

  Caller must ensure the iovec * \a data remains valid until the message
  is flushed.  Caller retains ownership of the iovec structs.
  */
QUnixSocketMessage::QUnixSocketMessage(const ::iovec* data, int vecLen )
: d(new QUnixSocketMessagePrivate())
{
    for ( int v = 0; v < vecLen; v++ )
        d->dataSize += data[v].iov_len;
    d->vec = const_cast<iovec*>(data);
    d->iovecLen = vecLen;
}

/*!
  Assign the contents of \a other to this object.
  */
QUnixSocketMessage & QUnixSocketMessage::operator=(const QUnixSocketMessage & other)
{
    d = other.d;
    return *this;
}

/*!
  Destroy this instance.
  */
QUnixSocketMessage::~QUnixSocketMessage()
{
}

/*!
  Set the data portion of the message to \a bytes.

  \sa QUnixSocketMessage::bytes()
  */
void QUnixSocketMessage::setBytes(const QByteArray & bytes)
{
    d.detach();
    d->bytes = bytes;
}

/*!
  Set the rights portion of the message to \a rights.

  A message with rights data but an empty byte data payload cannot be
  transmitted by the system.

  \sa QUnixSocketMessage::rights()
  */
void QUnixSocketMessage::setRights(const QList<QUnixSocketRights> & rights)
{
    d.detach();
    d->rights = rights;
}

/*!
  Return the rights portion of the message.

  \sa QUnixSocketMessage::setRights()
  */
const QList<QUnixSocketRights> & QUnixSocketMessage::rights() const
{
    return d->rights;
}

/*!
  Returns true if the rights portion of the message was truncated on reception
  due to insufficient buffer size.  The rights buffer size can be adjusted
  through calls to the \l QUnixSocket::setRightsBufferSize() method.
  \l QUnixSocket contains a discussion of the buffering and truncation
  characteristics of the Unix domain protocol.

  \sa QUnixSocket QUnixSocket::setRightsBufferSize()
  */
bool QUnixSocketMessage::rightsWereTruncated() const
{
    return d->state & QUnixSocketMessagePrivate::Truncated;
}

/*!
  Return the data portion of the message.

  \sa QUnixSocketMessage::setBytes()
  */
const QByteArray & QUnixSocketMessage::bytes() const
{
    return d->bytes;
}

/*!
  Returns the process id credential associated with this message.

  \sa QUnixSocketMessage::setProcessId()
  */
pid_t QUnixSocketMessage::processId() const
{
    if(QUnixSocketMessagePrivate::Credential & d->state)
        return d->pid;
    else
        return ::getpid();
}

/*!
  Returns the user id credential associated with this message.

  \sa QUnixSocketMessage::setUserId()
  */
uid_t QUnixSocketMessage::userId() const
{
    if(QUnixSocketMessagePrivate::Credential & d->state)
        return d->uid;
    else
        return ::geteuid();
}

/*!
  Returns the group id credential associated with this message.

  \sa QUnixSocketMessage::setGroupId()
  */
gid_t QUnixSocketMessage::groupId() const
{
    if(QUnixSocketMessagePrivate::Credential & d->state)
        return d->gid;
    else
        return ::getegid();
}

/*!
  Set the process id credential associated with this message to \a pid.  Unless
  you are the root user, setting a fraudulant credential will cause this message
  to fail.

  \sa QUnixSocketMessage::processId()
 */
void QUnixSocketMessage::setProcessId(pid_t pid)
{
    if(!(d->state & QUnixSocketMessagePrivate::Credential)) {
        d->state = (QUnixSocketMessagePrivate::AncillaryDataState)( d->state | QUnixSocketMessagePrivate::Credential );
        d->uid = ::geteuid();
        d->gid = ::getegid();
    }
    d->pid = pid;
}

/*!
  Set the user id credential associated with this message to \a uid.  Unless
  you are the root user, setting a fraudulant credential will cause this message
  to fail.

  \sa QUnixSocketMessage::userId()
 */
void QUnixSocketMessage::setUserId(uid_t uid)
{
    if(!(d->state & QUnixSocketMessagePrivate::Credential)) {
        d->state = (QUnixSocketMessagePrivate::AncillaryDataState)( d->state | QUnixSocketMessagePrivate::Credential );
        d->pid = ::getpid();
        d->gid = ::getegid();
    }
    d->uid = uid;
}

/*!
  Set the group id credential associated with this message to \a gid.  Unless
  you are the root user, setting a fraudulant credential will cause this message
  to fail.

  \sa QUnixSocketMessage::groupId()
 */
void QUnixSocketMessage::setGroupId(gid_t gid)
{
    if(!(d->state & QUnixSocketMessagePrivate::Credential)) {
        d->state = (QUnixSocketMessagePrivate::AncillaryDataState)( d->state | QUnixSocketMessagePrivate::Credential );
        d->pid = ::getpid();
        d->uid = ::geteuid();
    }
    d->gid = gid;
}

/*!
  Return true if this message is valid.  A message with rights data but an empty
  byte data payload cannot be transmitted by the system and is marked as
  invalid.
  */
bool QUnixSocketMessage::isValid() const
{
    return d->rights.isEmpty() || !d->bytes.isEmpty();
}

///////////////////////////////////////////////////////////////////////////////
// class QUnixSocket
///////////////////////////////////////////////////////////////////////////////
#define QUNIXSOCKET_DEFAULT_READBUFFER 1024
#define QUNIXSOCKET_DEFAULT_ANCILLARYBUFFER 0

/*!
  \class QUnixSocket
  \internal

  \brief The QUnixSocket class provides a Unix domain socket.

  \omit
  \ingroup Platform::DeviceSpecific
  \ingroup Platform::OS
  \ingroup Platform::Communications
  \endomit
  \ingroup qws

  Unix domain sockets provide an efficient mechanism for communications between
  Unix processes on the same machine.  Unix domain sockets support a reliable,
  stream-oriented, connection-oriented transport protocol, much like TCP
  sockets.  Unlike IP based sockets, the connection endpoint of a Unix domain
  socket is a file on disk of type socket.

  In addition to transporting raw data bytes, Unix domain sockets are able to
  transmit special ancillary data.  The two types of ancillary data supported
  by the QUnixSocket class are:

  \list
  \o Credential Data - Allows a receiver
  to reliably identify the process sending each message.
  \o \l {QUnixSocketRights}{Rights Data } - Allows Unix file descriptors
  to be transmitted between processes.
  \endlist

  Because of the need to support ancillary data, QUnixSocket is not a QIODevice,
  like QTcpSocket and QUdpSocket.  Instead, QUnixSocket contains a number of
  read and write methods that clients must invoke directly.  Rather than
  returning raw data bytes, \l QUnixSocket::read() returns \l QUnixSocketMessage
  instances that encapsulate the message's byte data and any other ancillary
  data.

  Ancillary data is transmitted "out of band".  Every \l QUnixSocketMessage
  received will have credential data associated with it that the client can
  access through calls to \l QUnixSocketMessage::processId(),
  \l QUnixSocketMessage::groupId() and \l QUnixSocketMessage::userId().
  Likewise, message creators can set the credential data to send through calls
  to \l QUnixSocketMessage::setProcessId(), \l QUnixSocketMessage::setGroupId()
  and \l QUnixSocketMessage::setUserId() respectively.  The authenticity of the
  credential values is verified by the system kernel and cannot be fabricated
  by unprivileged processes.  Only processes running as the root user can
  specify credential data that does not match the sending process.

  Unix file descriptors, known as "rights data", transmitted between processes
  appear as though they had been dup(2)'d between the two.  As Unix
  domain sockets present a continuous stream of bytes to the receiver, the
  rights data - which is transmitted out of band - must be "slotted" in at some
  point.  The rights data is logically associated with the first byte - called
  the anchor byte - of the \l QUnixSocketMessage to which they are attached.
  Received rights data will be available from the
  \l QUnixSocketMessage::rights() method for the \l QUnixSocketMessage
  instance that contains the anchor byte.

  In addition to a \l QUnixSocket::write() that takes a \l QUnixSocketMessage
  instance - allowing a client to transmit both byte and rights data - a
  number of convenience overloads are provided for use when only transmitting
  simple byte data.  Unix requires that at least one byte of raw data be
  transmitted in order to send rights data.  A \l QUnixSocketMessage instance
  with rights data, but no byte data, cannot be transmitted.

  Unix sockets present a stream interface, such that, for example, a single
  six byte transmission might be received as two three byte messages.  Rights
  data, on the other hand, is conceptually transmitted as unfragmentable
  datagrams.  If the receiving buffer is not large enough to contain all the
  transmitted rights information, the data is truncated and irretreivably lost.
  Users should use the \l QUnixSocket::setRightsBufferSize() method to control
  the buffer size used for this data, and develop protocols that avoid the
  problem.  If the buffer size is too small and rights data is truncated,
  the \l QUnixSocketMessage::rightsWereTruncated() flag will be set.

  \sa QUnixSocketMessage QUnixSocketRights
*/

/*!
  \enum QUnixSocket::SocketError

  The SocketError enumeration represents the various errors that can occur on
  a Unix domain socket.  The most recent error for the socket is available
  through the \l QUnixSocket::error() method.

  \value NoError No error has occurred.
  \value InvalidPath An invalid path endpoint was passed to
         \l QUnixSocket::connect().  As defined by unix(7), invalid paths
         include an empty path, or what more than 107 characters long.
  \value ResourceError An error acquiring or manipulating the system's socket
         resources occurred.  For example, if the process runs out of available
         socket descriptors, a ResourceError will occur.
  \value NonexistentPath The endpoing passed to \l QUnixSocket::connect() does
         not refer to a Unix domain socket entity on disk.
  \value ConnectionRefused The connection to the specified endpoint was refused.
         Generally this means that there is no server listening on that
         endpoint.
  \value UnknownError An unknown error has occurred.
  \value ReadFailure An error occurred while reading bytes from the connection.
  \value WriteFailure An error occurred while writing bytes into the connection.
  */

/*!
  \enum QUnixSocket::SocketState

  The SocketState enumeration represents the connection state of a QUnixSocket
  instance.

  \value UnconnectedState The connection is not established.
  \value ConnectedState The connection is established.
  \value ClosingState The connection is being closed, following a call to
         \l QUnixSocket::close().  While closing, any pending data will be
         transmitted, but further writes by the application will be refused.
  */

/*
  \fn QUnixSocket::bytesWritten(qint64 bytes)

  This signal is emitted every time a payload of data has been written to the
  connection.  The \a bytes argument is set to the number of bytes that were
  written in this payload.

  \sa QUnixSocket::readyRead()
*/

/*
  \fn QUnixSocket::readyRead()

  This signal is emitted once every time new data is available for reading from
  the connection. It will only be emitted again once new data is available.

  \sa QUnixSocket::bytesWritten()
*/

/*!
  \fn QUnixSocket::stateChanged(SocketState socketState)

  This signal is emitted each time the socket changes connection state.
  \a socketState will be set to the socket's new state.
*/

class QUnixSocketPrivate : public QObject {
Q_OBJECT
public:
    QUnixSocketPrivate(QUnixSocket * _me)
    : me(_me), fd(-1), readNotifier(0), writeNotifier(0),
      state(QUnixSocket::UnconnectedState), error(QUnixSocket::NoError),
      writeQueueBytes(0), messageValid(false), dataBuffer(0),
      dataBufferLength(0), dataBufferCapacity(0), ancillaryBuffer(0),
      ancillaryBufferCount(0), closingTimer(0) {
          QObject::connect(this, SIGNAL(readyRead()), me, SIGNAL(readyRead()));
          QObject::connect(this, SIGNAL(bytesWritten(qint64)),
                           me, SIGNAL(bytesWritten(qint64)));
      }
    ~QUnixSocketPrivate()
    {
        if(dataBuffer)
            delete [] dataBuffer;
        if(ancillaryBuffer)
            delete [] ancillaryBuffer;
    }

    enum { CausedAbort = 0x70000000 };

    QUnixSocket * me;

    int fd;

    QSocketNotifier * readNotifier;
    QSocketNotifier * writeNotifier;

    QUnixSocket::SocketState state;
    QUnixSocket::SocketError error;

    QQueue<QUnixSocketMessage> writeQueue;
    unsigned int writeQueueBytes;

    bool messageValid;
    ::msghdr message;
    inline void flushAncillary()
    {
        if(!messageValid) return;
        ::cmsghdr * h = (::cmsghdr *)CMSG_FIRSTHDR(&(message));
        while(h) {

            if(SCM_RIGHTS == h->cmsg_type) {
                int * fds = (int *)CMSG_DATA(h);
                int numFds = (h->cmsg_len - CMSG_LEN(0)) / sizeof(int);

                for(int ii = 0; ii < numFds; ++ii)
                    QT_CLOSE(fds[ii]);
            }

            h = (::cmsghdr *)CMSG_NXTHDR(&(message), h);
        }

        messageValid = false;
    }


    char * dataBuffer;
    unsigned int dataBufferLength;
    unsigned int dataBufferCapacity;

    char * ancillaryBuffer;
    inline unsigned int ancillaryBufferCapacity()
    {
        return CMSG_SPACE(sizeof(::ucred)) + CMSG_SPACE(sizeof(int) * ancillaryBufferCount);
    }
    unsigned int ancillaryBufferCount;

    QByteArray address;

    int closingTimer;

    virtual void timerEvent(QTimerEvent *)
    {
        me->abort();
        killTimer(closingTimer);
        closingTimer = 0;
    }
signals:
    void readyRead();
    void bytesWritten(qint64);

public slots:
    void readActivated();
    qint64 writeActivated();
};

/*!
  Construct a QUnixSocket instance, with \a parent.

  The read buffer is initially set to 1024 bytes, and the rights buffer to 0
  entries.

  \sa QUnixSocket::readBufferSize() QUnixSocket::rightsBufferSize()
  */
QUnixSocket::QUnixSocket(QObject * parent)
: QIODevice(parent), d(new QUnixSocketPrivate(this))
{
    setOpenMode(QIODevice::NotOpen);
    setReadBufferSize(QUNIXSOCKET_DEFAULT_READBUFFER);
    setRightsBufferSize(QUNIXSOCKET_DEFAULT_ANCILLARYBUFFER);
}

/*!
  Construct a QUnixSocket instance, with \a parent.

  The read buffer is initially set to \a readBufferSize bytes, and the rights
  buffer to \a rightsBufferSize entries.

  \sa QUnixSocket::readBufferSize() QUnixSocket::rightsBufferSize()
  */
QUnixSocket::QUnixSocket(qint64 readBufferSize, qint64 rightsBufferSize,
                         QObject * parent)
: QIODevice(parent), d(new QUnixSocketPrivate(this))
{
    Q_ASSERT(readBufferSize > 0 && rightsBufferSize >= 0);

    setOpenMode(QIODevice::NotOpen);
    setReadBufferSize(readBufferSize);
    setRightsBufferSize(rightsBufferSize);
}

/*!
  Destroys the QUnixSocket instance.  Any unsent data is discarded.
  */
QUnixSocket::~QUnixSocket()
{
    abort();
    delete d;
}

/*!
  Attempt to connect to \a path.

  This method is synchronous and will return true if the connection succeeds and
  false otherwise.  In the case of failure, \l QUnixSocket::error() will be set
  accordingly.

  Any existing connection will be aborted, and all pending data will be
  discarded.

  \sa QUnixSocket::close() QUnixSocket::abort() QUnixSocket::error()
  */
bool QUnixSocket::connect(const QByteArray & path)
{
    int _true;
    int crv;
#ifdef QUNIXSOCKET_DEBUG
    qDebug() << "QUnixSocket: Connect requested to '"
             << path << '\'';
#endif

    abort(); // Reset any existing connection

    if(UnconnectedState != d->state) // abort() caused a signal and someone messed
                                 // with us.  We'll assume they know what
                                 // they're doing and bail.  Alternative is to
                                 // have a special "Connecting" state
        return false;


    if(path.isEmpty() || path.size() > UNIX_PATH_MAX) {
        d->error = InvalidPath;
        return false;
    }

    // Create the socket
    d->fd = ::socket(PF_UNIX, SOCK_STREAM, 0);
    if(-1 == d->fd) {
#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: Unable to create socket ("
                 << strerror(errno) << ')';
#endif
        d->error = ResourceError;
        goto connect_error;
    }

    // Set socket options
    _true = 1;
    crv = ::setsockopt(d->fd, SOL_SOCKET, SO_PASSCRED, (void *)&_true,
                       sizeof(int));
    if(-1 == crv) {
#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: Unable to configure socket ("
                 << ::strerror(errno) << ')';
#endif
        d->error = ResourceError;

        goto connect_error;
    }

    // Construct our unix address
    struct ::sockaddr_un addr;
    addr.sun_family = AF_UNIX;
    ::memcpy(addr.sun_path, path.data(), path.size());
    if(path.size() < UNIX_PATH_MAX)
        addr.sun_path[path.size()] = '\0';

    // Attempt the connect
    crv = ::connect(d->fd, (sockaddr *)&addr, sizeof(sockaddr_un));
    if(-1 == crv) {
#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: Unable to connect ("
                 << ::strerror(errno) << ')';
#endif
        if(ECONNREFUSED == errno)
            d->error = ConnectionRefused;
        else if(ENOENT == errno)
            d->error = NonexistentPath;
        else
            d->error = UnknownError;

        goto connect_error;
    }

    // We're connected!
    d->address = path;
    d->state = ConnectedState;
    d->readNotifier = new QSocketNotifier(d->fd, QSocketNotifier::Read, d);
    d->writeNotifier = new QSocketNotifier(d->fd, QSocketNotifier::Write, d);
    QObject::connect(d->readNotifier, SIGNAL(activated(int)),
                     d, SLOT(readActivated()));
    QObject::connect(d->writeNotifier, SIGNAL(activated(int)),
                     d, SLOT(writeActivated()));
    d->readNotifier->setEnabled(true);
    d->writeNotifier->setEnabled(false);
    setOpenMode(QIODevice::ReadWrite);
    emit stateChanged(ConnectedState);

#ifdef QUNIXSOCKET_DEBUG
    qDebug() << "QUnixSocket: Connected to " << path;
#endif
    return true;

connect_error: // Cleanup failed connection
    if(-1 != d->fd) {
#ifdef QUNIXSOCKET_DEBUG
        int closerv =
#endif
            QT_CLOSE(d->fd);
#ifdef QUNIXSOCKET_DEBUG
        if(0 != closerv) {
            qDebug() << "QUnixSocket: Unable to close file descriptor after "
                        "failed connect (" << ::strerror(errno) << ')';
        }
#endif
    }
    d->fd = -1;
    return false;
}

/*!
  Sets the socket descriptor to use to \a socketDescriptor, bypassing
  QUnixSocket's connection infrastructure, and return true on success and false
  on failure.  \a socketDescriptor must be in the connected state, and must be
  a Unix domain socket descriptor.  Following a successful call to this method,
  the QUnixSocket instance will be in the Connected state and will have assumed
  ownership of \a socketDescriptor.

  Any existing connection will be aborted, and all pending data will be
  discarded.

  \sa QUnixSocket::connect()
*/
bool QUnixSocket::setSocketDescriptor(int socketDescriptor)
{
    abort();

    if(UnconnectedState != state()) // See QUnixSocket::connect()
        return false;

    // Attempt to set the socket options
    if(-1 == socketDescriptor) {
#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: User provided socket is invalid";
#endif
        d->error = ResourceError;
        return false;
    }

    // Set socket options
    int _true = 1;
    int crv = ::setsockopt(socketDescriptor, SOL_SOCKET,
                           SO_PASSCRED, (void *)&_true, sizeof(int));
    if(-1 == crv) {
#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: Unable to configure client provided socket ("
                 << ::strerror(errno) << ')';
#endif
        d->error = ResourceError;

        return false;
    }

    d->fd = socketDescriptor;
    d->state = ConnectedState;
    d->address = QByteArray();
    setOpenMode(QIODevice::ReadWrite);
    d->readNotifier = new QSocketNotifier(d->fd, QSocketNotifier::Read, d);
    d->writeNotifier = new QSocketNotifier(d->fd, QSocketNotifier::Write, d);
    QObject::connect(d->readNotifier, SIGNAL(activated(int)),
                     d, SLOT(readActivated()));
    QObject::connect(d->writeNotifier, SIGNAL(activated(int)),
                     d, SLOT(writeActivated()));
    d->readNotifier->setEnabled(true);
    d->writeNotifier->setEnabled(false);
    emit stateChanged(d->state);

    return true;
}

/*!
  Returns the socket descriptor currently in use.  This method will return -1
  if the QUnixSocket instance is in the UnconnectedState \l {QUnixSocket::state()}{state. }

  \sa QUnixSocket::setSocketDescriptor()
  */
int QUnixSocket::socketDescriptor() const
{
    return d->fd;
}

/*!
  Abort the connection.  This will immediately disconnect (if connected) and
  discard any pending data.  Following a call to QUnixSocket::abort() the
  object will always be in the disconnected \link QUnixSocket::state() state.
  \endlink

  \sa QUnixSocket::close()
*/
void QUnixSocket::abort()
{
    setOpenMode(QIODevice::NotOpen);

    // We want to be able to use QUnixSocket::abort() to cleanup our state but
    // also preserve the error message that caused the abort.  It is not
    // possible to reorder code to do this:
    //        abort();
    //        d->error = SomeError
    // as QUnixSocket::abort() might emit a signal and we need the error to be
    // set within that signal.  So, if we want an error message to be preserved
    // across a *single* call to abort(), we set the
    // QUnixSocketPrivate::CausedAbort flag in the error.
    if(d->error & QUnixSocketPrivate::CausedAbort)
        d->error = (QUnixSocket::SocketError)(d->error &
                                              ~QUnixSocketPrivate::CausedAbort);
    else
        d->error = NoError;

    if( UnconnectedState == d->state) return;

#ifdef QUNIXSOCKET_DEBUG
    int closerv =
#endif
        ::close(d->fd);
#ifdef QUNIXSOCKET_DEBUG
    if(0 != closerv) {
        qDebug() << "QUnixSocket: Unable to close socket during abort ("
                 << strerror(errno) << ')';
    }
#endif

    // Reset variables
    d->fd = -1;
    d->state = UnconnectedState;
    d->dataBufferLength = 0;
    d->flushAncillary();
    d->address = QByteArray();
    if(d->readNotifier) {
        d->readNotifier->setEnabled(false);
        d->readNotifier->deleteLater();
    }
    if(d->writeNotifier) {
        d->writeNotifier->setEnabled(false);
        d->writeNotifier->deleteLater();
    }
    d->readNotifier = 0;
    d->writeNotifier = 0;
    d->writeQueue.clear();
    d->writeQueueBytes = 0;
    if(d->closingTimer) {
        d->killTimer(d->closingTimer);
    }
    d->closingTimer = 0;
    emit stateChanged(d->state);
}

/*!
  Close the connection.  The instance will enter the Closing
  \l {QUnixSocket::state()}{state } until all pending data has been
  transmitted, at which point it will enter the Unconnected state.

  Even if there is no pending data for transmission, the object will never
  jump directly to Disconnect without first passing through the
  Closing state.

  \sa QUnixSocket::abort()
  */
void QUnixSocket::close()
{
    if(ConnectedState != state()) return;

    d->state = ClosingState;
    if(d->writeQueue.isEmpty()) {
        d->closingTimer = d->startTimer(0); // Start a timer to "fake"
                                            // completing writes
    }
    emit stateChanged(d->state);
}

/*!
    This function writes as much as possible from the internal write buffer to
    the underlying socket, without blocking. If any data was written, this
    function returns true; otherwise false is returned.
*/
// Note! docs partially copied from QAbstractSocket::flush()
bool QUnixSocket::flush()
{
    // This needs to have the same semantics as QAbstractSocket, if it is to
    // be used interchangeably with that class.
    if (d->writeQueue.isEmpty())
        return false;

    d->writeActivated();
    return true;
}

/*!
  Returns the last error to have occurred on this object.  This method is not
  destructive, so multiple calls to QUnixSocket::error() will return the same
  value.  The error is only reset by a call to \l QUnixSocket::connect() or
  \l QUnixSocket::abort()
  */
QUnixSocket::SocketError QUnixSocket::error() const
{
    return (QUnixSocket::SocketError)
        (d->error & ~QUnixSocketPrivate::CausedAbort);
}

/*!
  Returns the connection state of this instance.
  */
QUnixSocket::SocketState QUnixSocket::state() const
{
    return d->state;
}

/*!
  Returns the Unix path address passed to \l QUnixSocket::connect().  This
  method will return an empty path if the object is in the Unconnected
  \l {QUnixSocket::state()}{state } or was connected through a call
  to \l QUnixSocket::setSocketDescriptor()

  \sa QUnixSocket::connect() QUnixSocket::setSocketDescriptor()
  */
QByteArray QUnixSocket::address() const
{
    return d->address;
}

/*!
  Returns the number of bytes available for immediate retrieval through a call
  to \l QUnixSocket::read().
  */
qint64 QUnixSocket::bytesAvailable() const
{
    return QIODevice::bytesAvailable() + d->dataBufferLength;
}

/*!
  Returns the number of enqueued bytes still to be written to the socket.
  */
qint64 QUnixSocket::bytesToWrite() const
{
    return d->writeQueueBytes;
}

/*!
  Returns the size of the read buffer in bytes.  The read buffer size
  determines the amount of byte data that can be read from the socket in one go.
  The read buffer size caps the maximum value that can be returned by
  \l QUnixSocket::bytesAvailable() and will always be greater than zero.  By
  default, the read buffer size is 1024 bytes.

  The size of the read buffer is independent of the rights buffer, which can be
  queried by \l QUnixSocket::rightsBufferSize().

  \sa QUnixSocket::setReadBufferSize()
  */
qint64 QUnixSocket::readBufferSize() const
{
    return d->dataBufferCapacity;
}

/*!
  Sets the \a size of the socket's read buffer in bytes.

  The size of the read buffer is independent of the rights buffer, which can be
  set by \l QUnixSocket::setRightsBufferSize().

  Attempting to reduce the buffer size while bytes are available for reading
  (ie. while the buffer is in use) will fail.

  \sa QUnixSocket::readBufferSize()
  */
void QUnixSocket::setReadBufferSize(qint64 size)
{
    Q_ASSERT(size > 0);
    if(size == d->dataBufferCapacity || d->dataBufferLength) return;
    if(d->dataBuffer) delete [] d->dataBuffer;
    d->dataBuffer = new char[size];
    d->dataBufferCapacity = size;
}

/*!
  Returns the size of the rights buffer in rights entries.  The rights buffer
  size determines the number of rights transferences that can be received in
  any message.  Unlike byte stream data which can be fragmented into many
  smaller messages if the \link QUnixSocket::readBufferSize() read buffer
  \endlink is not large enough to contain all the available data, rights data
  is transmitted as unfragmentable datagrams.  If the rights buffer is not
  large enough to contain this unfragmentable datagram, the datagram will be
  truncated and rights data irretrievably lost.  If truncation occurs, the
  \l QUnixSocketMessage::rightsWereTruncated() flag will be set.  By default
  the rights buffer size is 0 entries - rights data cannot be received.

  The size of the rights buffer is independent of the read buffer, which can be
  queried by \l QUnixSocket::readBufferSize().

  \sa QUnixSocket::setRightsBufferSize()
  */
qint64 QUnixSocket::rightsBufferSize() const
{
    return d->ancillaryBufferCount;
}

/*!
  Sets the \a size of the socket's rights buffer in rights entries.

  The size of the rights buffer is independent of the read buffer, which can be
  set by \l QUnixSocket::setReadBufferSize().

  Attempting to reduce the buffer size while bytes are available for reading
  (ie. while the buffer is in use) will fail.

  \sa QUnixSocket::rightsBufferSize()
  */
void QUnixSocket::setRightsBufferSize(qint64 size)
{
    Q_ASSERT(size >= 0);

    if((size == d->ancillaryBufferCount || d->dataBufferLength) &&
            d->ancillaryBuffer)
        return;

    qint64 byteSize = CMSG_SPACE(sizeof(::ucred)) +
                      CMSG_SPACE(size * sizeof(int));

    if(d->ancillaryBuffer) delete [] d->ancillaryBuffer;
    d->ancillaryBuffer = new char[byteSize];
    d->ancillaryBufferCount = size;
}

/*!
  \overload

  Writes \a socketdata to the socket.  In addition to failing if the socket
  is not in the Connected state, writing will fail if \a socketdata is
  \l {QUnixSocketMessage::isValid()}{invalid. }

  Writes through the QUnixSocket class are asynchronous.  Rather than being
  written immediately, data is enqueued and written once the application
  reenters the Qt event loop and the socket becomes available for writing.
  Thus, this method will only fail if the socket is not in the Connected state
  - it is illegal to attempt a write on a Unconnected or Closing socket.

  Applications can monitor the progress of data writes through the
  \l QUnixSocket::bytesWritten() signal and \l QUnixSocket::bytesToWrite()
  method.

  \sa QUnixSocketMessage
  */
qint64 QUnixSocket::write(const QUnixSocketMessage & socketdata)
{
    if(ConnectedState != state() || !socketdata.isValid()) return -1;
    if(socketdata.d->size() == 0) return 0;

    d->writeQueue.enqueue(socketdata);
    d->writeQueueBytes += socketdata.d->size();
    d->writeNotifier->setEnabled(true);

    return socketdata.d->size();
}

/*!
  Return the next available message, or an empty message if none is available.

  To avoid retrieving empty messages, applications should connect to the
  \l QUnixSocket::readyRead() signal to be notified when new messages are
  available or periodically poll the \l QUnixSocket::bytesAvailable() method.

  \sa QUnixSocket::readyRead() QUnixSocket::bytesAvailable()
  */
QUnixSocketMessage QUnixSocket::read()
{
    QUnixSocketMessage data;
    if(!d->dataBufferLength)
        return data;

    data.d->state = QUnixSocketMessagePrivate::Credential;

    // Bytes are easy
    data.setBytes(QByteArray(d->dataBuffer, d->dataBufferLength));

    // Extract ancillary data
    QList<QUnixSocketRights> a;

    ::cmsghdr * h = (::cmsghdr *)CMSG_FIRSTHDR(&(d->message));
    while(h) {

        if(SCM_CREDENTIALS == h->cmsg_type) {
            ::ucred * cred = (::ucred *)CMSG_DATA(h);
#ifdef QUNIXSOCKET_DEBUG
            qDebug( "Credentials recd: pid %lu - gid %lu - uid %lu",
                    cred->pid, cred->gid, cred->uid );
#endif
            data.d->pid = cred->pid;
            data.d->gid = cred->gid;
            data.d->uid = cred->uid;

        } else if(SCM_RIGHTS == h->cmsg_type) {

            int * fds = (int *)CMSG_DATA(h);
            int numFds = (h->cmsg_len - CMSG_LEN(0)) / sizeof(int);

            for(int ii = 0; ii < numFds; ++ii) {
                QUnixSocketRights qusr(fds[ii], 0);
                a.append(qusr);
            }

        } else {

#ifdef QUNIXSOCKET_DEBUG
            qFatal("QUnixSocket: Unknown ancillary data type (%d) received.",
                   h->cmsg_type);
#endif

        }

        h = (::cmsghdr *)CMSG_NXTHDR(&(d->message), h);
    }

    if(d->message.msg_flags & MSG_CTRUNC) {
        data.d->state = (QUnixSocketMessagePrivate::AncillaryDataState)(QUnixSocketMessagePrivate::Truncated |
                               QUnixSocketMessagePrivate::Credential );
    }

    if(!a.isEmpty())
        data.d->rights = a;

    d->dataBufferLength = 0;
    d->messageValid = false;
    d->readNotifier->setEnabled(true);

    return data;
}

/*! \internal */
bool QUnixSocket::isSequential() const
{
    return true;
}

/*! \internal */
bool QUnixSocket::waitForReadyRead(int msecs)
{
    if(UnconnectedState == d->state)
        return false;

    if(d->messageValid) {
        return true;
    }

    Q_ASSERT(-1 != d->fd);

    int     timeout = msecs;
    struct  timeval tv;
    struct  timeval *ptrTv = 0;
    QTime   stopWatch;

    stopWatch.start();

    do
    {
        fd_set readset;

        FD_ZERO(&readset);
        FD_SET(d->fd, &readset);

        if(-1 != msecs) {
            tv.tv_sec = timeout / 1000;
            tv.tv_usec = (timeout % 1000) * 1000;
            ptrTv = &tv;
        }

        int rv = ::select(d->fd + 1, &readset, 0, 0, ptrTv);
        switch(rv) {
            case 0:
                // timeout
                return false;
            case 1:
                // ok
                d->readActivated();
                return true;
            default:
                if (errno != EINTR)
                    abort();    // error
                break;
        }

        timeout = msecs - stopWatch.elapsed();
    }
    while (timeout > 0);

    return false;
}

bool QUnixSocket::waitForBytesWritten(int msecs)
{
    if(UnconnectedState == d->state)
        return false;

    Q_ASSERT(-1 != d->fd);

    if ( d->writeQueue.isEmpty() )
        return true;

    QTime stopWatch;
    stopWatch.start();

    while ( true )
    {
        fd_set fdwrite;
        FD_ZERO(&fdwrite);
        FD_SET(d->fd, &fdwrite);
        int timeout = msecs < 0 ? 0 : msecs - stopWatch.elapsed();
        struct timeval tv;
        struct timeval *ptrTv = 0;
        if ( -1 != msecs )
        {
            tv.tv_sec = timeout / 1000;
            tv.tv_usec = (timeout % 1000) * 1000;
            ptrTv = &tv;
        }

        int rv = ::select(d->fd + 1, 0, &fdwrite, 0, ptrTv);
        switch ( rv )
        {
            case 0:
                // timeout
                return false;
            case 1:
            {
                // ok to write
                qint64 bytesWritten = d->writeActivated();
                if (bytesWritten == 0) {
                    // We need to retry
                    int delay = 1;
                    do {
                        if (-1 != msecs) {
                            timeout = msecs - stopWatch.elapsed();
                            if (timeout <= 0) {
                                // We have exceeded our allotted time
                                return false;
                            } else {
                                if (delay > timeout)
                                    delay = timeout;
                            }
                        }

                        // Pause before we make another attempt to send
                        ::usleep(delay * 1000);
                        if (delay < 1024)
                            delay *= 2;

                        bytesWritten = d->writeActivated();
                    } while (bytesWritten == 0);
                }
                return (bytesWritten != -1);
            }
            default:
                // error - or an uncaught signal!!!!!!!!!
                if ( rv == EINTR )
                    continue;
                abort();
                return false;
        }
    }
    return false; // fix warnings
}

/*! \internal */
bool QUnixSocket::canReadLine() const
{
    for(unsigned int ii = 0; ii < d->dataBufferLength; ++ii)
        if(d->dataBuffer[ii] == '\n') return true;
    return false;
}

/*! \internal */
qint64 QUnixSocket::readData(char * data, qint64 maxSize)
{
    Q_ASSERT(data);
    if(0 >= maxSize) return 0;
    if(!d->dataBufferLength) return 0;

    // Read data
    unsigned int size = d->dataBufferLength>maxSize?maxSize:d->dataBufferLength;
    memcpy(data, d->dataBuffer, size);
    if(size == d->dataBufferLength) {
        d->dataBufferLength = 0;
    } else {
        memmove(d->dataBuffer, d->dataBuffer + size, d->dataBufferLength - size);
        d->dataBufferLength -= size;
    }


    // Flush ancillary
    d->flushAncillary();

    if(0 == d->dataBufferLength)
        d->readNotifier->setEnabled(true);

    return size;
}

/*! \internal */
qint64 QUnixSocket::writeData (const char * data, qint64 maxSize)
{
    return write(QUnixSocketMessage(QByteArray(data, maxSize)));
}

qint64 QUnixSocketPrivate::writeActivated()
{
    writeNotifier->setEnabled(false);

    QUnixSocketMessage & m = writeQueue.head();
    const QList<QUnixSocketRights> & a = m.rights();

    //
    // Construct the message
    //
    ::iovec vec;
    if ( !m.d->vec ) // message does not already have an iovec
    {
        vec.iov_base = (void *)m.bytes().constData();
        vec.iov_len = m.bytes().size();
    }

    // Allocate the control buffer
    ::msghdr sendmessage;
    ::bzero(&sendmessage, sizeof(::msghdr));
    if ( m.d->vec )
    {
        sendmessage.msg_iov = m.d->vec;
        sendmessage.msg_iovlen = m.d->iovecLen;
    }
    else
    {
        sendmessage.msg_iov = &vec;
        sendmessage.msg_iovlen = 1;
    }
    unsigned int required = CMSG_SPACE(sizeof(::ucred)) +
                            a.size() * CMSG_SPACE(sizeof(int));
    sendmessage.msg_control = new char[required];
    ::bzero(sendmessage.msg_control, required);
    sendmessage.msg_controllen = required;

    // Create ancillary buffer
    ::cmsghdr * h = CMSG_FIRSTHDR(&sendmessage);

    if(m.d->state & QUnixSocketMessagePrivate::Credential) {
        h->cmsg_len = CMSG_LEN(sizeof(::ucred));
        h->cmsg_level = SOL_SOCKET;
        h->cmsg_type = SCM_CREDENTIALS;
        ((::ucred *)CMSG_DATA(h))->pid = m.d->pid;
        ((::ucred *)CMSG_DATA(h))->gid = m.d->gid;
        ((::ucred *)CMSG_DATA(h))->uid = m.d->uid;
        h = CMSG_NXTHDR(&sendmessage, h);
    } else {
        sendmessage.msg_controllen -= CMSG_SPACE(sizeof(::ucred));
    }

    for(int ii = 0; ii < a.count(); ++ii) {
        const QUnixSocketRights & r = a.at(ii);

        if(r.isValid()) {
            h->cmsg_len = CMSG_LEN(sizeof(int));
            h->cmsg_level = SOL_SOCKET;
            h->cmsg_type = SCM_RIGHTS;
            *((int *)CMSG_DATA(h)) = r.peekFd();
            h = CMSG_NXTHDR(&sendmessage, h);
        } else {
            sendmessage.msg_controllen -= CMSG_SPACE(sizeof(int));
        }
    }

#ifdef QUNIXSOCKET_DEBUG
    qDebug() << "QUnixSocket: Transmitting message (length" << m.d->size() << ')';
#endif
    ::ssize_t s = ::sendmsg(fd, &sendmessage, MSG_DONTWAIT | MSG_NOSIGNAL);
#ifdef QUNIXSOCKET_DEBUG
    qDebug() << "QUnixSocket: Transmitted message (" << s << ')';
#endif

    if(-1 == s) {
        if(EAGAIN == errno || EWOULDBLOCK == errno || EINTR == errno) {
            writeNotifier->setEnabled(true);
        } else if(EPIPE == errno) {
#ifdef QUNIXSOCKET_DEBUG
            qDebug() << "QUnixSocket: Remote side disconnected during transmit "
                        "(" << ::strerror(errno) << ')';
#endif
            me->abort();
        } else {
#ifdef QUNIXSOCKET_DEBUG
            qDebug() << "QUnixSocket: Unable to transmit data ("
                     << ::strerror(errno) << ')';
#endif
            error = (QUnixSocket::SocketError)(QUnixSocket::WriteFailure |
                    CausedAbort);
            me->abort();
        }
    } else if(s != m.d->size()) {

        // A partial transmission
        writeNotifier->setEnabled(true);
        delete [] (char *)sendmessage.msg_control;
        m.d->rights = QList<QUnixSocketRights>();
        m.d->removeBytes( s );
        writeQueueBytes -= s;
        emit bytesWritten(s);
        return s;

    } else {

        // Success!
        writeQueue.dequeue();
        Q_ASSERT(writeQueueBytes >= (unsigned)s);
        writeQueueBytes -= s;
        emit bytesWritten(s);

    }

    delete [] (char *)sendmessage.msg_control;
    if(-1 != s && !writeQueue.isEmpty())
        return writeActivated();
    else if(QUnixSocket::ClosingState == me->state() && writeQueue.isEmpty())
        me->abort();

    if((-1 == s) && (EAGAIN == errno || EWOULDBLOCK == errno || EINTR == errno))
        // Return zero bytes written to indicate retry may be required
        return 0;
    else
        return s;
}

void QUnixSocketPrivate::readActivated()
{
#ifdef QUNIXSOCKET_DEBUG
    qDebug() << "QUnixSocket: readActivated";
#endif
    readNotifier->setEnabled(false);

    ::iovec vec;
    vec.iov_base = dataBuffer;
    vec.iov_len = dataBufferCapacity;

    bzero(&message, sizeof(::msghdr));
    message.msg_iov = &vec;
    message.msg_iovlen = 1;
    message.msg_controllen = ancillaryBufferCapacity();
    message.msg_control = ancillaryBuffer;

    int flags = 0;
#ifdef MSG_CMSG_CLOEXEC
    flags = MSG_CMSG_CLOEXEC;
#endif

    int recvrv = ::recvmsg(fd, &message, flags);
#ifdef QUNIXSOCKET_DEBUG
    qDebug() << "QUnixSocket: Received message (" << recvrv << ')';
#endif
    if(-1 == recvrv) {
#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: Unable to receive data ("
                 << ::strerror(errno) << ')';
#endif
        error = (QUnixSocket::SocketError)(QUnixSocket::ReadFailure |
                                           CausedAbort);
        me->abort();
    } else if(0 == recvrv) {
        me->abort();
    } else {
        Q_ASSERT(recvrv);
        Q_ASSERT((unsigned)recvrv <= dataBufferCapacity);
        dataBufferLength = recvrv;
        messageValid = true;

#ifdef QUNIXSOCKET_DEBUG
        qDebug() << "QUnixSocket: readyRead() " << dataBufferLength;
#endif
        emit readyRead();
    }
}

QT_END_NAMESPACE

#include "qunixsocket.moc"