// SPDX-License-Identifier: Apache-2.0 #include #include #include #include #include #include #include #include #include #include #ifdef ESP_PLATFORM #include #else #include #endif constexpr auto* TAG = "mesh_settings"; constexpr auto* SETTINGS_FILE_NAME = "settings.properties"; constexpr auto* KEY_ENABLED = "enabled"; constexpr auto* KEY_BACKEND = "backend"; constexpr auto* KEY_PRESET = "preset"; constexpr auto* KEY_FREQUENCY = "frequency"; constexpr auto* KEY_BANDWIDTH = "bandwidth"; constexpr auto* KEY_SPREADING_FACTOR = "spreadingFactor"; constexpr auto* KEY_CODING_RATE = "codingRate"; constexpr auto* KEY_POWER = "power"; constexpr auto* KEY_PATH_HASH_SIZE = "pathHashSize"; constexpr auto* KEY_REGION_SCOPE = "regionScope"; constexpr auto* KEY_LEGACY_MIGRATED = "legacySettingsMigrated"; constexpr auto* KEY_NODE_NAME = "nodeName"; constexpr auto* KEY_RADIO = "radio"; constexpr auto* KEY_RX_BOOSTED_GAIN = "rxBoostedGain"; // Earlier versions stored this as the name when the user hadn't chosen one constexpr auto* LEGACY_DEFAULT_NODE_NAME = "Tactility"; static uint32_t random_u32() { #ifdef ESP_PLATFORM return esp_random(); #else std::random_device device; return device(); #endif } /** * Saving opens the file, sets keys and rewrites the whole file from what was read when it was opened. * Holding this from open to close keeps concurrent saves from reverting each other's keys. */ struct FileMutex { Mutex handle {}; FileMutex() { mutex_construct(&handle); } ~FileMutex() { mutex_destruct(&handle); } }; static FileMutex fileMutex; struct FileLock { FileLock() { mutex_lock(&fileMutex.handle); } ~FileLock() { mutex_unlock(&fileMutex.handle); } }; static void read_settings_file(MeshSettings* settings) { char path[FILE_MAX_PATH_STRING_LENGTH]; if (service_paths_get_user_data_path(MESH_SERVICE_ID, SETTINGS_FILE_NAME, path, sizeof(path)) != ERROR_NONE) { return; } PropertiesFile* file = properties_file_open(path); if (file == nullptr) { return; } char value[64]; if (properties_file_get(file, KEY_ENABLED, value, sizeof(value)) == ERROR_NONE) { settings->enabled = strcmp(value, "true") == 0; } if (properties_file_get(file, KEY_BACKEND, value, sizeof(value)) == ERROR_NONE) { strncpy(settings->backend, value, MESH_BACKEND_ID_MAX_LENGTH); } if (properties_file_get(file, KEY_NODE_NAME, value, sizeof(value)) == ERROR_NONE && value[0] != '\0') { strncpy(settings->node_name, value, MESH_NAME_MAX_LENGTH); } if (properties_file_get(file, KEY_RADIO, value, sizeof(value)) == ERROR_NONE) { strncpy(settings->radio, value, MESH_NAME_MAX_LENGTH); } if (properties_file_get(file, KEY_RX_BOOSTED_GAIN, value, sizeof(value)) == ERROR_NONE) { settings->rx_boosted_gain = strcmp(value, "true") == 0; } properties_file_discard(file); } void mesh_settings_load(MeshSettings* settings) { *settings = {}; settings->rx_boosted_gain = true; read_settings_file(settings); // A name that the user didn't choose is made up once and then kept if (settings->node_name[0] == '\0' || strcmp(settings->node_name, LEGACY_DEFAULT_NODE_NAME) == 0) { snprintf(settings->node_name, sizeof(settings->node_name), "TactilityUser-%08x", (unsigned)random_u32()); if (mesh_settings_save(settings) != ERROR_NONE) { LOG_E(TAG, "Failed to save the generated name"); } } } /** Opens the settings file for writing and makes sure that its directory exists */ static PropertiesFile* open_for_write() { char directory[FILE_MAX_PATH_STRING_LENGTH]; char path[FILE_MAX_PATH_STRING_LENGTH]; if (service_paths_get_user_data_directory(MESH_SERVICE_ID, directory, sizeof(directory)) != ERROR_NONE || service_paths_get_user_data_path(MESH_SERVICE_ID, SETTINGS_FILE_NAME, path, sizeof(path)) != ERROR_NONE) { return nullptr; } const error_t made = directory_make(directory, true); if (made != ERROR_NONE && made != ERROR_ALREADY_EXISTS) { LOG_E(TAG, "Failed to create %s", directory); return nullptr; } return properties_file_open(path); } constexpr auto* KEY_MUTED_PREFIX = "muted."; struct MutedVisit { void (*visitor)(const char* token, void* context); void* context; }; error_t mesh_settings_save_muted(const char* token, bool muted) { FileLock fileLock; PropertiesFile* file = open_for_write(); if (file == nullptr) { return ERROR_RESOURCE; } char key[128]; snprintf(key, sizeof(key), "%s%s", KEY_MUTED_PREFIX, token); properties_file_set(file, key, muted ? "1" : "0"); return properties_file_close(file); } void mesh_settings_load_muted(void (*visitor)(const char* token, void* context), void* context) { char path[FILE_MAX_PATH_STRING_LENGTH]; if (service_paths_get_user_data_path(MESH_SERVICE_ID, SETTINGS_FILE_NAME, path, sizeof(path)) != ERROR_NONE) { return; } FileLock fileLock; PropertiesFile* file = properties_file_open(path); if (file == nullptr) { return; } MutedVisit visit = { visitor, context }; properties_file_for_each(file, [](const char* key, const char* value, void* data) { auto* visit = static_cast(data); const size_t prefixLength = strlen(KEY_MUTED_PREFIX); if (strncmp(key, KEY_MUTED_PREFIX, prefixLength) == 0 && strcmp(value, "1") == 0) { visit->visitor(key + prefixLength, visit->context); } }, &visit); properties_file_discard(file); } constexpr auto* KEY_UNREAD_PREFIX = "unread."; struct UnreadVisit { void (*visitor)(const char* token, uint32_t count, void* context); void* context; }; error_t mesh_settings_save_unread(const char* token, uint32_t count) { FileLock fileLock; PropertiesFile* file = open_for_write(); if (file == nullptr) { return ERROR_RESOURCE; } char name[128]; char value[16]; snprintf(name, sizeof(name), "%s%s", KEY_UNREAD_PREFIX, token); snprintf(value, sizeof(value), "%u", static_cast(count)); properties_file_set(file, name, value); return properties_file_close(file); } void mesh_settings_load_unread(void (*visitor)(const char* token, uint32_t count, void* context), void* context) { char path[FILE_MAX_PATH_STRING_LENGTH]; if (service_paths_get_user_data_path(MESH_SERVICE_ID, SETTINGS_FILE_NAME, path, sizeof(path)) != ERROR_NONE) { return; } FileLock fileLock; PropertiesFile* file = properties_file_open(path); if (file == nullptr) { return; } UnreadVisit visit = { visitor, context }; properties_file_for_each(file, [](const char* key, const char* value, void* data) { auto* visit = static_cast(data); const size_t prefixLength = strlen(KEY_UNREAD_PREFIX); if (strncmp(key, KEY_UNREAD_PREFIX, prefixLength) == 0) { visit->visitor(key + prefixLength, static_cast(strtoul(value, nullptr, 10)), visit->context); } }, &visit); properties_file_discard(file); } error_t mesh_settings_save(const MeshSettings* settings) { FileLock fileLock; PropertiesFile* file = open_for_write(); if (file == nullptr) { return ERROR_RESOURCE; } properties_file_set(file, KEY_ENABLED, settings->enabled ? "true" : "false"); properties_file_set(file, KEY_BACKEND, settings->backend); properties_file_set(file, KEY_NODE_NAME, settings->node_name); properties_file_set(file, KEY_RADIO, settings->radio); properties_file_set(file, KEY_RX_BOOSTED_GAIN, settings->rx_boosted_gain ? "true" : "false"); return properties_file_close(file); } /** The keys of MeshBackendSettings */ static const char* const BACKEND_KEYS[] = { KEY_PRESET, KEY_FREQUENCY, KEY_BANDWIDTH, KEY_SPREADING_FACTOR, KEY_CODING_RATE, KEY_POWER, KEY_PATH_HASH_SIZE, KEY_REGION_SCOPE, }; static void qualified_name(const char* backend, const char* key, char* name, size_t size) { snprintf(name, size, "%s.%s", backend, key); } error_t mesh_settings_migrate_legacy(const char* owner) { FileLock fileLock; char path[FILE_MAX_PATH_STRING_LENGTH]; if (service_paths_get_user_data_path(MESH_SERVICE_ID, SETTINGS_FILE_NAME, path, sizeof(path)) != ERROR_NONE) { return ERROR_RESOURCE; } PropertiesFile* file = properties_file_open(path); if (file == nullptr) { return ERROR_RESOURCE; } if (properties_file_has(file, KEY_LEGACY_MIGRATED)) { properties_file_close(file); return ERROR_NONE; } char value[64]; char name[MESH_BACKEND_ID_MAX_LENGTH + 24]; for (const char* key : BACKEND_KEYS) { qualified_name(owner, key, name, sizeof(name)); if (!properties_file_has(file, name) && properties_file_get(file, key, value, sizeof(value)) == ERROR_NONE) { properties_file_set(file, name, value); } } properties_file_set(file, KEY_LEGACY_MIGRATED, "true"); return properties_file_close(file) == ERROR_NONE ? ERROR_NONE : ERROR_RESOURCE; } error_t mesh_settings_load_backend(const char* backend, MeshBackendSettings* settings) { *settings = {}; char path[FILE_MAX_PATH_STRING_LENGTH]; if (service_paths_get_user_data_path(MESH_SERVICE_ID, SETTINGS_FILE_NAME, path, sizeof(path)) != ERROR_NONE) { return ERROR_RESOURCE; } PropertiesFile* file = properties_file_open(path); if (file == nullptr) { return ERROR_RESOURCE; } char value[64]; char name[MESH_BACKEND_ID_MAX_LENGTH + 24]; qualified_name(backend, KEY_PRESET, name, sizeof(name)); if (properties_file_get(file, name, value, sizeof(value)) == ERROR_NONE) { strncpy(settings->preset, value, MESH_NAME_MAX_LENGTH); } const struct { const char* key; int32_t* target; } numbers[] = { { KEY_FREQUENCY, &settings->radio_settings.frequency }, { KEY_BANDWIDTH, &settings->radio_settings.bandwidth }, { KEY_SPREADING_FACTOR, &settings->radio_settings.spreading_factor }, { KEY_CODING_RATE, &settings->radio_settings.coding_rate }, { KEY_POWER, &settings->radio_settings.power }, { KEY_PATH_HASH_SIZE, &settings->network.path_hash_size }, }; for (const auto& number : numbers) { qualified_name(backend, number.key, name, sizeof(name)); if (properties_file_get(file, name, value, sizeof(value)) == ERROR_NONE) { *number.target = atoi(value); } } qualified_name(backend, KEY_REGION_SCOPE, name, sizeof(name)); if (properties_file_get(file, name, value, sizeof(value)) == ERROR_NONE) { strncpy(settings->network.region_scope, value, MESH_NAME_MAX_LENGTH); } properties_file_discard(file); return ERROR_NONE; } error_t mesh_settings_save_backend(const char* backend, const MeshBackendSettings* settings) { FileLock fileLock; PropertiesFile* file = open_for_write(); if (file == nullptr) { return ERROR_RESOURCE; } const struct { const char* key; int32_t value; } numbers[] = { { KEY_FREQUENCY, settings->radio_settings.frequency }, { KEY_BANDWIDTH, settings->radio_settings.bandwidth }, { KEY_SPREADING_FACTOR, settings->radio_settings.spreading_factor }, { KEY_CODING_RATE, settings->radio_settings.coding_rate }, { KEY_POWER, settings->radio_settings.power }, { KEY_PATH_HASH_SIZE, settings->network.path_hash_size }, }; char name[MESH_BACKEND_ID_MAX_LENGTH + 24]; snprintf(name, sizeof(name), "%s.%s", backend, KEY_PRESET); properties_file_set(file, name, settings->preset); for (const auto& number : numbers) { char value[16]; snprintf(name, sizeof(name), "%s.%s", backend, number.key); snprintf(value, sizeof(value), "%d", (int)number.value); properties_file_set(file, name, value); } snprintf(name, sizeof(name), "%s.%s", backend, KEY_REGION_SCOPE); properties_file_set(file, name, settings->network.region_scope); return properties_file_close(file); }