ParameterUser.cpp

// Author: Kang Lin <kl222@126.com>
 
#if HAVE_QTKEYCHAIN
    #include "keychain.h"
#endif
 
#include "ParameterUser.h"
#include "ParameterNet.h"
#include "RabbitCommonTools.h"
#include <QLoggingCategory>
 
static Q_LOGGING_CATEGORY(log, "Client.Parameter.User")
static QString ServiceName()
{
    // Use application name as the keychain service; fall back to a sensible default.
    return "io.github.KangLin/RabbitRemoteControl";
}
 
CParameterUser::CParameterUser(CParameterOperate *parent, const QString &szPrefix)
    : CParameterOperate(parent, szPrefix)
{
    m_Data.m_Type << TYPE::UserPassword;
    m_Data.m_UsedType = TYPE::UserPassword;
    m_Data.m_bSavePassword = false;
    m_Data.m_bUseSystemFile = true;
    m_Data.m_bSavePassphrase = false;
    m_Data.m_TypeName = {{TYPE::None, tr("None")},
        {TYPE::OnlyPassword, tr("Password")},
        {TYPE::UserPassword, tr("Username and password")},
        {TYPE::PublicKey, tr("Public key")},
        {TYPE::OnlyPasswordX509None, tr("Password with X509 none")},
        {TYPE::OnlyPasswordX509, tr("Password with X509")},
        {TYPE::UserPasswordX509None, tr("Username and password with X509 none")},
        {TYPE::UserPasswordX509, tr("Username and password with X509")}
    };
}
 
int CParameterUser::OnLoad(QSettings &set)
{
    set.beginGroup("User");
    SetUser(set.value("Name", GetUser()).toString());
    
    set.beginGroup("Authentication");
    QStringList type;
    foreach(auto t, GetType()) {
        type.push_back(QString::number((int)t));
    }
    QStringList vType;
    vType = set.value("Type", type).toStringList();
    QList<TYPE> lstType;
    foreach(auto s, vType)
    {
        lstType.push_back((TYPE)s.toInt());
    }
    SetType(lstType);
    SetUsedType((TYPE)set.value("Type/Used", (int)GetUsedType()).toInt());
    
    SetSavePassword(set.value("SavePassword", GetSavePassword()).toBool());
    if(GetSavePassword())
    {
#if HAVE_QTKEYCHAIN
        auto para = GetGlobalParameters();
        if(para && para->GetUseSystemCredential()) {
            QString key("Password");
            auto net = qobject_cast<CParameterNet*>(parent());
            if(net) {
                key = ServiceName() + "/" + GetUser() + "@" + net->GetHost() + ":" + QString::number(net->GetPort()) + "/" + key;
            }
            auto pReadJob = new QKeychain::ReadPasswordJob(ServiceName());
            connect(pReadJob, &QKeychain::ReadPasswordJob::finished, this, &CParameterUser::slotLoadPassword);
            pReadJob->setKey(key);
            pReadJob->start();
        } else
#endif
        {
            QString szPassword;
            if(!LoadPassword(tr("Password"), "Password", szPassword, set))
                SetPassword(szPassword);
        }
    }
 
    set.beginGroup("PublicKey");
    set.beginGroup("File");
    SetUseSystemFile(set.value("UseSystemFile", GetUseSystemFile()).toBool());
    SetPublicKeyFile(set.value("PublicKey",
                               GetPublicKeyFile()).toString());
    SetPrivateKeyFile(set.value("PrivateKey",
                                GetPrivateKeyFile()).toString());
    SetSavePassphrase(set.value("SavePassphrase", GetSavePassphrase()).toBool());
    if(GetSavePassphrase()) {
#if HAVE_QTKEYCHAIN
        auto para = GetGlobalParameters();
        if(para && para->GetUseSystemCredential()) {
            QString key("Passphrase");
            auto net = qobject_cast<CParameterNet*>(parent());
            if(net) {
                key = ServiceName() + "/" + GetUser() + "@" + net->GetHost() + ":" + QString::number(net->GetPort()) + "/" + key;
            }
            auto pReadJob = new QKeychain::ReadPasswordJob("io.github.KangLin/RabbitRemoteControl");
            connect(pReadJob, &QKeychain::ReadPasswordJob::finished, this, &CParameterUser::slotLoadPassPhrase);
            pReadJob->setKey(key);
            pReadJob->start();
        } else
#endif
        {
            QString szPassword;
            if(!LoadPassword(tr("Passphrase"), "Passphrase", szPassword, set))
                SetPassphrase(szPassword);
        }
    }
 
    SetCAFile(set.value("CA", GetCAFile()).toString());
    SetCRLFile(set.value("CRL", GetCRLFile()).toString());
    
    set.endGroup();
    
    set.endGroup();
    set.endGroup();
    set.endGroup();
    return 0;
}
 
int CParameterUser::OnSave(QSettings &set)
{
    set.beginGroup("User");
    set.setValue("Name", GetUser());
    
    set.beginGroup("Authentication");
    QStringList type;
    foreach(auto t, GetType()) {
        type.push_back(QString::number((int)t));
    }
    set.setValue("Type", type);
    set.setValue("Type/Used", (int)GetUsedType());
 
    set.setValue("SavePassword", GetSavePassword());
    if(GetSavePassword() && !GetPassword().isEmpty()) {
#if HAVE_QTKEYCHAIN
        auto para = GetGlobalParameters();
        if(para && para->GetUseSystemCredential()) {
            QString key("Password");
            auto net = qobject_cast<CParameterNet*>(parent());
            if(net) {
                key = ServiceName() + "/" + GetUser() + "@" + net->GetHost() + ":" + QString::number(net->GetPort()) + "/" + key;
            }
            auto pWriteJob = new QKeychain::WritePasswordJob(ServiceName());
            connect(pWriteJob, &QKeychain::WritePasswordJob::finished, [this, pWriteJob, key]() {
                if (pWriteJob->error()) {
                    qCritical(log) << "Fail: write key" << key << ";" << pWriteJob->errorString();
                    return;
                }
                qDebug(log) << "Write key" << key << "succeeded.";
            });
            pWriteJob->setKey(key);
            pWriteJob->setTextData(GetPassword());
            pWriteJob->start();
        } else
#endif
        {
            SavePassword("Password", GetPassword(), set, GetSavePassword());
        }
    }
 
    set.beginGroup("PublicKey");
    set.beginGroup("File");
    set.setValue("UseSystemFile", GetUseSystemFile());
    set.setValue("PublicKey", GetPublicKeyFile());
    set.setValue("PrivateKey", GetPrivateKeyFile());
    set.setValue("SavePassphrase", GetSavePassphrase());
    if(GetSavePassphrase() && !GetPassphrase().isEmpty()) {
#if HAVE_QTKEYCHAIN
        auto para = GetGlobalParameters();
        if(para && para->GetUseSystemCredential()) {
            QString key("Passphrase");
            auto net = qobject_cast<CParameterNet*>(parent());
            if(net) {
                key = ServiceName() + "/" + GetUser() + "@" + net->GetHost() + ":" + QString::number(net->GetPort()) + "/" + key;
            }
            auto pWriteJob = new QKeychain::WritePasswordJob(ServiceName());
            connect(pWriteJob, &QKeychain::WritePasswordJob::finished, [this, pWriteJob, key]() {
                if (pWriteJob->error()) {
                    qCritical(log) << "Fail: write pass phrase key" << key << ";" << pWriteJob->errorString();
                    return;
                }
                qDebug(log) << "Writepass phrase  key" << key << "succeeded.";
            });
            pWriteJob->setKey(key);
            pWriteJob->setTextData(GetPassphrase());
            pWriteJob->start();
        } else
#endif
        {
            SavePassword("Passphrase", GetPassphrase(), set, GetSavePassphrase());
        }
    }
 
    set.setValue("CA", GetCAFile());
    set.setValue("CRL", GetCRLFile());
    
    set.endGroup();
    
    set.endGroup();
    set.endGroup();
    set.endGroup();
    return 0;
}
 
CParameterUser& CParameterUser::operator =(const CParameterUser& in)
{
    m_Data = in.m_Data;
    return *this;
}
 
QList<CParameterUser::TYPE> CParameterUser::GetType() const
{
    return m_Data.m_Type;
}
 
int CParameterUser::SetType(QList<TYPE> type)
{
    if(m_Data.m_Type == type)
        return 0;
    m_Data.m_Type = type;
    SetModified(true);
    return 0;
}
 
CParameterUser::TYPE CParameterUser::GetUsedType() const
{
    return m_Data.m_UsedType;
}
 
int CParameterUser::SetUsedType(TYPE type)
{
    if(m_Data.m_UsedType == type)
        return 0;
    m_Data.m_UsedType = type;
    SetModified(true);
    return 0;
}
 
const QString CParameterUser::GetUser() const
{
    return m_Data.m_szUser;
}
 
void CParameterUser::SetUser(const QString &szUser)
{
    if (m_Data.m_szUser == szUser)
        return;
    m_Data.m_szUser = szUser;
    SetModified(true);
}
 
const QString CParameterUser::GetPassword() const
{
    return m_Data.m_szPassword;
}
 
void CParameterUser::SetPassword(const QString &szPassword)
{
    if(m_Data.m_szPassword == szPassword)
        return;
    m_Data.m_szPassword = szPassword;
    SetModified(true);
}
 
const bool CParameterUser::GetSavePassword() const
{
    return m_Data.m_bSavePassword;
}
 
void CParameterUser::SetSavePassword(bool save)
{
    if (m_Data.m_bSavePassword == save)
        return;
    m_Data.m_bSavePassword = save;
    SetModified(true);
}
 
void CParameterUser::slotSetGlobalParameters()
{
    if(!GetGlobalParameters()) {
        QString szErr = "The CParameterClient is null";
        qCritical(log) << szErr;
        Q_ASSERT_X(false, "CParameterUser", szErr.toStdString().c_str());
        return;
    }
    
    if(GetGlobalParameters())
    {
        if(GetGlobalParameters()->GetEnableSystemUserToUser())
            SetUser(RabbitCommon::CTools::GetCurrentUser());
        SetSavePassword(GetGlobalParameters()->GetSavePassword());
        SetSavePassphrase(GetGlobalParameters()->GetSavePassword());
    }
    
    return;
}
 
bool CParameterUser::GetUseSystemFile() const
{
    return m_Data.m_bUseSystemFile;
}
 
int CParameterUser::SetUseSystemFile(bool use)
{
    if(m_Data.m_bUseSystemFile == use)
        return 0;
    m_Data.m_bUseSystemFile = use;
    SetModified(true);
    return 0;
}
 
QString CParameterUser::GetPassphrase() const
{
    return m_Data.m_szPassphrase;
}
 
int CParameterUser::SetPassphrase(const QString passphrase)
{
    if(m_Data.m_szPassphrase == passphrase)
        return 0;
    m_Data.m_szPassphrase = passphrase;
    SetModified(true);
    return 0;
}
 
bool CParameterUser::GetSavePassphrase() const
{
    return m_Data.m_bSavePassphrase;
}
 
int CParameterUser::SetSavePassphrase(bool bSave)
{
    if(m_Data.m_bSavePassphrase == bSave)
        return 0;
    m_Data.m_bSavePassphrase = bSave;
    SetModified(true);
    return 0;
}
 
QString CParameterUser::GetPublicKeyFile() const
{
    return m_Data.m_szPublicKeyFile;
}
 
int CParameterUser::SetPublicKeyFile(const QString szFile)
{
    if(m_Data.m_szPublicKeyFile == szFile)
        return 0;
    m_Data.m_szPublicKeyFile = szFile;
    SetModified(true);
    return 0;
}
 
QString CParameterUser::GetPrivateKeyFile() const
{
    return m_Data.m_szPrivateKeyFile;
}
 
int CParameterUser::SetPrivateKeyFile(const QString szFile)
{
    if(m_Data.m_szPrivateKeyFile == szFile)
        return 0;
    m_Data.m_szPrivateKeyFile = szFile;
    SetModified(true);
    return 0;
}
 
QString CParameterUser::GetCAFile() const
{
    return m_Data.m_szCAFile;
}
 
int CParameterUser::SetCAFile(const QString &ca)
{
    if(m_Data.m_szCAFile == ca)
        return 0;
    m_Data.m_szCAFile = ca;
    SetModified(true);
    return 0;
}
 
QString CParameterUser::GetCRLFile() const
{
    return m_Data.m_szCRLFile;
}
 
int CParameterUser::SetCRLFile(const QString &crl)
{
    if(m_Data.m_szCRLFile == crl)
        return 0;
    m_Data.m_szCRLFile = crl;
    SetModified(true);
    return 0;
}
 
QString CParameterUser::ConvertTypeToName(TYPE t)
{
    return m_Data.m_TypeName[t];
}
 
int CParameterUser::SetTypeName(TYPE t, const QString& szName)
{
    m_Data.m_TypeName[t] = szName;
    return 0;
}
 
void CParameterUser::slotLoadPassword()
{
#if HAVE_QTKEYCHAIN
    qDebug(log) << Q_FUNC_INFO;
    QKeychain::ReadPasswordJob* pReadJob = qobject_cast<QKeychain::ReadPasswordJob*>(sender());
    if(!pReadJob) return;
    QString key = pReadJob->key();
    if (pReadJob->error()) {
        qCritical(log) << "Fail: read key" << key << ";" << pReadJob->errorString();
        return;
    }
    qDebug(log) << "Read key" << key << "succeeded.";
    SetPassword(pReadJob->textData());
#endif
}
 
void CParameterUser::slotLoadPassPhrase()
{
#if HAVE_QTKEYCHAIN
    qDebug(log) << Q_FUNC_INFO;
    QKeychain::ReadPasswordJob* pReadJob = qobject_cast<QKeychain::ReadPasswordJob*>(sender());
    if(!pReadJob) return;
    QString key = pReadJob->key();   
    if (pReadJob->error()) {
        qCritical(log) << "Fail: read pass phrase key" << key << ";" << pReadJob->errorString();
        return;
    }
    qDebug(log) << "Read pass phrase key" << key << "succeeded.";
    SetPassphrase(pReadJob->textData());
#endif
}