src/qwebsocket_p.h

   1 /**
   2  * @file websocket.h
   3  * @brief Defines the WebSocket class.
   4  *
   5  * \note Currently, only V13 (RFC6455) is supported.
   6  * \note Both text and binary websockets are supported.
   7  * \note The secure version (wss) is currently not implemented.
   8  * @author Kurt Pattyn (pattyn.kurt@gmail.com)
   9  */
  10
  11 #ifndef QWEBSOCKET_P_H
  12 #define QWEBSOCKET_P_H
  13 //
  14 //  W A R N I N G
  15 //  -------------
  16 //
  17 // This file is not part of the Qt API.  It exists purely as an
  18 // implementation detail.  This header file may change from version to
  19 // version without notice, or even be removed.
  20 //
  21 // We mean it.
  22 //
  23
  24 #include <QUrl>
  25 #include <QAbstractSocket>
  26 #include <QHostAddress>
  27 #ifndef QT_NO_NETWORKPROXY
  28 #include <QNetworkProxy>
  29 #endif
  30 #include <QTime>
  31 #include "qwebsocketsglobal.h"
  32 #include "qwebsocketprotocol.h"
  33 #include "dataprocessor_p.h"
  34
  35 QT_BEGIN_NAMESPACE
  36
  37 class HandshakeRequest;
  38 class HandshakeResponse;
  39 class QTcpSocket;
  40 class QWebSocket;
  41
  42 class QWebSocketPrivate:public QObject
  43 {
  44         Q_OBJECT
  45
  46 public:
  47         explicit QWebSocketPrivate(QString origin,
  48                                                            QWebSocketProtocol::Version version,
  49                                                            QWebSocket * const pWebSocket,
  50                                                            QObject *parent = 0);
  51         virtual ~QWebSocketPrivate();
  52
  53         void abort();
  54         QAbstractSocket::SocketError error() const;
  55         QString errorString() const;
  56         bool flush();
  57         bool isValid();
  58         QHostAddress localAddress() const;
  59         quint16 localPort() const;
  60         QHostAddress peerAddress() const;
  61         QString peerName() const;
  62         quint16 peerPort() const;
  63 #ifndef QT_NO_NETWORKPROXY
  64         QNetworkProxy proxy() const;
  65         void setProxy(const QNetworkProxy &networkProxy);
  66 #endif
  67         qint64 readBufferSize() const;
  68         void setReadBufferSize(qint64 size);
  69         void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value);
  70         QVariant socketOption(QAbstractSocket::SocketOption option);
  71         QAbstractSocket::SocketState state() const;
  72
  73         bool waitForConnected(int msecs = 30000);
  74         bool waitForDisconnected(int msecs = 30000);
  75
  76         QWebSocketProtocol::Version version();
  77         QString resourceName();
  78         QUrl requestUrl();
  79         QString origin();
  80         QString protocol();
  81         QString extension();
  82
  83         qint64 write(const char *message);              //send data as text
  84         qint64 write(const char *message, qint64 maxSize);              //send data as text
  85         qint64 write(const QString &message);   //send data as text
  86         qint64 write(const QByteArray &data);   //send data as binary
  87
  88 public Q_SLOTS:
  89         virtual void close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CC_NORMAL, QString reason = QString());
  90         virtual void open(const QUrl &url, bool mask = true);
  91         void ping();
  92
  93 Q_SIGNALS:
  94         void aboutToClose();
  95         void connected();
  96         void disconnected();
  97         void stateChanged(QAbstractSocket::SocketState state);
  98         void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *pAuthenticator);
  99         void readChannelFinished();
 100         void textFrameReceived(QString frame, bool isLastFrame);
 101         void binaryFrameReceived(QByteArray frame, bool isLastFrame);
 102         void textMessageReceived(QString message);
 103         void binaryMessageReceived(QByteArray message);
 104         void error(QAbstractSocket::SocketError error);
 105         void pong(quint64 elapsedTime);
 106
 107 private Q_SLOTS:
 108         void processData();
 109         void processControlFrame(QWebSocketProtocol::OpCode opCode, QByteArray frame);
 110         void processHandshake(QTcpSocket *pSocket);
 111         void processStateChanged(QAbstractSocket::SocketState socketState);
 112
 113 private:
 114         Q_DISABLE_COPY(QWebSocketPrivate)
 115
 116         QWebSocket * const q_ptr;
 117
 118         QWebSocketPrivate(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version, QWebSocket *pWebSocket, QObject *parent = 0);
 119         void setVersion(QWebSocketProtocol::Version version);
 120         void setResourceName(QString resourceName);
 121         void setRequestUrl(QUrl requestUrl);
 122         void setOrigin(QString origin);
 123         void setProtocol(QString protocol);
 124         void setExtension(QString extension);
 125         void enableMasking(bool enable);
 126         void setSocketState(QAbstractSocket::SocketState state);
 127         void setErrorString(QString errorString);
 128
 129         qint64 doWriteData(const QByteArray &data, bool isBinary);
 130         qint64 doWriteFrames(const QByteArray &data, bool isBinary);
 131
 132         void makeConnections(const QTcpSocket *pTcpSocket);
 133         void releaseConnections(const QTcpSocket *pTcpSocket);
 134
 135         QByteArray getFrameHeader(QWebSocketProtocol::OpCode opCode, quint64 payloadLength, quint32 maskingKey, bool lastFrame) const;
 136         QString calculateAcceptKey(const QString &key) const;
 137         QString createHandShakeRequest(QString resourceName,
 138                                                                    QString host,
 139                                                                    QString origin,
 140                                                                    QString extensions,
 141                                                                    QString protocols,
 142                                                                    QByteArray key);
 143
 144         static QWebSocket *upgradeFrom(QTcpSocket *tcpSocket,
 145                                                                    const HandshakeRequest &request,
 146                                                                    const HandshakeResponse &response,
 147                                                                    QObject *parent = 0);
 148
 149         quint32 generateMaskingKey() const;
 150         QByteArray generateKey() const;
 151         quint32 generateRandomNumber() const;
 152         qint64 writeFrames(const QList<QByteArray> &frames);
 153         qint64 writeFrame(const QByteArray &frame);
 154
 155         QTcpSocket *m_pSocket;
 156         QString m_errorString;
 157         QWebSocketProtocol::Version m_version;
 158         QUrl m_resource;
 159         QString m_resourceName;
 160         QUrl m_requestUrl;
 161         QString m_origin;
 162         QString m_protocol;
 163         QString m_extension;
 164         QAbstractSocket::SocketState m_socketState;
 165
 166         QByteArray m_key;       //identification key used in handshake requests
 167
 168         bool m_mustMask;        //a server must not mask the frames it sends
 169
 170         bool m_isClosingHandshakeSent;
 171         bool m_isClosingHandshakeReceived;
 172
 173         QTime m_pingTimer;
 174
 175         DataProcessor m_dataProcessor;
 176
 177
 178         friend class QWebSocketServerPrivate;
 179         friend class QWebSocket;
 180 };
 181
 182 QT_END_NAMESPACE
 183
 184 #endif // QWEBSOCKET_H