Warning, file /frameworks/kio/src/core/kssl/ksslsettings.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2000 George Staikos <staikos@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "ksslsettings.h"
 
 #include <KConfigGroup>
 
 #include <QStandardPaths>
 
 class CipherNode
 {
 public:
     CipherNode(const char *_name, int _keylen)
         : name(QString::fromUtf8(_name))
         , keylen(_keylen)
     {
     }
     QString name;
     int keylen;
     inline int operator==(const CipherNode &x)
     {
         return x.keylen == keylen && x.name == name;
     }
     inline int operator<(const CipherNode &x)
     {
         return keylen < x.keylen;
     }
     inline int operator<=(const CipherNode &x)
     {
         return keylen <= x.keylen;
     }
     inline int operator>(const CipherNode &x)
     {
         return keylen > x.keylen;
     }
     inline int operator>=(const CipherNode &x)
     {
         return keylen >= x.keylen;
     }
 };
 
 class KSSLSettingsPrivate
 {
 public:
     KSSLSettingsPrivate()
     {
     }
     ~KSSLSettingsPrivate()
     {
     }
 
     bool m_bUseEGD;
     bool m_bUseEFile;
     QString m_EGDPath;
     bool m_bSendX509;
     bool m_bPromptX509;
 
     KConfig *m_cfg;
     bool m_bWarnOnEnter, m_bWarnOnUnencrypted, m_bWarnOnLeave, m_bWarnOnMixed;
     bool m_bWarnSelfSigned, m_bWarnRevoked, m_bWarnExpired;
 
     QStringList m_v3ciphers;
     QStringList m_v3selectedciphers;
     QList<int> m_v3bits;
 };
 
 //
 // FIXME
 // Implementation note: for now, we only read cipher settings from disk,
 //                      and do not store them in memory.  This should change.
 //
 
 KSSLSettings::KSSLSettings(bool readConfig)
     : d(new KSSLSettingsPrivate)
 {
     d->m_cfg = new KConfig(QStringLiteral("cryptodefaults"), KConfig::NoGlobals);
 
     if (readConfig) {
         load();
     }
 }
 
 // we don't save settings in case it was a temporary object
 KSSLSettings::~KSSLSettings()
 {
     delete d->m_cfg;
 }
 
 QString KSSLSettings::getCipherList()
 {
     QString clist;
     // TODO fill in list here (or just remove this method!)
     return clist;
 }
 
 // FIXME - sync these up so that we can use them with the control module!!
 void KSSLSettings::load()
 {
     d->m_cfg->reparseConfiguration();
 
     KConfigGroup cfg(d->m_cfg, "Warnings");
     d->m_bWarnOnEnter = cfg.readEntry("OnEnter", false);
     d->m_bWarnOnLeave = cfg.readEntry("OnLeave", true);
     d->m_bWarnOnUnencrypted = cfg.readEntry("OnUnencrypted", false);
     d->m_bWarnOnMixed = cfg.readEntry("OnMixed", true);
 
     cfg = KConfigGroup(d->m_cfg, "Validation");
     d->m_bWarnSelfSigned = cfg.readEntry("WarnSelfSigned", true);
     d->m_bWarnExpired = cfg.readEntry("WarnExpired", true);
     d->m_bWarnRevoked = cfg.readEntry("WarnRevoked", true);
 
     cfg = KConfigGroup(d->m_cfg, "EGD");
     d->m_bUseEGD = cfg.readEntry("UseEGD", false);
     d->m_bUseEFile = cfg.readEntry("UseEFile", false);
     d->m_EGDPath = cfg.readPathEntry("EGDPath", QString());
 
     cfg = KConfigGroup(d->m_cfg, "Auth");
     d->m_bSendX509 = (QLatin1String("send") == cfg.readEntry("AuthMethod", ""));
     d->m_bPromptX509 = (QLatin1String("prompt") == cfg.readEntry("AuthMethod", ""));
 }
 
 void KSSLSettings::defaults()
 {
     d->m_bWarnOnEnter = false;
     d->m_bWarnOnLeave = true;
     d->m_bWarnOnUnencrypted = true;
     d->m_bWarnOnMixed = true;
     d->m_bWarnSelfSigned = true;
     d->m_bWarnExpired = true;
     d->m_bWarnRevoked = true;
     d->m_bUseEGD = false;
     d->m_bUseEFile = false;
     d->m_EGDPath = QLatin1String("");
 }
 
 void KSSLSettings::save()
 {
     KConfigGroup cfg(d->m_cfg, "Warnings");
     cfg.writeEntry("OnEnter", d->m_bWarnOnEnter);
     cfg.writeEntry("OnLeave", d->m_bWarnOnLeave);
     cfg.writeEntry("OnUnencrypted", d->m_bWarnOnUnencrypted);
     cfg.writeEntry("OnMixed", d->m_bWarnOnMixed);
 
     cfg = KConfigGroup(d->m_cfg, "Validation");
     cfg.writeEntry("WarnSelfSigned", d->m_bWarnSelfSigned);
     cfg.writeEntry("WarnExpired", d->m_bWarnExpired);
     cfg.writeEntry("WarnRevoked", d->m_bWarnRevoked);
 
     cfg = KConfigGroup(d->m_cfg, "EGD");
     cfg.writeEntry("UseEGD", d->m_bUseEGD);
     cfg.writeEntry("UseEFile", d->m_bUseEFile);
     cfg.writePathEntry("EGDPath", d->m_EGDPath);
 
     d->m_cfg->sync();
     // FIXME - ciphers
 }
 
 bool KSSLSettings::warnOnEnter() const
 {
     return d->m_bWarnOnEnter;
 }
 void KSSLSettings::setWarnOnEnter(bool x)
 {
     d->m_bWarnOnEnter = x;
 }
 bool KSSLSettings::warnOnUnencrypted() const
 {
     return d->m_bWarnOnUnencrypted;
 }
 void KSSLSettings::setWarnOnUnencrypted(bool x)
 {
     d->m_bWarnOnUnencrypted = x;
 }
 bool KSSLSettings::warnOnLeave() const
 {
     return d->m_bWarnOnLeave;
 }
 void KSSLSettings::setWarnOnLeave(bool x)
 {
     d->m_bWarnOnLeave = x;
 }
 bool KSSLSettings::warnOnMixed() const
 {
     return d->m_bWarnOnMixed;
 }
 bool KSSLSettings::useEGD() const
 {
     return d->m_bUseEGD;
 }
 bool KSSLSettings::useEFile() const
 {
     return d->m_bUseEFile;
 }
 bool KSSLSettings::autoSendX509() const
 {
     return d->m_bSendX509;
 }
 bool KSSLSettings::promptSendX509() const
 {
     return d->m_bPromptX509;
 }
 QString &KSSLSettings::getEGDPath()
 {
     return d->m_EGDPath;
 }