00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "ktcpsocket.h"
00021
00022 #include <kdebug.h>
00023 #include <kurl.h>
00024 #include <kglobal.h>
00025 #include <kstandarddirs.h>
00026
00027 #include <QtCore/QMutex>
00028 #include <QtCore/QStringList>
00029 #include <QtNetwork/QSslKey>
00030 #include <QtNetwork/QSslCipher>
00031 #include <QtNetwork/QNetworkProxy>
00032
00033 K_GLOBAL_STATIC(QMutex, ksslsocketInitMutex)
00034 static QList<QSslCertificate> *kdeCaCertificateList;
00035
00036 static void initKSslSocket()
00037 {
00038 static bool initialized = false;
00039 QMutexLocker locker(ksslsocketInitMutex);
00040 if (!initialized) {
00041 if (!kdeCaCertificateList) {
00042 kdeCaCertificateList = new QList<QSslCertificate>;
00043 QSslSocket::setDefaultCaCertificates(*kdeCaCertificateList);
00044 }
00045
00046 if (!KGlobal::hasMainComponent())
00047 return;
00048 initialized = true;
00049
00050
00051 QStringList bundles = KGlobal::dirs()->findAllResources("data", "kssl/ca-bundle.crt");
00052 foreach (const QString &bundle, bundles) {
00053 *kdeCaCertificateList += QSslCertificate::fromPath(bundle);
00054 }
00055
00056 }
00057 }
00058
00059 static KTcpSocket::SslVersion kSslVersionFromQ(QSsl::SslProtocol protocol)
00060 {
00061 switch (protocol) {
00062 case QSsl::SslV2:
00063 return KTcpSocket::SslV2;
00064 case QSsl::SslV3:
00065 return KTcpSocket::SslV3;
00066 case QSsl::TlsV1:
00067 return KTcpSocket::TlsV1;
00068 case QSsl::AnyProtocol:
00069 return KTcpSocket::AnySslVersion;
00070 default:
00071 return KTcpSocket::UnknownSslVersion;
00072 }
00073 }
00074
00075
00076 static QSsl::SslProtocol qSslProtocolFromK(KTcpSocket::SslVersion sslVersion)
00077 {
00078
00079 if (sslVersion == KTcpSocket::AnySslVersion) {
00080 return QSsl::AnyProtocol;
00081 }
00082
00083 if (!(sslVersion & (KTcpSocket::SslV2 | KTcpSocket::SslV2 | KTcpSocket::TlsV1))) {
00084 return QSsl::UnknownProtocol;
00085 }
00086
00087 switch (sslVersion) {
00088 case KTcpSocket::SslV2:
00089 return QSsl::SslV2;
00090 case KTcpSocket::SslV3:
00091 return QSsl::SslV3;
00092 case KTcpSocket::TlsV1:
00093 return QSsl::TlsV1;
00094 default:
00095
00096 return QSsl::AnyProtocol;
00097 }
00098 }
00099
00100
00101
00102 class CipherCc
00103 {
00104 public:
00105 CipherCc()
00106 {
00107 foreach (const QSslCipher &c, QSslSocket::supportedCiphers()) {
00108 allCiphers.insert(c.name(), c);
00109 }
00110 }
00111
00112 QSslCipher converted(const KSslCipher &ksc)
00113 {
00114 return allCiphers.value(ksc.name());
00115 }
00116
00117 private:
00118 QHash<QString, QSslCipher> allCiphers;
00119 };
00120
00121
00122 class KSslErrorPrivate
00123 {
00124 public:
00125 KSslError::Error errorFromQSslError(QSslError::SslError e)
00126 {
00127 switch (e) {
00128 case QSslError::NoError:
00129 return KSslError::NoError;
00130 case QSslError::UnableToGetLocalIssuerCertificate:
00131 case QSslError::InvalidCaCertificate:
00132 return KSslError::InvalidCertificateAuthority;
00133 case QSslError::InvalidNotBeforeField:
00134 case QSslError::InvalidNotAfterField:
00135 case QSslError::CertificateNotYetValid:
00136 case QSslError::CertificateExpired:
00137 return KSslError::ExpiredCertificate;
00138 case QSslError::UnableToDecodeIssuerPublicKey:
00139 case QSslError::SubjectIssuerMismatch:
00140 case QSslError::AuthorityIssuerSerialNumberMismatch:
00141 return KSslError::InvalidCertificate;
00142 case QSslError::SelfSignedCertificate:
00143 case QSslError::SelfSignedCertificateInChain:
00144 return KSslError::SelfSignedCertificate;
00145 case QSslError::CertificateRevoked:
00146 return KSslError::RevokedCertificate;
00147 case QSslError::InvalidPurpose:
00148 return KSslError::InvalidCertificatePurpose;
00149 case QSslError::CertificateUntrusted:
00150 return KSslError::UntrustedCertificate;
00151 case QSslError::CertificateRejected:
00152 return KSslError::RejectedCertificate;
00153 case QSslError::NoPeerCertificate:
00154 return KSslError::NoPeerCertificate;
00155 case QSslError::HostNameMismatch:
00156 return KSslError::HostNameMismatch;
00157 case QSslError::UnableToVerifyFirstCertificate:
00158 case QSslError::UnableToDecryptCertificateSignature:
00159 case QSslError::UnableToGetIssuerCertificate:
00160 case QSslError::CertificateSignatureFailed:
00161 return KSslError::CertificateSignatureFailed;
00162 case QSslError::PathLengthExceeded:
00163 return KSslError::PathLengthExceeded;
00164 case QSslError::UnspecifiedError:
00165 case QSslError::NoSslSupport:
00166 default:
00167 return KSslError::UnknownError;
00168 }
00169 }
00170
00171 KSslError::Error error;
00172 QString errorString;
00173 QSslCertificate certificate;
00174 };
00175
00176
00177 KSslError::KSslError(Error errorCode, const QSslCertificate &certificate)
00178 : d(new KSslErrorPrivate())
00179 {
00180 d->error = errorCode;
00181 d->certificate = certificate;
00182
00183 }
00184
00185
00186 KSslError::KSslError(const QSslError &other)
00187 : d(new KSslErrorPrivate())
00188 {
00189 d->error = d->errorFromQSslError(other.error());
00190 d->errorString = other.errorString();
00191 d->certificate = other.certificate();
00192 }
00193
00194
00195 KSslError::KSslError(const KSslError &other)
00196 : d(new KSslErrorPrivate())
00197 {
00198 *d = *other.d;
00199 }
00200
00201
00202 KSslError::~KSslError()
00203 {
00204 delete d;
00205 }
00206
00207
00208 KSslError &KSslError::operator=(const KSslError &other)
00209 {
00210 *d = *other.d;
00211 return *this;
00212 }
00213
00214
00215 KSslError::Error KSslError::error() const
00216 {
00217 return d->error;
00218 }
00219
00220
00221 QString KSslError::errorString() const
00222 {
00223 return d->errorString;
00224 }
00225
00226
00227 QSslCertificate KSslError::certificate() const
00228 {
00229 return d->certificate;
00230 }
00231
00232
00233 class KTcpSocketPrivate
00234 {
00235 public:
00236 KTcpSocketPrivate(KTcpSocket *qq)
00237 : q(qq),
00238 emittedReadyRead(false)
00239 {
00240 initKSslSocket();
00241
00242 Q_ASSERT(kdeCaCertificateList);
00243 sock.setCaCertificates(*kdeCaCertificateList);
00244 }
00245
00246 KTcpSocket::State state(QAbstractSocket::SocketState s)
00247 {
00248 switch (s) {
00249 case QAbstractSocket::UnconnectedState:
00250 return KTcpSocket::UnconnectedState;
00251 case QAbstractSocket::HostLookupState:
00252 return KTcpSocket::HostLookupState;
00253 case QAbstractSocket::ConnectingState:
00254 return KTcpSocket::ConnectingState;
00255 case QAbstractSocket::ConnectedState:
00256 return KTcpSocket::ConnectedState;
00257 case QAbstractSocket::ClosingState:
00258 return KTcpSocket::ClosingState;
00259 case QAbstractSocket::BoundState:
00260 case QAbstractSocket::ListeningState:
00261
00262 default:
00263 return KTcpSocket::UnconnectedState;
00264 }
00265 }
00266
00267 KTcpSocket::EncryptionMode encryptionMode(QSslSocket::SslMode mode)
00268 {
00269 switch (mode) {
00270 case QSslSocket::SslClientMode:
00271 return KTcpSocket::SslClientMode;
00272 case QSslSocket::SslServerMode:
00273 return KTcpSocket::SslServerMode;
00274 default:
00275 return KTcpSocket::UnencryptedMode;
00276 }
00277 }
00278
00279 KTcpSocket::Error errorFromAbsSocket(QAbstractSocket::SocketError e)
00280 {
00281 switch (e) {
00282 case QAbstractSocket::ConnectionRefusedError:
00283 return KTcpSocket::ConnectionRefusedError;
00284 case QAbstractSocket::RemoteHostClosedError:
00285 return KTcpSocket::RemoteHostClosedError;
00286 case QAbstractSocket::HostNotFoundError:
00287 return KTcpSocket::HostNotFoundError;
00288 case QAbstractSocket::SocketAccessError:
00289 return KTcpSocket::SocketAccessError;
00290 case QAbstractSocket::SocketResourceError:
00291 return KTcpSocket::SocketResourceError;
00292 case QAbstractSocket::SocketTimeoutError:
00293 return KTcpSocket::SocketTimeoutError;
00294 case QAbstractSocket::NetworkError:
00295 return KTcpSocket::NetworkError;
00296 case QAbstractSocket::UnsupportedSocketOperationError:
00297 return KTcpSocket::UnsupportedSocketOperationError;
00298 case QAbstractSocket::DatagramTooLargeError:
00299
00300 case QAbstractSocket::AddressInUseError:
00301 case QAbstractSocket::SocketAddressNotAvailableError:
00302
00303 case QAbstractSocket::ProxyAuthenticationRequiredError:
00304
00305 case QAbstractSocket::UnknownSocketError:
00306 default:
00307 return KTcpSocket::UnknownError;
00308 }
00309 }
00310
00311
00312 void reemitSocketError(QAbstractSocket::SocketError e)
00313 {
00314 emit q->error(errorFromAbsSocket(e));
00315 }
00316
00317 void reemitSslErrors(const QList<QSslError> &errors)
00318 {
00319 q->showSslErrors();
00320 emit q->sslErrors(errors);
00321 }
00322
00323 void reemitStateChanged(QAbstractSocket::SocketState s)
00324 {
00325 emit q->stateChanged(state(s));
00326 }
00327
00328 void reemitModeChanged(QSslSocket::SslMode m)
00329 {
00330 emit q->encryptionModeChanged(encryptionMode(m));
00331 }
00332
00333
00334
00335
00336 void reemitReadyRead()
00337 {
00338 if (!emittedReadyRead) {
00339 emittedReadyRead = true;
00340 emit q->readyRead();
00341 emittedReadyRead = false;
00342 }
00343 }
00344
00345 KTcpSocket *const q;
00346 bool emittedReadyRead;
00347 QSslSocket sock;
00348 QList<KSslCipher> ciphers;
00349 KTcpSocket::SslVersion advertisedSslVersion;
00350 CipherCc ccc;
00351 };
00352
00353
00354 KTcpSocket::KTcpSocket(QObject *parent)
00355 : QIODevice(parent),
00356 d(new KTcpSocketPrivate(this))
00357 {
00358 d->advertisedSslVersion = SslV3;
00359
00360 connect(&d->sock, SIGNAL(aboutToClose()), this, SIGNAL(aboutToClose()));
00361 connect(&d->sock, SIGNAL(bytesWritten(qint64)), this, SIGNAL(bytesWritten(qint64)));
00362 connect(&d->sock, SIGNAL(readyRead()), this, SLOT(reemitReadyRead()));
00363 connect(&d->sock, SIGNAL(connected()), this, SIGNAL(connected()));
00364 connect(&d->sock, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
00365 connect(&d->sock, SIGNAL(error(QAbstractSocket::SocketError)),
00366 this, SLOT(reemitSocketError(QAbstractSocket::SocketError)));
00367 connect(&d->sock, SIGNAL(sslErrors(const QList<QSslError> &)),
00368 this, SLOT(reemitSslErrors(const QList<QSslError> &)));
00369 connect(&d->sock, SIGNAL(hostFound()), this, SIGNAL(hostFound()));
00370 connect(&d->sock, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
00371 this, SLOT(reemitStateChanged(QAbstractSocket::SocketState)));
00372 connect(&d->sock, SIGNAL(modeChanged(QSslSocket::SslMode)),
00373 this, SLOT(reemitModeChanged(QSslSocket::SslMode)));
00374 }
00375
00376
00377 KTcpSocket::~KTcpSocket()
00378 {
00379 delete d;
00380 }
00381
00383
00384 bool KTcpSocket::atEnd() const
00385 {
00386 return d->sock.atEnd() && QIODevice::atEnd();
00387 }
00388
00389
00390 qint64 KTcpSocket::bytesAvailable() const
00391 {
00392 return d->sock.bytesAvailable() + QIODevice::bytesAvailable();
00393 }
00394
00395
00396 qint64 KTcpSocket::bytesToWrite() const
00397 {
00398 return d->sock.bytesToWrite();
00399 }
00400
00401
00402 bool KTcpSocket::canReadLine() const
00403 {
00404 return d->sock.canReadLine() || QIODevice::canReadLine();
00405 }
00406
00407
00408 void KTcpSocket::close()
00409 {
00410 d->sock.close();
00411 QIODevice::close();
00412 }
00413
00414
00415 bool KTcpSocket::isSequential() const
00416 {
00417 return true;
00418 }
00419
00420
00421 bool KTcpSocket::open(QIODevice::OpenMode open)
00422 {
00423 bool ret = d->sock.open(open);
00424 setOpenMode(d->sock.openMode());
00425 return ret;
00426 }
00427
00428
00429 bool KTcpSocket::waitForBytesWritten(int msecs)
00430 {
00431 return d->sock.waitForBytesWritten(msecs);
00432 }
00433
00434
00435 bool KTcpSocket::waitForReadyRead(int msecs)
00436 {
00437 return d->sock.waitForReadyRead(msecs);
00438 }
00439
00440
00441 qint64 KTcpSocket::readData(char *data, qint64 maxSize)
00442 {
00443 return d->sock.read(data, maxSize);
00444 }
00445
00446
00447 qint64 KTcpSocket::writeData(const char *data, qint64 maxSize)
00448 {
00449 return d->sock.write(data, maxSize);
00450 }
00451
00453
00454 void KTcpSocket::abort()
00455 {
00456 d->sock.abort();
00457 }
00458
00459
00460 void KTcpSocket::connectToHost(const QString &hostName, quint16 port, ProxyPolicy policy)
00461 {
00462 if (policy == AutoProxy) {
00463
00464 }
00465 d->sock.connectToHost(hostName, port);
00466 setOpenMode(d->sock.openMode());
00467 }
00468
00469
00470 void KTcpSocket::connectToHost(const QHostAddress &hostAddress, quint16 port, ProxyPolicy policy)
00471 {
00472 if (policy == AutoProxy) {
00473
00474 }
00475 d->sock.connectToHost(hostAddress, port);
00476 setOpenMode(d->sock.openMode());
00477 }
00478
00479
00480 void KTcpSocket::connectToHost(const KUrl &url, ProxyPolicy policy)
00481 {
00482 if (policy == AutoProxy) {
00483
00484 }
00485 d->sock.connectToHost(url.host(), url.port());
00486 setOpenMode(d->sock.openMode());
00487 }
00488
00489
00490 void KTcpSocket::disconnectFromHost()
00491 {
00492 d->sock.disconnectFromHost();
00493 setOpenMode(d->sock.openMode());
00494 }
00495
00496
00497 KTcpSocket::Error KTcpSocket::error() const
00498 {
00499 return d->errorFromAbsSocket(d->sock.error());
00500 }
00501
00502
00503 QList<KSslError> KTcpSocket::sslErrors() const
00504 {
00505
00506
00507
00508 QList<KSslError> ret;
00509 foreach (const QSslError &e, d->sock.sslErrors())
00510 ret.append(KSslError(e));
00511 return ret;
00512 }
00513
00514
00515 bool KTcpSocket::flush()
00516 {
00517 return d->sock.flush();
00518 }
00519
00520
00521 bool KTcpSocket::isValid() const
00522 {
00523 return d->sock.isValid();
00524 }
00525
00526
00527 QHostAddress KTcpSocket::localAddress() const
00528 {
00529 return d->sock.localAddress();
00530 }
00531
00532
00533 QHostAddress KTcpSocket::peerAddress() const
00534 {
00535 return d->sock.peerAddress();
00536 }
00537
00538
00539 QString KTcpSocket::peerName() const
00540 {
00541 return d->sock.peerName();
00542 }
00543
00544
00545 quint16 KTcpSocket::peerPort() const
00546 {
00547 return d->sock.peerPort();
00548 }
00549
00550
00551 QNetworkProxy KTcpSocket::proxy() const
00552 {
00553 return d->sock.proxy();
00554 }
00555
00556
00557 qint64 KTcpSocket::readBufferSize() const
00558 {
00559 return d->sock.readBufferSize();
00560 }
00561
00562
00563 void KTcpSocket::setProxy(const QNetworkProxy &proxy)
00564 {
00565 d->sock.setProxy(proxy);
00566 }
00567
00568
00569 void KTcpSocket::setReadBufferSize(qint64 size)
00570 {
00571 d->sock.setReadBufferSize(size);
00572 }
00573
00574
00575 KTcpSocket::State KTcpSocket::state() const
00576 {
00577 return d->state(d->sock.state());
00578 }
00579
00580
00581 bool KTcpSocket::waitForConnected(int msecs)
00582 {
00583 bool ret = d->sock.waitForConnected(msecs);
00584 setOpenMode(d->sock.openMode());
00585 return ret;
00586 }
00587
00588
00589 bool KTcpSocket::waitForDisconnected(int msecs)
00590 {
00591 bool ret = d->sock.waitForDisconnected(msecs);
00592 setOpenMode(d->sock.openMode());
00593 return ret;
00594 }
00595
00597
00598 void KTcpSocket::addCaCertificate(const QSslCertificate &certificate)
00599 {
00600 d->sock.addCaCertificate(certificate);
00601 }
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613 void KTcpSocket::addCaCertificates(const QList<QSslCertificate> &certificates)
00614 {
00615 d->sock.addCaCertificates(certificates);
00616 }
00617
00618
00619 QList<QSslCertificate> KTcpSocket::caCertificates() const
00620 {
00621 return d->sock.caCertificates();
00622 }
00623
00624
00625 QList<KSslCipher> KTcpSocket::ciphers() const
00626 {
00627 return d->ciphers;
00628 }
00629
00630
00631 void KTcpSocket::connectToHostEncrypted(const QString &hostName, quint16 port, OpenMode openMode)
00632 {
00633 d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
00634 d->sock.connectToHostEncrypted(hostName, port, openMode);
00635 setOpenMode(d->sock.openMode());
00636 }
00637
00638
00639 QSslCertificate KTcpSocket::localCertificate() const
00640 {
00641 return d->sock.localCertificate();
00642 }
00643
00644
00645 QList<QSslCertificate> KTcpSocket::peerCertificateChain() const
00646 {
00647 return d->sock.peerCertificateChain();
00648 }
00649
00650
00651 KSslKey KTcpSocket::privateKey() const
00652 {
00653 return KSslKey(d->sock.privateKey());
00654 }
00655
00656
00657 KSslCipher KTcpSocket::sessionCipher() const
00658 {
00659 return KSslCipher(d->sock.sessionCipher());
00660 }
00661
00662
00663 void KTcpSocket::setCaCertificates(const QList<QSslCertificate> &certificates)
00664 {
00665 d->sock.setCaCertificates(certificates);
00666 }
00667
00668
00669 void KTcpSocket::setCiphers(const QList<KSslCipher> &ciphers)
00670 {
00671 QList<QSslCipher> cl;
00672 foreach (const KSslCipher &c, d->ciphers) {
00673 cl.append(d->ccc.converted(c));
00674 }
00675 d->sock.setCiphers(cl);
00676 }
00677
00678
00679 void KTcpSocket::setLocalCertificate(const QSslCertificate &certificate)
00680 {
00681 d->sock.setLocalCertificate(certificate);
00682 }
00683
00684
00685 void KTcpSocket::setLocalCertificate(const QString &fileName, QSsl::EncodingFormat format)
00686 {
00687 d->sock.setLocalCertificate(fileName, format);
00688 }
00689
00690
00691
00692 void KTcpSocket::setPrivateKey(const KSslKey &key)
00693 {
00694 }
00695
00696
00697
00698 void KTcpSocket::setPrivateKey(const QString &fileName, KSslKey::Algorithm algorithm,
00699 QSsl::EncodingFormat format, const QByteArray &passPhrase)
00700 {
00701 }
00702
00703
00704 bool KTcpSocket::waitForEncrypted(int msecs)
00705 {
00706 return d->sock.waitForEncrypted(msecs);
00707 }
00708
00709
00710 KTcpSocket::EncryptionMode KTcpSocket::encryptionMode() const
00711 {
00712 return d->encryptionMode(d->sock.mode());
00713 }
00714
00715
00716
00717 void KTcpSocket::ignoreSslErrors()
00718 {
00719 d->sock.ignoreSslErrors();
00720 }
00721
00722
00723
00724 void KTcpSocket::startClientEncryption()
00725 {
00726 d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
00727 d->sock.startClientEncryption();
00728 }
00729
00730
00731
00732 void KTcpSocket::showSslErrors()
00733 {
00734 foreach (const QSslError &e, d->sock.sslErrors())
00735 kDebug(7029) << e.errorString();
00736 }
00737
00738
00739 void KTcpSocket::setAdvertisedSslVersion(KTcpSocket::SslVersion version)
00740 {
00741 d->advertisedSslVersion = version;
00742 }
00743
00744
00745 KTcpSocket::SslVersion KTcpSocket::advertisedSslVersion() const
00746 {
00747 return d->advertisedSslVersion;
00748 }
00749
00750
00751 KTcpSocket::SslVersion KTcpSocket::negotiatedSslVersion() const
00752 {
00753 if (!d->sock.isEncrypted()) {
00754 return UnknownSslVersion;
00755 }
00756 return kSslVersionFromQ(d->sock.protocol());
00757 }
00758
00759
00760 QString KTcpSocket::negotiatedSslVersionName() const
00761 {
00762 if (!d->sock.isEncrypted()) {
00763 return QString();
00764 }
00765 return d->sock.sessionCipher().protocolString();
00766 }
00767
00768
00770
00771 class KSslKeyPrivate
00772 {
00773 public:
00774 KSslKey::Algorithm convertAlgorithm(QSsl::KeyAlgorithm a)
00775 {
00776 switch(a) {
00777 case QSsl::Dsa:
00778 return KSslKey::Dsa;
00779 default:
00780 return KSslKey::Rsa;
00781 }
00782 }
00783
00784 KSslKey::Algorithm algorithm;
00785 KSslKey::KeySecrecy secrecy;
00786 bool isExportable;
00787 QByteArray der;
00788 };
00789
00790
00791 KSslKey::KSslKey()
00792 : d(new KSslKeyPrivate)
00793 {
00794 d->algorithm = Rsa;
00795 d->secrecy = PublicKey;
00796 d->isExportable = true;
00797 }
00798
00799
00800 KSslKey::KSslKey(const KSslKey &other)
00801 : d(new KSslKeyPrivate)
00802 {
00803 *d = *other.d;
00804 }
00805
00806
00807 KSslKey::KSslKey(const QSslKey &qsk)
00808 : d(new KSslKeyPrivate)
00809 {
00810 d->algorithm = d->convertAlgorithm(qsk.algorithm());
00811 d->secrecy = (qsk.type() == QSsl::PrivateKey) ? PrivateKey : PublicKey;
00812 d->isExportable = true;
00813 d->der = qsk.toDer();
00814 }
00815
00816
00817 KSslKey::~KSslKey()
00818 {
00819 delete d;
00820 }
00821
00822
00823 KSslKey &KSslKey::operator=(const KSslKey &other)
00824 {
00825 *d = *other.d;
00826 return *this;
00827 }
00828
00829
00830 KSslKey::Algorithm KSslKey::algorithm() const
00831 {
00832 return d->algorithm;
00833 }
00834
00835
00836 bool KSslKey::isExportable() const
00837 {
00838 return d->isExportable;
00839 }
00840
00841
00842 KSslKey::KeySecrecy KSslKey::secrecy() const
00843 {
00844 return d->secrecy;
00845 }
00846
00847
00848 QByteArray KSslKey::toDer() const
00849 {
00850 return d->der;
00851 }
00852
00854
00855
00856 class KSslCipherPrivate
00857 {
00858 public:
00859
00860 QString authenticationMethod;
00861 QString encryptionMethod;
00862 QString keyExchangeMethod;
00863 QString name;
00864 bool isNull;
00865 int supportedBits;
00866 int usedBits;
00867 };
00868
00869
00870 KSslCipher::KSslCipher()
00871 : d(new KSslCipherPrivate)
00872 {
00873 d->isNull = true;
00874 d->supportedBits = 0;
00875 d->usedBits = 0;
00876 }
00877
00878
00879 KSslCipher::KSslCipher(const KSslCipher &other)
00880 : d(new KSslCipherPrivate)
00881 {
00882 *d = *other.d;
00883 }
00884
00885
00886 KSslCipher::KSslCipher(const QSslCipher &qsc)
00887 : d(new KSslCipherPrivate)
00888 {
00889 d->authenticationMethod = qsc.authenticationMethod();
00890 d->encryptionMethod = qsc.encryptionMethod();
00891
00892
00893 int parenIdx = d->encryptionMethod.indexOf('(');
00894 if (parenIdx > 0)
00895 d->encryptionMethod.truncate(parenIdx);
00896 d->keyExchangeMethod = qsc.keyExchangeMethod();
00897 d->name = qsc.name();
00898 d->isNull = qsc.isNull();
00899 d->supportedBits = qsc.supportedBits();
00900 d->usedBits = qsc.usedBits();
00901 }
00902
00903
00904 KSslCipher::~KSslCipher()
00905 {
00906 delete d;
00907 }
00908
00909
00910 KSslCipher &KSslCipher::operator=(const KSslCipher &other)
00911 {
00912 *d = *other.d;
00913 return *this;
00914 }
00915
00916
00917 bool KSslCipher::isNull() const
00918 {
00919 return d->isNull;
00920 }
00921
00922
00923 QString KSslCipher::authenticationMethod() const
00924 {
00925 return d->authenticationMethod;
00926 }
00927
00928
00929 QString KSslCipher::encryptionMethod() const
00930 {
00931 return d->encryptionMethod;
00932 }
00933
00934
00935 QString KSslCipher::keyExchangeMethod() const
00936 {
00937 return d->keyExchangeMethod;
00938 }
00939
00940
00941 QString KSslCipher::digestMethod() const
00942 {
00943
00944
00945 if (d->name.endsWith("SHA"))
00946 return "SHA-1";
00947 else if (d->name.endsWith("MD5"))
00948 return "MD5";
00949 else
00950 return "";
00951 }
00952
00953
00954 QString KSslCipher::name() const
00955 {
00956 return d->name;
00957 }
00958
00959
00960 int KSslCipher::supportedBits() const
00961 {
00962 return d->supportedBits;
00963 }
00964
00965
00966 int KSslCipher::usedBits() const
00967 {
00968 return d->usedBits;
00969 }
00970
00971
00972
00973 QList<KSslCipher> KSslCipher::supportedCiphers()
00974 {
00975 QList<KSslCipher> ret;
00976 QList<QSslCipher> candidates = QSslSocket::supportedCiphers();
00977 foreach(const QSslCipher &c, candidates) {
00978 ret.append(KSslCipher(c));
00979 }
00980 return ret;
00981 }
00982
00983
00984 #include "ktcpsocket.moc"