qunixsocketserver.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, 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, Digia gives you certain additional
** rights.  These rights are described in the Digia 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.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qunixsocketserver_p.h"

// #define QUNIXSOCKETSERVER_DEBUG

#ifdef QUNIXSOCKETSERVER_DEBUG
#include <QDebug>
#endif

#include <QtCore/qsocketnotifier.h>

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

#define UNIX_PATH_MAX 108 // From unix(7)

QT_BEGIN_NAMESPACE

class QUnixSocketServerPrivate : public QObject
{
Q_OBJECT
public:
    QUnixSocketServerPrivate(QUnixSocketServer * parent)
    : QObject(), me(parent), fd(-1), maxConns(30),
      error(QUnixSocketServer::NoError), acceptNotifier(0)
    {}

    QUnixSocketServer * me;
    int fd;
    int maxConns;
    QByteArray address;
    QUnixSocketServer::ServerError error;
    QSocketNotifier * acceptNotifier;
public slots:
    void acceptActivated();
};

QUnixSocketServer::QUnixSocketServer(QObject *parent)
: QObject(parent), d(0)
{
}

QUnixSocketServer::~QUnixSocketServer()
{
    close();
    if(d)
        delete d;
}

void QUnixSocketServer::close()
{
    if(!d)
        return;

    if(d->acceptNotifier) {
        d->acceptNotifier->setEnabled(false);
        delete d->acceptNotifier;
    }
    d->acceptNotifier = 0;

    if(-1 != d->fd) {
#ifdef QUNIXSOCKET_DEBUG
        int closerv =
#endif
            ::close(d->fd);
#ifdef QUNIXSOCKET_DEBUG
        if(0 != closerv) {
            qDebug() << "QUnixSocketServer: Unable to close socket ("
                     << strerror(errno) << ')';
        }
#endif
    }
    d->fd = -1;
    d->address = QByteArray();
    d->error = NoError;
}

QUnixSocketServer::ServerError QUnixSocketServer::serverError() const
{
    if(!d)
        return NoError;

    return d->error;
}

bool QUnixSocketServer::isListening() const
{
    if(!d)
        return false;

    return (-1 != d->fd);
}

bool QUnixSocketServer::listen(const QByteArray & path)
{
    if(d) {
        close(); // Any existing server is destroyed
    } else {
        d = new QUnixSocketServerPrivate(this);
    }

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

    // Create the socket
    d->fd = ::socket(PF_UNIX, SOCK_STREAM, 0);
    if(-1 == d->fd) {
#ifdef QUNIXSOCKETSERVER_DEBUG
        qDebug() << "QUnixSocketServer: Unable to create socket ("
                 << strerror(errno) << ')';
#endif
        close();
        d->error = ResourceError;
        return false;
    }

    // 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 to bind
    if(-1 == ::bind(d->fd, (sockaddr *)&addr, sizeof(sockaddr_un))) {
#ifdef QUNIXSOCKETSERVER_DEBUG
        qDebug() << "QUnixSocketServer: Unable to bind socket ("
                 << strerror(errno) << ')';
#endif
        close();
        d->error = BindError;
        return false;
    }

    // Listen to socket
    if(-1 == ::listen(d->fd, d->maxConns)) {
#ifdef QUNIXSOCKETSERVER_DEBUG
        qDebug() << "QUnixSocketServer: Unable to listen socket ("
                 << strerror(errno) << ')';
#endif
        close();
        d->error = ListenError;
        return false;
    }

    // Success!
    d->address = path;
    d->acceptNotifier = new QSocketNotifier(d->fd, QSocketNotifier::Read, d);
    d->acceptNotifier->setEnabled(true);
    QObject::connect(d->acceptNotifier, SIGNAL(activated(int)),
                     d, SLOT(acceptActivated()));

    return true;
}

QByteArray QUnixSocketServer::serverAddress() const
{
    if(!d)
        return QByteArray();
    return d->address;
}

int QUnixSocketServer::socketDescriptor() const
{
    if (!d)
        return -1;
    return d->fd;
}


int QUnixSocketServer::maxPendingConnections() const
{
    if(!d)
        return 30;

    return d->maxConns;
}

void QUnixSocketServer::setMaxPendingConnections(int numConnections)
{
    Q_ASSERT(numConnections >= 1);
    if(!d)
        d = new QUnixSocketServerPrivate(this);

    d->maxConns = numConnections;
}

void QUnixSocketServerPrivate::acceptActivated()
{
    ::sockaddr_un r;
    socklen_t len = sizeof(sockaddr_un);
    int connsock = ::accept(fd, (sockaddr *)&r, &len);
#ifdef QUNIXSOCKETSERVER_DEBUG
    qDebug() << "QUnixSocketServer: Accept connection " << connsock;
#endif
    if(-1 != connsock)
        me->incomingConnection(connsock);
}

QT_END_NAMESPACE

#include "qunixsocketserver.moc"