src/gui/embedded/qunixsocketserver.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtGui module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qunixsocketserver_p.h"
  43
  44 // #define QUNIXSOCKETSERVER_DEBUG
  45
  46 #ifdef QUNIXSOCKETSERVER_DEBUG
  47 #include <QDebug>
  48 #endif
  49
  50 #include <QtCore/qsocketnotifier.h>
  51
  52 extern "C" {
  53 #include <sys/types.h>
  54 #include <sys/socket.h>
  55 #include <sys/un.h>
  56 #include <unistd.h>
  57 #include <errno.h>
  58 };
  59
  60 #define UNIX_PATH_MAX 108 // From unix(7)
  61
  62 QT_BEGIN_NAMESPACE
  63
  64 class QUnixSocketServerPrivate : public QObject
  65 {
  66 Q_OBJECT
  67 public:
  68     QUnixSocketServerPrivate(QUnixSocketServer * parent)
  69     : QObject(), me(parent), fd(-1), maxConns(30),
  70       error(QUnixSocketServer::NoError), acceptNotifier(0)
  71     {}
  72
  73     QUnixSocketServer * me;
  74     int fd;
  75     int maxConns;
  76     QByteArray address;
  77     QUnixSocketServer::ServerError error;
  78     QSocketNotifier * acceptNotifier;
  79 public slots:
  80     void acceptActivated();
  81 };
  82
  83 /*!
  84   \class QUnixSocketServer
  85   \internal
  86
  87   \brief The QUnixSocketServer class provides a Unix domain socket based server.
  88   \omit
  89   \ingroup Platform::DeviceSpecific
  90   \ingroup Platform::OS
  91   \ingroup Platform::Communications
  92   \endomit
  93   \ingroup qws
  94
  95   This class makes it possible to accept incoming Unix domain socket
  96   connections.  Call \l QUnixSocketServer::listen() to have the server listen
  97   for incoming connections on a specified path.  The pure virtual
  98   \l QUnixSocketServer::incomingConnection() is called each time a new
  99   connection is established.  Users must inherit from QUnixSocketServer and
 100   implement this method.
 101
 102   If an error occurs, \l QUnixSocketServer::serverError() returns the type of
 103   error.  Errors can only occur during server establishment - that is, during a
 104   call to \l QUnixSocketServer::listen().  Calling \l QUnixSocketServer::close()
 105   causes QUnixSocketServer to stop listening for connections and reset its
 106   state.
 107
 108   QUnixSocketServer is often used in conjunction with the \l QUnixSocket class.
 109
 110   \sa QUnixSocket
 111 */
 112
 113 /*!
 114   \enum QUnixSocketServer::ServerError
 115
 116   The ServerError enumeration represents the errors that can occur during server
 117   establishment.  The most recent error can be retrieved through a call to
 118   \l QUnixSocketServer::serverError().
 119
 120   \value NoError No error has occurred.
 121   \value InvalidPath An invalid path endpoint was passed to
 122          \l QUnixSocketServer::listen().  As defined by unix(7), invalid paths
 123          include an empty path, or what more than 107 characters long.
 124   \value ResourceError An error acquiring or manipulating the system's socket
 125          resources occurred.  For example, if the process runs out of available
 126          socket descriptors, a ResourceError will occur.
 127   \value BindError The server was unable to bind to the specified path.
 128   \value ListenError The server was unable to listen on the specified path for
 129          incoming connections.
 130   */
 131
 132 /*!
 133   Create a new Unix socket server with the given \a parent.
 134   */
 135 QUnixSocketServer::QUnixSocketServer(QObject *parent)
 136 : QObject(parent), d(0)
 137 {
 138 }
 139
 140 /*!
 141   Stops listening for incoming connection and destroys the Unix socket server.
 142   */
 143 QUnixSocketServer::~QUnixSocketServer()
 144 {
 145     close();
 146     if(d)
 147         delete d;
 148 }
 149
 150 /*!
 151   Stop listening for incoming connections and resets the Unix socket server's
 152   state.  Calling this method while \l {QUnixSocketServer::isListening()}{not listening } for incoming connections is a no-op.
 153
 154   \sa QUnixSocketServer::listen()
 155   */
 156 void QUnixSocketServer::close()
 157 {
 158     if(!d)
 159         return;
 160
 161     if(d->acceptNotifier) {
 162         d->acceptNotifier->setEnabled(false);
 163         delete d->acceptNotifier;
 164     }
 165     d->acceptNotifier = 0;
 166
 167     if(-1 != d->fd) {
 168 #ifdef QUNIXSOCKET_DEBUG
 169         int closerv =
 170 #endif
 171             ::close(d->fd);
 172 #ifdef QUNIXSOCKET_DEBUG
 173         if(0 != closerv) {
 174             qDebug() << "QUnixSocketServer: Unable to close socket ("
 175                      << strerror(errno) << ')';
 176         }
 177 #endif
 178     }
 179     d->fd = -1;
 180     d->address = QByteArray();
 181     d->error = NoError;
 182 }
 183
 184 /*!
 185   Returns the last server error.  Errors may only occur within a call to
 186   \l QUnixSocketServer::listen(), and only when such a call fails.
 187
 188   This method is not destructive, so multiple calls to
 189   QUnixSocketServer::serverError() will return the same value.  The error is
 190   only reset by an explicit call to \l QUnixSocketServer::close() or
 191   by further calls to \l QUnixSocketServer::listen().
 192   */
 193 QUnixSocketServer::ServerError QUnixSocketServer::serverError() const
 194 {
 195     if(!d)
 196         return NoError;
 197
 198     return d->error;
 199 }
 200
 201 /*!
 202   Returns true if this server is listening for incoming connections, false
 203   otherwise.
 204
 205   \sa QUnixSocketServer::listen()
 206   */
 207 bool QUnixSocketServer::isListening() const
 208 {
 209     if(!d)
 210         return false;
 211
 212     return (-1 != d->fd);
 213 }
 214
 215 /*!
 216   Tells the server to listen for incoming connections on \a path.  Returns true
 217   if it successfully initializes, false otherwise.  In the case of failure, the
 218   \l QUnixSocketServer::serverError() error status is set accordingly.
 219
 220   Calling this method while the server is already running will result in the
 221   server begin reset, and then attempting to listen on \a path.  This will not
 222   affect connections established prior to the server being reset, but further
 223   incoming connections on the previous path will be refused.
 224
 225   The server can be explicitly reset by a call to \l QUnixSocketServer::close().
 226
 227   \sa QUnixSocketServer::close()
 228   */
 229 bool QUnixSocketServer::listen(const QByteArray & path)
 230 {
 231     if(d) {
 232         close(); // Any existing server is destroyed
 233     } else {
 234         d = new QUnixSocketServerPrivate(this);
 235     }
 236
 237     if(path.isEmpty() || path.size() > UNIX_PATH_MAX) {
 238         d->error = InvalidPath;
 239         return false;
 240     }
 241     unlink( path );  // ok if this fails
 242
 243     // Create the socket
 244     d->fd = ::socket(PF_UNIX, SOCK_STREAM, 0);
 245     if(-1 == d->fd) {
 246 #ifdef QUNIXSOCKETSERVER_DEBUG
 247         qDebug() << "QUnixSocketServer: Unable to create socket ("
 248                  << strerror(errno) << ')';
 249 #endif
 250         close();
 251         d->error = ResourceError;
 252         return false;
 253     }
 254
 255     // Construct our unix address
 256     struct ::sockaddr_un addr;
 257     addr.sun_family = AF_UNIX;
 258     ::memcpy(addr.sun_path, path.data(), path.size());
 259     if(path.size() < UNIX_PATH_MAX)
 260         addr.sun_path[path.size()] = '\0';
 261
 262     // Attempt to bind
 263     if(-1 == ::bind(d->fd, (sockaddr *)&addr, sizeof(sockaddr_un))) {
 264 #ifdef QUNIXSOCKETSERVER_DEBUG
 265         qDebug() << "QUnixSocketServer: Unable to bind socket ("
 266                  << strerror(errno) << ')';
 267 #endif
 268         close();
 269         d->error = BindError;
 270         return false;
 271     }
 272
 273     // Listen to socket
 274     if(-1 == ::listen(d->fd, d->maxConns)) {
 275 #ifdef QUNIXSOCKETSERVER_DEBUG
 276         qDebug() << "QUnixSocketServer: Unable to listen socket ("
 277                  << strerror(errno) << ')';
 278 #endif
 279         close();
 280         d->error = ListenError;
 281         return false;
 282     }
 283
 284     // Success!
 285     d->address = path;
 286     d->acceptNotifier = new QSocketNotifier(d->fd, QSocketNotifier::Read, d);
 287     d->acceptNotifier->setEnabled(true);
 288     QObject::connect(d->acceptNotifier, SIGNAL(activated(int)),
 289                      d, SLOT(acceptActivated()));
 290
 291     return true;
 292 }
 293
 294 /*!
 295   Returns the Unix path on which this server is listening.  If this server is
 296   not listening, and empty address will be returned.
 297   */
 298 QByteArray QUnixSocketServer::serverAddress() const
 299 {
 300     if(!d)
 301         return QByteArray();
 302     return d->address;
 303 }
 304
 305 int QUnixSocketServer::socketDescriptor() const
 306 {
 307     if (!d)
 308         return -1;
 309     return d->fd;
 310 }
 311
 312
 313 /*!
 314   Returns the maximum length the queue of pending connections may grow to.  That
 315   is, the maximum number of clients attempting to connect for which the Unix
 316   socket server has not yet accepted and passed to
 317   \l QUnixSocketServer::incomingConnection().  If a connection request arrives
 318   with the queue full, the client may receive a connection refused notification.
 319
 320   By default a queue length of 30 is used.
 321
 322   \sa QUnixSocketServer::setMaxPendingConnections()
 323   */
 324 int QUnixSocketServer::maxPendingConnections() const
 325 {
 326     if(!d)
 327         return 30;
 328
 329     return d->maxConns;
 330 }
 331
 332 /*!
 333   Sets the maximum length the queue of pending connections may grow to
 334   \a numConnections.  This value will only apply to
 335   \l QUnixSocketServer::listen() calls made following the value change - it will
 336   not be retroactively applied.
 337
 338   \sa QUnixSocketServer::maxPendingConnections()
 339   */
 340 void QUnixSocketServer::setMaxPendingConnections(int numConnections)
 341 {
 342     Q_ASSERT(numConnections >= 1);
 343     if(!d)
 344         d = new QUnixSocketServerPrivate(this);
 345
 346     d->maxConns = numConnections;
 347 }
 348
 349 /*!
 350   \fn void QUnixSocketServer::incomingConnection(int socketDescriptor)
 351
 352   This method is invoked each time a new incoming connection is established with
 353   the server.  Clients must reimplement this function in their QUnixSocketServer
 354   derived class to handle the connection.
 355
 356   A common approach to handling the connection is to pass \a socketDescriptor to
 357   a QUnixSocket instance.
 358
 359   \sa QUnixSocket
 360   */
 361
 362 void QUnixSocketServerPrivate::acceptActivated()
 363 {
 364     ::sockaddr_un r;
 365     socklen_t len = sizeof(sockaddr_un);
 366     int connsock = ::accept(fd, (sockaddr *)&r, &len);
 367 #ifdef QUNIXSOCKETSERVER_DEBUG
 368     qDebug() << "QUnixSocketServer: Accept connection " << connsock;
 369 #endif
 370     if(-1 != connsock)
 371         me->incomingConnection(connsock);
 372 }
 373
 374 QT_END_NAMESPACE
 375
 376 #include "qunixsocketserver.moc"