#include <qsslsocket_openssl_p.h>

Inheritance diagram for QSslSocketBackendPrivate:

Public Functions
void	destroySslContext ()

void	disconnected ()

void	disconnectFromHost ()

bool	initSslContext ()

	QSslSocketBackendPrivate ()

QSslCipher	sessionCipher () const

void	startClientEncryption ()

bool	startHandshake ()

void	startServerEncryption ()

void	transmit ()
	Transmits encrypted data between the BIOs and the socket. More...

virtual	~QSslSocketBackendPrivate ()

Public Functions inherited from QSslSocketPrivate
void	_q_bytesWrittenSlot (qint64)

void	_q_connectedSlot ()

void	_q_disconnectedSlot ()

void	_q_errorSlot (QAbstractSocket::SocketError)

void	_q_flushReadBuffer ()

void	_q_flushWriteBuffer ()

void	_q_hostFoundSlot ()

void	_q_readyReadSlot ()

void	_q_stateChangedSlot (QAbstractSocket::SocketState)

void	createPlainSocket (QIODevice::OpenMode openMode)

void	init ()

virtual qint64	peek (char *data, qint64 maxSize)

virtual QByteArray	peek (qint64 maxSize)

	QSslSocketPrivate ()

virtual	~QSslSocketPrivate ()

Public Functions inherited from QAbstractSocketPrivate
void	_q_abortConnectionAttempt ()
	This function is called after a certain number of seconds has passed while waiting for a connection. More...

void	_q_connectToNextAddress ()
	Called by a queued or direct connection from _q_startConnecting() or _q_testConnection(), this function takes the first address of the pending addresses list and tries to connect to it. More...

void	_q_forceDisconnect ()

void	_q_startConnecting (const QHostInfo &hostInfo)
	Slot connected to QHostInfo::lookupHost() in connectToHost(). More...

void	_q_testConnection ()
	Tests if a connection has been established. More...

bool	canReadNotification ()
	Slot connected to the read socket notifier. More...

bool	canWriteNotification ()
	Slot connected to the write socket notifier. More...

void	connectionNotification ()
	Slot connected to a notification of connection status change. More...

void	exceptionNotification ()

void	fetchConnectionParameters ()
	Sets up the internal state after the connection has succeeded. More...

bool	flush ()
	Writes pending data in the write buffers to the socket. More...

bool	initSocketLayer (QAbstractSocket::NetworkLayerProtocol protocol)
	Initializes the socket layer to by of type type, using the network layer protocol protocol. More...

void	proxyAuthenticationRequired (const QNetworkProxy &proxy, QAuthenticator *authenticator)

	QAbstractSocketPrivate ()
	Constructs a QAbstractSocketPrivate. More...

bool	readFromSocket ()
	Reads data from the socket layer into the read buffer. More...

void	readNotification ()

void	resetSocketLayer ()
	Resets the socket layer, clears the read and write buffers and deletes any socket notifiers. More...

void	resolveProxy (const QString &hostName, quint16 port)
	Resolve the proxy to its final value. More...

void	resolveProxy (quint16 port)

void	setupSocketNotifiers ()

void	startConnectingByName (const QString &host)
	Starts the connection to host, like _q_startConnecting below, but without hostname resolution. More...

void	writeNotification ()

virtual	~QAbstractSocketPrivate ()
	Destructs the QAbstractSocket. More...

Public Functions inherited from QIODevicePrivate
bool	isSequential () const

virtual bool	putCharHelper (char c)

	QIODevicePrivate ()

virtual	~QIODevicePrivate ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Functions inherited from QAbstractSocketEngineReceiver
virtual	~QAbstractSocketEngineReceiver ()

Static Public Functions
static QString	getErrorsFromOpenSsl ()

static Q_AUTOTEST_EXPORT bool	isMatchingHostname (const QString &cn, const QString &hostname)

static QSslCipher	QSslCipher_from_SSL_CIPHER (SSL_CIPHER *cipher)

static QList< QSslCertificate >	STACKOFX509_to_QSslCertificates (STACK_OF(X509) *x509)

Static Public Functions inherited from QSslSocketPrivate
static void	addDefaultCaCertificate (const QSslCertificate &cert)

static bool	addDefaultCaCertificates (const QString &path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax)

static void	addDefaultCaCertificates (const QList< QSslCertificate > &certs)

static QList< QSslCertificate >	defaultCaCertificates ()

static QList< QSslCipher >	defaultCiphers ()

static void	deinitialize ()

static void	ensureInitialized ()
	Declared static in QSslSocketPrivate, makes sure the SSL libraries have been initialized. More...

static void	pauseSocketNotifiers (QSslSocket *)

static void	resetDefaultCiphers ()
	Declared static in QSslSocketPrivate, backend-dependent loading of application-wide global ciphers. More...

static void	resumeSocketNotifiers (QSslSocket *)

static Q_AUTOTEST_EXPORT bool	rootCertOnDemandLoadingSupported ()

static void	setDefaultCaCertificates (const QList< QSslCertificate > &certs)

static void	setDefaultCiphers (const QList< QSslCipher > &ciphers)

static void	setDefaultSupportedCiphers (const QList< QSslCipher > &ciphers)

static QList< QSslCipher >	supportedCiphers ()

static bool	supportsSsl ()
	Does the minimum amount of initialization to determine whether SSL is supported or not. More...

static QList< QSslCertificate >	systemCaCertificates ()

Static Public Functions inherited from QAbstractSocketPrivate
static QAbstractSocketEngine *	getSocketEngine (QAbstractSocket *)

static void	pauseSocketNotifiers (QAbstractSocket *)

static void	resumeSocketNotifiers (QAbstractSocket *)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
X509_STORE *	certificateStore

X509_STORE_CTX *	certificateStoreCtx

SSL_CTX *	ctx

QList< QPair< int, int > >	errorList

EVP_PKEY *	pkey

BIO *	readBio

SSL_SESSION *	session

SSL *	ssl

BIO *	writeBio

Public Variables inherited from QSslSocketPrivate
bool	allowRootCertOnDemandLoading

bool	autoStartHandshake

QSslConfigurationPrivate	configuration

bool	connectionEncrypted

bool	ignoreAllSslErrors

QList< QSslError >	ignoreErrorsList

bool	initialized

QSslSocket::SslMode	mode

QTcpSocket *	plainSocket

bool *	readyReadEmittedPointer

bool	shutdown

QList< QSslError >	sslErrors

QString	verificationPeerName

Public Variables inherited from QAbstractSocketPrivate
bool	abortCalled

QList< QHostAddress >	addresses

int	blockingTimeout

int	cachedSocketDescriptor

bool	closeCalled

int	connectTimeElapsed

QTimer *	connectTimer

QTimer *	disconnectTimer

bool	emittedBytesWritten

bool	emittedReadyRead

QHostAddress	host

int	hostLookupId

QString	hostName

bool	isBuffered

QHostAddress	localAddress

quint16	localPort

QHostAddress	peerAddress

QString	peerName

quint16	peerPort

bool	pendingClose

quint16	port

bool	prePauseExceptionSocketNotifierState

bool	prePauseReadSocketNotifierState

bool	prePauseWriteSocketNotifierState

QNetworkProxy	proxy

QNetworkProxy	proxyInUse

QRingBuffer	readBuffer

qint64	readBufferMaxSize

bool	readSocketNotifierCalled

bool	readSocketNotifierState

bool	readSocketNotifierStateSet

QAbstractSocketEngine *	socketEngine

QAbstractSocket::SocketError	socketError

QAbstractSocket::SocketType	socketType

QAbstractSocket::SocketState	state

QRingBuffer	writeBuffer

Public Variables inherited from QIODevicePrivate
AccessMode	accessMode

bool	baseReadLineDataCalled

QIODevicePrivateLinearBuffer	buffer

qint64	devicePos

QString	errorString

bool	firstRead

QIODevice::OpenMode	openMode

qint64 *	pDevicePos

qint64	pos

qint64 *	pPos

qint64	seqDumpPos

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QIODevicePrivate
enum	AccessMode { Unset, Sequential, RandomAccess }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Static Public Variables inherited from QSslSocketPrivate
static PtrSecCertificateGetData	ptrSecCertificateGetData = 0

static PtrSecTrustCopyAnchorCertificates	ptrSecTrustCopyAnchorCertificates = 0

static PtrSecTrustSettingsCopyCertificates	ptrSecTrustSettingsCopyCertificates = 0

Static Protected Functions inherited from QSslSocketPrivate
static QList< QByteArray >	unixRootCertDirectories ()

Static Protected Variables inherited from QSslSocketPrivate
static bool	s_loadRootCertsOnDemand = false

Detailed Description

Definition at line 93 of file qsslsocket_openssl_p.h.

Constructors and Destructors

◆ QSslSocketBackendPrivate()

QSslSocketBackendPrivate::QSslSocketBackendPrivate ( )

Definition at line 173 of file qsslsocket_openssl.cpp.

     : ssl(0),
       ctx(0),
       pkey(0),
       readBio(0),
       writeBio(0),
       session(0)
 {
     // Calls SSL_library_init().
     ensureInitialized();
 }

◆ ~QSslSocketBackendPrivate()

QSslSocketBackendPrivate::~QSslSocketBackendPrivate ( )

virtual

Definition at line 185 of file qsslsocket_openssl.cpp.

 {
     destroySslContext();
 }

Functions

◆ destroySslContext()

void QSslSocketBackendPrivate::destroySslContext ( )

Definition at line 485 of file qsslsocket_openssl.cpp.

Referenced by disconnected(), and ~QSslSocketBackendPrivate().

 {
     if (ssl) {
         q_SSL_free(ssl);
         ssl = 0;
     }
     if (ctx) {
         q_SSL_CTX_free(ctx);
         ctx = 0;
     }
     if (pkey) {
         q_EVP_PKEY_free(pkey);
         pkey = 0;
     }
 }

◆ disconnected()

void QSslSocketBackendPrivate::disconnected ( )

virtual

Implements QSslSocketPrivate.

Definition at line 1473 of file qsslsocket_openssl.cpp.

 {
     if (plainSocket->bytesAvailable() <= 0)
         destroySslContext();
     //if there is still buffered data in the plain socket, don't destroy the ssl context yet.
     //it will be destroyed when the socket is deleted.
 }

◆ disconnectFromHost()

void QSslSocketBackendPrivate::disconnectFromHost ( )

virtual

Implements QSslSocketPrivate.

Definition at line 1461 of file qsslsocket_openssl.cpp.

 {
     if (ssl) {
         if (!shutdown) {
             q_SSL_shutdown(ssl);
             shutdown = true;
             transmit();
         }
     }
     plainSocket->disconnectFromHost();
 }

◆ getErrorsFromOpenSsl()

QString QSslSocketBackendPrivate::getErrorsFromOpenSsl ( )

static

Definition at line 1507 of file qsslsocket_openssl.cpp.

Referenced by initSslContext(), startHandshake(), and transmit().

 {
     QString errorString;
     unsigned long errNum;
     while((errNum = q_ERR_get_error())) {
         if (! errorString.isEmpty())
             errorString.append(QLatin1String(", "));
         const char *error = q_ERR_error_string(errNum, NULL);
         errorString.append(QString::fromAscii(error)); // error is ascii according to man ERR_error_string
     }
     return errorString;
 }

◆ initSslContext()

bool QSslSocketBackendPrivate::initSslContext ( )

Definition at line 248 of file qsslsocket_openssl.cpp.

Referenced by startClientEncryption(), and startServerEncryption().

 {
     Q_Q(QSslSocket);
 
     // Create and initialize SSL context. Accept SSLv2, SSLv3 and TLSv1.
     bool client = (mode == QSslSocket::SslClientMode);
 
     bool reinitialized = false;
 init_context:
     switch (configuration.protocol) {
     case QSsl::SslV2:
 #ifndef OPENSSL_NO_SSL2
         ctx = q_SSL_CTX_new(client ? q_SSLv2_client_method() : q_SSLv2_server_method());
 #else
         ctx = 0; // SSL 2 not supported by the system, but chosen deliberately -> error
 #endif
         break;
     case QSsl::SslV3:
         ctx = q_SSL_CTX_new(client ? q_SSLv3_client_method() : q_SSLv3_server_method());
         break;
     case QSsl::SecureProtocols: // SslV2 will be disabled below
     case QSsl::TlsV1SslV3: // SslV2 will be disabled below
     case QSsl::AnyProtocol:
     default:
         ctx = q_SSL_CTX_new(client ? q_SSLv23_client_method() : q_SSLv23_server_method());
         break;
     case QSsl::TlsV1:
         ctx = q_SSL_CTX_new(client ? q_TLSv1_client_method() : q_TLSv1_server_method());
         break;
     }
     if (!ctx) {
         // After stopping Flash 10 the SSL library looses its ciphers. Try re-adding them
         // by re-initializing the library.
         if (!reinitialized) {
             reinitialized = true;
             if (q_SSL_library_init() == 1)
                 goto init_context;
         }
 
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Error creating SSL context (%1)").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
         return false;
     }
 
     // Enable bug workarounds.
     long options;
     if (configuration.protocol == QSsl::TlsV1SslV3 || configuration.protocol == QSsl::SecureProtocols)
         options = SSL_OP_ALL|SSL_OP_NO_SSLv2;
     else
         options = SSL_OP_ALL;
 
     // This option is disabled by default, so we need to be able to clear it
     if (configuration.sslOptions & QSsl::SslOptionDisableEmptyFragments)
         options |= SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
     else
         options &= ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
 
 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
     // This option is disabled by default, so we need to be able to clear it
     if (configuration.sslOptions & QSsl::SslOptionDisableLegacyRenegotiation)
         options &= ~SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION;
     else
         options |= SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION;
 #endif
 
 #ifdef SSL_OP_NO_TICKET
     if (configuration.sslOptions & QSsl::SslOptionDisableSessionTickets)
         options |= SSL_OP_NO_TICKET;
 #endif
 #ifdef SSL_OP_NO_COMPRESSION
     if (configuration.sslOptions & QSsl::SslOptionDisableCompression)
         options |= SSL_OP_NO_COMPRESSION;
 #endif
 
     q_SSL_CTX_set_options(ctx, options);
 
     // Initialize ciphers
     QByteArray cipherString;
     int first = true;
     QList<QSslCipher> ciphers = configuration.ciphers;
     if (ciphers.isEmpty())
         ciphers = defaultCiphers();
     foreach (const QSslCipher &cipher, ciphers) {
         if (first)
             first = false;
         else
             cipherString.append(':');
         cipherString.append(cipher.name().toLatin1());
     }
 
     if (!q_SSL_CTX_set_cipher_list(ctx, cipherString.data())) {
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Invalid or empty cipher list (%1)").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
         return false;
     }
 
     // Add all our CAs to this store.
     QList<QSslCertificate> expiredCerts;
     foreach (const QSslCertificate &caCertificate, q->caCertificates()) {
         // add expired certs later, so that the
         // valid ones are used before the expired ones
         if (! caCertificate.isValid()) {
             expiredCerts.append(caCertificate);
         } else {
             q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle());
         }
     }
 
     bool addExpiredCerts = true;
 #if defined(Q_OS_MAC) && (MAC_OS_X_VERSION_MAX_ALLOWED == MAC_OS_X_VERSION_10_5)
     //On Leopard SSL does not work if we add the expired certificates.
     if (QSysInfo::MacintoshVersion == QSysInfo::MV_10_5)
        addExpiredCerts = false;
 #endif
     // now add the expired certs
     if (addExpiredCerts) {
         foreach (const QSslCertificate &caCertificate, expiredCerts) {
             q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle());
         }
     }
 
     if (s_loadRootCertsOnDemand && allowRootCertOnDemandLoading) {
         // tell OpenSSL the directories where to look up the root certs on demand
         QList<QByteArray> unixDirs = unixRootCertDirectories();
         for (int a = 0; a < unixDirs.count(); ++a)
             q_SSL_CTX_load_verify_locations(ctx, 0, unixDirs.at(a).constData());
     }
 
     if (!configuration.localCertificate.isNull()) {
         // Require a private key as well.
         if (configuration.privateKey.isNull()) {
             q->setErrorString(QSslSocket::tr("Cannot provide a certificate with no key, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
         }
 
         // Load certificate
         if (!q_SSL_CTX_use_certificate(ctx, (X509 *)configuration.localCertificate.handle())) {
             q->setErrorString(QSslSocket::tr("Error loading local certificate, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
         }
 
         // Load private key
         pkey = q_EVP_PKEY_new();
         // before we were using EVP_PKEY_assign_R* functions and did not use EVP_PKEY_free.
         // this lead to a memory leak. Now we use the *_set1_* functions which do not
         // take ownership of the RSA/DSA key instance because the QSslKey already has ownership.
         if (configuration.privateKey.algorithm() == QSsl::Rsa)
             q_EVP_PKEY_set1_RSA(pkey, (RSA *)configuration.privateKey.handle());
         else
             q_EVP_PKEY_set1_DSA(pkey, (DSA *)configuration.privateKey.handle());
         if (!q_SSL_CTX_use_PrivateKey(ctx, pkey)) {
             q->setErrorString(QSslSocket::tr("Error loading private key, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
         }
 
         // Check if the certificate matches the private key.
         if (!q_SSL_CTX_check_private_key(ctx)) {
             q->setErrorString(QSslSocket::tr("Private key does not certify public key, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
         }
     }
 
     // Initialize peer verification.
     if (configuration.peerVerifyMode == QSslSocket::VerifyNone) {
         q_SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
     } else {
         q_SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, q_X509Callback);
     }
 
     // Set verification depth.
     if (configuration.peerVerifyDepth != 0)
         q_SSL_CTX_set_verify_depth(ctx, configuration.peerVerifyDepth);
 
     // Create and initialize SSL session
     if (!(ssl = q_SSL_new(ctx))) {
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Error creating SSL session, %1").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
         return false;
     }
 
 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
     if ((configuration.protocol == QSsl::TlsV1SslV3 ||
         configuration.protocol == QSsl::TlsV1 ||
         configuration.protocol == QSsl::SecureProtocols ||
         configuration.protocol == QSsl::AnyProtocol) &&
         client && q_SSLeay() >= 0x00090806fL) {
         // Set server hostname on TLS extension. RFC4366 section 3.1 requires it in ACE format.
         QString tlsHostName = verificationPeerName.isEmpty() ? q->peerName() : verificationPeerName;
         if (tlsHostName.isEmpty())
             tlsHostName = hostName;
         QByteArray ace = QUrl::toAce(tlsHostName);
         // only send the SNI header if the URL is valid and not an IP
         if (!ace.isEmpty()
             && !QHostAddress().setAddress(tlsHostName)
             && !(configuration.sslOptions & QSsl::SslOptionDisableServerNameIndication)) {
             if (!q_SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, ace.data()))
                 qWarning("could not set SSL_CTRL_SET_TLSEXT_HOSTNAME, Server Name Indication disabled");
         }
     }
 #endif
 
     // Clear the session.
     q_SSL_clear(ssl);
     errorList.clear();
 
     // Initialize memory BIOs for encryption and decryption.
     readBio = q_BIO_new(q_BIO_s_mem());
     writeBio = q_BIO_new(q_BIO_s_mem());
     if (!readBio || !writeBio) {
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Error creating SSL session: %1").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
         return false;
     }
 
     // Assign the bios.
     q_SSL_set_bio(ssl, readBio, writeBio);
 
     if (mode == QSslSocket::SslClientMode)
         q_SSL_set_connect_state(ssl);
     else
         q_SSL_set_accept_state(ssl);
 
     return true;
 }

◆ isMatchingHostname()

bool QSslSocketBackendPrivate::isMatchingHostname	(	const QString &	cn,
		const QString &	hostname
	)

static

Definition at line 1520 of file qsslsocket_openssl.cpp.

Referenced by startHandshake().

 {
     int wildcard = cn.indexOf(QLatin1Char('*'));
 
     // Check this is a wildcard cert, if not then just compare the strings
     if (wildcard < 0)
         return cn == hostname;
 
     int firstCnDot = cn.indexOf(QLatin1Char('.'));
     int secondCnDot = cn.indexOf(QLatin1Char('.'), firstCnDot+1);
 
     // Check at least 3 components
     if ((-1 == secondCnDot) || (secondCnDot+1 >= cn.length()))
         return false;
 
     // Check * is last character of 1st component (ie. there's a following .)
     if (wildcard+1 != firstCnDot)
         return false;
 
     // Check only one star
     if (cn.lastIndexOf(QLatin1Char('*')) != wildcard)
         return false;
 
     // Check characters preceding * (if any) match
     if (wildcard && (hostname.leftRef(wildcard) != cn.leftRef(wildcard)))
         return false;
 
     // Check characters following first . match
     if (hostname.midRef(hostname.indexOf(QLatin1Char('.'))) != cn.midRef(firstCnDot))
         return false;
 
     // Check if the hostname is an IP address, if so then wildcards are not allowed
     QHostAddress addr(hostname);
     if (!addr.isNull())
         return false;
 
     // Ok, I guess this was a wildcard CN and the hostname matches.
     return true;
 }

◆ QSslCipher_from_SSL_CIPHER()

QSslCipher QSslSocketBackendPrivate::QSslCipher_from_SSL_CIPHER ( SSL_CIPHER * cipher )

static

Definition at line 190 of file qsslsocket_openssl.cpp.

Referenced by QSslSocketPrivate::resetDefaultCiphers(), and sessionCipher().

 {
     QSslCipher ciph;
 
     char buf [256];
     QString descriptionOneLine = QString::fromLatin1(q_SSL_CIPHER_description(cipher, buf, sizeof(buf)));
 
     QStringList descriptionList = descriptionOneLine.split(QLatin1String(" "), QString::SkipEmptyParts);
     if (descriptionList.size() > 5) {
         // ### crude code.
         ciph.d->isNull = false;
         ciph.d->name = descriptionList.at(0);
 
         QString protoString = descriptionList.at(1);
         ciph.d->protocolString = protoString;
         ciph.d->protocol = QSsl::UnknownProtocol;
         if (protoString == QLatin1String("SSLv3"))
             ciph.d->protocol = QSsl::SslV3;
         else if (protoString == QLatin1String("SSLv2"))
             ciph.d->protocol = QSsl::SslV2;
         else if (protoString == QLatin1String("TLSv1"))
             ciph.d->protocol = QSsl::TlsV1;
 
         if (descriptionList.at(2).startsWith(QLatin1String("Kx=")))
             ciph.d->keyExchangeMethod = descriptionList.at(2).mid(3);
         if (descriptionList.at(3).startsWith(QLatin1String("Au=")))
             ciph.d->authenticationMethod = descriptionList.at(3).mid(3);
         if (descriptionList.at(4).startsWith(QLatin1String("Enc=")))
             ciph.d->encryptionMethod = descriptionList.at(4).mid(4);
         ciph.d->exportable = (descriptionList.size() > 6 && descriptionList.at(6) == QLatin1String("export"));
 
         ciph.d->bits = cipher->strength_bits;
         ciph.d->supportedBits = cipher->alg_bits;
 
     }
     return ciph;
 }

◆ sessionCipher()

QSslCipher QSslSocketBackendPrivate::sessionCipher ( ) const

virtual

Implements QSslSocketPrivate.

Definition at line 1481 of file qsslsocket_openssl.cpp.

 {
     if (!ssl || !ctx)
         return QSslCipher();
 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
     // FIXME This is fairly evil, but needed to keep source level compatibility
     // with the OpenSSL 0.9.x implementation at maximum -- some other functions
     // don't take a const SSL_CIPHER* when they should
     SSL_CIPHER *sessionCipher = const_cast<SSL_CIPHER *>(q_SSL_get_current_cipher(ssl));
 #else
     SSL_CIPHER *sessionCipher = q_SSL_get_current_cipher(ssl);
 #endif
     return sessionCipher ? QSslCipher_from_SSL_CIPHER(sessionCipher) : QSslCipher();
 }

◆ STACKOFX509_to_QSslCertificates()

QList< QSslCertificate > QSslSocketBackendPrivate::STACKOFX509_to_QSslCertificates ( STACK_OF(X509) * x509 )

static

Definition at line 1496 of file qsslsocket_openssl.cpp.

Referenced by startHandshake().

 {
     ensureInitialized();
     QList<QSslCertificate> certificates;
     for (int i = 0; i < q_sk_X509_num(x509); ++i) {
         if (X509 *entry = q_sk_X509_value(x509, i))
             certificates << QSslCertificatePrivate::QSslCertificate_from_X509(entry);
     }
     return certificates;
 }

◆ startClientEncryption()

void QSslSocketBackendPrivate::startClientEncryption ( )

virtual

Implements QSslSocketPrivate.

Definition at line 980 of file qsslsocket_openssl.cpp.

 {
     if (!initSslContext()) {
         // ### report error: internal OpenSSL failure
         return;
     }
 
     // Start connecting. This will place outgoing data in the BIO, so we
     // follow up with calling transmit().
     startHandshake();
     transmit();
 }

◆ startHandshake()

bool QSslSocketBackendPrivate::startHandshake ( )

Definition at line 1254 of file qsslsocket_openssl.cpp.

Referenced by startClientEncryption(), startServerEncryption(), and transmit().

 {
     Q_Q(QSslSocket);
 
     // Check if the connection has been established. Get all errors from the
     // verification stage.
     _q_sslErrorList()->mutex.lock();
     _q_sslErrorList()->errors.clear();
     int result = (mode == QSslSocket::SslClientMode) ? q_SSL_connect(ssl) : q_SSL_accept(ssl);
 
     const QList<QPair<int, int> > &lastErrors = _q_sslErrorList()->errors;
     for (int i = 0; i < lastErrors.size(); ++i) {
         const QPair<int, int> &currentError = lastErrors.at(i);
         // Initialize the peer certificate chain in order to find which certificate caused this error
         if (configuration.peerCertificateChain.isEmpty())
             configuration.peerCertificateChain = STACKOFX509_to_QSslCertificates(q_SSL_get_peer_cert_chain(ssl));
         emit q->peerVerifyError(_q_OpenSSL_to_QSslError(currentError.first,
                                 configuration.peerCertificateChain.value(currentError.second)));
         if (q->state() != QAbstractSocket::ConnectedState)
             break;
     }
 
     errorList << lastErrors;
     _q_sslErrorList()->mutex.unlock();
 
     // Connection aborted during handshake phase.
     if (q->state() != QAbstractSocket::ConnectedState)
         return false;
 
     // Check if we're encrypted or not.
     if (result <= 0) {
         switch (q_SSL_get_error(ssl, result)) {
         case SSL_ERROR_WANT_READ:
         case SSL_ERROR_WANT_WRITE:
             // The handshake is not yet complete.
             break;
         default:
             q->setErrorString(QSslSocket::tr("Error during SSL handshake: %1").arg(getErrorsFromOpenSsl()));
             q->setSocketError(QAbstractSocket::SslHandshakeFailedError);
 #ifdef QSSLSOCKET_DEBUG
             qDebug() << "QSslSocketBackendPrivate::startHandshake: error!" << q->errorString();
 #endif
             emit q->error(QAbstractSocket::SslHandshakeFailedError);
             q->abort();
         }
         return false;
     }
 
     // Store the peer certificate and chain. For clients, the peer certificate
     // chain includes the peer certificate; for servers, it doesn't. Both the
     // peer certificate and the chain may be empty if the peer didn't present
     // any certificate.
     if (configuration.peerCertificateChain.isEmpty())
         configuration.peerCertificateChain = STACKOFX509_to_QSslCertificates(q_SSL_get_peer_cert_chain(ssl));
     X509 *x509 = q_SSL_get_peer_certificate(ssl);
     configuration.peerCertificate = QSslCertificatePrivate::QSslCertificate_from_X509(x509);
     q_X509_free(x509);
 
     // Start translating errors.
     QList<QSslError> errors;
 
     // check the whole chain for blacklisting (including root, as we check for subjectInfo and issuer)
     foreach (const QSslCertificate &cert, configuration.peerCertificateChain) {
         if (QSslCertificatePrivate::isBlacklisted(cert)) {
             QSslError error(QSslError::CertificateBlacklisted, cert);
             errors << error;
             emit q->peerVerifyError(error);
             if (q->state() != QAbstractSocket::ConnectedState)
                 return false;
         }
     }
 
     bool doVerifyPeer = configuration.peerVerifyMode == QSslSocket::VerifyPeer
                         || (configuration.peerVerifyMode == QSslSocket::AutoVerifyPeer
                             && mode == QSslSocket::SslClientMode);
 
     // Check the peer certificate itself. First try the subject's common name
     // (CN) as a wildcard, then try all alternate subject name DNS entries the
     // same way.
     if (!configuration.peerCertificate.isNull()) {
         // but only if we're a client connecting to a server
         // if we're the server, don't check CN
         if (mode == QSslSocket::SslClientMode) {
             QString peerName = (verificationPeerName.isEmpty () ? q->peerName() : verificationPeerName);
             QString commonName = configuration.peerCertificate.subjectInfo(QSslCertificate::CommonName);
 
             if (!isMatchingHostname(commonName.toLower(), peerName.toLower())) {
                 bool matched = false;
                 foreach (const QString &altName, configuration.peerCertificate
                          .alternateSubjectNames().values(QSsl::DnsEntry)) {
                     if (isMatchingHostname(altName.toLower(), peerName.toLower())) {
                         matched = true;
                         break;
                     }
                 }
 
                 if (!matched) {
                     // No matches in common names or alternate names.
                     QSslError error(QSslError::HostNameMismatch, configuration.peerCertificate);
                     errors << error;
                     emit q->peerVerifyError(error);
                     if (q->state() != QAbstractSocket::ConnectedState)
                         return false;
                 }
             }
         }
     } else {
         // No peer certificate presented. Report as error if the socket
         // expected one.
         if (doVerifyPeer) {
             QSslError error(QSslError::NoPeerCertificate);
             errors << error;
             emit q->peerVerifyError(error);
             if (q->state() != QAbstractSocket::ConnectedState)
                 return false;
         }
     }
 
     // Translate errors from the error list into QSslErrors.
     for (int i = 0; i < errorList.size(); ++i) {
         const QPair<int, int> &errorAndDepth = errorList.at(i);
         int err = errorAndDepth.first;
         int depth = errorAndDepth.second;
         errors << _q_OpenSSL_to_QSslError(err, configuration.peerCertificateChain.value(depth));
     }
 
     if (!errors.isEmpty()) {
         sslErrors = errors;
         emit q->sslErrors(errors);
 
         bool doEmitSslError;
         if (!ignoreErrorsList.empty()) {
             // check whether the errors we got are all in the list of expected errors
             // (applies only if the method QSslSocket::ignoreSslErrors(const QList<QSslError> &errors)
             // was called)
             doEmitSslError = false;
             for (int a = 0; a < errors.count(); a++) {
                 if (!ignoreErrorsList.contains(errors.at(a))) {
                     doEmitSslError = true;
                     break;
                 }
             }
         } else {
             // if QSslSocket::ignoreSslErrors(const QList<QSslError> &errors) was not called and
             // we get an SSL error, emit a signal unless we ignored all errors (by calling
             // QSslSocket::ignoreSslErrors() )
             doEmitSslError = !ignoreAllSslErrors;
         }
         // check whether we need to emit an SSL handshake error
         if (doVerifyPeer && doEmitSslError) {
             q->setErrorString(sslErrors.first().errorString());
             q->setSocketError(QAbstractSocket::SslHandshakeFailedError);
             emit q->error(QAbstractSocket::SslHandshakeFailedError);
             plainSocket->disconnectFromHost();
             return false;
         }
     } else {
         sslErrors.clear();
     }
 
     // if we have a max read buffer size, reset the plain socket's to 32k
     if (readBufferMaxSize)
         plainSocket->setReadBufferSize(32768);
 
 #ifdef QT_DECRYPT_SSL_TRAFFIC
     if (ssl->session && ssl->s3) {
         const char *mk = reinterpret_cast<const char *>(ssl->session->master_key);
         QByteArray masterKey(mk, ssl->session->master_key_length);
         const char *random = reinterpret_cast<const char *>(ssl->s3->client_random);
         QByteArray clientRandom(random, SSL3_RANDOM_SIZE);
 
         // different format, needed for e.g. older Wireshark versions:
 //        const char *sid = reinterpret_cast<const char *>(ssl->session->session_id);
 //        QByteArray sessionID(sid, ssl->session->session_id_length);
 //        QByteArray debugLineRSA("RSA Session-ID:");
 //        debugLineRSA.append(sessionID.toHex().toUpper());
 //        debugLineRSA.append(" Master-Key:");
 //        debugLineRSA.append(masterKey.toHex().toUpper());
 //        debugLineRSA.append("\n");
 
         QByteArray debugLineClientRandom("CLIENT_RANDOM ");
         debugLineClientRandom.append(clientRandom.toHex().toUpper());
         debugLineClientRandom.append(" ");
         debugLineClientRandom.append(masterKey.toHex().toUpper());
         debugLineClientRandom.append("\n");
 
         QString sslKeyFile = QDir::tempPath() + QLatin1String("/qt-ssl-keys");
         QFile file(sslKeyFile);
         if (!file.open(QIODevice::Append))
             qWarning() << "could not open file" << sslKeyFile << "for appending";
         if (!file.write(debugLineClientRandom))
             qWarning() << "could not write to file" << sslKeyFile;
         file.close();
     } else {
         qWarning("could not decrypt SSL traffic");
     }
 #endif
 
     connectionEncrypted = true;
     emit q->encrypted();
     if (autoStartHandshake && pendingClose) {
         pendingClose = false;
         q->disconnectFromHost();
     }
     return true;
 }

◆ startServerEncryption()

void QSslSocketBackendPrivate::startServerEncryption ( )

virtual

Implements QSslSocketPrivate.

Definition at line 993 of file qsslsocket_openssl.cpp.

 {
     if (!initSslContext()) {
         // ### report error: internal OpenSSL failure
         return;
     }
 
     // Start connecting. This will place outgoing data in the BIO, so we
     // follow up with calling transmit().
     startHandshake();
     transmit();
 }

◆ transmit()

void QSslSocketBackendPrivate::transmit ( )

virtual

Transmits encrypted data between the BIOs and the socket.

Warning: This function is not part of the public interface.

Implements QSslSocketPrivate.

Definition at line 1014 of file qsslsocket_openssl.cpp.

Referenced by disconnectFromHost(), startClientEncryption(), and startServerEncryption().

 {
     Q_Q(QSslSocket);
 
     // If we don't have any SSL context, don't bother transmitting.
     if (!ssl)
         return;
 
     bool transmitting;
     do {
         transmitting = false;
 
         // If the connection is secure, we can transfer data from the write
         // buffer (in plain text) to the write BIO through SSL_write.
         if (connectionEncrypted && !writeBuffer.isEmpty()) {
             qint64 totalBytesWritten = 0;
             int nextDataBlockSize;
             while ((nextDataBlockSize = writeBuffer.nextDataBlockSize()) > 0) {
                 int writtenBytes = q_SSL_write(ssl, writeBuffer.readPointer(), nextDataBlockSize);
                 if (writtenBytes <= 0) {
                     // ### Better error handling.
                     q->setErrorString(QSslSocket::tr("Unable to write data: %1").arg(getErrorsFromOpenSsl()));
                     q->setSocketError(QAbstractSocket::UnknownSocketError);
                     emit q->error(QAbstractSocket::UnknownSocketError);
                     return;
                 }
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: encrypted" << writtenBytes << "bytes";
 #endif
                 writeBuffer.free(writtenBytes);
                 totalBytesWritten += writtenBytes;
 
                 if (writtenBytes < nextDataBlockSize) {
                     // break out of the writing loop and try again after we had read
                     transmitting = true;
                     break;
                 }
             }
 
             if (totalBytesWritten > 0) {
                 // Don't emit bytesWritten() recursively.
                 if (!emittedBytesWritten) {
                     emittedBytesWritten = true;
                     emit q->bytesWritten(totalBytesWritten);
                     emittedBytesWritten = false;
                 }
             }
         }
 
         // Check if we've got any data to be written to the socket.
         QVarLengthArray<char, 4096> data;
         int pendingBytes;
         while (plainSocket->isValid() && (pendingBytes = q_BIO_pending(writeBio)) > 0) {
             // Read encrypted data from the write BIO into a buffer.
             data.resize(pendingBytes);
             int encryptedBytesRead = q_BIO_read(writeBio, data.data(), pendingBytes);
 
             // Write encrypted data from the buffer to the socket.
             qint64 actualWritten = plainSocket->write(data.constData(), encryptedBytesRead);
 #ifdef QSSLSOCKET_DEBUG
             qDebug() << "QSslSocketBackendPrivate::transmit: wrote" << encryptedBytesRead << "encrypted bytes to the socket" << actualWritten << "actual.";
 #endif
             if (actualWritten < 0) {
                 //plain socket write fails if it was in the pending close state.
                 q->setErrorString(plainSocket->errorString());
                 q->setSocketError(plainSocket->error());
                 emit q->error(plainSocket->error());
                 return;
             }
             transmitting = true;
         }
 
         // Check if we've got any data to be read from the socket.
         if (!connectionEncrypted || !readBufferMaxSize || readBuffer.size() < readBufferMaxSize)
             while ((pendingBytes = plainSocket->bytesAvailable()) > 0) {
                 // Read encrypted data from the socket into a buffer.
                 data.resize(pendingBytes);
                 // just peek() here because q_BIO_write could write less data than expected
                 int encryptedBytesRead = plainSocket->peek(data.data(), pendingBytes);
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: read" << encryptedBytesRead << "encrypted bytes from the socket";
 #endif
                 // Write encrypted data from the buffer into the read BIO.
                 int writtenToBio = q_BIO_write(readBio, data.constData(), encryptedBytesRead);
 
                 // do the actual read() here and throw away the results.
                 if (writtenToBio > 0) {
                     // ### TODO: make this cheaper by not making it memcpy. E.g. make it work with data=0x0 or make it work with seek
                     plainSocket->read(data.data(), writtenToBio);
                 } else {
                     // ### Better error handling.
                     q->setErrorString(QSslSocket::tr("Unable to decrypt data: %1").arg(getErrorsFromOpenSsl()));
                     q->setSocketError(QAbstractSocket::UnknownSocketError);
                     emit q->error(QAbstractSocket::UnknownSocketError);
                     return;
                 }
 
                 transmitting = true;
             }
 
         // If the connection isn't secured yet, this is the time to retry the
         // connect / accept.
         if (!connectionEncrypted) {
 #ifdef QSSLSOCKET_DEBUG
             qDebug() << "QSslSocketBackendPrivate::transmit: testing encryption";
 #endif
             if (startHandshake()) {
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: encryption established";
 #endif
                 connectionEncrypted = true;
                 transmitting = true;
             } else if (plainSocket->state() != QAbstractSocket::ConnectedState) {
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: connection lost";
 #endif
                 break;
             } else {
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: encryption not done yet";
 #endif
             }
         }
 
         // If the request is small and the remote host closes the transmission
         // after sending, there's a chance that startHandshake() will already
         // have triggered a shutdown.
         if (!ssl)
             continue;
 
         // We always read everything from the SSL decryption buffers, even if
         // we have a readBufferMaxSize. There's no point in leaving data there
         // just so that readBuffer.size() == readBufferMaxSize.
         int readBytes = 0;
         data.resize(4096);
         ::memset(data.data(), 0, data.size());
         do {
             // Don't use SSL_pending(). It's very unreliable.
             if ((readBytes = q_SSL_read(ssl, data.data(), data.size())) > 0) {
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: decrypted" << readBytes << "bytes";
 #endif
                 char *ptr = readBuffer.reserve(readBytes);
                 ::memcpy(ptr, data.data(), readBytes);
 
                 if (readyReadEmittedPointer)
                     *readyReadEmittedPointer = true;
                 emit q->readyRead();
                 transmitting = true;
                 continue;
             }
 
             // Error.
             switch (q_SSL_get_error(ssl, readBytes)) {
             case SSL_ERROR_WANT_READ:
             case SSL_ERROR_WANT_WRITE:
                 // Out of data.
                 break;
             case SSL_ERROR_ZERO_RETURN:
                 // The remote host closed the connection.
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: remote disconnect";
 #endif
                 shutdown = true; // the other side shut down, make sure we do not send shutdown ourselves
                 q->setErrorString(QSslSocket::tr("The TLS/SSL connection has been closed"));
                 q->setSocketError(QAbstractSocket::RemoteHostClosedError);
                 emit q->error(QAbstractSocket::RemoteHostClosedError);
                 return;
             case SSL_ERROR_SYSCALL: // some IO error
             case SSL_ERROR_SSL: // error in the SSL library
                 // we do not know exactly what the error is, nor whether we can recover from it,
                 // so just return to prevent an endless loop in the outer "while" statement
                 q->setErrorString(QSslSocket::tr("Error while reading: %1").arg(getErrorsFromOpenSsl()));
                 q->setSocketError(QAbstractSocket::UnknownSocketError);
                 emit q->error(QAbstractSocket::UnknownSocketError);
                 return;
             default:
                 // SSL_ERROR_WANT_CONNECT, SSL_ERROR_WANT_ACCEPT: can only happen with a
                 // BIO_s_connect() or BIO_s_accept(), which we do not call.
                 // SSL_ERROR_WANT_X509_LOOKUP: can only happen with a
                 // SSL_CTX_set_client_cert_cb(), which we do not call.
                 // So this default case should never be triggered.
                 q->setErrorString(QSslSocket::tr("Error while reading: %1").arg(getErrorsFromOpenSsl()));
                 q->setSocketError(QAbstractSocket::UnknownSocketError);
                 emit q->error(QAbstractSocket::UnknownSocketError);
                 break;
             }
         } while (ssl && readBytes > 0);
     } while (ssl && ctx && transmitting);
 }

Properties

◆ certificateStore

X509_STORE* QSslSocketBackendPrivate::certificateStore

Definition at line 109 of file qsslsocket_openssl_p.h.

◆ certificateStoreCtx

X509_STORE_CTX* QSslSocketBackendPrivate::certificateStoreCtx

Definition at line 110 of file qsslsocket_openssl_p.h.

◆ ctx

SSL_CTX* QSslSocketBackendPrivate::ctx

Definition at line 104 of file qsslsocket_openssl_p.h.

Referenced by destroySslContext(), initSslContext(), sessionCipher(), and transmit().

◆ errorList

QList<QPair<int, int> > QSslSocketBackendPrivate::errorList

Definition at line 111 of file qsslsocket_openssl_p.h.

Referenced by initSslContext(), and startHandshake().

◆ pkey

EVP_PKEY* QSslSocketBackendPrivate::pkey

Definition at line 105 of file qsslsocket_openssl_p.h.

Referenced by destroySslContext(), and initSslContext().

◆ readBio

BIO* QSslSocketBackendPrivate::readBio

Definition at line 106 of file qsslsocket_openssl_p.h.

Referenced by initSslContext(), and transmit().

◆ session

SSL_SESSION* QSslSocketBackendPrivate::session

Definition at line 108 of file qsslsocket_openssl_p.h.

◆ ssl

SSL* QSslSocketBackendPrivate::ssl

Definition at line 103 of file qsslsocket_openssl_p.h.

Referenced by destroySslContext(), disconnectFromHost(), initSslContext(), sessionCipher(), startHandshake(), and transmit().

◆ writeBio

BIO* QSslSocketBackendPrivate::writeBio

Definition at line 107 of file qsslsocket_openssl_p.h.

Referenced by initSslContext(), and transmit().

The documentation for this class was generated from the following files:

/src/network/ssl/qsslsocket_openssl_p.h
/src/network/ssl/qsslsocket_openssl.cpp

Public Functions

Static Public Functions

Public Variables

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QSslSocketBackendPrivate()

◆ ~QSslSocketBackendPrivate()

Functions

◆ destroySslContext()

◆ disconnected()

◆ disconnectFromHost()

◆ getErrorsFromOpenSsl()

◆ initSslContext()

◆ isMatchingHostname()

◆ QSslCipher_from_SSL_CIPHER()

◆ sessionCipher()

◆ STACKOFX509_to_QSslCertificates()

◆ startClientEncryption()

◆ startHandshake()

◆ startServerEncryption()

◆ transmit()

Properties

◆ certificateStore

◆ certificateStoreCtx

◆ ctx

◆ errorList

◆ pkey

◆ readBio

◆ session

◆ ssl

◆ writeBio