En esta página

QWebSocket Class

Implementa un socket TCP que utiliza el protocolo WebSocket. Más información...

Encabezado: #include <QWebSocket>
CMake: find_package(Qt6 REQUIRED COMPONENTS WebSockets)
target_link_libraries(mytarget PRIVATE Qt6::WebSockets)
qmake: QT += websockets
Heredado de: QObject

Funciones públicas

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

Ranuras públicas

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())

Señales

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)

Miembros públicos estáticos

Descripción detallada

WebSockets es una tecnología web que proporciona canales de comunicación full-duplex a través de una única conexión TCP. El protocolo WebSocket fue estandarizado por la IETF como RFC 6455 en 2011. QWebSocket puede utilizarse tanto en una aplicación cliente como en una aplicación servidor.

Esta clase se ha diseñado siguiendo el modelo de QAbstractSocket.

Actualmente, QWebSocket no admite extensiones de WebSocket.

QWebSocket solo es compatible con la versión 13 del protocolo WebSocket, tal y como se describe en el RFC 6455.

Nota: Algunos proxies no reconocen determinados encabezados HTTP utilizados durante el establecimiento de la conexión WebSocket. En ese caso, las conexiones WebSocket no seguras fallan. La mejor forma de mitigar este problema es utilizar WebSocket a través de una conexión segura.

Advertencia: Para generar máscaras, esta implementación de WebSockets utiliza la función «generate()» de QRandomGenerator::global(), que se considera razonablemente segura. Para obtener más información sobre la importancia de un buen enmascaramiento, consulta «Talking to Yourself for Fun and Profit», de Lin-Shung Huang et al. La mejor medida contra los ataques mencionados en el documento anterior es utilizar QWebSocket a través de una conexión segura (wss://). En general, hay que tener siempre cuidado de que ningún script de terceros tenga acceso a un QWebSocket en tu aplicación.

Véase también QAbstractSocket, QTcpSocket y el ejemplo de cliente de QWebSocket.

Documentación de las funciones de miembro

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

Crea un nuevo QWebSocket con el ` origin` indicado, el ` version ` del protocolo que se va a utilizar y el ` parent`.

El origin del cliente es el especificado en el RFC 6454. (El origin no es obligatorio para los clientes que no sean navegadores web (véase el RFC 6455)). El origin no puede contener caracteres de nueva línea; de lo contrario, la conexión se interrumpirá inmediatamente durante la fase de establecimiento de la conexión.

Nota: Actualmente solo se admite la versión V13 (RFC 6455).

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

Elimina el objeto ` QWebSocket`. Cierra el socket si aún está abierto y libera los recursos utilizados.

void QWebSocket::abort()

Cancela la operación actual del socket y lo restablece. A diferencia de ` close()`, esta función cierra inmediatamente el socket, descartando cualquier dato pendiente en el búfer de escritura.

[signal] void QWebSocket::aboutToClose()

Esta señal se emite cuando el socket está a punto de cerrarse. Conecta esta señal si tienes operaciones que deban realizarse antes de que se cierre el socket (por ejemplo, si tienes datos en un búfer independiente que deban escribirse en el dispositivo).

Véase también close().

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

QWebSocket Emite esta señal si se ha recibido un mensaje de alerta de un par. « level » indica si la alerta fue grave o si se trataba de una advertencia. « type » es el código que explica por qué se envió la alerta. Cuando hay disponible una descripción textual del mensaje de alerta, se proporciona en « description ».

Nota: La señal tiene principalmente fines informativos y de depuración, y no requiere ningún tipo de gestión por parte de la aplicación. Si la alerta fue grave, el backend subyacente se encargará de gestionarla y cerrará la conexión.

Nota: No todos los backends admiten esta funcionalidad.

Esta función se introdujo en Qt 6.2.

Véase también alertSent(), QSsl::AlertLevel y QSsl::AlertType.

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

QWebSocket Emite esta señal si se ha enviado un mensaje de alerta a un par. level indica si se trata de una advertencia o de un error grave. type proporciona el código del mensaje de alerta. Cuando hay disponible una descripción textual del mensaje de alerta, esta se incluye en description.

Nota: Esta señal tiene un carácter principalmente informativo y puede utilizarse con fines de depuración; normalmente no requiere ninguna acción por parte de la aplicación.

Nota: No todos los backends admiten esta funcionalidad.

Esta función se introdujo en Qt 6.2.

Véase también alertReceived(), QSsl::AlertLevel y QSsl::AlertType.

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

Esta señal se emite cuando el servidor requiere autenticación. A continuación, hay que rellenar el objeto ` authenticator ` con los datos necesarios para permitir la autenticación y continuar con la conexión.

Si sabes que el servidor puede requerir autenticación, puedes establecer el nombre de usuario y la contraseña en el objeto ` QUrl` inicial, utilizando ` QUrl::setUserName ` y ` QUrl::setPassword`. ` QWebSocket ` seguirá intentando conectarse una vez sin utilizar las credenciales proporcionadas.

Nota: Noes posible utilizar una `QueuedConnection` para conectarse a esta señal, ya que la conexión fallará si no se ha rellenado el autenticador con información nueva cuando la señal devuelva un resultado.

Esta función se introdujo en Qt 6.6.

Véase también QAuthenticator.

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

Esta señal se emite cada vez que se recibe una trama binaria. El « frame » contiene los datos y el « isLastFrame » indica si se trata de la última trama del mensaje completo.

Esta señal se puede utilizar para procesar mensajes grandes trama por trama, en lugar de esperar a que llegue el mensaje completo.

Véase también textFrameReceived().

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

Esta señal se emite cada vez que se recibe un mensaje binario. El campo « message » contiene los bytes recibidos.

Véase también textMessageReceived().

qint64 QWebSocket::bytesToWrite() const

Devuelve el número de bytes que están a la espera de ser escritos. Los bytes se escriben cuando el control vuelve al bucle de eventos o cuando se llama a flush().

Véase también ` flush`.

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

Esta señal se emite cada vez que se ha escrito una carga útil de datos en el socket. El argumento ` bytes ` se establece en el número de bytes que se han escrito en esta carga útil.

Nota: Esta señal tiene el mismo significado tanto para WebSockets seguros como para los no seguros. A diferencia de ` QSslSocket`, `bytesWritten()` solo se emite cuando se escriben efectivamente datos cifrados (véase ` QSslSocket::encryptedBytesWritten()`).

Véase también close().

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

Cierra de forma controlada el socket utilizando los parámetros « closeCode » y « reason » indicados.

Cualquier dato presente en el búfer de escritura se vacía antes de cerrar el socket. El closeCode es un QWebSocketProtocol::CloseCode que indica el motivo del cierre, y reason describe dicho motivo con más detalle. Todas las tramas de control, incluida la trama «Close», tienen un límite de 125 bytes. Dado que dos de ellos se utilizan para « closeCode », la longitud máxima de « reason » es de 123. Si « reason » supera este límite, se truncará.

QWebSocketProtocol::CloseCode QWebSocket::closeCode() const

Devuelve el código que indica el motivo por el que se cerró el socket.

Véase también QWebSocketProtocol::CloseCode y closeReason().

QString QWebSocket::closeReason() const

Devuelve el motivo por el que se cerró el socket.

Véase también closeCode().

[signal] void QWebSocket::connected()

Se emite cuando se establece correctamente una conexión. Una conexión se establece correctamente cuando el socket está conectado y el protocolo de establecimiento de conexión se ha completado con éxito.

Véase también open() y disconnected().

[since 6.2] void QWebSocket::continueInterruptedHandshake()

Si una aplicación desea finalizar un handshake incluso después de recibir una señal d handshakeInterruptedOnError(), debe llamar a esta función. Esta llamada debe realizarse desde una función de slot asociada a la señal. La conexión señal-slot debe ser directa.

Esta función se introdujo en Qt 6.2.

Véanse también ` handshakeInterruptedOnError()` y ` QSslConfiguration::setHandshakeMustInterruptOnError()`.

[signal] void QWebSocket::disconnected()

Se emite cuando se desconecta el socket.

Véase también close() y connected().

QAbstractSocket::SocketError QWebSocket::error() const

Devuelve el tipo de error que se ha producido por última vez

Véase también errorString().

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

Esta señal se emite cuando se produce un error.

El parámetro « error » describe el tipo de error que se ha producido.

QAbstractSocket::SocketError no es un metatipo registrado, por lo que, en el caso de las conexiones en cola, tendrás que registrarlo con Q_DECLARE_METATYPE() y qRegisterMetaType().

Esta función se introdujo en Qt 6.5.

Véase también error() y errorString().

QString QWebSocket::errorString() const

Devuelve una descripción comprensible para el usuario del último error que se ha producido

Véase también ` error()`.

bool QWebSocket::flush()

Esta función escribe todo lo posible desde el búfer de escritura interno al socket de red subyacente, sin bloquearse. Si se han escrito datos, esta función devuelve «true»; en caso contrario, devuelve «false». Llama a esta función si necesitas que QWebSocket comience a enviar los datos almacenados en el búfer de inmediato. El número de bytes escritos con éxito depende del sistema operativo. En la mayoría de los casos, no es necesario llamar a esta función, ya que QWebSocket comenzará a enviar datos automáticamente en cuanto el control vuelva al bucle de eventos.

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

QWebSocket Emite esta señal si se ha detectado un error en la verificación del certificado y si se ha habilitado la notificación temprana de errores en ` QSslConfiguration`. Se espera que la aplicación compruebe el ` error ` y decida si desea continuar con el protocolo de enlace o interrumpirlo y enviar un mensaje de alerta al interlocutor. La conexión señal-ranura debe ser directa.

Esta función se introdujo en Qt 6.2.

Véanse también continueInterruptedHandshake(), sslErrors() y QSslConfiguration::setHandshakeMustInterruptOnError().

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

Devuelve las opciones de establecimiento de conexión que se utilizaron para abrir este socket.

Esta función se introdujo en Qt 6.4.

[slot] void QWebSocket::ignoreSslErrors()

Esta ranura indica a QWebSocket que ignore los errores que se produzcan durante la fase de establecimiento de conexión de QWebSocket y que continúe con la conexión. Si deseas continuar con la conexión aunque se produzcan errores durante la fase de establecimiento de conexión, debes llamar a esta ranura, ya sea desde una ranura conectada a sslErrors(), o bien antes de la fase de establecimiento de conexión. Si no se llama a este slot, ya sea en respuesta a los errores o antes del establecimiento de la conexión, la conexión se interrumpirá tras emitirse la señal sslErrors().

Advertencia: Asegúrate de permitir siempre que el usuario compruebe los errores notificados por la señal sslErrors(), y llama a este método únicamente tras recibir la confirmación del usuario de que puede continuar. Si se producen errores inesperados, la conexión debe abortarse. Llamar a este método sin comprobar los errores reales supondrá, con toda probabilidad, un riesgo de seguridad para tu aplicación. ¡Úsalo con mucho cuidado!

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload<>(&QWebSocket::ignoreSslErrors));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket]() { receiver->ignoreSslErrors(); });
Para ver más ejemplos y enfoques, consulta «Conexión a ranuras sobrecargadas».

Véase también sslErrors(), QSslSocket::ignoreSslErrors() y QNetworkReply::ignoreSslErrors().

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

Este método indica a QWebSocket que ignore los errores que se indican en errors.

Ten en cuenta que puedes configurar el certificado esperado en el error SSL: si, por ejemplo, deseas conectarte a un servidor que utiliza un certificado autofirmado, ten en cuenta el siguiente fragmento de código:

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")));

Las llamadas sucesivas a esta función sustituirán la lista de errores que se haya pasado en llamadas anteriores. Puedes borrar la lista de errores que deseas ignorar llamando a esta función con una lista vacía.

Esta es una función sobrecargada.

Véase también sslErrors().

bool QWebSocket::isValid() const

Devuelve ` true ` si el socket está listo para leer y escribir; en caso contrario, devuelve ` false`.

QHostAddress QWebSocket::localAddress() const

Devuelve la dirección local

quint16 QWebSocket::localPort() const

Devuelve el puerto local

const QMaskGenerator *QWebSocket::maskGenerator() const

Devuelve el generador de máscaras que utiliza actualmente este ` QWebSocket`.

Véase también setMaskGenerator().

quint64 QWebSocket::maxAllowedIncomingFrameSize() const

Devuelve el tamaño máximo permitido de una trama WebSocket entrante.

Véase también setMaxAllowedIncomingFrameSize().

quint64 QWebSocket::maxAllowedIncomingMessageSize() const

Devuelve el tamaño máximo permitido de un mensaje WebSocket entrante.

Véase también setMaxAllowedIncomingMessageSize().

[static] quint64 QWebSocket::maxIncomingFrameSize()

Devuelve el tamaño máximo admitido de una trama de WebSocket entrante para esta implementación de WebSocket.

[static] quint64 QWebSocket::maxIncomingMessageSize()

Devuelve el tamaño máximo admitido de un mensaje WebSocket entrante para esta implementación de WebSocket.

[static] quint64 QWebSocket::maxOutgoingFrameSize()

Devuelve el tamaño máximo admitido de una trama de WebSocket saliente para esta implementación de WebSocket.

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

Abre una conexión WebSocket utilizando la URL request proporcionada.

La URL request se utilizará para abrir la conexión WebSocket. Los encabezados presentes en la solicitud se enviarán al servidor en la solicitud de actualización, junto con los necesarios para el protocolo de enlace de WebSocket.

Nota: Este slot está sobrecargado. Para conectarse a este slot:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QNetworkRequest &request) { receiver->open(request); });
Para ver más ejemplos y métodos, consulta «Conexión a ranuras sobrecargadas».

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

Abre una conexión WebSocket utilizando la URL proporcionada: url.

Si la URL contiene caracteres de salto de línea (\r\n ), se emitirá una señal de error con el tipo de error « QAbstractSocket::ConnectionRefusedError ».

Nota: Este slot está sobrecargado. Para conectarse a este slot:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QUrl &url) { receiver->open(url); });
Para ver más ejemplos y enfoques, consulta «Conexión a ranuras sobrecargadas».

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

Abre una conexión WebSocket utilizando las direcciones request y options indicadas.

La URL request se utilizará para abrir la conexión WebSocket. Los encabezados presentes en la solicitud se enviarán al servidor en la solicitud de actualización, junto con los necesarios para el protocolo de establecimiento de conexión de WebSocket.

En options se pueden especificar opciones adicionales para el protocolo de enlace de WebSocket, como los subprotocolos.

Nota: Este slot está sobrecargado. Para conectarse a este slot:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QNetworkRequest &request, const QWebSocketHandshakeOptions &options) { receiver->open(request, options); });
Para ver más ejemplos y enfoques, consulta «Conexión a ranuras sobrecargadas».

Esta función se introdujo en Qt 6.4.

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

Abre una conexión WebSocket utilizando las direcciones url y options.

Si la URL contiene caracteres de salto de línea (\r\n ), se emitirá una señal de error con el tipo de error « QAbstractSocket::ConnectionRefusedError ».

En options se pueden especificar opciones adicionales para el handshake de WebSocket, como los subprotocolos.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        webSocket, qOverload(&QWebSocket::open));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        webSocket, [receiver = webSocket](const QUrl &url, const QWebSocketHandshakeOptions &options) { receiver->open(url, options); });
Para ver más ejemplos y métodos, consulta «Conexión a ranuras sobrecargadas».

Esta función se introdujo en Qt 6.4.

QString QWebSocket::origin() const

Devuelve el origen actual.

quint64 QWebSocket::outgoingFrameSize() const

Devuelve el tamaño máximo de una trama de WebSocket saliente.

Véase también ` setOutgoingFrameSize()`.

QAbstractSocket::PauseModes QWebSocket::pauseMode() const

Devuelve el modo de pausa de este socket

Véase también setPauseMode().

QHostAddress QWebSocket::peerAddress() const

Devuelve la dirección del par

QString QWebSocket::peerName() const

Devuelve el peerName

quint16 QWebSocket::peerPort() const

Devuelve el puerto de conexión

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

QWebSocket Puede emitir esta señal varias veces durante el protocolo de enlace SSL, antes de que se haya establecido el cifrado, para indicar que se ha producido un error al establecer la identidad del interlocutor. La señal « error » suele indicar que QWebSocket no puede identificar de forma segura al interlocutor.

Esta señal te proporciona una indicación temprana de que algo va mal. Al conectarte a esta señal, puedes optar manualmente por interrumpir la conexión desde el interior del slot «connected» antes de que se haya completado el protocolo de enlace. Si no se toma ninguna medida, QWebSocket procederá a emitir QWebSocket::sslErrors().

Esta función se introdujo en Qt 6.2.

Véase también sslErrors().

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

Envía un ping al servidor para indicar que la conexión sigue activa. Se puede enviar un « payload » adicional junto con el mensaje de ping.

El tamaño del archivo « payload » no puede superar los 125 bytes. Si es mayor, el archivo « payload » se recorta a 125 bytes.

Nota: Las funciones ` QWebSocket ` y ` QWebSocketServer ` gestionan las solicitudes de ping internamente, lo que significa que envían automáticamente una respuesta «pong» al interlocutor.

Véase también pong().

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

Se emite cuando se recibe un mensaje «pong» en respuesta a un «ping» anterior. elapsedTime contiene el tiempo de ida y vuelta en milisegundos y payload contiene una carga útil opcional que se envió junto con el «ping».

Véase también ping().

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

Esta señal se emite si el protocolo de enlace SSL/TLS negocia un conjunto de cifrado PSK y, por lo tanto, se requiere una autenticación PSK.

Al utilizar PSK, el cliente debe enviar al servidor una identidad válida y una clave precompartida válida para que el protocolo de enlace SSL pueda continuar. Las aplicaciones pueden proporcionar esta información en un canal conectado a esta señal, rellenando el objeto ` authenticator ` pasado según sus necesidades.

Nota: Ignorar esta señal o no proporcionar las credenciales necesarias provocará que el protocolo de enlace falle y, por lo tanto, que la conexión se interrumpa.

Nota: El objeto ` authenticator ` es propiedad del WebSocket y la aplicación no debe eliminarlo.

Véase también QSslPreSharedKeyAuthenticator y QSslSocket::preSharedKeyAuthenticationRequired().

QNetworkProxy QWebSocket::proxy() const

Devuelve el proxy configurado actualmente

Véase también setProxy().

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

Esta señal puede emitirse cuando se utiliza una conexión en cola ( proxy ) que requiere autenticación. A continuación, se pueden introducir los datos necesarios en el objeto « authenticator » para permitir la autenticación y continuar con la conexión.

Nota: Noes posible utilizar una QueuedConnection para conectarse a esta señal, ya que la conexión fallará si no se ha introducido información nueva en el autenticador cuando la señal vuelva.

Véase también QAuthenticator y QNetworkProxy.

qint64 QWebSocket::readBufferSize() const

Devuelve el tamaño, en bytes, del búfer de lectura que utiliza el socket.

Véase también setReadBufferSize().

[signal] void QWebSocket::readChannelFinished()

Esta señal se emite cuando se cierra el flujo de entrada (lectura) en este dispositivo. Se emite tan pronto como se detecta el cierre.

Véase también ` close()`.

QNetworkRequest QWebSocket::request() const

Devuelve la solicitud que se ha utilizado o se utilizará para abrir este socket.

QUrl QWebSocket::requestUrl() const

Devuelve la URL a la que está conectado el socket o a la que se conectará.

QString QWebSocket::resourceName() const

Devuelve el nombre del recurso al que se está accediendo en ese momento.

void QWebSocket::resume()

Continúa la transferencia de datos en el socket. Este método solo debe utilizarse después de que el socket se haya configurado para pausarse ante las notificaciones y se haya recibido una notificación. La única notificación compatible actualmente es ` sslErrors()` (). Llamar a este método si el socket no está en pausa da lugar a un comportamiento indefinido.

Véanse también pauseMode() y setPauseMode().

qint64 QWebSocket::sendBinaryMessage(const QByteArray &data)

Envía el objeto ` data ` indicado a través del socket como un mensaje binario y devuelve el número de bytes enviados realmente.

Véase también sendTextMessage().

qint64 QWebSocket::sendTextMessage(const QString &message)

Envía el « message » indicado a través del socket como un mensaje de texto y devuelve el número de bytes enviados realmente.

Véase también sendBinaryMessage().

void QWebSocket::setMaskGenerator(const QMaskGenerator *maskGenerator)

Establece el generador que se utilizará para crear máscaras en maskGenerator. El generador predeterminado QWebSocket se puede restablecer pasando un `nullptr`. El generador de máscaras se puede cambiar en cualquier momento, incluso mientras la conexión está abierta.

Véase también maskGenerator().

void QWebSocket::setMaxAllowedIncomingFrameSize(quint64 maxAllowedIncomingFrameSize)

Establece el tamaño máximo permitido de una trama WebSocket entrante en maxAllowedIncomingFrameSize. Si una trama entrante supera este límite, el par se desconecta. El rango aceptado está comprendido entre 0 y maxIncomingFrameSize(); el valor por defecto es maxIncomingFrameSize(). El objetivo de esta función es evitar que se agote la memoria virtual.

Véase también maxAllowedIncomingFrameSize().

void QWebSocket::setMaxAllowedIncomingMessageSize(quint64 maxAllowedIncomingMessageSize)

Establece el tamaño máximo permitido de un mensaje WebSocket entrante en maxAllowedIncomingMessageSize. Si un mensaje entrante supera este límite, el par se desconecta. El rango aceptado está comprendido entre 0 y maxIncomingMessageSize(); el valor por defecto es maxIncomingMessageSize(). El objetivo de esta función es evitar que se agote la memoria virtual.

Véase también maxAllowedIncomingMessageSize().

void QWebSocket::setOutgoingFrameSize(quint64 outgoingFrameSize)

Establece el tamaño máximo de una trama de WebSocket saliente en outgoingFrameSize. El rango admitido está comprendido entre 0 y maxOutgoingFrameSize(); el valor por defecto es 512 kB. El objetivo de esta función es adaptarse al tamaño máximo de trama permitido por el receptor.

Véase también outgoingFrameSize().

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

Determina si se debe pausar al recibir una notificación. El parámetro ` pauseMode ` especifica las condiciones en las que se debe pausar el socket.

La única notificación compatible actualmente es ` sslErrors()`. Si se establece en `PauseOnSslErrors`, la transferencia de datos en el socket se detendrá y deberá reactivarse explícitamente llamando a ` resume()`. Por defecto, esta opción está establecida en `PauseNever`. Esta opción debe llamarse antes de conectarse al servidor; de lo contrario, se producirá un comportamiento indefinido.

Véanse también pauseMode() y resume().

void QWebSocket::setProxy(const QNetworkProxy &networkProxy)

Establece el proxy en networkProxy

Véase también proxy().

void QWebSocket::setReadBufferSize(qint64 size)

Establece el tamaño del búfer de lectura interno de ` QWebSocket` en size bytes.

Si el tamaño del búfer se limita a un valor determinado, QWebSocket no almacenará en el búfer más datos que los que quepan en dicho tamaño. Excepcionalmente, un tamaño de búfer igual a 0 significa que el búfer de lectura es ilimitado y que se almacenan en él todos los datos entrantes. Este es el valor por defecto. Esta opción resulta útil si solo se leen los datos en determinados momentos (por ejemplo, en una aplicación de streaming en tiempo real) o si se desea proteger el socket contra la recepción de un volumen excesivo de datos, lo que podría acabar provocando que la aplicación se quede sin memoria.

Véase también readBufferSize().

void QWebSocket::setSslConfiguration(const QSslConfiguration &sslConfiguration)

Establece la configuración SSL del socket con el contenido de sslConfiguration.

Esta función establece el certificado local, los algoritmos de cifrado, la clave privada y los certificados de CA según los almacenados en sslConfiguration. No es posible configurar los campos relacionados con el estado de SSL.

Véase también sslConfiguration().

QSslConfiguration QWebSocket::sslConfiguration() const

Devuelve el estado de la configuración SSL del socket. La configuración SSL predeterminada de un socket consiste en utilizar los cifrados predeterminados, los certificados CA predeterminados y no utilizar ninguna clave privada ni certificado local. La configuración SSL también contiene campos que pueden cambiar con el tiempo sin previo aviso.

Véase también setSslConfiguration().

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

QWebSocket Emite esta señal tras el protocolo de enlace SSL para indicar que se han producido uno o más errores al establecer la identidad del interlocutor. Estos errores suelen indicar que QWebSocket no puede identificar de forma segura al interlocutor. A menos que se tome alguna medida, la conexión se interrumpirá tras la emisión de esta señal. Si desea continuar con la conexión a pesar de los errores que se han producido, debe llamar a ` QWebSocket::ignoreSslErrors()` desde dentro de un slot conectado a esta señal. Si necesita acceder a la lista de errores más adelante, puede llamar a `sslErrors()` (sin argumentos).

errors contiene uno o más errores que impiden que QWebSocket verifique la identidad del interlocutor.

Nota: Nopuedes utilizar Qt::QueuedConnection al conectarte a esta señal, ya que, de lo contrario, llamar a QWebSocket::ignoreSslErrors() no tendrá ningún efecto.

QAbstractSocket::SocketState QWebSocket::state() const

Devuelve el estado actual del socket.

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

Esta señal se emite cada vez que cambia el estado de ` QWebSocket`. El parámetro ` state ` indica el nuevo estado.

Nota: QAbstractSocket::ConnectedState se emite una vez que se ha completado con éxito el establecimiento de la conexión con el servidor.

QAbstractSocket::SocketState no es un metatipo registrado, por lo que, para las conexiones en cola, tendrás que registrarlo con Q_REGISTER_METATYPE() y qRegisterMetaType().

Véase también state().

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

Devuelve el protocolo WebSocket utilizado.

Esta función se introdujo en Qt 6.4.

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

Esta señal se emite cada vez que se recibe una trama de texto. El campo « frame » contiene los datos y el campo « isLastFrame » indica si se trata de la última trama del mensaje completo.

Esta señal se puede utilizar para procesar mensajes largos trama a trama, en lugar de esperar a que llegue el mensaje completo.

Véase también binaryFrameReceived().

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

Esta señal se emite cada vez que se recibe un mensaje de texto. El objeto ` message ` contiene el texto recibido.

Véase también binaryMessageReceived().

QWebSocketProtocol::Version QWebSocket::version() const

Devuelve la versión que está utilizando actualmente el socket.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.