• Skip to content
  • Skip to link menu
KDE 4.1 API Reference
  • KDE API Reference
  • kdelibs
  • Sitemap
  • Contact Us
 

KDECore

ktcpsocket.cpp

Go to the documentation of this file.
00001 /* This file is part of the KDE libraries
00002     Copyright (C) 2007 Andreas Hartmetz <ahartmetz@gmail.com>
00003 
00004     This library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation; either
00007     version 2 of the License, or (at your option) any later version.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017     Boston, MA 02110-1301, USA.
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); // set Qt's set to empty
00044         }
00045 
00046         if (!KGlobal::hasMainComponent())
00047             return;                 // we need KGlobal::dirs() available
00048         initialized = true;
00049 
00050         // set default CAs from KDE's own bundle
00051         QStringList bundles = KGlobal::dirs()->findAllResources("data", "kssl/ca-bundle.crt");
00052         foreach (const QString &bundle, bundles) {
00053             *kdeCaCertificateList += QSslCertificate::fromPath(bundle);
00054         }
00055         //kDebug(7029) << "Loading" << kdeCaCertificateList->count() << "CA certificates from" << bundles;
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     //### this lowlevel bit-banging is a little dangerous and a likely source of bugs
00079     if (sslVersion == KTcpSocket::AnySslVersion) {
00080         return QSsl::AnyProtocol;
00081     }
00082     //does it contain any valid protocol?
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         //QSslSocket doesn't really take arbitrary combinations. It's one or all.
00096         return QSsl::AnyProtocol;
00097     }
00098 }
00099 
00100 
00101 //cipher class converter KSslCipher -> QSslCipher
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     //TODO do *something* about the error string
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             //### these two are not relevant as long as this can't be a server socket
00262         default:
00263             return KTcpSocket::UnconnectedState; //the closest to "error"
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             //we don't do UDP
00300         case QAbstractSocket::AddressInUseError:
00301         case QAbstractSocket::SocketAddressNotAvailableError:
00302             //### own values if/when we ever get server socket support
00303         case QAbstractSocket::ProxyAuthenticationRequiredError:
00304             //### maybe we need an enum value for this
00305         case QAbstractSocket::UnknownSocketError:
00306         default:
00307             return KTcpSocket::UnknownError;
00308         }
00309     }
00310 
00311     //private slots
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(); //H4X
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     // This method is needed because we might emit readyRead() due to this QIODevice
00334     // having some data buffered, so we need to care about blocking, too.
00335     //### useless ATM as readyRead() now just calls d->sock.readyRead().
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     //### pretty slow; also consider throwing out duplicate error codes. We may get
00506     //    duplicates even though there were none in the original list because KSslError
00507     //    has a smallest common denominator range of SSL error codes.
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 bool KTcpSocket::addCaCertificates(const QString &path, QSsl::EncodingFormat format,
00606                                    QRegExp::PatternSyntax syntax)
00607 {
00608     return d->sock.addCaCertificates(path, format, syntax);
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 //TODO
00692 void KTcpSocket::setPrivateKey(const KSslKey &key)
00693 {
00694 }
00695 
00696 
00697 //TODO
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 //slot
00717 void KTcpSocket::ignoreSslErrors()
00718 {
00719     d->sock.ignoreSslErrors();
00720 }
00721 
00722 
00723 //slot
00724 void KTcpSocket::startClientEncryption()
00725 {
00726     d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
00727     d->sock.startClientEncryption();
00728 }
00729 
00730 
00731 //debugging H4X
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 //nice-to-have: make implicitly shared
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     //Qt likes to append the number of bits (usedBits?) to the algorithm,
00892     //for example "AES(256)". We only want the pure algorithm name, though.
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     //### This is not really backend neutral. It works for OpenSSL and
00944     //    for RFC compliant names, though.
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 //static 
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"

KDECore

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

kdelibs

Skip menu "kdelibs"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • Kate
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • KIO
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • Kross
  • KUtils
  • Nepomuk
  • Solid
  • Sonnet
  • ThreadWeaver
Generated for kdelibs by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal