File indexing completed on 2024-12-22 05:16:01

 /*
     localegenhelper.cpp
     SPDX-FileCopyrightText: 2021 Han Young <hanyoung@protonmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "localegenhelper.h"
 #include "localegenhelperadaptor.h"
 
 #include <KLocalizedString>
 
 #include <QDBusConnection>
 #include <QDebug>
 
 #include <chrono>
 
 LocaleGenHelper::LocaleGenHelper()
     : m_authority(PolkitQt1::Authority::instance())
 {
     new LocaleGenHelperAdaptor(this);
     if (!QDBusConnection::systemBus().registerService(QStringLiteral("org.kde.localegenhelper"))) {
         qWarning() << "another helper is already running";
         QCoreApplication::instance()->exit();
     }
     if (!QDBusConnection::systemBus().registerObject(QStringLiteral("/LocaleGenHelper"), this)) {
         qWarning() << "unable to register service interface to dbus";
         QCoreApplication::instance()->exit();
     }
     connect(m_authority, &PolkitQt1::Authority::checkAuthorizationFinished, this, &LocaleGenHelper::enableLocalesPrivate);
     connect(&m_timer, &QTimer::timeout, this, [] {
         QCoreApplication::instance()->exit();
     });
     exitAfterTimeOut();
 }
 
 void LocaleGenHelper::enableLocales(const QStringList &locales)
 {
     qDebug() << locales;
     if (m_timer.isActive()) {
         m_timer.stop();
     }
     if (m_isGenerating) {
         Q_EMIT error(i18n("Another process is already running, please retry later"));
         exitAfterTimeOut();
         return;
     }
     processLocales(locales);
     m_isGenerating = true;
     if (shouldGenerate()) {
         m_authority->checkAuthorization(QStringLiteral("org.kde.localegenhelper.enableLocales"),
                                         PolkitQt1::SystemBusNameSubject(message().service()),
                                         PolkitQt1::Authority::AllowUserInteraction);
     } else {
         exitAfterTimeOut();
         Q_EMIT success();
     }
 }
 
 void LocaleGenHelper::enableLocalesPrivate(PolkitQt1::Authority::Result result)
 {
     qDebug() << result;
     if (result != PolkitQt1::Authority::Result::Yes) {
         Q_EMIT error(i18n("Unauthorized to edit locale configuration file"));
         exitAfterTimeOut();
         return;
     }
 
     // if success, handleLocaleGen will call exit
     if (editLocaleGen()) {
         exitAfterTimeOut();
     }
 }
 
 bool LocaleGenHelper::shouldGenerate()
 {
     QFile localegen(QStringLiteral("/etc/locale.gen"));
     if (!localegen.open(QIODevice::ReadOnly)) {
         return false;
     }
     m_alreadyEnabled.clear();
     while (!localegen.atEnd()) {
         QString locale = localegen.readLine().simplified();
         if (!m_comment && locale == QStringLiteral("# generated by KDE Plasma Region & Language KCM")) {
             m_comment = true;
         }
         if (locale.isEmpty() || locale.front() == QLatin1Char('#')) {
             continue;
         }
         QStringList localeAndCharset = locale.split(QLatin1Char(' '));
         if (localeAndCharset.size() != 2 || localeAndCharset.at(1) != QStringLiteral("UTF-8")) {
             continue;
         } else {
             QString localeNameWithoutCharset = localeAndCharset.front().remove(QStringLiteral(".UTF-8"));
             m_alreadyEnabled.insert(localeNameWithoutCharset);
         }
     }
     for (const auto &locale : std::as_const(m_locales)) {
         if (locale == QStringLiteral("C")) {
             continue;
         }
         if (m_alreadyEnabled.count(locale) == 0) {
             return true;
         }
     }
     return false;
 }
 
 bool LocaleGenHelper::editLocaleGen()
 {
     bool result = false;
     QFile localegen(QStringLiteral("/etc/locale.gen"));
     if (!localegen.open(QIODevice::Append)) {
         Q_EMIT error(i18n("Can't open file `/etc/locale.gen`"));
         return result;
     }
     for (const auto &locale : std::as_const(m_locales)) {
         if (m_alreadyEnabled.count(locale) || locale == QStringLiteral("C")) {
             continue;
         }
         // start at newline first time
         if (!m_comment) {
             localegen.write("\n# generated by KDE Plasma Region & Language KCM\n");
             m_comment = true;
         }
         localegen.write(locale.toUtf8() + ".UTF-8 UTF-8\n");
     }
 
     QString localeGenPath = QStandardPaths::findExecutable(QStringLiteral("locale-gen"));
     if (localeGenPath.isEmpty()) {
         localeGenPath = QStandardPaths::findExecutable(QStringLiteral("locale-gen"),
                                                        {
                                                            QStringLiteral("/usr/sbin"),
                                                            QStringLiteral("/sbin"),
                                                            QStringLiteral("/usr/local/sbin"),
                                                        });
     }
     if (!localeGenPath.isEmpty()) {
         auto *process = new QProcess(this);
         process->setProgram(localeGenPath);
         connect(process, &QProcess::finished, this, [this, process](int statusCode, QProcess::ExitStatus status) {
             handleLocaleGen(statusCode, status, process);
         });
         process->start();
         result = true;
     } else {
         Q_EMIT error(i18n("Can't locate executable `locale-gen`"));
     }
     return result;
 }
 
 void LocaleGenHelper::handleLocaleGen(int statusCode, QProcess::ExitStatus status, QProcess *process)
 {
     Q_UNUSED(status)
     if (statusCode == 0) {
         Q_EMIT success();
     } else {
         QString all_error;
         if (!process) {
             all_error = i18n("Unknown");
         } else {
             all_error.append(process->readAllStandardOutput());
             all_error.append(QChar('\n'));
             all_error.append(process->readAllStandardError());
         }
         Q_EMIT error(all_error);
     }
     exitAfterTimeOut();
 }
 
 void LocaleGenHelper::exitAfterTimeOut()
 {
     m_isGenerating = false;
     m_timer.start(30s);
 }
 
 void LocaleGenHelper::processLocales(const QStringList &locales)
 {
     QStringList processedLocales = locales;
     for (auto &locale : processedLocales) {
         locale.remove(QStringLiteral(".UTF-8"));
         if (locale == QStringLiteral("C")) {
             continue;
         }
     }
     m_locales = std::move(processedLocales);
 }
 
 int main(int argc, char *argv[])
 {
     QCoreApplication app(argc, argv);
     LocaleGenHelper generator;
     return app.exec();
 }