363 lines
14 KiB
C++
363 lines
14 KiB
C++
// Isotope Updater
|
|
// Copyright (C) 2020 Nichole Mattera
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
#include "ConfigManager.hpp"
|
|
|
|
using namespace std;
|
|
|
|
namespace dsu {
|
|
void ConfigManager::initialize() {
|
|
config_init(&_cfg);
|
|
config_init(&_internalDb);
|
|
|
|
if(!config_read_file(&_internalDb, INTERNAL_FILENAME.c_str())) {
|
|
config_setting_t * root, * setting;
|
|
root = config_root_setting(&_internalDb);
|
|
|
|
setting = config_setting_add(root, VERSION_KEY.c_str(), CONFIG_TYPE_STRING);
|
|
config_setting_set_string(setting, VERSION_DEF.c_str());
|
|
|
|
setting = config_setting_add(root, INSTALLED_FILES_KEY.c_str(), CONFIG_TYPE_ARRAY);
|
|
|
|
setting = config_setting_add(root, RECEIVED_EXFAT_WARNING_KEY.c_str(), CONFIG_TYPE_BOOL);
|
|
config_setting_set_bool(setting, RECEIVED_EXFAT_WARNING_DEF);
|
|
|
|
// setting = config_setting_add(root, RECEIVED_IGNORE_CONFIG_WARNING_KEY.c_str(), CONFIG_TYPE_BOOL);
|
|
// config_setting_set_bool(setting, RECEIVED_IGNORE_CONFIG_WARNING_DEF);
|
|
|
|
setting = config_setting_add(root, IGNORE_CONFIG_FILES_KEY.c_str(), CONFIG_TYPE_BOOL);
|
|
config_setting_set_bool(setting, IGNORE_CONFIG_FILES_DEF);
|
|
|
|
setting = config_setting_add(root, CONFIG_VERSION_KEY.c_str(), CONFIG_TYPE_INT);
|
|
config_setting_set_int(setting, INTERNAL_CONFIG_VERSION);
|
|
|
|
config_write_file(&_internalDb, INTERNAL_FILENAME.c_str());
|
|
}
|
|
|
|
if(!config_read_file(&_cfg, CONFIG_FILENAME.c_str())) {
|
|
config_setting_t * root, * setting;
|
|
root = config_root_setting(&_cfg);
|
|
|
|
setting = config_setting_add(root, IGNORE_KEY.c_str(), CONFIG_TYPE_ARRAY);
|
|
|
|
setting = config_setting_add(root, AUTOUPDATE_KEY.c_str(), CONFIG_TYPE_BOOL);
|
|
config_setting_set_bool(setting, AUTOUPDATE_DEF);
|
|
|
|
setting = config_setting_add(root, PROXY_ENABLED_KEY.c_str(), CONFIG_TYPE_BOOL);
|
|
config_setting_set_bool(setting, PROXY_ENABLED_DEF);
|
|
|
|
setting = config_setting_add(root, PROXY_URL_KEY.c_str(), CONFIG_TYPE_STRING);
|
|
config_setting_set_string(setting, PROXY_URL_DEF.c_str());
|
|
|
|
setting = config_setting_add(root, PROXY_USERNAME_KEY.c_str(), CONFIG_TYPE_STRING);
|
|
config_setting_set_string(setting, PROXY_USERNAME_DEF.c_str());
|
|
|
|
setting = config_setting_add(root, PROXY_PASSWORD_KEY.c_str(), CONFIG_TYPE_STRING);
|
|
config_setting_set_string(setting, PROXY_PASSWORD_DEF.c_str());
|
|
|
|
setting = config_setting_add(root, CONFIG_VERSION_KEY.c_str(), CONFIG_TYPE_INT);
|
|
config_setting_set_int(setting, SETTING_CONFIG_VERSION);
|
|
|
|
config_write_file(&_cfg, CONFIG_FILENAME.c_str());
|
|
}
|
|
|
|
_migrateConfigFiles();
|
|
}
|
|
|
|
void ConfigManager::dealloc() {
|
|
config_destroy(&_cfg);
|
|
config_destroy(&_internalDb);
|
|
}
|
|
|
|
vector<string> ConfigManager::getFilesToIgnore() {
|
|
vector<string> defaultValue;
|
|
return _readArrayOfStrings(IGNORE_KEY, defaultValue, _cfg);
|
|
}
|
|
|
|
bool ConfigManager::shouldAutoUpdate() {
|
|
#ifdef DEBUG
|
|
return false;
|
|
#endif
|
|
|
|
return _readBoolean(AUTOUPDATE_KEY, AUTOUPDATE_DEF, _cfg);
|
|
}
|
|
|
|
bool ConfigManager::shouldUseProxy() {
|
|
return _readBoolean(PROXY_ENABLED_KEY, PROXY_ENABLED_DEF, _cfg);
|
|
}
|
|
|
|
string ConfigManager::getProxy() {
|
|
return _readString(PROXY_URL_KEY, PROXY_URL_DEF, _cfg);
|
|
}
|
|
|
|
string ConfigManager::getProxyUsername() {
|
|
return _readString(PROXY_USERNAME_KEY, PROXY_USERNAME_DEF, _cfg);
|
|
}
|
|
|
|
string ConfigManager::getProxyPassword() {
|
|
return _readString(PROXY_PASSWORD_KEY, PROXY_PASSWORD_DEF, _cfg);
|
|
}
|
|
|
|
int ConfigManager::getSettingsConfigVersion() {
|
|
return _readInt(CONFIG_VERSION_KEY, CONFIG_VERSION_DEF, _cfg);
|
|
}
|
|
|
|
bool ConfigManager::setFilesToIgnore(vector<string> files) {
|
|
return _appendArrayOfStrings(IGNORE_KEY, files, _cfg, CONFIG_FILENAME);
|
|
}
|
|
|
|
string ConfigManager::getCurrentVersion() {
|
|
return _readString(VERSION_KEY, VERSION_DEF, _internalDb);
|
|
}
|
|
|
|
vector<string> ConfigManager::getInstalledFiles() {
|
|
vector<string> defaultValue;
|
|
return _readArrayOfStrings(INSTALLED_FILES_KEY, defaultValue, _internalDb);
|
|
}
|
|
|
|
bool ConfigManager::getReceivedExFATWarning() {
|
|
return _readBoolean(RECEIVED_EXFAT_WARNING_KEY, RECEIVED_EXFAT_WARNING_DEF, _internalDb);
|
|
}
|
|
|
|
// bool ConfigManager::getReceivedIgnoreConfigWarning() {
|
|
// return _readBoolean(RECEIVED_IGNORE_CONFIG_WARNING_KEY, RECEIVED_IGNORE_CONFIG_WARNING_DEF, _internalDb);
|
|
// }
|
|
|
|
bool ConfigManager::getIgnoreConfigFiles() {
|
|
return _readBoolean(IGNORE_CONFIG_FILES_KEY, IGNORE_CONFIG_FILES_DEF, _internalDb);
|
|
}
|
|
|
|
int ConfigManager::getInternalConfigVersion() {
|
|
return _readInt(CONFIG_VERSION_KEY, CONFIG_VERSION_DEF, _internalDb);
|
|
}
|
|
|
|
bool ConfigManager::setCurrentVersion(string version) {
|
|
return _writeString(VERSION_KEY, version, _internalDb, INTERNAL_FILENAME);
|
|
}
|
|
|
|
bool ConfigManager::setInstalledFiles(vector<string> files) {
|
|
return _writeArrayOfStrings(INSTALLED_FILES_KEY, files, _internalDb, INTERNAL_FILENAME);
|
|
}
|
|
|
|
bool ConfigManager::setReceivedExFATWarning(bool received) {
|
|
return _writeBoolean(RECEIVED_EXFAT_WARNING_KEY, received, _internalDb, INTERNAL_FILENAME);
|
|
}
|
|
|
|
// bool ConfigManager::setReceivedIgnoreConfigWarning(bool received) {
|
|
// return _writeBoolean(RECEIVED_IGNORE_CONFIG_WARNING_KEY, received, _internalDb, INTERNAL_FILENAME);
|
|
// }
|
|
|
|
bool ConfigManager::setIgnoreConfigFiles(bool ignore) {
|
|
return _writeBoolean(IGNORE_CONFIG_FILES_KEY, ignore, _internalDb, INTERNAL_FILENAME);
|
|
}
|
|
|
|
// Private Methods
|
|
|
|
bool ConfigManager::_readBoolean(string key, bool def, config_t config) {
|
|
int result;
|
|
|
|
if (!config_lookup_bool(&config, key.c_str(), &result))
|
|
return def;
|
|
|
|
return result;
|
|
}
|
|
|
|
int ConfigManager::_readInt(std::string key, int def, config_t config) {
|
|
int result;
|
|
|
|
if (!config_lookup_int(&config, key.c_str(), &result))
|
|
return def;
|
|
|
|
return result;
|
|
}
|
|
|
|
string ConfigManager::_readString(string key, string def, config_t config) {
|
|
const char * result;
|
|
|
|
if (!config_lookup_string(&config, key.c_str(), &result))
|
|
return def;
|
|
|
|
return string(result);
|
|
}
|
|
|
|
vector<string> ConfigManager::_readArrayOfStrings(string key, vector<string> def, config_t config) {
|
|
vector<string> result;
|
|
|
|
config_setting_t * array = config_lookup(&config, key.c_str());
|
|
if (array == NULL)
|
|
return def;
|
|
|
|
int count = config_setting_length(array);
|
|
for (int i = 0; i < count; i++) {
|
|
auto file = string(config_setting_get_string_elem(array, i));
|
|
|
|
if (file.substr(0,1) == "/") {
|
|
result.push_back("sdmc:" + file);
|
|
}
|
|
else if (file.substr(0,7) == "sdmc://") {
|
|
result.push_back("sdmc:/" + file.substr(7, file.length() - 7));
|
|
}
|
|
else {
|
|
result.push_back(file);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool ConfigManager::_writeBoolean(string key, bool value, config_t config, string filename) {
|
|
config_setting_t * root, * setting;
|
|
root = config_root_setting(&config);
|
|
|
|
setting = config_setting_get_member(root, key.c_str());
|
|
if (setting == NULL) {
|
|
setting = config_setting_add(root, key.c_str(), CONFIG_TYPE_BOOL);
|
|
}
|
|
|
|
config_setting_set_bool(setting, value);
|
|
|
|
return config_write_file(&config, filename.c_str());
|
|
}
|
|
|
|
bool ConfigManager::_writeString(string key, string value, config_t config, string filename) {
|
|
config_setting_t * root, * setting;
|
|
root = config_root_setting(&config);
|
|
|
|
setting = config_setting_get_member(root, key.c_str());
|
|
if (setting == NULL) {
|
|
setting = config_setting_add(root, key.c_str(), CONFIG_TYPE_STRING);
|
|
}
|
|
|
|
config_setting_set_string(setting, value.c_str());
|
|
|
|
return config_write_file(&config, filename.c_str());
|
|
}
|
|
|
|
bool ConfigManager::_writeArrayOfStrings(string key, vector<string> values, config_t config, string filename) {
|
|
config_setting_t * root = config_root_setting(&config);
|
|
config_setting_remove(root, key.c_str());
|
|
|
|
config_setting_t * array = config_setting_add(root, key.c_str(), CONFIG_TYPE_ARRAY);
|
|
for (auto const& value : values) {
|
|
config_setting_set_string_elem(array, -1, value.c_str());
|
|
}
|
|
|
|
return config_write_file(&config, filename.c_str());
|
|
}
|
|
|
|
bool ConfigManager::_appendArrayOfStrings(string key, vector<string> values, config_t config, string filename) {
|
|
config_setting_t * root = config_root_setting(&config);
|
|
|
|
config_setting_t * array = config_lookup(&config, key.c_str());
|
|
if (array == NULL)
|
|
array = config_setting_add(root, key.c_str(), CONFIG_TYPE_ARRAY);
|
|
|
|
for (auto const& value : values) {
|
|
config_setting_set_string_elem(array, -1, value.c_str());
|
|
}
|
|
|
|
return config_write_file(&config, filename.c_str());
|
|
}
|
|
|
|
bool ConfigManager::_removeSetting(string key, config_t config, string filename) {
|
|
config_setting_t * root = config_root_setting(&config);
|
|
config_setting_remove(root, key.c_str());
|
|
return config_write_file(&config, filename.c_str());
|
|
}
|
|
|
|
void ConfigManager::_migrateConfigFiles() {
|
|
auto settingsVersion = getSettingsConfigVersion();
|
|
auto internalVersion = getInternalConfigVersion();
|
|
|
|
if (internalVersion < INTERNAL_CONFIG_VERSION) {
|
|
_migrateInternalConfigFiles(internalVersion);
|
|
}
|
|
|
|
if (settingsVersion < SETTING_CONFIG_VERSION) {
|
|
_migrateSettingsConfigFiles(settingsVersion);
|
|
}
|
|
}
|
|
|
|
void ConfigManager::_migrateSettingsConfigFiles(int currentVersion) {
|
|
bool configChanged = false;
|
|
config_setting_t * root = config_root_setting(&_cfg);
|
|
|
|
if (currentVersion < 2) {
|
|
configChanged = true;
|
|
|
|
config_setting_remove(root, "host");
|
|
|
|
// Migrate sys-ftp path.
|
|
config_setting_t * ignoredFiles = config_lookup(&_cfg, IGNORE_KEY.c_str());
|
|
if (ignoredFiles != NULL) {
|
|
int count = config_setting_length(ignoredFiles);
|
|
for (int i = 0; i < count; i++) {
|
|
auto file = string(config_setting_get_string_elem(ignoredFiles, i));
|
|
if (file == "sdmc:/config/ftpd/config.ini") {
|
|
config_setting_set_string_elem(ignoredFiles, i, "sdmc:/config/sys-ftpd/config.ini");
|
|
setIgnoreConfigFiles(true);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Added config version for future migrations
|
|
if (currentVersion < 1) {
|
|
config_setting_t * configVersion = config_setting_add(root, CONFIG_VERSION_KEY.c_str(), CONFIG_TYPE_INT);
|
|
config_setting_set_int(configVersion, 2);
|
|
} else {
|
|
config_setting_t * configVersion = config_setting_get_member(root, CONFIG_VERSION_KEY.c_str());
|
|
config_setting_set_int(configVersion, 2);
|
|
}
|
|
}
|
|
|
|
if (configChanged) {
|
|
config_write_file(&_cfg, CONFIG_FILENAME.c_str());
|
|
}
|
|
}
|
|
|
|
void ConfigManager::_migrateInternalConfigFiles(int currentVersion) {
|
|
bool configChanged = false;
|
|
config_setting_t * root = config_root_setting(&_internalDb);
|
|
|
|
if (currentVersion < 1 && config_lookup(&_internalDb, IGNORE_CONFIG_FILES_KEY.c_str()) == NULL) {
|
|
configChanged = true;
|
|
|
|
// Added setting in internal to keep track of if the user is ignoring config files.
|
|
config_setting_t * ignoreConfigFiles = config_setting_add(root, IGNORE_CONFIG_FILES_KEY.c_str(), CONFIG_TYPE_BOOL);
|
|
config_setting_set_bool(ignoreConfigFiles, IGNORE_CONFIG_FILES_DEF);
|
|
}
|
|
|
|
if (currentVersion < 2) {
|
|
configChanged = true;
|
|
|
|
if (config_lookup(&_internalDb, CONFIG_VERSION_KEY.c_str()) == NULL) {
|
|
// Added separate config version to internal db.
|
|
config_setting_t * configVersion = config_setting_add(root, CONFIG_VERSION_KEY.c_str(), CONFIG_TYPE_INT);
|
|
config_setting_set_int(configVersion, 2);
|
|
} else {
|
|
// How???
|
|
config_setting_t * configVersion = config_lookup(&_internalDb, CONFIG_VERSION_KEY.c_str());
|
|
config_setting_set_int(configVersion, 2);
|
|
}
|
|
}
|
|
|
|
if (configChanged) {
|
|
config_write_file(&_internalDb, INTERNAL_FILENAME.c_str());
|
|
}
|
|
}
|
|
} |