• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KDECore

  • kdecore
  • network
ktcpsocket.cpp
Go to the documentation of this file.
1/* This file is part of the KDE libraries
2 Copyright (C) 2007, 2008 Andreas Hartmetz <ahartmetz@gmail.com>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License as published by the Free Software Foundation; either
7 version 2 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public License
15 along with this library; see the file COPYING.LIB. If not, write to
16 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 Boston, MA 02110-1301, USA.
18*/
19
20#include "ktcpsocket.h"
21#include "ktcpsocket_p.h"
22
23#include <kdebug.h>
24#include <kurl.h>
25#include <kglobal.h>
26#include <ksslcertificatemanager.h>
27#include <kstandarddirs.h>
28#include <klocale.h>
29
30#include <QtCore/QStringList>
31#include <QtNetwork/QSslKey>
32#include <QtNetwork/QSslCipher>
33#include <QtNetwork/QHostAddress>
34#include <QtNetwork/QNetworkProxy>
35
36static KTcpSocket::SslVersion kSslVersionFromQ(QSsl::SslProtocol protocol)
37{
38 switch (protocol) {
39 case QSsl::SslV2:
40 return KTcpSocket::SslV2;
41 case QSsl::SslV3:
42 return KTcpSocket::SslV3;
43 case QSsl::TlsV1:
44 return KTcpSocket::TlsV1;
45 case QSsl::AnyProtocol:
46 return KTcpSocket::AnySslVersion;
47#if QT_VERSION >= 0x040800
48 case QSsl::TlsV1SslV3:
49 return KTcpSocket::TlsV1SslV3;
50 case QSsl::SecureProtocols:
51 return KTcpSocket::SecureProtocols;
52#endif
53 default:
54 return KTcpSocket::UnknownSslVersion;
55 }
56}
57
58
59static QSsl::SslProtocol qSslProtocolFromK(KTcpSocket::SslVersion sslVersion)
60{
61 //### this lowlevel bit-banging is a little dangerous and a likely source of bugs
62 if (sslVersion == KTcpSocket::AnySslVersion) {
63 return QSsl::AnyProtocol;
64 }
65 //does it contain any valid protocol?
66 KTcpSocket::SslVersions validVersions (KTcpSocket::SslV2 | KTcpSocket::SslV3 | KTcpSocket::TlsV1);
67#if QT_VERSION >= 0x040800
68 validVersions |= KTcpSocket::TlsV1SslV3;
69 validVersions |= KTcpSocket::SecureProtocols;
70#endif
71 if (!(sslVersion & validVersions)) {
72 return QSsl::UnknownProtocol;
73 }
74
75 switch (sslVersion) {
76 case KTcpSocket::SslV2:
77 return QSsl::SslV2;
78 case KTcpSocket::SslV3:
79 return QSsl::SslV3;
80 case KTcpSocket::TlsV1:
81 return QSsl::TlsV1;
82#if QT_VERSION >= 0x040800
83 case KTcpSocket::TlsV1SslV3:
84 return QSsl::TlsV1SslV3;
85 case KTcpSocket::SecureProtocols:
86 return QSsl::SecureProtocols;
87#endif
88
89 default:
90 //QSslSocket doesn't really take arbitrary combinations. It's one or all.
91 return QSsl::AnyProtocol;
92 }
93}
94
95
96//cipher class converter KSslCipher -> QSslCipher
97class CipherCc
98{
99public:
100 CipherCc()
101 {
102 foreach (const QSslCipher &c, QSslSocket::supportedCiphers()) {
103 allCiphers.insert(c.name(), c);
104 }
105 }
106
107 QSslCipher converted(const KSslCipher &ksc)
108 {
109 return allCiphers.value(ksc.name());
110 }
111
112private:
113 QHash<QString, QSslCipher> allCiphers;
114};
115
116
117class KSslErrorPrivate
118{
119public:
120 static KSslError::Error errorFromQSslError(QSslError::SslError e)
121 {
122 switch (e) {
123 case QSslError::NoError:
124 return KSslError::NoError;
125 case QSslError::UnableToGetLocalIssuerCertificate:
126 case QSslError::InvalidCaCertificate:
127 return KSslError::InvalidCertificateAuthorityCertificate;
128 case QSslError::InvalidNotBeforeField:
129 case QSslError::InvalidNotAfterField:
130 case QSslError::CertificateNotYetValid:
131 case QSslError::CertificateExpired:
132 return KSslError::ExpiredCertificate;
133 case QSslError::UnableToDecodeIssuerPublicKey:
134 case QSslError::SubjectIssuerMismatch:
135 case QSslError::AuthorityIssuerSerialNumberMismatch:
136 return KSslError::InvalidCertificate;
137 case QSslError::SelfSignedCertificate:
138 case QSslError::SelfSignedCertificateInChain:
139 return KSslError::SelfSignedCertificate;
140 case QSslError::CertificateRevoked:
141 return KSslError::RevokedCertificate;
142 case QSslError::InvalidPurpose:
143 return KSslError::InvalidCertificatePurpose;
144 case QSslError::CertificateUntrusted:
145 return KSslError::UntrustedCertificate;
146 case QSslError::CertificateRejected:
147 return KSslError::RejectedCertificate;
148 case QSslError::NoPeerCertificate:
149 return KSslError::NoPeerCertificate;
150 case QSslError::HostNameMismatch:
151 return KSslError::HostNameMismatch;
152 case QSslError::UnableToVerifyFirstCertificate:
153 case QSslError::UnableToDecryptCertificateSignature:
154 case QSslError::UnableToGetIssuerCertificate:
155 case QSslError::CertificateSignatureFailed:
156 return KSslError::CertificateSignatureFailed;
157 case QSslError::PathLengthExceeded:
158 return KSslError::PathLengthExceeded;
159 case QSslError::UnspecifiedError:
160 case QSslError::NoSslSupport:
161 default:
162 return KSslError::UnknownError;
163 }
164 }
165
166 static QString errorString(KSslError::Error e)
167 {
168 switch (e) {
169 case KSslError::NoError:
170 return i18nc("SSL error","No error");
171 case KSslError::InvalidCertificateAuthorityCertificate:
172 return i18nc("SSL error","The certificate authority's certificate is invalid");
173 case KSslError::ExpiredCertificate:
174 return i18nc("SSL error","The certificate has expired");
175 case KSslError::InvalidCertificate:
176 return i18nc("SSL error","The certificate is invalid");
177 case KSslError::SelfSignedCertificate:
178 return i18nc("SSL error","The certificate is not signed by any trusted certificate authority");
179 case KSslError::RevokedCertificate:
180 return i18nc("SSL error","The certificate has been revoked");
181 case KSslError::InvalidCertificatePurpose:
182 return i18nc("SSL error","The certificate is unsuitable for this purpose");
183 case KSslError::UntrustedCertificate:
184 return i18nc("SSL error","The root certificate authority's certificate is not trusted for this purpose");
185 case KSslError::RejectedCertificate:
186 return i18nc("SSL error","The certificate authority's certificate is marked to reject this certificate's purpose");
187 case KSslError::NoPeerCertificate:
188 return i18nc("SSL error","The peer did not present any certificate");
189 case KSslError::HostNameMismatch:
190 return i18nc("SSL error","The certificate does not apply to the given host");
191 case KSslError::CertificateSignatureFailed:
192 return i18nc("SSL error","The certificate cannot be verified for internal reasons");
193 case KSslError::PathLengthExceeded:
194 return i18nc("SSL error","The certificate chain is too long");
195 case KSslError::UnknownError:
196 default:
197 return i18nc("SSL error","Unknown error");
198 }
199 }
200
201 KSslError::Error error;
202 QSslCertificate certificate;
203};
204
205
206KSslError::KSslError(Error errorCode, const QSslCertificate &certificate)
207 : d(new KSslErrorPrivate())
208{
209 d->error = errorCode;
210 d->certificate = certificate;
211}
212
213
214KSslError::KSslError(const QSslError &other)
215 : d(new KSslErrorPrivate())
216{
217 d->error = KSslErrorPrivate::errorFromQSslError(other.error());
218 d->certificate = other.certificate();
219}
220
221
222KSslError::KSslError(const KSslError &other)
223 : d(new KSslErrorPrivate())
224{
225 *d = *other.d;
226}
227
228
229KSslError::~KSslError()
230{
231 delete d;
232}
233
234
235KSslError &KSslError::operator=(const KSslError &other)
236{
237 *d = *other.d;
238 return *this;
239}
240
241
242KSslError::Error KSslError::error() const
243{
244 return d->error;
245}
246
247
248QString KSslError::errorString() const
249{
250 return KSslErrorPrivate::errorString(d->error);
251}
252
253
254QSslCertificate KSslError::certificate() const
255{
256 return d->certificate;
257}
258
259
260class KTcpSocketPrivate
261{
262public:
263 KTcpSocketPrivate(KTcpSocket *qq)
264 : q(qq),
265 certificatesLoaded(false),
266 emittedReadyRead(false)
267 {
268 // create the instance, which sets Qt's static internal cert set to empty.
269 KSslCertificateManager::self();
270 }
271
272 KTcpSocket::State state(QAbstractSocket::SocketState s)
273 {
274 switch (s) {
275 case QAbstractSocket::UnconnectedState:
276 return KTcpSocket::UnconnectedState;
277 case QAbstractSocket::HostLookupState:
278 return KTcpSocket::HostLookupState;
279 case QAbstractSocket::ConnectingState:
280 return KTcpSocket::ConnectingState;
281 case QAbstractSocket::ConnectedState:
282 return KTcpSocket::ConnectedState;
283 case QAbstractSocket::ClosingState:
284 return KTcpSocket::ClosingState;
285 case QAbstractSocket::BoundState:
286 case QAbstractSocket::ListeningState:
287 //### these two are not relevant as long as this can't be a server socket
288 default:
289 return KTcpSocket::UnconnectedState; //the closest to "error"
290 }
291 }
292
293 KTcpSocket::EncryptionMode encryptionMode(QSslSocket::SslMode mode)
294 {
295 switch (mode) {
296 case QSslSocket::SslClientMode:
297 return KTcpSocket::SslClientMode;
298 case QSslSocket::SslServerMode:
299 return KTcpSocket::SslServerMode;
300 default:
301 return KTcpSocket::UnencryptedMode;
302 }
303 }
304
305 KTcpSocket::Error errorFromAbsSocket(QAbstractSocket::SocketError e)
306 {
307 switch (e) {
308 case QAbstractSocket::ConnectionRefusedError:
309 return KTcpSocket::ConnectionRefusedError;
310 case QAbstractSocket::RemoteHostClosedError:
311 return KTcpSocket::RemoteHostClosedError;
312 case QAbstractSocket::HostNotFoundError:
313 return KTcpSocket::HostNotFoundError;
314 case QAbstractSocket::SocketAccessError:
315 return KTcpSocket::SocketAccessError;
316 case QAbstractSocket::SocketResourceError:
317 return KTcpSocket::SocketResourceError;
318 case QAbstractSocket::SocketTimeoutError:
319 return KTcpSocket::SocketTimeoutError;
320 case QAbstractSocket::NetworkError:
321 return KTcpSocket::NetworkError;
322 case QAbstractSocket::UnsupportedSocketOperationError:
323 return KTcpSocket::UnsupportedSocketOperationError;
324 case QAbstractSocket::SslHandshakeFailedError:
325 return KTcpSocket::SslHandshakeFailedError;
326 case QAbstractSocket::DatagramTooLargeError:
327 //we don't do UDP
328 case QAbstractSocket::AddressInUseError:
329 case QAbstractSocket::SocketAddressNotAvailableError:
330 //### own values if/when we ever get server socket support
331 case QAbstractSocket::ProxyAuthenticationRequiredError:
332 //### maybe we need an enum value for this
333 case QAbstractSocket::UnknownSocketError:
334 default:
335 return KTcpSocket::UnknownError;
336 }
337 }
338
339 //private slots
340 void reemitSocketError(QAbstractSocket::SocketError e)
341 {
342 emit q->error(errorFromAbsSocket(e));
343 }
344
345 void reemitSslErrors(const QList<QSslError> &errors)
346 {
347 q->showSslErrors(); //H4X
348 QList<KSslError> kErrors;
349 foreach (const QSslError &e, errors) {
350 kErrors.append(KSslError(e));
351 }
352 emit q->sslErrors(kErrors);
353 }
354
355 void reemitStateChanged(QAbstractSocket::SocketState s)
356 {
357 emit q->stateChanged(state(s));
358 }
359
360 void reemitModeChanged(QSslSocket::SslMode m)
361 {
362 emit q->encryptionModeChanged(encryptionMode(m));
363 }
364
365 // This method is needed because we might emit readyRead() due to this QIODevice
366 // having some data buffered, so we need to care about blocking, too.
367 //### useless ATM as readyRead() now just calls d->sock.readyRead().
368 void reemitReadyRead()
369 {
370 if (!emittedReadyRead) {
371 emittedReadyRead = true;
372 emit q->readyRead();
373 emittedReadyRead = false;
374 }
375 }
376
377 void maybeLoadCertificates()
378 {
379 if (!certificatesLoaded) {
380 sock.setCaCertificates(KSslCertificateManager::self()->caCertificates());
381 certificatesLoaded = true;
382 }
383 }
384
385 KTcpSocket *const q;
386 bool certificatesLoaded;
387 bool emittedReadyRead;
388 QSslSocket sock;
389 QList<KSslCipher> ciphers;
390 KTcpSocket::SslVersion advertisedSslVersion;
391 CipherCc ccc;
392};
393
394
395KTcpSocket::KTcpSocket(QObject *parent)
396 : QIODevice(parent),
397 d(new KTcpSocketPrivate(this))
398{
399 d->advertisedSslVersion = SslV3;
400
401 connect(&d->sock, SIGNAL(aboutToClose()), this, SIGNAL(aboutToClose()));
402 connect(&d->sock, SIGNAL(bytesWritten(qint64)), this, SIGNAL(bytesWritten(qint64)));
403 connect(&d->sock, SIGNAL(encryptedBytesWritten(qint64)), this, SIGNAL(encryptedBytesWritten(qint64)));
404 connect(&d->sock, SIGNAL(readyRead()), this, SLOT(reemitReadyRead()));
405 connect(&d->sock, SIGNAL(connected()), this, SIGNAL(connected()));
406 connect(&d->sock, SIGNAL(encrypted()), this, SIGNAL(encrypted()));
407 connect(&d->sock, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
408#ifndef QT_NO_NETWORKPROXY
409 connect(&d->sock, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
410 this, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
411#endif
412 connect(&d->sock, SIGNAL(error(QAbstractSocket::SocketError)),
413 this, SLOT(reemitSocketError(QAbstractSocket::SocketError)));
414 connect(&d->sock, SIGNAL(sslErrors(QList<QSslError>)),
415 this, SLOT(reemitSslErrors(QList<QSslError>)));
416 connect(&d->sock, SIGNAL(hostFound()), this, SIGNAL(hostFound()));
417 connect(&d->sock, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
418 this, SLOT(reemitStateChanged(QAbstractSocket::SocketState)));
419 connect(&d->sock, SIGNAL(modeChanged(QSslSocket::SslMode)),
420 this, SLOT(reemitModeChanged(QSslSocket::SslMode)));
421}
422
423
424KTcpSocket::~KTcpSocket()
425{
426 delete d;
427}
428
430
431bool KTcpSocket::atEnd() const
432{
433 return d->sock.atEnd() && QIODevice::atEnd();
434}
435
436
437qint64 KTcpSocket::bytesAvailable() const
438{
439 return d->sock.bytesAvailable() + QIODevice::bytesAvailable();
440}
441
442
443qint64 KTcpSocket::bytesToWrite() const
444{
445 return d->sock.bytesToWrite();
446}
447
448
449bool KTcpSocket::canReadLine() const
450{
451 return d->sock.canReadLine() || QIODevice::canReadLine();
452}
453
454
455void KTcpSocket::close()
456{
457 d->sock.close();
458 QIODevice::close();
459}
460
461
462bool KTcpSocket::isSequential() const
463{
464 return true;
465}
466
467
468bool KTcpSocket::open(QIODevice::OpenMode open)
469{
470 bool ret = d->sock.open(open);
471 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
472 return ret;
473}
474
475
476bool KTcpSocket::waitForBytesWritten(int msecs)
477{
478 return d->sock.waitForBytesWritten(msecs);
479}
480
481
482bool KTcpSocket::waitForReadyRead(int msecs)
483{
484 return d->sock.waitForReadyRead(msecs);
485}
486
487
488qint64 KTcpSocket::readData(char *data, qint64 maxSize)
489{
490 return d->sock.read(data, maxSize);
491}
492
493
494qint64 KTcpSocket::writeData(const char *data, qint64 maxSize)
495{
496 return d->sock.write(data, maxSize);
497}
498
500
501void KTcpSocket::abort()
502{
503 d->sock.abort();
504}
505
506
507void KTcpSocket::connectToHost(const QString &hostName, quint16 port, ProxyPolicy policy)
508{
509 if (policy == AutoProxy) {
510 //###
511 }
512 d->sock.connectToHost(hostName, port);
513 // there are enough layers of buffers between us and the network, and there is a quirk
514 // in QIODevice that can make it try to readData() twice per read() call if buffered and
515 // reaData() does not deliver enough data the first time. like when the other side is
516 // simply not sending any more data...
517 // this can *apparently* lead to long delays sometimes which stalls applications.
518 // do not want.
519 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
520}
521
522
523void KTcpSocket::connectToHost(const QHostAddress &hostAddress, quint16 port, ProxyPolicy policy)
524{
525 if (policy == AutoProxy) {
526 //###
527 }
528 d->sock.connectToHost(hostAddress, port);
529 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
530}
531
532
533void KTcpSocket::connectToHost(const KUrl &url, ProxyPolicy policy)
534{
535 if (policy == AutoProxy) {
536 //###
537 }
538 d->sock.connectToHost(url.host(), url.port());
539 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
540}
541
542
543void KTcpSocket::disconnectFromHost()
544{
545 d->sock.disconnectFromHost();
546 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
547}
548
549
550KTcpSocket::Error KTcpSocket::error() const
551{
552 return d->errorFromAbsSocket(d->sock.error());
553}
554
555
556QList<KSslError> KTcpSocket::sslErrors() const
557{
558 //### pretty slow; also consider throwing out duplicate error codes. We may get
559 // duplicates even though there were none in the original list because KSslError
560 // has a smallest common denominator range of SSL error codes.
561 QList<KSslError> ret;
562 foreach (const QSslError &e, d->sock.sslErrors())
563 ret.append(KSslError(e));
564 return ret;
565}
566
567
568bool KTcpSocket::flush()
569{
570 return d->sock.flush();
571}
572
573
574bool KTcpSocket::isValid() const
575{
576 return d->sock.isValid();
577}
578
579
580QHostAddress KTcpSocket::localAddress() const
581{
582 return d->sock.localAddress();
583}
584
585
586QHostAddress KTcpSocket::peerAddress() const
587{
588 return d->sock.peerAddress();
589}
590
591
592QString KTcpSocket::peerName() const
593{
594 return d->sock.peerName();
595}
596
597
598quint16 KTcpSocket::peerPort() const
599{
600 return d->sock.peerPort();
601}
602
603
604#ifndef QT_NO_NETWORKPROXY
605QNetworkProxy KTcpSocket::proxy() const
606{
607 return d->sock.proxy();
608}
609#endif
610
611qint64 KTcpSocket::readBufferSize() const
612{
613 return d->sock.readBufferSize();
614}
615
616
617#ifndef QT_NO_NETWORKPROXY
618void KTcpSocket::setProxy(const QNetworkProxy &proxy)
619{
620 d->sock.setProxy(proxy);
621}
622#endif
623
624void KTcpSocket::setReadBufferSize(qint64 size)
625{
626 d->sock.setReadBufferSize(size);
627}
628
629
630KTcpSocket::State KTcpSocket::state() const
631{
632 return d->state(d->sock.state());
633}
634
635
636bool KTcpSocket::waitForConnected(int msecs)
637{
638 bool ret = d->sock.waitForConnected(msecs);
639 if (!ret)
640 setErrorString(d->sock.errorString());
641 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
642 return ret;
643}
644
645
646bool KTcpSocket::waitForDisconnected(int msecs)
647{
648 bool ret = d->sock.waitForDisconnected(msecs);
649 if (!ret)
650 setErrorString(d->sock.errorString());
651 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
652 return ret;
653}
654
656
657void KTcpSocket::addCaCertificate(const QSslCertificate &certificate)
658{
659 d->maybeLoadCertificates();
660 d->sock.addCaCertificate(certificate);
661}
662
663
664/*
665bool KTcpSocket::addCaCertificates(const QString &path, QSsl::EncodingFormat format,
666 QRegExp::PatternSyntax syntax)
667{
668 d->maybeLoadCertificates();
669 return d->sock.addCaCertificates(path, format, syntax);
670}
671*/
672
673
674void KTcpSocket::addCaCertificates(const QList<QSslCertificate> &certificates)
675{
676 d->maybeLoadCertificates();
677 d->sock.addCaCertificates(certificates);
678}
679
680
681QList<QSslCertificate> KTcpSocket::caCertificates() const
682{
683 d->maybeLoadCertificates();
684 return d->sock.caCertificates();
685}
686
687
688QList<KSslCipher> KTcpSocket::ciphers() const
689{
690 return d->ciphers;
691}
692
693
694void KTcpSocket::connectToHostEncrypted(const QString &hostName, quint16 port, OpenMode openMode)
695{
696 d->maybeLoadCertificates();
697 d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
698 d->sock.connectToHostEncrypted(hostName, port, openMode);
699 setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
700}
701
702
703QSslCertificate KTcpSocket::localCertificate() const
704{
705 return d->sock.localCertificate();
706}
707
708
709QList<QSslCertificate> KTcpSocket::peerCertificateChain() const
710{
711 return d->sock.peerCertificateChain();
712}
713
714
715KSslKey KTcpSocket::privateKey() const
716{
717 return KSslKey(d->sock.privateKey());
718}
719
720
721KSslCipher KTcpSocket::sessionCipher() const
722{
723 return KSslCipher(d->sock.sessionCipher());
724}
725
726
727void KTcpSocket::setCaCertificates(const QList<QSslCertificate> &certificates)
728{
729 d->sock.setCaCertificates(certificates);
730 d->certificatesLoaded = true;
731}
732
733
734void KTcpSocket::setCiphers(const QList<KSslCipher> &ciphers)
735{
736 d->ciphers = ciphers;
737 QList<QSslCipher> cl;
738 foreach (const KSslCipher &c, d->ciphers) {
739 cl.append(d->ccc.converted(c));
740 }
741 d->sock.setCiphers(cl);
742}
743
744
745void KTcpSocket::setLocalCertificate(const QSslCertificate &certificate)
746{
747 d->sock.setLocalCertificate(certificate);
748}
749
750
751void KTcpSocket::setLocalCertificate(const QString &fileName, QSsl::EncodingFormat format)
752{
753 d->sock.setLocalCertificate(fileName, format);
754}
755
756
757void KTcpSocket::setVerificationPeerName(const QString& hostName)
758{
759#if QT_VERSION >= 0x040800
760 d->sock.setPeerVerifyName(hostName);
761#else
762 Q_UNUSED(hostName);
763#endif
764}
765
766
767void KTcpSocket::setPrivateKey(const KSslKey &key)
768{
769 // We cannot map KSslKey::Algorithm:Dh to anything in QSsl::KeyAlgorithm.
770 if (key.algorithm() == KSslKey::Dh)
771 return;
772
773 QSslKey _key(key.toDer(),
774 (key.algorithm() == KSslKey::Rsa) ? QSsl::Rsa : QSsl::Dsa,
775 QSsl::Der,
776 (key.secrecy() == KSslKey::PrivateKey) ? QSsl::PrivateKey : QSsl::PublicKey);
777
778 d->sock.setPrivateKey(_key);
779}
780
781
782void KTcpSocket::setPrivateKey(const QString &fileName, KSslKey::Algorithm algorithm,
783 QSsl::EncodingFormat format, const QByteArray &passPhrase)
784{
785 // We cannot map KSslKey::Algorithm:Dh to anything in QSsl::KeyAlgorithm.
786 if (algorithm == KSslKey::Dh)
787 return;
788
789 d->sock.setPrivateKey(fileName,
790 (algorithm == KSslKey::Rsa) ? QSsl::Rsa : QSsl::Dsa,
791 format,
792 passPhrase);
793}
794
795
796bool KTcpSocket::waitForEncrypted(int msecs)
797{
798 return d->sock.waitForEncrypted(msecs);
799}
800
801
802KTcpSocket::EncryptionMode KTcpSocket::encryptionMode() const
803{
804 return d->encryptionMode(d->sock.mode());
805}
806
807QVariant KTcpSocket::socketOption(QAbstractSocket::SocketOption options) const
808{
809 return d->sock.socketOption(options);
810}
811
812void KTcpSocket::setSocketOption(QAbstractSocket::SocketOption options, const QVariant &value)
813{
814 d->sock.setSocketOption(options, value);
815}
816
817QSslConfiguration KTcpSocket::sslConfiguration() const
818{
819 return d->sock.sslConfiguration();
820}
821
822void KTcpSocket::setSslConfiguration (const QSslConfiguration& configuration)
823{
824 d->sock.setSslConfiguration(configuration);
825}
826
827//slot
828void KTcpSocket::ignoreSslErrors()
829{
830 d->sock.ignoreSslErrors();
831}
832
833
834//slot
835void KTcpSocket::startClientEncryption()
836{
837 d->maybeLoadCertificates();
838 d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
839 d->sock.startClientEncryption();
840}
841
842
843//debugging H4X
844void KTcpSocket::showSslErrors()
845{
846 foreach (const QSslError &e, d->sock.sslErrors())
847 kDebug(7029) << e.errorString();
848}
849
850
851void KTcpSocket::setAdvertisedSslVersion(KTcpSocket::SslVersion version)
852{
853 d->advertisedSslVersion = version;
854}
855
856
857KTcpSocket::SslVersion KTcpSocket::advertisedSslVersion() const
858{
859 return d->advertisedSslVersion;
860}
861
862
863KTcpSocket::SslVersion KTcpSocket::negotiatedSslVersion() const
864{
865 if (!d->sock.isEncrypted()) {
866 return UnknownSslVersion;
867 }
868 return kSslVersionFromQ(d->sock.protocol());
869}
870
871
872QString KTcpSocket::negotiatedSslVersionName() const
873{
874 if (!d->sock.isEncrypted()) {
875 return QString();
876 }
877 return d->sock.sessionCipher().protocolString();
878}
879
880
882
883class KSslKeyPrivate
884{
885public:
886 KSslKey::Algorithm convertAlgorithm(QSsl::KeyAlgorithm a)
887 {
888 switch(a) {
889 case QSsl::Dsa:
890 return KSslKey::Dsa;
891 default:
892 return KSslKey::Rsa;
893 }
894 }
895
896 KSslKey::Algorithm algorithm;
897 KSslKey::KeySecrecy secrecy;
898 bool isExportable;
899 QByteArray der;
900};
901
902
903KSslKey::KSslKey()
904 : d(new KSslKeyPrivate)
905{
906 d->algorithm = Rsa;
907 d->secrecy = PublicKey;
908 d->isExportable = true;
909}
910
911
912KSslKey::KSslKey(const KSslKey &other)
913 : d(new KSslKeyPrivate)
914{
915 *d = *other.d;
916}
917
918
919KSslKey::KSslKey(const QSslKey &qsk)
920 : d(new KSslKeyPrivate)
921{
922 d->algorithm = d->convertAlgorithm(qsk.algorithm());
923 d->secrecy = (qsk.type() == QSsl::PrivateKey) ? PrivateKey : PublicKey;
924 d->isExportable = true;
925 d->der = qsk.toDer();
926}
927
928
929KSslKey::~KSslKey()
930{
931 delete d;
932}
933
934
935KSslKey &KSslKey::operator=(const KSslKey &other)
936{
937 *d = *other.d;
938 return *this;
939}
940
941
942KSslKey::Algorithm KSslKey::algorithm() const
943{
944 return d->algorithm;
945}
946
947
948bool KSslKey::isExportable() const
949{
950 return d->isExportable;
951}
952
953
954KSslKey::KeySecrecy KSslKey::secrecy() const
955{
956 return d->secrecy;
957}
958
959
960QByteArray KSslKey::toDer() const
961{
962 return d->der;
963}
964
966
967//nice-to-have: make implicitly shared
968class KSslCipherPrivate
969{
970public:
971
972 QString authenticationMethod;
973 QString encryptionMethod;
974 QString keyExchangeMethod;
975 QString name;
976 bool isNull;
977 int supportedBits;
978 int usedBits;
979};
980
981
982KSslCipher::KSslCipher()
983 : d(new KSslCipherPrivate)
984{
985 d->isNull = true;
986 d->supportedBits = 0;
987 d->usedBits = 0;
988}
989
990
991KSslCipher::KSslCipher(const KSslCipher &other)
992 : d(new KSslCipherPrivate)
993{
994 *d = *other.d;
995}
996
997
998KSslCipher::KSslCipher(const QSslCipher &qsc)
999 : d(new KSslCipherPrivate)
1000{
1001 d->authenticationMethod = qsc.authenticationMethod();
1002 d->encryptionMethod = qsc.encryptionMethod();
1003 //Qt likes to append the number of bits (usedBits?) to the algorithm,
1004 //for example "AES(256)". We only want the pure algorithm name, though.
1005 int parenIdx = d->encryptionMethod.indexOf(QLatin1Char('('));
1006 if (parenIdx > 0)
1007 d->encryptionMethod.truncate(parenIdx);
1008 d->keyExchangeMethod = qsc.keyExchangeMethod();
1009 d->name = qsc.name();
1010 d->isNull = qsc.isNull();
1011 d->supportedBits = qsc.supportedBits();
1012 d->usedBits = qsc.usedBits();
1013}
1014
1015
1016KSslCipher::~KSslCipher()
1017{
1018 delete d;
1019}
1020
1021
1022KSslCipher &KSslCipher::operator=(const KSslCipher &other)
1023{
1024 *d = *other.d;
1025 return *this;
1026}
1027
1028
1029bool KSslCipher::isNull() const
1030{
1031 return d->isNull;
1032}
1033
1034
1035QString KSslCipher::authenticationMethod() const
1036{
1037 return d->authenticationMethod;
1038}
1039
1040
1041QString KSslCipher::encryptionMethod() const
1042{
1043 return d->encryptionMethod;
1044}
1045
1046
1047QString KSslCipher::keyExchangeMethod() const
1048{
1049 return d->keyExchangeMethod;
1050}
1051
1052
1053QString KSslCipher::digestMethod() const
1054{
1055 //### This is not really backend neutral. It works for OpenSSL and
1056 // for RFC compliant names, though.
1057 if (d->name.endsWith(QLatin1String("SHA")))
1058 return QString::fromLatin1("SHA-1");
1059 else if (d->name.endsWith(QLatin1String("MD5")))
1060 return QString::fromLatin1("MD5");
1061 else
1062 return QString::fromLatin1(""); // ## probably QString() is enough
1063}
1064
1065
1066QString KSslCipher::name() const
1067{
1068 return d->name;
1069}
1070
1071
1072int KSslCipher::supportedBits() const
1073{
1074 return d->supportedBits;
1075}
1076
1077
1078int KSslCipher::usedBits() const
1079{
1080 return d->usedBits;
1081}
1082
1083
1084//static
1085QList<KSslCipher> KSslCipher::supportedCiphers()
1086{
1087 QList<KSslCipher> ret;
1088 QList<QSslCipher> candidates = QSslSocket::supportedCiphers();
1089 foreach(const QSslCipher &c, candidates) {
1090 ret.append(KSslCipher(c));
1091 }
1092 return ret;
1093}
1094
1095
1096KSslErrorUiData::KSslErrorUiData()
1097 : d(new Private())
1098{
1099 d->usedBits = 0;
1100 d->bits = 0;
1101}
1102
1103
1104KSslErrorUiData::KSslErrorUiData(const KTcpSocket *socket)
1105 : d(new Private())
1106{
1107 d->certificateChain = socket->peerCertificateChain();
1108 d->sslErrors = socket->sslErrors();
1109 d->ip = socket->peerAddress().toString();
1110 d->host = socket->peerName();
1111 d->sslProtocol = socket->negotiatedSslVersionName();
1112 d->cipher = socket->sessionCipher().name();
1113 d->usedBits = socket->sessionCipher().usedBits();
1114 d->bits = socket->sessionCipher().supportedBits();
1115}
1116
1117KSslErrorUiData::KSslErrorUiData(const QSslSocket *socket)
1118 : d(new Private())
1119{
1120 d->certificateChain = socket->peerCertificateChain();
1121
1122 // See KTcpSocket::sslErrors()
1123 foreach (const QSslError &e, socket->sslErrors())
1124 d->sslErrors.append(KSslError(e));
1125
1126 d->ip = socket->peerAddress().toString();
1127 d->host = socket->peerName();
1128 if (socket->isEncrypted()) {
1129 d->sslProtocol = socket->sessionCipher().protocolString();
1130 }
1131 d->cipher = socket->sessionCipher().name();
1132 d->usedBits = socket->sessionCipher().usedBits();
1133 d->bits = socket->sessionCipher().supportedBits();
1134}
1135
1136
1137KSslErrorUiData::KSslErrorUiData(const KSslErrorUiData &other)
1138 : d(new Private(*other.d))
1139{}
1140
1141KSslErrorUiData::~KSslErrorUiData()
1142{
1143 delete d;
1144}
1145
1146KSslErrorUiData &KSslErrorUiData::operator=(const KSslErrorUiData &other)
1147{
1148 *d = *other.d;
1149 return *this;
1150}
1151
1152
1153#include "ktcpsocket.moc"
KSslCertificateManager::self
static KSslCertificateManager * self()
Definition: ksslcertificatemanager.cpp:466
KSslCipher
Definition: ktcpsocket.h:70
KSslCipher::usedBits
int usedBits() const
Definition: ktcpsocket.cpp:1078
KSslCipher::~KSslCipher
~KSslCipher()
Definition: ktcpsocket.cpp:1016
KSslCipher::encryptionMethod
QString encryptionMethod() const
Definition: ktcpsocket.cpp:1041
KSslCipher::KSslCipher
KSslCipher()
Definition: ktcpsocket.cpp:982
KSslCipher::name
QString name() const
Definition: ktcpsocket.cpp:1066
KSslCipher::isNull
bool isNull() const
Definition: ktcpsocket.cpp:1029
KSslCipher::keyExchangeMethod
QString keyExchangeMethod() const
Definition: ktcpsocket.cpp:1047
KSslCipher::authenticationMethod
QString authenticationMethod() const
Definition: ktcpsocket.cpp:1035
KSslCipher::digestMethod
QString digestMethod() const
Definition: ktcpsocket.cpp:1053
KSslCipher::supportedBits
int supportedBits() const
Definition: ktcpsocket.cpp:1072
KSslCipher::operator=
KSslCipher & operator=(const KSslCipher &other)
Definition: ktcpsocket.cpp:1022
KSslCipher::supportedCiphers
static QList< KSslCipher > supportedCiphers()
Definition: ktcpsocket.cpp:1085
KSslErrorUiData::Private
Definition: ktcpsocket_p.h:24
KSslErrorUiData::Private::sslErrors
QList< KSslError > sslErrors
Definition: ktcpsocket_p.h:30
KSslErrorUiData::Private::ip
QString ip
Definition: ktcpsocket_p.h:31
KSslErrorUiData::Private::certificateChain
QList< QSslCertificate > certificateChain
Definition: ktcpsocket_p.h:29
KSslErrorUiData::Private::host
QString host
Definition: ktcpsocket_p.h:32
KSslErrorUiData::Private::usedBits
int usedBits
Definition: ktcpsocket_p.h:35
KSslErrorUiData::Private::cipher
QString cipher
Definition: ktcpsocket_p.h:34
KSslErrorUiData::Private::bits
int bits
Definition: ktcpsocket_p.h:36
KSslErrorUiData::Private::sslProtocol
QString sslProtocol
Definition: ktcpsocket_p.h:33
KSslErrorUiData
This class can hold all the necessary data from a KTcpSocket to ask the user to continue connecting i...
Definition: ktcpsocket.h:398
KSslErrorUiData::KSslErrorUiData
KSslErrorUiData()
Default construct an instance with no useful data.
Definition: ktcpsocket.cpp:1096
KSslErrorUiData::~KSslErrorUiData
~KSslErrorUiData()
Destructor.
Definition: ktcpsocket.cpp:1141
KSslErrorUiData::operator=
KSslErrorUiData & operator=(const KSslErrorUiData &)
Definition: ktcpsocket.cpp:1146
KSslError
Definition: ktcpsocket.h:99
KSslError::operator=
KSslError & operator=(const KSslError &other)
Definition: ktcpsocket.cpp:235
KSslError::error
Error error() const
Definition: ktcpsocket.cpp:242
KSslError::certificate
QSslCertificate certificate() const
Definition: ktcpsocket.cpp:254
KSslError::Error
Error
Definition: ktcpsocket.h:101
KSslError::NoError
@ NoError
Definition: ktcpsocket.h:102
KSslError::SelfSignedCertificate
@ SelfSignedCertificate
Definition: ktcpsocket.h:107
KSslError::UntrustedCertificate
@ UntrustedCertificate
Definition: ktcpsocket.h:112
KSslError::ExpiredCertificate
@ ExpiredCertificate
Definition: ktcpsocket.h:108
KSslError::UnknownError
@ UnknownError
Definition: ktcpsocket.h:103
KSslError::CertificateSignatureFailed
@ CertificateSignatureFailed
Definition: ktcpsocket.h:106
KSslError::InvalidCertificatePurpose
@ InvalidCertificatePurpose
Definition: ktcpsocket.h:110
KSslError::NoPeerCertificate
@ NoPeerCertificate
Definition: ktcpsocket.h:113
KSslError::PathLengthExceeded
@ PathLengthExceeded
Definition: ktcpsocket.h:115
KSslError::InvalidCertificateAuthorityCertificate
@ InvalidCertificateAuthorityCertificate
Definition: ktcpsocket.h:104
KSslError::RevokedCertificate
@ RevokedCertificate
Definition: ktcpsocket.h:109
KSslError::HostNameMismatch
@ HostNameMismatch
Definition: ktcpsocket.h:114
KSslError::RejectedCertificate
@ RejectedCertificate
Definition: ktcpsocket.h:111
KSslError::InvalidCertificate
@ InvalidCertificate
Definition: ktcpsocket.h:105
KSslError::~KSslError
~KSslError()
Definition: ktcpsocket.cpp:229
KSslError::errorString
QString errorString() const
Definition: ktcpsocket.cpp:248
KSslError::KSslError
KSslError(KSslError::Error error=NoError, const QSslCertificate &cert=QSslCertificate())
Definition: ktcpsocket.cpp:206
KSslKey
Definition: ktcpsocket.h:41
KSslKey::isExportable
bool isExportable() const
Definition: ktcpsocket.cpp:948
KSslKey::KeySecrecy
KeySecrecy
Definition: ktcpsocket.h:48
KSslKey::PublicKey
@ PublicKey
Definition: ktcpsocket.h:49
KSslKey::PrivateKey
@ PrivateKey
Definition: ktcpsocket.h:50
KSslKey::~KSslKey
~KSslKey()
Definition: ktcpsocket.cpp:929
KSslKey::toDer
QByteArray toDer() const
Definition: ktcpsocket.cpp:960
KSslKey::Algorithm
Algorithm
Definition: ktcpsocket.h:43
KSslKey::Dsa
@ Dsa
Definition: ktcpsocket.h:45
KSslKey::Dh
@ Dh
Definition: ktcpsocket.h:46
KSslKey::Rsa
@ Rsa
Definition: ktcpsocket.h:44
KSslKey::KSslKey
KSslKey()
Definition: ktcpsocket.cpp:903
KSslKey::operator=
KSslKey & operator=(const KSslKey &other)
Definition: ktcpsocket.cpp:935
KSslKey::algorithm
Algorithm algorithm() const
Definition: ktcpsocket.cpp:942
KSslKey::secrecy
KeySecrecy secrecy() const
Definition: ktcpsocket.cpp:954
KTcpSocket
Definition: ktcpsocket.h:145
KTcpSocket::waitForEncrypted
bool waitForEncrypted(int msecs=30000)
Definition: ktcpsocket.cpp:796
KTcpSocket::waitForReadyRead
virtual bool waitForReadyRead(int msecs=30000)
Definition: ktcpsocket.cpp:482
KTcpSocket::addCaCertificates
void addCaCertificates(const QList< QSslCertificate > &certificates)
Definition: ktcpsocket.cpp:674
KTcpSocket::close
virtual void close()
Definition: ktcpsocket.cpp:455
KTcpSocket::EncryptionMode
EncryptionMode
Definition: ktcpsocket.h:213
KTcpSocket::SslServerMode
@ SslServerMode
Definition: ktcpsocket.h:216
KTcpSocket::UnencryptedMode
@ UnencryptedMode
Definition: ktcpsocket.h:214
KTcpSocket::SslClientMode
@ SslClientMode
Definition: ktcpsocket.h:215
KTcpSocket::canReadLine
virtual bool canReadLine() const
Definition: ktcpsocket.cpp:449
KTcpSocket::state
State state() const
Definition: ktcpsocket.cpp:630
KTcpSocket::sslConfiguration
QSslConfiguration sslConfiguration() const
Returns the socket's SSL configuration.
Definition: ktcpsocket.cpp:817
KTcpSocket::~KTcpSocket
~KTcpSocket()
Definition: ktcpsocket.cpp:424
KTcpSocket::bytesToWrite
virtual qint64 bytesToWrite() const
Definition: ktcpsocket.cpp:443
KTcpSocket::peerName
QString peerName() const
Definition: ktcpsocket.cpp:592
KTcpSocket::sessionCipher
KSslCipher sessionCipher() const
Definition: ktcpsocket.cpp:721
KTcpSocket::privateKey
KSslKey privateKey() const
Definition: ktcpsocket.cpp:715
KTcpSocket::peerCertificateChain
QList< QSslCertificate > peerCertificateChain() const
Definition: ktcpsocket.cpp:709
KTcpSocket::socketOption
QVariant socketOption(QAbstractSocket::SocketOption options) const
Returns the state of the socket option.
Definition: ktcpsocket.cpp:807
KTcpSocket::setProxy
void setProxy(const QNetworkProxy &proxy)
Definition: ktcpsocket.cpp:618
KTcpSocket::encryptedBytesWritten
void encryptedBytesWritten(qint64 written)
KTcpSocket::error
Error error() const
Definition: ktcpsocket.cpp:550
KTcpSocket::proxyAuthenticationRequired
void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)
KTcpSocket::SslVersion
SslVersion
Definition: ktcpsocket.h:158
KTcpSocket::SslV3
@ SslV3
Definition: ktcpsocket.h:161
KTcpSocket::SslV2
@ SslV2
Definition: ktcpsocket.h:160
KTcpSocket::TlsV1SslV3
@ TlsV1SslV3
Definition: ktcpsocket.h:164
KTcpSocket::TlsV1
@ TlsV1
Definition: ktcpsocket.h:162
KTcpSocket::SecureProtocols
@ SecureProtocols
Definition: ktcpsocket.h:165
KTcpSocket::AnySslVersion
@ AnySslVersion
Definition: ktcpsocket.h:166
KTcpSocket::UnknownSslVersion
@ UnknownSslVersion
Definition: ktcpsocket.h:159
KTcpSocket::isValid
bool isValid() const
Definition: ktcpsocket.cpp:574
KTcpSocket::atEnd
virtual bool atEnd() const
Definition: ktcpsocket.cpp:431
KTcpSocket::connectToHost
void connectToHost(const QString &hostName, quint16 port, ProxyPolicy policy=AutoProxy)
Definition: ktcpsocket.cpp:507
KTcpSocket::setCaCertificates
void setCaCertificates(const QList< QSslCertificate > &certificates)
Definition: ktcpsocket.cpp:727
KTcpSocket::flush
bool flush()
Definition: ktcpsocket.cpp:568
KTcpSocket::readData
virtual qint64 readData(char *data, qint64 maxSize)
Definition: ktcpsocket.cpp:488
KTcpSocket::ignoreSslErrors
void ignoreSslErrors()
Definition: ktcpsocket.cpp:828
KTcpSocket::encryptionMode
EncryptionMode encryptionMode() const
Definition: ktcpsocket.cpp:802
KTcpSocket::localAddress
QHostAddress localAddress() const
Definition: ktcpsocket.cpp:580
KTcpSocket::setSslConfiguration
void setSslConfiguration(const QSslConfiguration &configuration)
Sets the socket's SSL configuration.
Definition: ktcpsocket.cpp:822
KTcpSocket::setCiphers
void setCiphers(const QList< KSslCipher > &ciphers)
Definition: ktcpsocket.cpp:734
KTcpSocket::writeData
virtual qint64 writeData(const char *data, qint64 maxSize)
Definition: ktcpsocket.cpp:494
KTcpSocket::setSocketOption
void setSocketOption(QAbstractSocket::SocketOption options, const QVariant &value)
Sets the socket option to value.
Definition: ktcpsocket.cpp:812
KTcpSocket::readBufferSize
qint64 readBufferSize() const
Definition: ktcpsocket.cpp:611
KTcpSocket::addCaCertificate
void addCaCertificate(const QSslCertificate &certificate)
Definition: ktcpsocket.cpp:657
KTcpSocket::ProxyPolicy
ProxyPolicy
Definition: ktcpsocket.h:218
KTcpSocket::AutoProxy
@ AutoProxy
Use the proxy that KProtocolManager suggests for the connection parameters given.
Definition: ktcpsocket.h:220
KTcpSocket::State
State
Definition: ktcpsocket.h:148
KTcpSocket::UnconnectedState
@ UnconnectedState
Definition: ktcpsocket.h:149
KTcpSocket::ClosingState
@ ClosingState
Definition: ktcpsocket.h:155
KTcpSocket::ConnectingState
@ ConnectingState
Definition: ktcpsocket.h:151
KTcpSocket::HostLookupState
@ HostLookupState
Definition: ktcpsocket.h:150
KTcpSocket::ConnectedState
@ ConnectedState
Definition: ktcpsocket.h:152
KTcpSocket::encrypted
void encrypted()
KTcpSocket::waitForDisconnected
bool waitForDisconnected(int msecs=30000)
Definition: ktcpsocket.cpp:646
KTcpSocket::negotiatedSslVersionName
QString negotiatedSslVersionName() const
Definition: ktcpsocket.cpp:872
KTcpSocket::stateChanged
void stateChanged(KTcpSocket::State)
KTcpSocket::proxy
QNetworkProxy proxy() const
Definition: ktcpsocket.cpp:605
KTcpSocket::peerAddress
QHostAddress peerAddress() const
Definition: ktcpsocket.cpp:586
KTcpSocket::setLocalCertificate
void setLocalCertificate(const QSslCertificate &certificate)
Definition: ktcpsocket.cpp:745
KTcpSocket::waitForBytesWritten
virtual bool waitForBytesWritten(int msecs)
Definition: ktcpsocket.cpp:476
KTcpSocket::peerPort
quint16 peerPort() const
Definition: ktcpsocket.cpp:598
KTcpSocket::hostFound
void hostFound()
KTcpSocket::connected
void connected()
KTcpSocket::caCertificates
QList< QSslCertificate > caCertificates() const
Definition: ktcpsocket.cpp:681
KTcpSocket::bytesAvailable
virtual qint64 bytesAvailable() const
Definition: ktcpsocket.cpp:437
KTcpSocket::ciphers
QList< KSslCipher > ciphers() const
Definition: ktcpsocket.cpp:688
KTcpSocket::advertisedSslVersion
SslVersion advertisedSslVersion() const
Definition: ktcpsocket.cpp:857
KTcpSocket::sslErrors
QList< KSslError > sslErrors() const
Definition: ktcpsocket.cpp:556
KTcpSocket::setReadBufferSize
void setReadBufferSize(qint64 size)
Definition: ktcpsocket.cpp:624
KTcpSocket::isSequential
virtual bool isSequential() const
Definition: ktcpsocket.cpp:462
KTcpSocket::Error
Error
Definition: ktcpsocket.h:169
KTcpSocket::SocketTimeoutError
@ SocketTimeoutError
Definition: ktcpsocket.h:176
KTcpSocket::NetworkError
@ NetworkError
Definition: ktcpsocket.h:177
KTcpSocket::UnsupportedSocketOperationError
@ UnsupportedSocketOperationError
Definition: ktcpsocket.h:178
KTcpSocket::ConnectionRefusedError
@ ConnectionRefusedError
Definition: ktcpsocket.h:171
KTcpSocket::RemoteHostClosedError
@ RemoteHostClosedError
Definition: ktcpsocket.h:172
KTcpSocket::SocketResourceError
@ SocketResourceError
Definition: ktcpsocket.h:175
KTcpSocket::SocketAccessError
@ SocketAccessError
Definition: ktcpsocket.h:174
KTcpSocket::UnknownError
@ UnknownError
Definition: ktcpsocket.h:170
KTcpSocket::SslHandshakeFailedError
@ SslHandshakeFailedError
Definition: ktcpsocket.h:179
KTcpSocket::HostNotFoundError
@ HostNotFoundError
Definition: ktcpsocket.h:173
KTcpSocket::disconnectFromHost
void disconnectFromHost()
Definition: ktcpsocket.cpp:543
KTcpSocket::abort
void abort()
Definition: ktcpsocket.cpp:501
KTcpSocket::open
virtual bool open(QIODevice::OpenMode open)
Definition: ktcpsocket.cpp:468
KTcpSocket::negotiatedSslVersion
SslVersion negotiatedSslVersion() const
Definition: ktcpsocket.cpp:863
KTcpSocket::KTcpSocket
KTcpSocket(QObject *parent=0)
Definition: ktcpsocket.cpp:395
KTcpSocket::connectToHostEncrypted
void connectToHostEncrypted(const QString &hostName, quint16 port, OpenMode openMode=ReadWrite)
Definition: ktcpsocket.cpp:694
KTcpSocket::localCertificate
QSslCertificate localCertificate() const
Definition: ktcpsocket.cpp:703
KTcpSocket::setPrivateKey
void setPrivateKey(const KSslKey &key)
Definition: ktcpsocket.cpp:767
KTcpSocket::setAdvertisedSslVersion
void setAdvertisedSslVersion(SslVersion version)
Definition: ktcpsocket.cpp:851
KTcpSocket::waitForConnected
bool waitForConnected(int msecs=30000)
Definition: ktcpsocket.cpp:636
KTcpSocket::disconnected
void disconnected()
KTcpSocket::startClientEncryption
void startClientEncryption()
Definition: ktcpsocket.cpp:835
KTcpSocket::setVerificationPeerName
void setVerificationPeerName(const QString &hostName)
Definition: ktcpsocket.cpp:757
KUrl
Represents and parses a URL.
Definition: kurl.h:112
QHash
Definition: ksycocafactory.h:28
QIODevice
QList
Definition: kaboutdata.h:33
QObject
QString
QVariant
qint64
kDebug
#define kDebug
Definition: kdebug.h:316
kdebug.h
kglobal.h
klocale.h
i18nc
QString i18nc(const char *ctxt, const char *text)
Returns a localized version of a string and a context.
Definition: klocalizedstring.h:797
ksslcertificatemanager.h
kstandarddirs.h
kSslVersionFromQ
static KTcpSocket::SslVersion kSslVersionFromQ(QSsl::SslProtocol protocol)
Definition: ktcpsocket.cpp:36
qSslProtocolFromK
static QSsl::SslProtocol qSslProtocolFromK(KTcpSocket::SslVersion sslVersion)
Definition: ktcpsocket.cpp:59
ktcpsocket.h
ktcpsocket_p.h
kurl.h
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KDECore

Skip menu "KDECore"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal