- Qt 6.10
- Qt WebSockets
- C++ Classes
- QWebSocket
- Qt 6.10.0 Reference Documentation

# QWebSocket Class

Implements a TCP socket that talks the WebSocket protocol. More...

Header: | `#include <QWebSocket>`
CMake: | `find_package(Qt6 REQUIRED COMPONENTS WebSockets)` `target_link_libraries(mytarget PRIVATE Qt6::WebSockets)`
qmake: | `QT += websockets`
Inherits: | QObject

- List of all members, including inherited members
- Deprecated members

## Public Functions

| QWebSocket(const QString &origin = QString(), QWebSocketProtocol::Version version = QWebSocketProtocol::VersionLatest, QObject *parent = nullptr)
virtual | ~QWebSocket() override
void | abort()
qint64 | bytesToWrite() const
QWebSocketProtocol::CloseCode | closeCode() const
QString | closeReason() const
`(since 6.2)` void | continueInterruptedHandshake()
QAbstractSocket::SocketError | error() const
QString | errorString() const
bool | flush()
`(since 6.4)` QWebSocketHandshakeOptions | handshakeOptions() const
void | ignoreSslErrors(const QList<QSslError> &errors)
bool | isValid() const
QHostAddress | localAddress() const
quint16 | localPort() const
const QMaskGenerator * | maskGenerator() const
quint64 | maxAllowedIncomingFrameSize() const
quint64 | maxAllowedIncomingMessageSize() const
QString | origin() const
quint64 | outgoingFrameSize() const
QAbstractSocket::PauseModes | pauseMode() const
QHostAddress | peerAddress() const
QString | peerName() const
quint16 | peerPort() const
QNetworkProxy | proxy() const
qint64 | readBufferSize() const
QNetworkRequest | request() const
QUrl | requestUrl() const
QString | resourceName() const
void | resume()
qint64 | sendBinaryMessage(const QByteArray &data)
qint64 | sendTextMessage(const QString &message)
void | setMaskGenerator(const QMaskGenerator *maskGenerator)
void | setMaxAllowedIncomingFrameSize(quint64 maxAllowedIncomingFrameSize)
void | setMaxAllowedIncomingMessageSize(quint64 maxAllowedIncomingMessageSize)
void | setOutgoingFrameSize(quint64 outgoingFrameSize)
void | setPauseMode(QAbstractSocket::PauseModes pauseMode)
void | setProxy(const QNetworkProxy &networkProxy)
void | setReadBufferSize(qint64 size)
void | setSslConfiguration(const QSslConfiguration &sslConfiguration)
QSslConfiguration | sslConfiguration() const
QAbstractSocket::SocketState | state() const
`(since 6.4)` QString | subprotocol() const
QWebSocketProtocol::Version | version() const

## Public Slots

void | close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CloseCodeNormal, const QString &reason = QString())
void | ignoreSslErrors()
void | open(const QNetworkRequest &request)
void | open(const QUrl &url)
`(since 6.4)` void | open(const QNetworkRequest &request, const QWebSocketHandshakeOptions &options)
`(since 6.4)` void | open(const QUrl &url, const QWebSocketHandshakeOptions &options)
void | ping(const QByteArray &payload = QByteArray())

## Signals

void | aboutToClose()
`(since 6.2)` void | alertReceived(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)
`(since 6.2)` void | alertSent(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)
`(since 6.6)` void | authenticationRequired(QAuthenticator *authenticator)
void | binaryFrameReceived(const QByteArray &frame, bool isLastFrame)
void | binaryMessageReceived(const QByteArray &message)
void | bytesWritten(qint64 bytes)
void | connected()
void | disconnected()
`(since 6.5)` void | errorOccurred(QAbstractSocket::SocketError error)
`(since 6.2)` void | handshakeInterruptedOnError(const QSslError &error)
`(since 6.2)` void | peerVerifyError(const QSslError &error)
void | pong(quint64 elapsedTime, const QByteArray &payload)
void | preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator)
void | proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)
void | readChannelFinished()
void | sslErrors(const QList<QSslError> &errors)
void | stateChanged(QAbstractSocket::SocketState state)
void | textFrameReceived(const QString &frame, bool isLastFrame)
void | textMessageReceived(const QString &message)

## Static Public Members

quint64 | maxIncomingFrameSize()
quint64 | maxIncomingMessageSize()
quint64 | maxOutgoingFrameSize()

## Detailed Description

WebSockets is a web technology providing full-duplex communications channels over a single TCP connection. The WebSocket protocol was standardized by the IETF as RFC 6455 in 2011. QWebSocket can both be used in a client application and server application.

This class was modeled after QAbstractSocket.

QWebSocket currently does not support WebSocket Extensions.

QWebSocket only supports version 13 of the WebSocket protocol, as outlined in RFC 6455.

Note: Some proxies do not understand certain HTTP headers used during a WebSocket handshake. In that case, non-secure WebSocket connections fail. The best way to mitigate against this problem is to use WebSocket over a secure connection.

Warning: To generate masks, this implementation of WebSockets uses the reasonably secure QRandomGenerator::global()->generate() function. For more information about the importance of good masking, see "Talking to Yourself for Fun and Profit" by Lin-Shung Huang et al. The best measure against attacks mentioned in the document above, is to use QWebSocket over a secure connection (wss://). In general, always be careful to not have 3rd party script access to a QWebSocket in your application.

See also QAbstractSocket, QTcpSocket, and QWebSocket client example.

## Member Function Documentation

### `[explicit]` QWebSocket::QWebSocket(const QString &origin = QString(), QWebSocketProtocol::Version version = QWebSocketProtocol::VersionLatest, QObject *parent = nullptr)

Creates a new QWebSocket with the given origin, the version of the protocol to use and parent.

The origin of the client is as specified in RFC 6454. (The origin is not required for non-web browser clients (see RFC 6455)). The origin may not contain new line characters, otherwise the connection will be aborted immediately during the handshake phase.

Note: Currently only V13 (RFC 6455) is supported

### `[override virtual noexcept]` QWebSocket::~QWebSocket()

Destroys the QWebSocket. Closes the socket if it is still open, and releases any used resources.

### void QWebSocket::abort()

Aborts the current socket and resets the socket. Unlike close(), this function immediately closes the socket, discarding any pending data in the write buffer.

### `[signal]` void QWebSocket::aboutToClose()

This signal is emitted when the socket is about to close. Connect this signal if you have operations that need to be performed before the socket closes (e.g., if you have data in a separate buffer that needs to be written to the device).

See also close().

### `[signal, since 6.2]` void QWebSocket::alertReceived(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)

QWebSocket emits this signal if an alert message was received from a peer. level tells if the alert was fatal or it was a warning. type is the code explaining why the alert was sent. When a textual description of the alert message is available, it is supplied in description.

Note: The signal is mostly for informational and debugging purposes and does not require any handling in the application. If the alert was fatal, underlying backend will handle it and close the connection.

Note: Not all backends support this functionality.

This function was introduced in Qt 6.2.

See also alertSent(), QSsl::AlertLevel, and QSsl::AlertType.

### `[signal, since 6.2]` void QWebSocket::alertSent(QSsl::AlertLevel level, QSsl::AlertType type, const QString &description)

QWebSocket emits this signal if an alert message was sent to a peer. level describes if it was a warning or a fatal error. type gives the code of the alert message. When a textual description of the alert message is available, it is supplied in description.

Note: This signal is mostly informational and can be used for debugging purposes, normally it does not require any actions from the application.

Note: Not all backends support this functionality.

This function was introduced in Qt 6.2.

See also alertReceived(), QSsl::AlertLevel, and QSsl::AlertType.

### `[signal, since 6.6]` void QWebSocket::authenticationRequired(QAuthenticator *authenticator)

This signal is emitted when the server requires authentication. The authenticator object must then be filled in with the required details to allow authentication and continue the connection.

If you know that the server may require authentication, you can set the username and password on the initial QUrl, using QUrl::setUserName and QUrl::setPassword. QWebSocket will still try to connect once without using the provided credentials.

Note: It is not possible to use a QueuedConnection to connect to this signal, as the connection will fail if the authenticator has not been filled in with new information when the signal returns.

This function was introduced in Qt 6.6.

See also QAuthenticator.

### `[signal]` void QWebSocket::binaryFrameReceived(const QByteArray &frame, bool isLastFrame)

This signal is emitted whenever a binary frame is received. The frame contains the data and isLastFrame indicates whether this is the last frame of the complete message.

This signal can be used to process large messages frame by frame, instead of waiting for the complete message to arrive.

See also textFrameReceived().

### `[signal]` void QWebSocket::binaryMessageReceived(const QByteArray &message)

This signal is emitted whenever a binary message is received. The message contains the received bytes.

See also textMessageReceived().

### qint64 QWebSocket::bytesToWrite() const

Returns the number of bytes that are waiting to be written. The bytes are written when control goes back to the event loop or when flush() is called.

See also flush.

### `[signal]` void QWebSocket::bytesWritten(qint64 bytes)

This signal is emitted every time a payload of data has been written to the socket. The bytes argument is set to the number of bytes that were written in this payload.

Note: This signal has the same meaning both for secure and non-secure WebSockets. As opposed to QSslSocket, bytesWritten() is only emitted when encrypted data is effectively written (see QSslSocket::encryptedBytesWritten()).

See also close().

### `[slot]` void QWebSocket::close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CloseCodeNormal, const QString &reason = QString())

Gracefully closes the socket with the given closeCode and reason.

Any data in the write buffer is flushed before the socket is closed. The closeCode is a QWebSocketProtocol::CloseCode indicating the reason to close, and reason describes the reason of the closure more in detail. All control frames, including the Close frame, are limited to 125 bytes. Since two of these are used for closeCode the maximum length of reason is 123! If reason exceeds this limit it will be truncated.

### QWebSocketProtocol::CloseCode QWebSocket::closeCode() const

Returns the code indicating why the socket was closed.

See also QWebSocketProtocol::CloseCode and closeReason().

### QString QWebSocket::closeReason() const

Returns the reason why the socket was closed.

See also closeCode().

### `[signal]` void QWebSocket::connected()

Emitted when a connection is successfully established. A connection is successfully established when the socket is connected and the handshake was successful.

See also open() and disconnected().

### `[since 6.2]` void QWebSocket::continueInterruptedHandshake()

If an application wants to conclude a handshake even after receiving handshakeInterruptedOnError() signal, it must call this function. This call must be done from a slot function attached to the signal. The signal-slot connection must be direct.

This function was introduced in Qt 6.2.

See also handshakeInterruptedOnError() and QSslConfiguration::setHandshakeMustInterruptOnError().

### `[signal]` void QWebSocket::disconnected()

Emitted when the socket is disconnected.

See also close() and connected().

### QAbstractSocket::SocketError QWebSocket::error() const

Returns the type of error that last occurred

See also errorString().

### `[signal, since 6.5]` void QWebSocket::errorOccurred(QAbstractSocket::SocketError error)

This signal is emitted after an error occurred.

The error parameter describes the type of error that occurred.

QAbstractSocket::SocketError is not a registered metatype, so for queued connections, you will have to register it with Q_DECLARE_METATYPE() and qRegisterMetaType().

This function was introduced in Qt 6.5.

See also error() and errorString().

### QString QWebSocket::errorString() const

Returns a human-readable description of the last error that occurred

See also error().

### bool QWebSocket::flush()

This function writes as much as possible from the internal write buffer to the underlying network socket, without blocking. If any data was written, this function returns true; otherwise false is returned. Call this function if you need QWebSocket to start sending buffered data immediately. The number of bytes successfully written depends on the operating system. In most cases, you do not need to call this function, because QWebSocket will start sending data automatically once control goes back to the event loop.

### `[signal, since 6.2]` void QWebSocket::handshakeInterruptedOnError(const QSslError &error)

QWebSocket emits this signal if a certificate verification error was found and if early error reporting was enabled in QSslConfiguration. An application is expected to inspect the error and decide if it wants to continue the handshake, or abort it and send an alert message to the peer. The signal-slot connection must be direct.

This function was introduced in Qt 6.2.

See also continueInterruptedHandshake(), sslErrors(), and QSslConfiguration::setHandshakeMustInterruptOnError().

### `[since 6.4]` QWebSocketHandshakeOptions QWebSocket::handshakeOptions() const

Returns the handshake options that were used to open this socket.

This function was introduced in Qt 6.4.

### `[slot]` void QWebSocket::ignoreSslErrors()

This slot tells QWebSocket to ignore errors during QWebSocket's handshake phase and continue connecting. If you want to continue with the connection even if errors occur during the handshake phase, then you must call this slot, either from a slot connected to sslErrors(), or before the handshake phase. If you don't call this slot, either in response to errors or before the handshake, the connection will be dropped after the sslErrors() signal has been emitted.

Warning: Be sure to always let the user inspect the errors reported by the sslErrors() signal, and only call this method upon confirmation from the user that proceeding is ok. If there are unexpected errors, the connection should be aborted. Calling this method without inspecting the actual errors will most likely pose a security risk for your application. Use it with great care!

Note: This slot is overloaded. To connect to this slot:

     // Connect using qOverload:
     connect(webSocket, qOverload<>(&QWebSocket::ignoreSslErrors),
             receiver, &ReceiverClass::slot);

     // Or using a lambda:
     connect(webSocket, qOverload<>(&QWebSocket::ignoreSslErrors),
             this, []() { /* handle ignoreSslErrors */ });

For more examples and approaches, see connecting to overloaded slots.

See also sslErrors(), QSslSocket::ignoreSslErrors(), and QNetworkReply::ignoreSslErrors().

### void QWebSocket::ignoreSslErrors(const QList<QSslError> &errors)

This method tells QWebSocket to ignore the errors given in errors.

Note that you can set the expected certificate in the SSL error: If, for instance, you want to connect to a server that uses a self-signed certificate, consider the following snippet:

     QList<QSslCertificate> cert = QSslCertificate::fromPath(QLatin1String("server-certificate.pem"));
     QSslError error(QSslError::SelfSignedCertificate, cert.at(0));
     QList<QSslError> expectedSslErrors;
     expectedSslErrors.append(error);

     QWebSocket socket;
     socket.ignoreSslErrors(expectedSslErrors);
     socket.open(QUrl(QStringLiteral("wss://myserver.at.home")));

Multiple calls to this function will replace the list of errors that were passed in previous calls. You can clear the list of errors you want to ignore by calling this function with an empty list.

This is an overloaded function.

See also sslErrors().

### bool QWebSocket::isValid() const

Returns `true` if the socket is ready for reading and writing; otherwise returns `false`.

### QHostAddress QWebSocket::localAddress() const

Returns the local address

### quint16 QWebSocket::localPort() const

Returns the local port

### const QMaskGenerator *QWebSocket::maskGenerator() const

Returns the mask generator that is currently used by this QWebSocket.

See also setMaskGenerator().

### quint64 QWebSocket::maxAllowedIncomingFrameSize() const

Returns the maximum allowed size of an incoming websocket frame.

See also setMaxAllowedIncomingFrameSize().

### quint64 QWebSocket::maxAllowedIncomingMessageSize() const

Returns the maximum allowed size of an incoming websocket message.

See also setMaxAllowedIncomingMessageSize().

### `[static]` quint64 QWebSocket::maxIncomingFrameSize()

Returns the maximum supported size of an incoming websocket frame for this websocket implementation.

### `[static]` quint64 QWebSocket::maxIncomingMessageSize()

Returns the maximum supported size of an incoming websocket message for this websocket implementation.

### `[static]` quint64 QWebSocket::maxOutgoingFrameSize()

Returns the maximum supported size of an outgoing websocket frame for this websocket implementation.

### `[slot]` void QWebSocket::open(const QNetworkRequest &request)

Opens a WebSocket connection using the given request.

The request url will be used to open the WebSocket connection. Headers present in the request will be sent to the server in the upgrade request, together with the ones needed for the websocket handshake.

Note: This slot is overloaded. To connect to this slot:

     // Connect using qOverload:
     connect(webSocket, qOverload(&QWebSocket::open),
             receiver, &ReceiverClass::slot);

     // Or using a lambda:
     connect(webSocket, qOverload(&QWebSocket::open),
             this, [](const QNetworkRequest &request) { /* handle open */ });

For more examples and approaches, see connecting to overloaded slots.

### `[slot]` void QWebSocket::open(const QUrl &url)

Opens a WebSocket connection using the given url.

If the url contains newline characters (\r\n), then the error signal will be emitted with QAbstractSocket::ConnectionRefusedError as error type.

Note: This slot is overloaded. To connect to this slot:

     // Connect using qOverload:
     connect(webSocket, qOverload(&QWebSocket::open),
             receiver, &ReceiverClass::slot);

     // Or using a lambda:
     connect(webSocket, qOverload(&QWebSocket::open),
             this, [](const QUrl &url) { /* handle open */ });

For more examples and approaches, see connecting to overloaded slots.

### `[slot, since 6.4]` void QWebSocket::open(const QNetworkRequest &request, const QWebSocketHandshakeOptions &options)

Opens a WebSocket connection using the given request and options.

The request url will be used to open the WebSocket connection. Headers present in the request will be sent to the server in the upgrade request, together with the ones needed for the websocket handshake.

Additional options for the WebSocket handshake such as subprotocols can be specified in options.

Note: This slot is overloaded. To connect to this slot:

     // Connect using qOverload:
     connect(webSocket, qOverload(&QWebSocket::open),
             receiver, &ReceiverClass::slot);

     // Or using a lambda:
     connect(webSocket, qOverload(&QWebSocket::open),
             this, [](const QNetworkRequest &request, const QWebSocketHandshakeOptions &options) { /* handle open */ });

For more examples and approaches, see connecting to overloaded slots.

This function was introduced in Qt 6.4.

### `[slot, since 6.4]` void QWebSocket::open(const QUrl &url, const QWebSocketHandshakeOptions &options)

Opens a WebSocket connection using the given url and options.

If the url contains newline characters (\r\n), then the error signal will be emitted with QAbstractSocket::ConnectionRefusedError as error type.

Additional options for the WebSocket handshake such as subprotocols can be specified in options.

Note: This slot is overloaded. To connect to this slot:

     // Connect using qOverload:
     connect(webSocket, qOverload(&QWebSocket::open),
             receiver, &ReceiverClass::slot);

     // Or using a lambda:
     connect(webSocket, qOverload(&QWebSocket::open),
             this, [](const QUrl &url, const QWebSocketHandshakeOptions &options) { /* handle open */ });

For more examples and approaches, see connecting to overloaded slots.

This function was introduced in Qt 6.4.

### QString QWebSocket::origin() const

Returns the current origin.

### quint64 QWebSocket::outgoingFrameSize() const

Returns the maximum size of an outgoing websocket frame.

See also setOutgoingFrameSize().

### QAbstractSocket::PauseModes QWebSocket::pauseMode() const

Returns the pause mode of this socket

See also setPauseMode().

### QHostAddress QWebSocket::peerAddress() const

Returns the peer address

### QString QWebSocket::peerName() const

Returns the peerName

### quint16 QWebSocket::peerPort() const

Returns the peerport

### `[signal, since 6.2]` void QWebSocket::peerVerifyError(const QSslError &error)

QWebSocket can emit this signal several times during the SSL handshake, before encryption has been established, to indicate that an error has occurred while establishing the identity of the peer. The error is usually an indication that QWebSocket is unable to securely identify the peer.

This signal provides you with an early indication when something's wrong. By connecting to this signal, you can manually choose to tear down the connection from inside the connected slot before the handshake has completed. If no action is taken, QWebSocket will proceed to emitting QWebSocket::sslErrors().

This function was introduced in Qt 6.2.

See also sslErrors().

### `[slot]` void QWebSocket::ping(const QByteArray &payload = QByteArray())

Pings the server to indicate that the connection is still alive. An additional payload can be sent along with the ping message.

The size of the payload cannot be bigger than 125 bytes. If it is larger, the payload is clipped to 125 bytes.

Note: QWebSocket and QWebSocketServer handles ping requests internally, which means they automatically send back a pong response to the peer.

See also pong().

### `[signal]` void QWebSocket::pong(quint64 elapsedTime, const QByteArray &payload)

Emitted when a pong message is received in reply to a previous ping. elapsedTime contains the roundtrip time in milliseconds and payload contains an optional payload that was sent with the ping.

See also ping().

### `[signal]` void QWebSocket::preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator)

This signal is emitted if the SSL/TLS handshake negotiates a PSK ciphersuite, and therefore a PSK authentication is then required.

When using PSK, the client must send to the server a valid identity and a valid pre shared key, in order for the SSL handshake to continue. Applications can provide this information in a slot connected to this signal, by filling in the passed authenticator object according to their needs.

Note: Ignoring this signal, or failing to provide the required credentials, will cause the handshake to fail, and therefore the connection to be aborted.

Note: The authenticator object is owned by the websocket and must not be deleted by the application.

See also QSslPreSharedKeyAuthenticator and QSslSocket::preSharedKeyAuthenticationRequired().

### QNetworkProxy QWebSocket::proxy() const

Returns the currently configured proxy

See also setProxy().

### `[signal]` void QWebSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)

This signal can be emitted when a proxy that requires authentication is used. The authenticator object can then be filled in with the required details to allow authentication and continue the connection.

Note: It is not possible to use a QueuedConnection to connect to this signal, as the connection will fail if the authenticator has not been filled in with new information when the signal returns.

See also QAuthenticator and QNetworkProxy.

### qint64 QWebSocket::readBufferSize() const

Returns the size in bytes of the readbuffer that is used by the socket.

See also setReadBufferSize().

### `[signal]` void QWebSocket::readChannelFinished()

This signal is emitted when the input (reading) stream is closed in this device. It is emitted as soon as the closing is detected.

See also close().

### QNetworkRequest QWebSocket::request() const

Returns the request that was or will be used to open this socket.

### QUrl QWebSocket::requestUrl() const

Returns the url the socket is connected to or will connect to.

### QString QWebSocket::resourceName() const

Returns the name of the resource currently accessed.

### void QWebSocket::resume()

Continues data transfer on the socket. This method should only be used after the socket has been set to pause upon notifications and a notification has been received. The only notification currently supported is sslErrors(). Calling this method if the socket is not paused results in undefined behavior.

See also pauseMode() and setPauseMode().

### qint64 QWebSocket::sendBinaryMessage(const QByteArray &data)

Sends the given data over the socket as a binary message and returns the number of bytes actually sent.

See also sendTextMessage().

### qint64 QWebSocket::sendTextMessage(const QString &message)

Sends the given message over the socket as a text message and returns the number of bytes actually sent.

See also sendBinaryMessage().

### void QWebSocket::setMaskGenerator(const QMaskGenerator *maskGenerator)

Sets the generator to use for creating masks to maskGenerator. The default QWebSocket generator can be reset by supplying a nullptr. The mask generator can be changed at any time, even while the connection is open.

See also maskGenerator().

### void QWebSocket::setMaxAllowedIncomingFrameSize(quint64 maxAllowedIncomingFrameSize)

Sets the maximum allowed size of an incoming websocket frame to maxAllowedIncomingFrameSize. If an incoming frame exceeds this limit, the peer gets disconnected. The accepted range is between 0 and maxIncomingFrameSize(), default is maxIncomingFrameSize(). The purpose of this function is to avoid exhausting virtual memory.

See also maxAllowedIncomingFrameSize().

### void QWebSocket::setMaxAllowedIncomingMessageSize(quint64 maxAllowedIncomingMessageSize)

Sets the maximum allowed size of an incoming websocket message to maxAllowedIncomingMessageSize. If an incoming message exceeds this limit, the peer gets disconnected. The accepted range is between 0 and maxIncomingMessageSize(), default is maxIncomingMessageSize(). The purpose of this function is to avoid exhausting virtual memory.

See also maxAllowedIncomingMessageSize().

### void QWebSocket::setOutgoingFrameSize(quint64 outgoingFrameSize)

Sets the maximum size of an outgoing websocket frame to outgoingFrameSize. The accepted range is between 0 and maxOutgoingFrameSize(), default is 512kB. The purpose of this function is to adapt to the maximum allowed frame size of the receiver.

See also outgoingFrameSize().

### void QWebSocket::setPauseMode(QAbstractSocket::PauseModes pauseMode)

Controls whether to pause upon receiving a notification. The pauseMode parameter specifies the conditions in which the socket should be paused.

The only notification currently supported is sslErrors(). If set to PauseOnSslErrors, data transfer on the socket will be paused and needs to be enabled explicitly again by calling resume(). By default, this option is set to PauseNever. This option must be called before connecting to the server, otherwise it will result in undefined behavior.

See also pauseMode() and resume().

### void QWebSocket::setProxy(const QNetworkProxy &networkProxy)

Sets the proxy to networkProxy

See also proxy().

### void QWebSocket::setReadBufferSize(qint64 size)

Sets the size of QWebSocket's internal read buffer to be size bytes.

If the buffer size is limited to a certain size, QWebSocket won't buffer more than this size of data. Exceptionally, a buffer size of 0 means that the read buffer is unlimited and all incoming data is buffered. This is the default. This option is useful if you only read the data at certain points in time (for example, in a real-time streaming application) or if you want to protect your socket against receiving too much data, which may eventually cause your application to run out of memory.

See also readBufferSize().

### void QWebSocket::setSslConfiguration(const QSslConfiguration &sslConfiguration)

Sets the socket's SSL configuration to be the contents of sslConfiguration.

This function sets the local certificate, the ciphers, the private key and the CA certificates to those stored in sslConfiguration. It is not possible to set the SSL-state related fields.

See also sslConfiguration().

### QSslConfiguration QWebSocket::sslConfiguration() const

Returns the socket's SSL configuration state. The default SSL configuration of a socket is to use the default ciphers, default CA certificates, no local private key or certificate. The SSL configuration also contains fields that can change with time without notice.

See also setSslConfiguration().

### `[signal]` void QWebSocket::sslErrors(const QList<QSslError> &errors)

QWebSocket emits this signal after the SSL handshake to indicate that one or more errors have occurred while establishing the identity of the peer. The errors are usually an indication that QWebSocket is unable to securely identify the peer. Unless any action is taken, the connection will be dropped after this signal has been emitted. If you want to continue connecting despite the errors that have occurred, you must call QWebSocket::ignoreSslErrors() from inside a slot connected to this signal. If you need to access the error list at a later point, you can call sslErrors() (without arguments).

errors contains one or more errors that prevent QWebSocket from verifying the identity of the peer.

Note: You cannot use Qt::QueuedConnection when connecting to this signal, or calling QWebSocket::ignoreSslErrors() will have no effect.

### QAbstractSocket::SocketState QWebSocket::state() const

Returns the current state of the socket.

### `[signal]` void QWebSocket::stateChanged(QAbstractSocket::SocketState state)

This signal is emitted whenever QWebSocket's state changes. The state parameter is the new state.

Note: QAbstractSocket::ConnectedState is emitted after the handshake with the server has succeeded.

QAbstractSocket::SocketState is not a registered metatype, so for queued connections, you will have to register it with Q_REGISTER_METATYPE() and qRegisterMetaType().

See also state().

### `[since 6.4]` QString QWebSocket::subprotocol() const

Returns the used WebSocket protocol.

This function was introduced in Qt 6.4.

### `[signal]` void QWebSocket::textFrameReceived(const QString &frame, bool isLastFrame)

This signal is emitted whenever a text frame is received. The frame contains the data and isLastFrame indicates whether this is the last frame of the complete message.

This signal can be used to process large messages frame by frame, instead of waiting for the complete message to arrive.

See also binaryFrameReceived().

### `[signal]` void QWebSocket::textMessageReceived(const QString &message)

This signal is emitted whenever a text message is received. The message contains the received text.

See also binaryMessageReceived().

### QWebSocketProtocol::Version QWebSocket::version() const

Returns the version the socket is currently using.