src/websockets/qwebsocket.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 /*!
  43     \class QWebSocket
  44
  45     \inmodule QtWebSockets
  46     \brief Implements a TCP socket that talks the websocket protocol.
  47
  48     WebSockets is a web technology providing full-duplex communications channels over
  49     a single TCP connection.
  50     The WebSocket protocol was standardized by the IETF as
  51     \l {http://tools.ietf.org/html/rfc6455} {RFC 6455} in 2011.
  52     QWebSocket can both be used in a client application and server application.
  53
  54     This class was modeled after QAbstractSocket.
  55
  56     QWebSocket currently does not support
  57     \l {http://tools.ietf.org/html/rfc6455#page-39} {extensions} and
  58     \l {http://tools.ietf.org/html/rfc6455#page-12} {subprotocols}.
  59
  60     QWebSocket only supports version 13 of the WebSocket protocol, as outlined in RFC 6455.
  61
  62     \sa QAbstractSocket, QTcpSocket
  63
  64     \sa {QWebSocket client example}
  65 */
  66
  67 /*!
  68     \page echoclient.html example
  69     \title QWebSocket client example
  70     \brief A sample websocket client that sends a message and displays the message that
  71     it receives back.
  72
  73     \section1 Description
  74     The EchoClient example implements a web socket client that sends a message to a websocket server
  75     and dumps the answer that it gets back.
  76     This example should ideally be used with the EchoServer example.
  77     \section1 Code
  78     We start by connecting to the `connected()` signal.
  79     \snippet echoclient/echoclient.cpp constructor
  80     After the connection, we open the socket to the given \a url.
  81
  82     \snippet echoclient/echoclient.cpp onConnected
  83     When the client is connected successfully, we connect to the `onTextMessageReceived()` signal,
  84     and send out "Hello, world!".
  85     If connected with the EchoServer, we will receive the same message back.
  86
  87     \snippet echoclient/echoclient.cpp onTextMessageReceived
  88     Whenever a message is received, we write it out.
  89 */
  90
  91 /*!
  92   \fn void QWebSocket::connected()
  93   \brief Emitted when a connection is successfully established.
  94   A connection is successfully established when the socket is connected
  95   and the handshake was successful.
  96   \sa open(), disconnected()
  97 */
  98 /*!
  99   \fn void QWebSocket::disconnected()
 100   \brief Emitted when the socket is disconnected.
 101   \sa close(), connected()
 102 */
 103 /*!
 104     \fn void QWebSocket::aboutToClose()
 105
 106     This signal is emitted when the socket is about to close.
 107     Connect this signal if you have operations that need to be performed before the socket closes
 108     (e.g., if you have data in a separate buffer that needs to be written to the device).
 109
 110     \sa close()
 111  */
 112 /*!
 113 \fn void QWebSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)
 114
 115 This signal can be emitted when a \a proxy that requires
 116 authentication is used. The \a authenticator object can then be
 117 filled in with the required details to allow authentication and
 118 continue the connection.
 119
 120 \note It is not possible to use a QueuedConnection to connect to
 121 this signal, as the connection will fail if the authenticator has
 122 not been filled in with new information when the signal returns.
 123
 124 \sa QAuthenticator, QNetworkProxy
 125 */
 126 /*!
 127     \fn void QWebSocket::stateChanged(QAbstractSocket::SocketState state);
 128
 129     This signal is emitted whenever QWebSocket's state changes.
 130     The \a state parameter is the new state.
 131
 132     \note QAbstractSocket::ConnectedState is emitted after the handshake has
 133     with the server has succeeded.
 134
 135     QAbstractSocket::SocketState is not a registered metatype, so for queued
 136     connections, you will have to register it with Q_REGISTER_METATYPE() and
 137     qRegisterMetaType().
 138
 139     \sa state()
 140 */
 141 /*!
 142     \fn void QWebSocket::readChannelFinished()
 143
 144     This signal is emitted when the input (reading) stream is closed in this device.
 145     It is emitted as soon as the closing is detected.
 146
 147     \sa close()
 148 */
 149 /*!
 150     \fn void QWebSocket::bytesWritten(qint64 bytes)
 151
 152     This signal is emitted every time a payload of data has been written to the socket.
 153     The \a bytes argument is set to the number of bytes that were written in this payload.
 154
 155     \note This signal has the same meaning both for secure and non-secure websockets.
 156     As opposed to QSslSocket, bytesWritten() is only emitted when encrypted data is effectively
 157     written (see QSslSocket:encryptedBytesWritten()).
 158     \sa close()
 159 */
 160
 161 /*!
 162     \fn void QWebSocket::textFrameReceived(const QString &frame, bool isLastFrame);
 163
 164     This signal is emitted whenever a text frame is received. The \a frame contains the data and
 165     \a isLastFrame indicates whether this is the last frame of the complete message.
 166
 167     This signal can be used to process large messages frame by frame, instead of waiting for the
 168     complete message to arrive.
 169
 170     \sa binaryFrameReceived()
 171 */
 172 /*!
 173     \fn void QWebSocket::binaryFrameReceived(const QByteArray &frame, bool isLastFrame);
 174
 175     This signal is emitted whenever a binary frame is received. The \a frame contains the data and
 176     \a isLastFrame indicates whether this is the last frame of the complete message.
 177
 178     This signal can be used to process large messages frame by frame, instead of waiting for the
 179     complete message to arrive.
 180
 181     \sa textFrameReceived()
 182 */
 183 /*!
 184     \fn void QWebSocket::textMessageReceived(const QString &message);
 185
 186     This signal is emitted whenever a text message is received. The \a message contains the
 187     received text.
 188
 189     \sa binaryMessageReceived()
 190 */
 191 /*!
 192     \fn void QWebSocket::binaryMessageReceived(const QByteArray &message);
 193
 194     This signal is emitted whenever a binary message is received. The \a message contains the
 195     received bytes.
 196
 197     \sa textMessageReceived()
 198 */
 199 /*!
 200     \fn void QWebSocket::error(QAbstractSocket::SocketError error);
 201
 202     This signal is emitted after an error occurred. The \a error
 203     parameter describes the type of error that occurred.
 204
 205     QAbstractSocket::SocketError is not a registered metatype, so for queued
 206     connections, you will have to register it with Q_DECLARE_METATYPE() and
 207     qRegisterMetaType().
 208
 209     \sa error(), errorString()
 210 */
 211 /*!
 212     \fn void QWebSocket::sslErrors(const QList<QSslError> &errors)
 213     QWebSocket emits this signal after the SSL handshake to indicate that one or more errors have
 214     occurred while establishing the identity of the peer.
 215     The errors are usually an indication that QWebSocket is unable to securely identify the peer.
 216     Unless any action is taken, the connection will be dropped after this signal has been emitted.
 217     If you want to continue connecting despite the errors that have occurred, you must call
 218     QWebSocket::ignoreSslErrors() from inside a slot connected to this signal.
 219     If you need to access the error list at a later point, you can call sslErrors()
 220     (without arguments).
 221
 222     \a errors contains one or more errors that prevent QWebSocket from verifying the identity of
 223     the peer.
 224
 225     \note You cannot use Qt::QueuedConnection when connecting to this signal, or calling
 226     QWebSocket::ignoreSslErrors() will have no effect.
 227 */
 228 /*!
 229     \fn void QWebSocket::pong(quint64 elapsedTime, const QByteArray &payload)
 230
 231     Emitted when a pong message is received in reply to a previous ping.
 232     \a elapsedTime contains the roundtrip time in milliseconds and \a payload contains an optional
 233     payload that was sent with the ping.
 234
 235     \sa ping()
 236   */
 237 #include "qwebsocket.h"
 238 #include "qwebsocket_p.h"
 239
 240 #include <QtCore/QUrl>
 241 #include <QtNetwork/QTcpSocket>
 242 #include <QtCore/QByteArray>
 243 #include <QtNetwork/QHostAddress>
 244
 245 #include <QtCore/QDebug>
 246
 247 #include <limits>
 248
 249 QT_BEGIN_NAMESPACE
 250
 251 /*!
 252  * \brief Creates a new QWebSocket with the given \a origin,
 253  * the \a version of the protocol to use and \a parent.
 254  *
 255  * The \a origin of the client is as specified \l {http://tools.ietf.org/html/rfc6454}{RFC 6454}.
 256  * (The \a origin is not required for non-web browser clients
 257  * (see \l {http://tools.ietf.org/html/rfc6455}{RFC 6455})).
 258  * \note Currently only V13 (\l {http://tools.ietf.org/html/rfc6455} {RFC 6455}) is supported
 259  */
 260 QWebSocket::QWebSocket(const QString &origin,
 261                        QWebSocketProtocol::Version version,
 262                        QObject *parent) :
 263     QObject(*(new QWebSocketPrivate(origin, version, this)), parent)
 264 {
 265 }
 266
 267 /*!
 268  * \brief Destroys the QWebSocket. Closes the socket if it is still open,
 269  * and releases any used resources.
 270  */
 271 QWebSocket::~QWebSocket()
 272 {
 273 }
 274
 275 /*!
 276  * \brief Aborts the current socket and resets the socket.
 277  * Unlike close(), this function immediately closes the socket,
 278  * discarding any pending data in the write buffer.
 279  */
 280 void QWebSocket::abort()
 281 {
 282     Q_D(QWebSocket);
 283     d->abort();
 284 }
 285
 286 /*!
 287  * Returns the type of error that last occurred
 288  * \sa errorString()
 289  */
 290 QAbstractSocket::SocketError QWebSocket::error() const
 291 {
 292     Q_D(const QWebSocket);
 293     return d->error();
 294 }
 295
 296 //only called by QWebSocketPrivate::upgradeFrom
 297 /*!
 298   \internal
 299  */
 300 QWebSocket::QWebSocket(QTcpSocket *pTcpSocket,
 301                        QWebSocketProtocol::Version version, QObject *parent) :
 302     QObject(*(new QWebSocketPrivate(pTcpSocket, version, this)), parent)
 303 {
 304 }
 305
 306 /*!
 307  * Returns a human-readable description of the last error that occurred
 308  *
 309  * \sa error()
 310  */
 311 QString QWebSocket::errorString() const
 312 {
 313     Q_D(const QWebSocket);
 314     return d->errorString();
 315 }
 316
 317 /*!
 318     This function writes as much as possible from the internal write buffer
 319     to the underlying network socket, without blocking.
 320     If any data was written, this function returns true; otherwise false is returned.
 321     Call this function if you need QWebSocket to start sending buffered data immediately.
 322     The number of bytes successfully written depends on the operating system.
 323     In most cases, you do not need to call this function,
 324     because QWebSocket will start sending data automatically
 325     once control goes back to the event loop.
 326 */
 327 bool QWebSocket::flush()
 328 {
 329     Q_D(QWebSocket);
 330     return d->flush();
 331 }
 332
 333 /*!
 334     \brief Sends the given \a message over the socket as a text message and
 335     returns the number of bytes actually sent.
 336
 337     \sa sendBinaryMessage()
 338  */
 339 qint64 QWebSocket::sendTextMessage(const QString &message)
 340 {
 341     Q_D(QWebSocket);
 342     return d->sendTextMessage(message);
 343 }
 344
 345 /*!
 346     \brief Sends the given \a data over the socket as a binary message and
 347     returns the number of bytes actually sent.
 348
 349     \sa sendTextMessage()
 350  */
 351 qint64 QWebSocket::sendBinaryMessage(const QByteArray &data)
 352 {
 353     Q_D(QWebSocket);
 354     return d->sendBinaryMessage(data);
 355 }
 356
 357 /*!
 358     \brief Gracefully closes the socket with the given \a closeCode and \a reason.
 359
 360     Any data in the write buffer is flushed before the socket is closed.
 361     The \a closeCode is a QWebSocketProtocol::CloseCode indicating the reason to close, and
 362     \a reason describes the reason of the closure more in detail
 363  */
 364 void QWebSocket::close(QWebSocketProtocol::CloseCode closeCode, const QString &reason)
 365 {
 366     Q_D(QWebSocket);
 367     d->close(closeCode, reason);
 368 }
 369
 370 /*!
 371     \brief Opens a websocket connection using the given \a url.
 372     If \a mask is true, all frames will be masked; this is only necessary for client side sockets;
 373     servers should never mask.
 374     \note A client socket must *always* mask its frames; servers may *never* mask its frames.
 375  */
 376 void QWebSocket::open(const QUrl &url, bool mask)
 377 {
 378     Q_D(QWebSocket);
 379     d->open(url, mask);
 380 }
 381
 382 /*!
 383     \brief Pings the server to indicate that the connection is still alive.
 384     Additional \a payload can be sent along the ping message.
 385
 386     The size of the \a payload cannot be bigger than 125.
 387     If it is larger, the \a payload is clipped to 125 bytes.
 388
 389     \sa pong()
 390  */
 391 void QWebSocket::ping(const QByteArray &payload)
 392 {
 393     Q_D(QWebSocket);
 394     d->ping(payload);
 395 }
 396
 397 #ifndef QT_NO_SSL
 398 /*!
 399     This slot tells QWebSocket to ignore errors during QWebSocket's
 400     handshake phase and continue connecting. If you want to continue
 401     with the connection even if errors occur during the handshake
 402     phase, then you must call this slot, either from a slot connected
 403     to sslErrors(), or before the handshake phase. If you don't call
 404     this slot, either in response to errors or before the handshake,
 405     the connection will be dropped after the sslErrors() signal has
 406     been emitted.
 407
 408     \warning Be sure to always let the user inspect the errors
 409     reported by the sslErrors() signal, and only call this method
 410     upon confirmation from the user that proceeding is ok.
 411     If there are unexpected errors, the connection should be aborted.
 412     Calling this method without inspecting the actual errors will
 413     most likely pose a security risk for your application. Use it
 414     with great care!
 415
 416     \sa sslErrors(), QSslSocket::ignoreSslErrors(), QNetworkReply::ignoreSslErrors()
 417 */
 418 void QWebSocket::ignoreSslErrors()
 419 {
 420     Q_D(QWebSocket);
 421     d->ignoreSslErrors();
 422 }
 423
 424 /*!
 425     \overload
 426
 427     This method tells QWebSocket to ignore the errors given in \a errors.
 428
 429     Note that you can set the expected certificate in the SSL error:
 430     If, for instance, you want to connect to a server that uses
 431     a self-signed certificate, consider the following snippet:
 432
 433     \snippet src_websockets_ssl_qwebsocket.cpp 6
 434
 435     Multiple calls to this function will replace the list of errors that
 436     were passed in previous calls.
 437     You can clear the list of errors you want to ignore by calling this
 438     function with an empty list.
 439
 440     \sa sslErrors()
 441 */
 442 void QWebSocket::ignoreSslErrors(const QList<QSslError> &errors)
 443 {
 444     Q_D(QWebSocket);
 445     d->ignoreSslErrors(errors);
 446 }
 447
 448 /*!
 449     Sets the socket's SSL configuration to be the contents of \a sslConfiguration.
 450
 451     This function sets the local certificate, the ciphers, the private key and
 452     the CA certificates to those stored in \a sslConfiguration.
 453     It is not possible to set the SSL-state related fields.
 454     \sa sslConfiguration()
 455  */
 456 void QWebSocket::setSslConfiguration(const QSslConfiguration &sslConfiguration)
 457 {
 458     Q_D(QWebSocket);
 459     d->setSslConfiguration(sslConfiguration);
 460 }
 461
 462 /*!
 463     Returns the socket's SSL configuration state.
 464     The default SSL configuration of a socket is to use the default ciphers,
 465     default CA certificates, no local private key or certificate.
 466     The SSL configuration also contains fields that can change with time without notice.
 467
 468     \sa setSslConfiguration()
 469  */
 470 QSslConfiguration QWebSocket::sslConfiguration() const
 471 {
 472     Q_D(const QWebSocket);
 473     return d->sslConfiguration();
 474 }
 475
 476 #endif  //not QT_NO_SSL
 477
 478 /*!
 479     \brief Returns the version the socket is currently using
 480  */
 481 QWebSocketProtocol::Version QWebSocket::version() const
 482 {
 483     Q_D(const QWebSocket);
 484     return d->version();
 485 }
 486
 487 /*!
 488     \brief Returns the name of the resource currently accessed.
 489  */
 490 QString QWebSocket::resourceName() const
 491 {
 492     Q_D(const QWebSocket);
 493     return d->resourceName();
 494 }
 495
 496 /*!
 497     \brief Returns the url the socket is connected to or will connect to.
 498  */
 499 QUrl QWebSocket::requestUrl() const
 500 {
 501     Q_D(const QWebSocket);
 502     return d->requestUrl();
 503 }
 504
 505 /*!
 506     \brief Returns the current origin
 507  */
 508 QString QWebSocket::origin() const
 509 {
 510     Q_D(const QWebSocket);
 511     return d->origin();
 512 }
 513
 514 /*!
 515     \brief Returns the code indicating why the socket was closed.
 516     \sa QWebSocketProtocol::CloseCode, closeReason()
 517  */
 518 QWebSocketProtocol::CloseCode QWebSocket::closeCode() const
 519 {
 520     Q_D(const QWebSocket);
 521     return d->closeCode();
 522 }
 523
 524 /*!
 525     \brief Returns the reason why the socket was closed.
 526     \sa closeCode()
 527  */
 528 QString QWebSocket::closeReason() const
 529 {
 530     Q_D(const QWebSocket);
 531     return d->closeReason();
 532 }
 533
 534 /*!
 535     \brief Returns the current state of the socket
 536  */
 537 QAbstractSocket::SocketState QWebSocket::state() const
 538 {
 539     Q_D(const QWebSocket);
 540     return d->state();
 541 }
 542
 543 /*!
 544     Returns the local address
 545  */
 546 QHostAddress QWebSocket::localAddress() const
 547 {
 548     Q_D(const QWebSocket);
 549     return d->localAddress();
 550 }
 551
 552 /*!
 553     Returns the local port
 554  */
 555 quint16 QWebSocket::localPort() const
 556 {
 557     Q_D(const QWebSocket);
 558     return d->localPort();
 559 }
 560
 561 /*!
 562     Returns the pause mode of this socket
 563  */
 564 QAbstractSocket::PauseModes QWebSocket::pauseMode() const
 565 {
 566     Q_D(const QWebSocket);
 567     return d->pauseMode();
 568 }
 569
 570 /*!
 571     Returns the peer address
 572  */
 573 QHostAddress QWebSocket::peerAddress() const
 574 {
 575     Q_D(const QWebSocket);
 576     return d->peerAddress();
 577 }
 578
 579 /*!
 580     Returns the peerName
 581  */
 582 QString QWebSocket::peerName() const
 583 {
 584     Q_D(const QWebSocket);
 585     return d->peerName();
 586 }
 587
 588 /*!
 589     Returns the peerport
 590  */
 591 quint16 QWebSocket::peerPort() const
 592 {
 593     Q_D(const QWebSocket);
 594     return d->peerPort();
 595 }
 596
 597 #ifndef QT_NO_NETWORKPROXY
 598 /*!
 599     Returns the currently configured proxy
 600  */
 601 QNetworkProxy QWebSocket::proxy() const
 602 {
 603     Q_D(const QWebSocket);
 604     return d->proxy();
 605 }
 606
 607 /*!
 608     Sets the proxy to \a networkProxy
 609  */
 610 void QWebSocket::setProxy(const QNetworkProxy &networkProxy)
 611 {
 612     Q_D(QWebSocket);
 613     d->setProxy(networkProxy);
 614 }
 615 #endif
 616
 617 /*!
 618     Returns the size in bytes of the readbuffer that is used by the socket.
 619  */
 620 qint64 QWebSocket::readBufferSize() const
 621 {
 622     Q_D(const QWebSocket);
 623     return d->readBufferSize();
 624 }
 625
 626 /*!
 627     Continues data transfer on the socket. This method should only be used after the socket
 628     has been set to pause upon notifications and a notification has been received.
 629     The only notification currently supported is sslErrors().
 630     Calling this method if the socket is not paused results in undefined behavior.
 631
 632     \sa pauseMode(), setPauseMode()
 633  */
 634 void QWebSocket::resume()
 635 {
 636     Q_D(QWebSocket);
 637     d->resume();
 638 }
 639
 640 /*!
 641     Controls whether to pause upon receiving a notification. The \a pauseMode parameter specifies
 642     the conditions in which the socket should be paused.
 643
 644     The only notification currently supported is sslErrors().
 645     If set to PauseOnSslErrors, data transfer on the socket will be paused
 646     and needs to be enabled explicitly again by calling resume().
 647     By default, this option is set to PauseNever. This option must be called
 648     before connecting to the server, otherwise it will result in undefined behavior.
 649
 650     \sa pauseMode(), resume()
 651  */
 652 void QWebSocket::setPauseMode(QAbstractSocket::PauseModes pauseMode)
 653 {
 654     Q_D(QWebSocket);
 655     d->setPauseMode(pauseMode);
 656 }
 657
 658 /*!
 659     Sets the size of QWebSocket's internal read buffer to be \a size bytes.
 660
 661     If the buffer size is limited to a certain size, QWebSocket won't buffer more than
 662     this size of data.
 663     Exceptionally, a buffer size of 0 means that the read buffer is unlimited and
 664     all incoming data is buffered. This is the default.
 665     This option is useful if you only read the data at certain points in time
 666     (e.g., in a real-time streaming application) or if you want to protect your socket against
 667     receiving too much data, which may eventually cause your application to run out of memory.
 668
 669     \sa readBufferSize()
 670 */
 671 void QWebSocket::setReadBufferSize(qint64 size)
 672 {
 673     Q_D(QWebSocket);
 674     d->setReadBufferSize(size);
 675 }
 676
 677 /*!
 678     Returns \c true if the socket is ready for reading and writing; otherwise
 679     returns \c false.
 680  */
 681 bool QWebSocket::isValid() const
 682 {
 683     Q_D(const QWebSocket);
 684     return d->isValid();
 685 }
 686
 687 QT_END_NAMESPACE