src/websockets/qwebsocketserver_p.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/legal
   5 **
   6 ** This file is part of the QtWebSockets module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** Commercial License Usage
  10 ** Licensees holding valid commercial Qt licenses may use this file in
  11 ** accordance with the commercial license agreement provided with the
  12 ** Software or, alternatively, in accordance with the terms contained in
  13 ** a written agreement between you and Digia.  For licensing terms and
  14 ** conditions see http://qt.digia.com/licensing.  For further information
  15 ** use the contact form at http://qt.digia.com/contact-us.
  16 **
  17 ** GNU Lesser General Public License Usage
  18 ** Alternatively, this file may be used under the terms of the GNU Lesser
  19 ** General Public License version 2.1 as published by the Free Software
  20 ** Foundation and appearing in the file LICENSE.LGPL included in the
  21 ** packaging of this file.  Please review the following information to
  22 ** ensure the GNU Lesser General Public License version 2.1 requirements
  23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  24 **
  25 ** In addition, as a special exception, Digia gives you certain additional
  26 ** rights.  These rights are described in the Digia Qt LGPL Exception
  27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  28 **
  29 ** GNU General Public License Usage
  30 ** Alternatively, this file may be used under the terms of the GNU
  31 ** General Public License version 3.0 as published by the Free Software
  32 ** Foundation and appearing in the file LICENSE.GPL included in the
  33 ** packaging of this file.  Please review the following information to
  34 ** ensure the GNU General Public License version 3.0 requirements will be
  35 ** met: http://www.gnu.org/copyleft/gpl.html.
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qwebsocketserver.h"
  43 #include "qwebsocketserver_p.h"
  44 #ifndef QT_NO_SSL
  45 #include "qsslserver_p.h"
  46 #endif
  47 #include "qwebsocketprotocol.h"
  48 #include "qwebsockethandshakerequest_p.h"
  49 #include "qwebsockethandshakeresponse_p.h"
  50 #include "qwebsocket.h"
  51 #include "qwebsocket_p.h"
  52 #include "qwebsocketcorsauthenticator.h"
  53
  54 #include <QtNetwork/QTcpServer>
  55 #include <QtNetwork/QTcpSocket>
  56 #include <QtNetwork/QNetworkProxy>
  57
  58 QT_BEGIN_NAMESPACE
  59
  60 /*!
  61     \internal
  62  */
  63 QWebSocketServerPrivate::QWebSocketServerPrivate(const QString &serverName,
  64                                                  QWebSocketServerPrivate::SslMode secureMode,
  65                                                  QWebSocketServer * const pWebSocketServer,
  66                                                  QObject *parent) :
  67     QObject(parent),
  68     q_ptr(pWebSocketServer),
  69     m_pTcpServer(Q_NULLPTR),
  70     m_serverName(serverName),
  71     m_secureMode(secureMode),
  72     m_pendingConnections(),
  73     m_error(QWebSocketProtocol::CloseCodeNormal),
  74     m_errorString()
  75 {
  76     Q_ASSERT(pWebSocketServer);
  77     if (m_secureMode == NonSecureMode) {
  78         m_pTcpServer = new QTcpServer(this);
  79         if (Q_LIKELY(m_pTcpServer))
  80             connect(m_pTcpServer, &QTcpServer::newConnection,
  81                     this, &QWebSocketServerPrivate::onNewConnection);
  82         else
  83             qFatal("Could not allocate memory for tcp server.");
  84     } else {
  85 #ifndef QT_NO_SSL
  86         QSslServer *pSslServer = new QSslServer(this);
  87         m_pTcpServer = pSslServer;
  88         if (Q_LIKELY(m_pTcpServer)) {
  89             connect(pSslServer, &QSslServer::newEncryptedConnection,
  90                     this, &QWebSocketServerPrivate::onNewConnection);
  91             connect(pSslServer, &QSslServer::peerVerifyError,
  92                     q_ptr, &QWebSocketServer::peerVerifyError);
  93             connect(pSslServer, &QSslServer::sslErrors,
  94                     q_ptr, &QWebSocketServer::sslErrors);
  95         }
  96 #else
  97         qFatal("SSL not supported on this platform.");
  98 #endif
  99     }
 100     connect(m_pTcpServer, &QTcpServer::acceptError, q_ptr, &QWebSocketServer::acceptError);
 101 }
 102
 103 /*!
 104     \internal
 105  */
 106 QWebSocketServerPrivate::~QWebSocketServerPrivate()
 107 {
 108     close();
 109     m_pTcpServer->deleteLater();
 110 }
 111
 112 /*!
 113     \internal
 114  */
 115 void QWebSocketServerPrivate::close()
 116 {
 117     Q_Q(QWebSocketServer);
 118     m_pTcpServer->close();
 119     while (!m_pendingConnections.isEmpty()) {
 120         QWebSocket *pWebSocket = m_pendingConnections.dequeue();
 121         pWebSocket->close(QWebSocketProtocol::CloseCodeGoingAway, tr("Server closed."));
 122         pWebSocket->deleteLater();
 123     }
 124     //emit signal via the event queue, so the server gets time
 125     //to process any hanging events, like flushing buffers aso
 126     QMetaObject::invokeMethod(q, "closed", Qt::QueuedConnection);
 127 }
 128
 129 /*!
 130     \internal
 131  */
 132 QString QWebSocketServerPrivate::errorString() const
 133 {
 134     if (m_errorString.isEmpty())
 135         return m_pTcpServer->errorString();
 136     else
 137         return m_errorString;
 138 }
 139
 140 /*!
 141     \internal
 142  */
 143 bool QWebSocketServerPrivate::hasPendingConnections() const
 144 {
 145     return !m_pendingConnections.isEmpty();
 146 }
 147
 148 /*!
 149     \internal
 150  */
 151 bool QWebSocketServerPrivate::isListening() const
 152 {
 153     return m_pTcpServer->isListening();
 154 }
 155
 156 /*!
 157     \internal
 158  */
 159 bool QWebSocketServerPrivate::listen(const QHostAddress &address, quint16 port)
 160 {
 161     bool success = m_pTcpServer->listen(address, port);
 162     if (!success)
 163         setErrorFromSocketError(m_pTcpServer->serverError(), m_pTcpServer->errorString());
 164     return success;
 165 }
 166
 167 /*!
 168     \internal
 169  */
 170 int QWebSocketServerPrivate::maxPendingConnections() const
 171 {
 172     return m_pTcpServer->maxPendingConnections();
 173 }
 174
 175 /*!
 176     \internal
 177  */
 178 void QWebSocketServerPrivate::addPendingConnection(QWebSocket *pWebSocket)
 179 {
 180     if (m_pendingConnections.size() < maxPendingConnections())
 181         m_pendingConnections.enqueue(pWebSocket);
 182 }
 183
 184 /*!
 185     \internal
 186  */
 187 void QWebSocketServerPrivate::setErrorFromSocketError(QAbstractSocket::SocketError error,
 188                                                       const QString &errorDescription)
 189 {
 190     Q_UNUSED(error);
 191     setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection, errorDescription);
 192 }
 193
 194 /*!
 195     \internal
 196  */
 197 QWebSocket *QWebSocketServerPrivate::nextPendingConnection()
 198 {
 199     QWebSocket *pWebSocket = Q_NULLPTR;
 200     if (Q_LIKELY(!m_pendingConnections.isEmpty()))
 201         pWebSocket = m_pendingConnections.dequeue();
 202     return pWebSocket;
 203 }
 204
 205 /*!
 206     \internal
 207  */
 208 void QWebSocketServerPrivate::pauseAccepting()
 209 {
 210     m_pTcpServer->pauseAccepting();
 211 }
 212
 213 #ifndef QT_NO_NETWORKPROXY
 214 /*!
 215     \internal
 216  */
 217 QNetworkProxy QWebSocketServerPrivate::proxy() const
 218 {
 219     return m_pTcpServer->proxy();
 220 }
 221
 222 /*!
 223     \internal
 224  */
 225 void QWebSocketServerPrivate::setProxy(const QNetworkProxy &networkProxy)
 226 {
 227     m_pTcpServer->setProxy(networkProxy);
 228 }
 229 #endif
 230 /*!
 231     \internal
 232  */
 233 void QWebSocketServerPrivate::resumeAccepting()
 234 {
 235     m_pTcpServer->resumeAccepting();
 236 }
 237
 238 /*!
 239     \internal
 240  */
 241 QHostAddress QWebSocketServerPrivate::serverAddress() const
 242 {
 243     return m_pTcpServer->serverAddress();
 244 }
 245
 246 /*!
 247     \internal
 248  */
 249 QWebSocketProtocol::CloseCode QWebSocketServerPrivate::serverError() const
 250 {
 251     return m_error;
 252 }
 253
 254 /*!
 255     \internal
 256  */
 257 quint16 QWebSocketServerPrivate::serverPort() const
 258 {
 259     return m_pTcpServer->serverPort();
 260 }
 261
 262 /*!
 263     \internal
 264  */
 265 void QWebSocketServerPrivate::setMaxPendingConnections(int numConnections)
 266 {
 267     m_pTcpServer->setMaxPendingConnections(numConnections);
 268 }
 269
 270 /*!
 271     \internal
 272  */
 273 bool QWebSocketServerPrivate::setSocketDescriptor(qintptr socketDescriptor)
 274 {
 275     return m_pTcpServer->setSocketDescriptor(socketDescriptor);
 276 }
 277
 278 /*!
 279     \internal
 280  */
 281 qintptr QWebSocketServerPrivate::socketDescriptor() const
 282 {
 283     return m_pTcpServer->socketDescriptor();
 284 }
 285
 286 /*!
 287     \internal
 288  */
 289 QList<QWebSocketProtocol::Version> QWebSocketServerPrivate::supportedVersions() const
 290 {
 291     QList<QWebSocketProtocol::Version> supportedVersions;
 292     supportedVersions << QWebSocketProtocol::currentVersion();  //we only support V13
 293     return supportedVersions;
 294 }
 295
 296 /*!
 297     \internal
 298  */
 299 QStringList QWebSocketServerPrivate::supportedProtocols() const
 300 {
 301     QStringList supportedProtocols;
 302     return supportedProtocols;  //no protocols are currently supported
 303 }
 304
 305 /*!
 306     \internal
 307  */
 308 QStringList QWebSocketServerPrivate::supportedExtensions() const
 309 {
 310     QStringList supportedExtensions;
 311     return supportedExtensions; //no extensions are currently supported
 312 }
 313
 314 /*!
 315   \internal
 316  */
 317 void QWebSocketServerPrivate::setServerName(const QString &serverName)
 318 {
 319     if (m_serverName != serverName)
 320         m_serverName = serverName;
 321 }
 322
 323 /*!
 324   \internal
 325  */
 326 QString QWebSocketServerPrivate::serverName() const
 327 {
 328     return m_serverName;
 329 }
 330
 331 /*!
 332   \internal
 333  */
 334 QWebSocketServerPrivate::SslMode QWebSocketServerPrivate::secureMode() const
 335 {
 336     return m_secureMode;
 337 }
 338
 339 #ifndef QT_NO_SSL
 340 void QWebSocketServerPrivate::setSslConfiguration(const QSslConfiguration &sslConfiguration)
 341 {
 342     if (m_secureMode == SecureMode)
 343         qobject_cast<QSslServer *>(m_pTcpServer)->setSslConfiguration(sslConfiguration);
 344 }
 345
 346 QSslConfiguration QWebSocketServerPrivate::sslConfiguration() const
 347 {
 348     if (m_secureMode == SecureMode)
 349         return qobject_cast<QSslServer *>(m_pTcpServer)->sslConfiguration();
 350     else
 351         return QSslConfiguration::defaultConfiguration();
 352 }
 353 #endif
 354
 355 void QWebSocketServerPrivate::setError(QWebSocketProtocol::CloseCode code, const QString &errorString)
 356 {
 357     if ((m_error != code) || (m_errorString != errorString)) {
 358         Q_Q(QWebSocketServer);
 359         m_error = code;
 360         m_errorString = errorString;
 361         Q_EMIT q->serverError(code);
 362     }
 363 }
 364
 365 /*!
 366     \internal
 367  */
 368 void QWebSocketServerPrivate::onNewConnection()
 369 {
 370     QTcpSocket *pTcpSocket = m_pTcpServer->nextPendingConnection();
 371     connect(pTcpSocket, &QTcpSocket::readyRead, this, &QWebSocketServerPrivate::handshakeReceived);
 372 }
 373
 374 /*!
 375     \internal
 376  */
 377 void QWebSocketServerPrivate::onCloseConnection()
 378 {
 379     QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
 380     if (Q_LIKELY(pTcpSocket))
 381         pTcpSocket->close();
 382 }
 383
 384 /*!
 385     \internal
 386  */
 387 void QWebSocketServerPrivate::handshakeReceived()
 388 {
 389     Q_Q(QWebSocketServer);
 390     QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
 391     if (Q_LIKELY(pTcpSocket)) {
 392         bool success = false;
 393         bool isSecure = false;
 394
 395         disconnect(pTcpSocket, &QTcpSocket::readyRead,
 396                    this, &QWebSocketServerPrivate::handshakeReceived);
 397
 398         if (m_pendingConnections.length() >= maxPendingConnections()) {
 399             pTcpSocket->close();
 400             pTcpSocket->deleteLater();
 401             setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
 402                      tr("Too many pending connections."));
 403             return;
 404         }
 405
 406         QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure);
 407         QTextStream textStream(pTcpSocket);
 408         request.readHandshake(textStream);
 409
 410         if (request.isValid()) {
 411             QWebSocketCorsAuthenticator corsAuthenticator(request.origin());
 412             Q_EMIT q->originAuthenticationRequired(&corsAuthenticator);
 413
 414             QWebSocketHandshakeResponse response(request,
 415                                                  m_serverName,
 416                                                  corsAuthenticator.allowed(),
 417                                                  supportedVersions(),
 418                                                  supportedProtocols(),
 419                                                  supportedExtensions());
 420
 421             if (response.isValid()) {
 422                 QTextStream httpStream(pTcpSocket);
 423                 httpStream << response;
 424                 httpStream.flush();
 425
 426                 if (response.canUpgrade()) {
 427                     QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket,
 428                                                                             request,
 429                                                                             response);
 430                     if (pWebSocket) {
 431                         addPendingConnection(pWebSocket);
 432                         Q_EMIT q->newConnection();
 433                         success = true;
 434                     } else {
 435                         setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
 436                                  tr("Upgrading to websocket failed."));
 437                     }
 438                 }
 439                 else {
 440                     setError(response.error(), response.errorString());
 441                 }
 442             } else {
 443                 setError(QWebSocketProtocol::CloseCodeProtocolError, tr("Invalid response received."));
 444             }
 445         }
 446         if (!success) {
 447             qWarning() << tr("Closing socket because of invalid or unsupported request.");
 448             pTcpSocket->close();
 449             pTcpSocket->deleteLater();
 450         }
 451     } else {
 452         qWarning() <<
 453             tr("Sender socket is NULL. This should not happen, otherwise it is a Qt bug!!!");
 454     }
 455 }
 456
 457 QT_END_NAMESPACE