QSslSocket Class

Documentación de las funciones miembro

[explicit] QSslSocket::QSslSocket(QObject *parent = nullptr)

Construye un objeto QSslSocket. parent se pasa al constructor de QObject. El conjunto cipher del nuevo socket se establece al devuelto por el método estático defaultCiphers().

[virtual noexcept] QSslSocket::~QSslSocket()

Destruye el QSslSocket.

[static, since 6.1] QString QSslSocket::activeBackend()

Devuelve el nombre del backend que utilizan QSslSocket y las clases relacionadas. Si el backend activo no fue establecido explícitamente, esta función devuelve el nombre de un backend por defecto que QSslSocket selecciona implícitamente de la lista de backends disponibles.

Esta función se introdujo en Qt 6.1.

Véase también setActiveBackend() y availableBackends().

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

QSslSocket emite esta señal si se ha recibido un mensaje de alerta de un par. level indica si la alerta era fatal o era una advertencia. type es el código que explica por qué se envió la alerta. Cuando se dispone de una descripción textual del mensaje de alerta, se proporciona en description.

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

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

QSslSocket emite esta señal si se ha enviado un mensaje de alerta a un par. level describe si se trata de una advertencia o de un error fatal. type proporciona el código del mensaje de alerta. Cuando se dispone de una descripción textual del mensaje de alerta, se proporciona en description.

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

[override virtual] bool QSslSocket::atEnd() const

Reimplementa: QIODevice::atEnd() const.

[static, since 6.1] QList<QString> QSslSocket::availableBackends()

Devuelve los nombres de los backends disponibles actualmente. Estos nombres están en minúsculas, por ejemplo, "openssl", "securetransport", "schannel" (similar a los nombres de funciones ya existentes para los backends TLS en Qt).

Esta función se introdujo en Qt 6.1.

Véase también activeBackend().

[override virtual] qint64 QSslSocket::bytesAvailable() const

Reimplementa: QAbstractSocket::bytesAvailable() const.

Devuelve el número de bytes descifrados que están inmediatamente disponibles para su lectura.

[override virtual] qint64 QSslSocket::bytesToWrite() const

Reimplementa: QAbstractSocket::bytesToWrite() const.

Devuelve el número de bytes sin cifrar que están esperando a ser cifrados y escritos en la red.

[override virtual] bool QSslSocket::canReadLine() const

Reimplementa: QIODevice::canReadLine() const.

Devuelve true si se puede leer una línea while (terminada por un único carácter ASCII '\n') de caracteres descifrados; en caso contrario, se devuelve false.

[override virtual] void QSslSocket::close()

Reimplementa: QAbstractSocket::close().

[override virtual] void QSslSocket::connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

Reimplementa: QAbstractSocket::connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol).

void QSslSocket::connectToHostEncrypted(const QString &hostName, quint16 port, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

Inicia una conexión cifrada con el dispositivo hostName en port, utilizando mode como OpenMode. Esto equivale a llamar a connectToHost() para establecer la conexión, seguido de una llamada a startClientEncryption(). El parámetro protocol puede utilizarse para especificar qué protocolo de red utilizar (por ejemplo, IPv4 o IPv6).

QSslSocket entra primero en el HostLookupState. Luego, después de entrar en el bucle de eventos o en una de las funciones waitFor...(), entra en el ConnectingState, emite connected(), y luego inicia el handshake del cliente SSL. En cada cambio de estado, QSslSocket emite la señal stateChanged().

Después de iniciar el SSL client handshake, si no se puede establecer la identidad del peer, se emite la señal sslErrors(). Si desea ignorar los errores y continuar la conexión, debe llamar a ignoreSslErrors(), ya sea desde dentro de una función de ranura conectada a la señal sslErrors(), o antes de entrar en modo cifrado. Si no se llama a ignoreSslErrors(), se abandona la conexión, se emite la señal disconnected(), y QSslSocket vuelve al estado UnconnectedState.

Si el SSL handshake tiene éxito, QSslSocket emite encrypted().

QSslSocket socket;
connect(&socket, &QSslSocket::encrypted, receiver, &Receiver::socketEncrypted);

socket.connectToHostEncrypted("imap", 993);
socket->write("1 CAPABILITY\r\n");

El valor por defecto para mode es ReadWrite.

Si desea crear un QSslSocket en el lado del servidor de una conexión, deberá llamar a startServerEncryption() al recibir la conexión entrante a través de QTcpServer.

Véase también connectToHost(), startClientEncryption(), waitForConnected(), y waitForEncrypted().

void QSslSocket::connectToHostEncrypted(const QString &hostName, quint16 port, const QString &sslPeerName, QIODeviceBase::OpenMode mode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

Además del comportamiento original de connectToHostEncrypted, este método sobrecargado permite el uso de un nombre de host diferente (sslPeerName) para la validación del certificado en lugar del utilizado para la conexión TCP (hostName).

Véase también connectToHostEncrypted().

[since 6.0] void QSslSocket::continueInterruptedHandshake()

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

Esta función se introdujo en Qt 6.0.

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

[override virtual] void QSslSocket::disconnectFromHost()

Reimplementa: QAbstractSocket::disconnectFromHost().

[signal] void QSslSocket::encrypted()

Esta señal se emite cuando QSslSocket entra en modo encriptado. Después de que esta señal haya sido emitida, QSslSocket::isEncrypted() devolverá true, y todas las transmisiones posteriores en el socket serán encriptadas.

Véase también QSslSocket::connectToHostEncrypted() y QSslSocket::isEncrypted().

qint64 QSslSocket::encryptedBytesAvailable() const

Devuelve el número de bytes encriptados que están a la espera de ser desencriptados. Normalmente, esta función devolverá 0 porque QSslSocket descifra sus datos entrantes tan pronto como puede.

qint64 QSslSocket::encryptedBytesToWrite() const

Devuelve el número de bytes encriptados que están a la espera de ser escritos en la red.

[signal] void QSslSocket::encryptedBytesWritten(qint64 written)

Esta señal se emite cuando QSslSocket escribe sus datos cifrados en la red. El parámetro written contiene el número de bytes que se han escrito correctamente.

Véase también QIODevice::bytesWritten().

[signal] void QSslSocket::handshakeInterruptedOnError(const QSslError &error)

QSslSocket emite esta señal si se ha encontrado un error de verificación de certificado y si se ha habilitado la notificación anticipada de errores en QSslConfiguration. Se espera que una aplicación inspeccione el error y decida si quiere continuar con el handshake, o abortarlo y enviar un mensaje de alerta al peer. La conexión señal-ranura debe ser directa.

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

[slot] void QSslSocket::ignoreSslErrors()

Esta ranura indica a QSslSocket que ignore los errores durante la fase de handshake de QSslSocket y continúe con la conexión. Si quieres continuar con la conexión incluso si se producen errores durante la fase de handshake, entonces debes llamar a esta ranura, ya sea desde una ranura conectada a sslErrors(), o antes de la fase de handshake. Si no llama a esta ranura, ya sea en respuesta a errores o antes del handshake, la conexión se interrumpirá después de que se haya emitido la señal sslErrors().

Si no hay errores durante la fase de handshake SSL (es decir, la identidad del peer se establece sin problemas), QSslSocket no emitirá la señal sslErrors(), y no es necesario llamar a esta función.

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

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        sslSocket, [receiver = sslSocket]() { receiver->ignoreSslErrors(); });

Véase también sslErrors().

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

Este método indica a QSslSocket que ignore sólo los errores indicados en errors.

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

QSslSocket socket;
socket.ignoreSslErrors(expectedSslErrors);
socket.connectToHostEncrypted("server.tld", 443);

Múltiples llamadas a esta función reemplazarán la lista de errores que fueron pasados en llamadas previas. Puede borrar la lista de errores que desea ignorar llamando a esta función con una lista vacía.

Véase también sslErrors() y sslHandshakeErrors().

[static, since 6.1] QList<QSsl::ImplementedClass> QSslSocket::implementedClasses(const QString &backendName = {})

Esta función devuelve clases específicas del backend implementadas por el backend llamado backendName. Un backendName vacío se entiende como una consulta sobre el backend actualmente activo.

Esta función se introdujo en Qt 6.1.

Véase también QSsl::ImplementedClass, activeBackend(), y isClassImplemented().

[static, since 6.1] bool QSslSocket::isClassImplemented(QSsl::ImplementedClass cl, const QString &backendName = {})

Devuelve true si una clase cl está implementada por el backend llamado backendName. Un backendName vacío se entiende como una consulta sobre el backend actualmente activo.

Esta función se introdujo en Qt 6.1.

Véase también implementedClasses().

bool QSslSocket::isEncrypted() const

Devuelve true si el socket está encriptado; en caso contrario, devuelve false.

Un socket encriptado encripta todos los datos que se escriben llamando a write() o putChar() antes de que los datos se escriban en la red, y desencripta todos los datos entrantes a medida que los datos se reciben de la red, antes de llamar a read(), readLine() o getChar().

QSslSocket emite encrypted() cuando entra en modo cifrado.

Puedes llamar a sessionCipher() para averiguar qué cifrado criptográfico se utiliza para cifrar y descifrar tus datos.

Véase también mode().

[static, since 6.1] bool QSslSocket::isFeatureSupported(QSsl::SupportedFeature ft, const QString &backendName = {})

Devuelve true si una característica ft está soportada por un backend llamado backendName. Un backendName vacío se entiende como una consulta sobre el backend actualmente activo.

Esta función se introdujo en Qt 6.1.

Véase también QSsl::SupportedFeature y supportedFeatures().

[static, since 6.1] bool QSslSocket::isProtocolSupported(QSsl::SslProtocol protocol, const QString &backendName = {})

Devuelve true si protocol está soportado por un backend llamado backendName. Un backendName vacío se entiende como una consulta sobre el backend actualmente activo.

Esta función se introdujo en Qt 6.1.

Véase también supportedProtocols().

QSslCertificate QSslSocket::localCertificate() const

Devuelve el certificado local del socket certificate, o un certificado vacío si no se ha asignado ningún certificado local.

Véase también setLocalCertificate() y privateKey().

QList<QSslCertificate> QSslSocket::localCertificateChain() const

Devuelve la cadena local certificate del socket, o una lista vacía si no se han asignado certificados locales.

Véase también setLocalCertificateChain().

QSslSocket::SslMode QSslSocket::mode() const

Devuelve el modo actual del socket; ya sea UnencryptedMode, donde QSslSocket se comporta de forma idéntica a QTcpSocket, o uno de SslClientMode o SslServerMode, donde el cliente está negociando o en modo encriptado.

Cuando el modo cambia, QSslSocket emite modeChanged()

Véase también SslMode.

[signal] void QSslSocket::modeChanged(QSslSocket::SslMode mode)

Esta señal se emite cuando QSslSocket cambia de QSslSocket::UnencryptedMode a QSslSocket::SslClientMode o QSslSocket::SslServerMode. mode es el nuevo modo.

Véase también QSslSocket::mode().

[signal] void QSslSocket::newSessionTicketReceived()

Si se negoció el protocolo TLS 1.3 durante un handshake, QSslSocket emite esta señal tras recibir el mensaje NewSessionTicket. La sesión y el tiempo de vida del ticket de sesión se actualizan en la configuración del socket. La sesión puede ser utilizada para reanudar la sesión (y acortar el handshake) en futuras conexiones TLS.

Véase también QSslSocket::sslConfiguration(), QSslConfiguration::sessionTicket(), y QSslConfiguration::sessionTicketLifeTimeHint().

QList<QOcspResponse> QSslSocket::ocspResponses() const

Esta función devuelve las respuestas del protocolo de estado de certificados en línea que un servidor puede enviar durante un protocolo de enlace TLS utilizando el grapado OCSP. La lista está vacía si no se ha recibido ninguna respuesta definitiva o ninguna respuesta en absoluto.

Véase también QSslConfiguration::setOcspStaplingEnabled().

QSslCertificate QSslSocket::peerCertificate() const

Devuelve el certificado digital del peer (es decir, el certificado inmediato del host al que se está conectado), o un certificado nulo, si el peer no ha asignado un certificado.

El certificado del peer se comprueba automáticamente durante la fase de handshake, por lo que esta función se utiliza normalmente para obtener el certificado para su visualización o con fines de diagnóstico de la conexión. Contiene información sobre el peer, incluyendo su nombre de host, el emisor del certificado y la clave pública del peer.

Dado que el certificado del peer se establece durante la fase de handshake, es seguro acceder al certificado del peer desde una ranura conectada a la señal sslErrors() o a la señal encrypted().

Si se devuelve un certificado nulo, puede significar que el handshake SSL falló, o puede significar que el host al que estás conectado no tiene certificado, o puede significar que no hay conexión.

Si desea comprobar la cadena completa de certificados del homólogo, utilice peerCertificateChain() para obtenerlos todos a la vez.

Véase también peerCertificateChain().

QList<QSslCertificate> QSslSocket::peerCertificateChain() const

Devuelve la cadena de certificados digitales del peer, o una lista vacía de certificados.

Los certificados de los pares se comprueban automáticamente durante la fase de handshake. Esta función se utiliza normalmente para obtener certificados para su visualización o para realizar diagnósticos de conexión. Los certificados contienen información sobre el peer y los emisores de certificados, incluyendo el nombre del host, los nombres de los emisores y las claves públicas de los emisores.

Los certificados peer se establecen en QSslSocket durante la fase de handshake, por lo que es seguro llamar a esta función desde una ranura conectada a la señal sslErrors() o a la señal encrypted().

Si se devuelve una lista vacía, puede significar que el handshake SSL falló, o puede significar que el host al que se está conectado no tiene certificado, o puede significar que no hay conexión.

Si sólo desea obtener el certificado inmediato del homólogo, utilice peerCertificate().

Véase también peerCertificate().

int QSslSocket::peerVerifyDepth() const

Devuelve el número máximo de certificados de la cadena de certificados del par que se comprobarán durante la fase de enlace SSL, o 0 (valor predeterminado) si no se ha establecido ninguna profundidad máxima, lo que indica que se debe comprobar toda la cadena de certificados.

Los certificados se comprueban en orden de emisión, empezando por el propio certificado del peer, luego el certificado de su emisor, y así sucesivamente.

Véase también setPeerVerifyDepth() y peerVerifyMode().

[signal] void QSslSocket::peerVerifyError(const QSslError &error)

QSslSocket puede emitir esta señal varias veces durante el handshake SSL, antes de que se haya establecido el cifrado, para indicar que se ha producido un error al establecer la identidad del peer. La error suele ser una indicación de que QSslSocket es incapaz de identificar de forma segura al peer.

Esta señal te proporciona una indicación temprana de que algo va mal. Al conectarte a esta señal, puedes elegir manualmente cortar la conexión desde dentro de la ranura conectada antes de que el apretón de manos se haya completado. Si no se realiza ninguna acción, QSslSocket procederá a emitir QSslSocket::sslErrors().

Véase también sslErrors().

QSslSocket::PeerVerifyMode QSslSocket::peerVerifyMode() const

Devuelve el modo de verificación del socket. Este modo decide si QSslSocket debe solicitar un certificado al par (es decir, el cliente solicita un certificado al servidor, o un servidor solicita un certificado al cliente), y si debe requerir que este certificado sea válido.

El modo por defecto es AutoVerifyPeer, que indica a QSslSocket que utilice VerifyPeer para los clientes y QueryPeer para los servidores.

Véase también setPeerVerifyMode(), peerVerifyDepth(), y mode().

QString QSslSocket::peerVerifyName() const

Devuelve el nombre de host diferente para la validación del certificado, según lo establecido por setPeerVerifyName o por connectToHostEncrypted.

Véase también setPeerVerifyName() y connectToHostEncrypted().

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

QSslSocket emite esta señal cuando negocia un ciphersuite PSK, y por lo tanto se requiere entonces una autenticación PSK.

Cuando se utiliza PSK, el cliente debe enviar al servidor una identidad válida y una clave precompartida válida, para que el handshake SSL pueda continuar. Las aplicaciones pueden proporcionar esta información en una ranura conectada a esta señal, rellenando el objeto authenticator pasado según sus necesidades.

Véase también QSslPreSharedKeyAuthenticator.

QSslKey QSslSocket::privateKey() const

Devuelve la clave privada de este socket.

Véase también setPrivateKey() y localCertificate().

QSsl::SslProtocol QSslSocket::protocol() const

Devuelve el protocolo SSL del socket. Por defecto, se utiliza QSsl::SecureProtocols.

Véase también setProtocol().

[override virtual protected] qint64 QSslSocket::readData(char *data, qint64 maxlen)

Reimplementa: QAbstractSocket::readData(char *data, qint64 maxSize).

[override virtual] void QSslSocket::resume()

Reimplementa: QAbstractSocket::resume().

Continúa la transferencia de datos en el socket después de haber sido pausado. Si se ha llamado a "setPauseMode(QAbstractSocket::PauseOnSslErrors);" en este socket y se recibe una señal sslErrors(), es necesario llamar a este método para que el socket continúe.

Véase también QAbstractSocket::pauseMode() y QAbstractSocket::setPauseMode().

QSslCipher QSslSocket::sessionCipher() const

Devuelve el cifrado del socket cipher, o un cifrado nulo si la conexión no está cifrada. El cifrado del socket para la sesión se establece durante la fase de handshake. El cifrado se utiliza para cifrar y descifrar los datos transmitidos a través del socket.

QSslSocket también proporciona funciones para establecer la lista ordenada de cifradores de la que la fase de handshake seleccionará finalmente el cifrado de la sesión. Esta lista ordenada debe estar en su lugar antes de que comience la fase de handshake.

Véase también QSslConfiguration::ciphers(), QSslConfiguration::setCiphers(), y QSslConfiguration::supportedCiphers().

QSsl::SslProtocol QSslSocket::sessionProtocol() const

Devuelve el protocolo SSL/TLS del socket o UnknownProtocol si la conexión no está cifrada. El protocolo del socket para la sesión se establece durante la fase de handshake.

Véase también protocol() y setProtocol().

[static, since 6.1] bool QSslSocket::setActiveBackend(const QString &backendName)

Devuelve true si un backend con nombre backendName fue establecido como backend activo. backendName debe ser uno de los nombres devueltos por availableBackends().

Esta función se introdujo en Qt 6.1.

Véase también activeBackend() y availableBackends().

void QSslSocket::setLocalCertificate(const QSslCertificate &certificate)

Establece el certificado local del socket en certificate. El certificado local es necesario si necesitas confirmar tu identidad al peer. Se utiliza junto con la clave privada; si estableces el certificado local, también debes establecer la clave privada.

El certificado local y la clave privada son siempre necesarios para los sockets de servidor, pero también son raramente utilizados por los sockets de cliente si el servidor requiere que el cliente se autentique.

Véase también localCertificate() y setPrivateKey().

void QSslSocket::setLocalCertificate(const QString &path, QSsl::EncodingFormat format = QSsl::Pem)

Establece el certificate local del socket al primero encontrado en el archivo path, que se analiza según el format especificado.

void QSslSocket::setLocalCertificateChain(const QList<QSslCertificate> &localChain)

Establece que la cadena de certificados que se presentará al homólogo durante el protocolo de enlace SSL sea localChain.

Véase también localCertificateChain() y QSslConfiguration::setLocalCertificateChain().

void QSslSocket::setPeerVerifyDepth(int depth)

Establece el número máximo de certificados de la cadena de certificados del homólogo que se comprobarán durante la fase de enlace SSL, en depth. Establecer una profundidad de 0 significa que no se establece ninguna profundidad máxima, lo que indica que se debe comprobar toda la cadena de certificados.

Los certificados se comprueban en orden de emisión, empezando por el propio certificado del par, luego el certificado de su emisor, y así sucesivamente.

Véase también peerVerifyDepth() y setPeerVerifyMode().

void QSslSocket::setPeerVerifyMode(QSslSocket::PeerVerifyMode mode)

Establece el modo de verificación del socket en mode. Este modo decide si QSslSocket debe solicitar un certificado al par (es decir, el cliente solicita un certificado al servidor, o un servidor solicita un certificado al cliente), y si debe requerir que este certificado sea válido.

El modo predeterminado es AutoVerifyPeer, que indica a QSslSocket que utilice VerifyPeer para los clientes y QueryPeer para los servidores.

Establecer este modo una vez iniciada la encriptación no afecta a la conexión actual.

Véase también peerVerifyMode(), setPeerVerifyDepth() y mode().

void QSslSocket::setPeerVerifyName(const QString &hostName)

Establece un nombre de host diferente, dado por hostName, para la validación del certificado en lugar del utilizado para la conexión TCP.

Véase también peerVerifyName() y connectToHostEncrypted().

void QSslSocket::setPrivateKey(const QSslKey &key)

Establece el key privado del socket en key. La clave privada y el certificate local son utilizados por los clientes y servidores que deben demostrar su identidad a los pares SSL.

Tanto la clave como el certificado local son necesarios si estás creando un socket de servidor SSL. Si está creando un socket cliente SSL, la clave y el certificado local son necesarios si su cliente debe identificarse ante un servidor SSL.

Véase también privateKey() y setLocalCertificate().

void QSslSocket::setPrivateKey(const QString &fileName, QSsl::KeyAlgorithm algorithm = QSsl::Rsa, QSsl::EncodingFormat format = QSsl::Pem, const QByteArray &passPhrase = QByteArray())

Lee la cadena del archivo fileName y la descodifica utilizando un algorithm especificado y codificando format para construir un SSL key. Si la clave codificada está cifrada, se utiliza passPhrase para descifrarla.

La clave privada del socket se establece en la clave construida. La clave privada y el certificate local son utilizados por los clientes y servidores que deben demostrar su identidad a los pares SSL.

Tanto la clave como el certificado local son necesarios si está creando un socket de servidor SSL. Si está creando un socket de cliente SSL, la clave y el certificado local son necesarios si su cliente debe identificarse ante un servidor SSL.

Véase también privateKey() y setLocalCertificate().

void QSslSocket::setProtocol(QSsl::SslProtocol protocol)

Establece el protocolo SSL del socket en protocol. Esto afectará al siguiente handshake iniciado; llamar a esta función en un socket ya encriptado no afectará al protocolo del socket.

Véase también protocol().

[override virtual] void QSslSocket::setReadBufferSize(qint64 size)

Reimplementa: QAbstractSocket::setReadBufferSize(qint64 tamaño).

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

[override virtual] bool QSslSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState state = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)

Reimplementa: QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState socketState, QIODeviceBase::OpenMode openMode).

Inicializa QSslSocket con el descriptor de socket nativo socketDescriptor. Devuelve true si socketDescriptor es aceptado como un descriptor de socket válido; en caso contrario devuelve false. El socket se abre en el modo especificado por openMode, y entra en el estado de socket especificado por state.

Véase también socketDescriptor().

[override virtual] void QSslSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)

Reimplementa: QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value).

Establece el option dado al valor descrito por value.

Ver también socketOption().

void QSslSocket::setSslConfiguration(const QSslConfiguration &configuration)

Establece la configuración SSL del socket para que sea el contenido de configuration. Esta función establece el certificado local, los cifrados, la clave privada y los certificados CA a los almacenados en configuration.

No es posible establecer los campos relacionados con el estado SSL.

Véase también sslConfiguration(), setLocalCertificate(), setPrivateKey(), QSslConfiguration::setCaCertificates(), y QSslConfiguration::setCiphers().

[override virtual protected] qint64 QSslSocket::skipData(qint64 maxSize)

Reimplementa: QAbstractSocket::skipData(qint64 maxSize).

[override virtual] QVariant QSslSocket::socketOption(QAbstractSocket::SocketOption option)

Reimplementa: QAbstractSocket::socketOption(Opción QAbstractSocket::SocketOption).

Devuelve el valor de la opción option.

Ver también setSocketOption().

QSslConfiguration QSslSocket::sslConfiguration() const

Devuelve el estado de configuración SSL del socket. La configuración SSL por defecto de un socket es usar los cifrados por defecto, certificados CA por defecto, sin clave privada local ni certificado.

La configuración SSL también contiene campos que pueden cambiar con el tiempo sin previo aviso.

Véase también setSslConfiguration(), localCertificate(), peerCertificate(), peerCertificateChain(), sessionCipher(), privateKey(), QSslConfiguration::ciphers(), y QSslConfiguration::caCertificates().

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

QSslSocket emite esta señal después del handshake SSL para indicar que se han producido uno o más errores mientras se establecía la identidad del peer. Los errores son normalmente una indicación de que QSslSocket es incapaz de identificar de forma segura al peer. A menos que se realice alguna acción, la conexión se interrumpirá tras la emisión de esta señal.

Si desea continuar la conexión a pesar de los errores que se han producido, debe llamar a QSslSocket::ignoreSslErrors() desde dentro de una ranura conectada a esta señal. Si necesita acceder a la lista de errores en un momento posterior, puede llamar a sslHandshakeErrors().

errors contiene uno o más errores que impiden que QSslSocket verifique la identidad del par.

Véase también peerVerifyError().

QList<QSslError> QSslSocket::sslHandshakeErrors() const

Devuelve una lista de los últimos errores SSL ocurridos. Esta es la misma lista que QSslSocket pasa a través de la señal sslErrors(). Si la conexión ha sido encriptada sin errores, esta función devolverá una lista vacía.

Véase también connectToHostEncrypted().

[static] long QSslSocket::sslLibraryBuildVersionNumber()

Devuelve el número de versión de la biblioteca SSL en uso en tiempo de compilación. Si no hay soporte SSL disponible, devolverá -1.

Véase también sslLibraryVersionNumber().

[static] QString QSslSocket::sslLibraryBuildVersionString()

Devuelve la cadena de versión de la biblioteca SSL en uso en tiempo de compilación. Si no hay soporte SSL disponible, devolverá un valor vacío.

Véase también sslLibraryVersionString().

[static] long QSslSocket::sslLibraryVersionNumber()

Devuelve el número de versión de la biblioteca SSL en uso. Tenga en cuenta que esta es la versión de la biblioteca en uso en tiempo de ejecución, no en tiempo de compilación. Si no hay soporte SSL disponible, devolverá -1.

[static] QString QSslSocket::sslLibraryVersionString()

Devuelve la cadena de versión de la biblioteca SSL en uso. Tenga en cuenta que esta es la versión de la biblioteca en uso en tiempo de ejecución, no en tiempo de compilación. Si no hay soporte SSL disponible, devolverá un valor vacío.

[slot] void QSslSocket::startClientEncryption()

Inicia un handshake SSL retardado para una conexión cliente. Esta función puede ser llamada cuando el socket está en ConnectedState pero aún en UnencryptedMode. Si aún no está conectado, o si ya está encriptado, esta función no tiene efecto.

Los clientes que implementan la funcionalidad STARTTLS a menudo hacen uso de handshakes SSL retardados. La mayoría de los otros clientes pueden evitar llamar a esta función directamente utilizando connectToHostEncrypted() en su lugar, que realiza automáticamente el handshake.

Véase también connectToHostEncrypted() y startServerEncryption().

[slot] void QSslSocket::startServerEncryption()

Inicia un handshake SSL retardado para una conexión al servidor. Esta función puede ser llamada cuando el socket está en ConnectedState pero todavía en UnencryptedMode. Si no está conectado o ya está encriptado, la función no tiene efecto.

Para los sockets de servidor, llamar a esta función es la única manera de iniciar el handshake SSL. La mayoría de los servidores llamarán a esta función inmediatamente después de recibir una conexión, o como resultado de haber recibido un comando específico del protocolo para entrar en modo SSL (por ejemplo, el servidor puede responder a la recepción de la cadena "STARTTLS\r\n " llamando a esta función).

La forma más común de implementar un servidor SSL es crear una subclase de QTcpServer y reimplementar QTcpServer::incomingConnection(). El descriptor de socket devuelto se pasa entonces a QSslSocket::setSocketDescriptor().

Véase también connectToHostEncrypted() y startClientEncryption().

[static, since 6.1] QList<QSsl::SupportedFeature> QSslSocket::supportedFeatures(const QString &backendName = {})

Esta función devuelve características soportadas por un backend llamado backendName. Un backendName vacío se entiende como una consulta sobre el backend actualmente activo.

Esta función se introdujo en Qt 6.1.

Véase también QSsl::SupportedFeature y activeBackend().

[static, since 6.1] QList<QSsl::SslProtocol> QSslSocket::supportedProtocols(const QString &backendName = {})

Si está disponible un backend con el nombre backendName, esta función devuelve la lista de versiones del protocolo TLS soportadas por este backend. Un backendName vacío se entiende como una consulta sobre el backend actualmente activo. En caso contrario, esta función devuelve una lista vacía.

Esta función se introdujo en Qt 6.1.

Véase también availableBackends(), activeBackend() y isProtocolSupported().

[static] bool QSslSocket::supportsSsl()

Devuelve true si esta plataforma soporta SSL; en caso contrario, devuelve false. Si la plataforma no soporta SSL, el socket fallará en la fase de conexión.

[override virtual] bool QSslSocket::waitForBytesWritten(int msecs = 30000)

Reimplementa: QAbstractSocket::waitForBytesWritten(int msecs).

[override virtual] bool QSslSocket::waitForConnected(int msecs = 30000)

Reimplementa: QAbstractSocket::waitForConnected(int msecs).

Espera hasta que el socket se conecta, o msecs milisegundos, lo que ocurra primero. Si se ha establecido la conexión, esta función devuelve true; en caso contrario devuelve false.

Véase también QAbstractSocket::waitForConnected().

[override virtual] bool QSslSocket::waitForDisconnected(int msecs = 30000)

Reimplementa: QAbstractSocket::waitForDisconnected(int msecs).

Espera hasta que el socket se haya desconectado o msecs milisegundos, lo que ocurra primero. Si la conexión se ha desconectado, esta función devuelve true; en caso contrario devuelve false.

Véase también QAbstractSocket::waitForDisconnected().

bool QSslSocket::waitForEncrypted(int msecs = 30000)

Espera hasta que el socket haya completado el protocolo SSL y haya emitido encrypted(), o msecs milisegundos, lo que ocurra primero. Si se ha emitido encrypted(), esta función devuelve true; en caso contrario (por ejemplo, el socket se desconecta, o falla el handshake SSL), se devuelve false.

El siguiente ejemplo espera hasta un segundo para que el socket sea encriptado:

socket->connectToHostEncrypted("imap", 993);if (socket->waitForEncrypted(1000))    qDebug("Encrypted!");

Si msecs es -1, esta función no agotará el tiempo de espera.

Véase también startClientEncryption(), startServerEncryption(), encrypted() y isEncrypted().

[override virtual] bool QSslSocket::waitForReadyRead(int msecs = 30000)

Reimplementa: QAbstractSocket::waitForReadyRead(int msecs).

[override virtual protected] qint64 QSslSocket::writeData(const char *data, qint64 len)

Reimplementa: QAbstractSocket::writeData(const char *data, qint64 size).