Function LoadFileTokens

src/common/local_metadata_store.cpp:200–260

}

std::unordered_map<std::string, std::string> LoadFileTokens(uint32_t accountId, uint32_t appId,
                                                            const std::unordered_set<std::string>& validRootTokens) {
    std::shared_lock<std::shared_mutex> lock(g_metadataMutex);
    std::string appPath = GetAppPathInternal(accountId, appId);
    std::string path = appPath + kFileTokensFilename;
    std::string legacyPath = appPath + kLegacyFileTokensFilename;
    std::unordered_map<std::string, std::string> result;
    bool fromLegacy = false;

    std::ifstream f(FileUtil::Utf8ToPath(path));
    if (!f) {
        f.open(FileUtil::Utf8ToPath(legacyPath));
        if (f) fromLegacy = true;
    }
    if (f) {
        std::string line;
        while (std::getline(f, line)) {
            while (!line.empty() && (line.back() == '\r' || line.back() == '\n'))
                line.pop_back();
            if (line.empty()) continue;
            auto tab = line.find('\t');
            if (tab == std::string::npos) continue;
            std::string cleanName = line.substr(0, tab);
            std::string token = line.substr(tab + 1);
            if (!cleanName.empty()) {
                result[cleanName] = token;
            }
        }
        f.close();
        if (!result.empty()) {
            LOG("LoadFileTokens: loaded %zu entries from %s for app %u",
                result.size(), fromLegacy ? "legacy path" : "disk", appId);
        }
    }

    // Migrate from legacy if needed. Skip if canonical file already
    // exists (prior session or concurrent thread may have migrated).
    if (fromLegacy && !result.empty()) {
        std::string canonicalPath = appPath + kFileTokensFilename;
        if (!std::filesystem::exists(FileUtil::Utf8ToPath(canonicalPath))) {
            // Re-check under exclusive lock.
            lock.unlock();
            // Re-check existence to mitigate TOCTOU with concurrent migration.
            if (!std::filesystem::exists(FileUtil::Utf8ToPath(canonicalPath))) {
                LOG("LoadFileTokens: migrating file tokens for app %u", appId);
                SaveFileTokens(accountId, appId, result, validRootTokens);
            }
        }
    }

    // Filter against valid root tokens and metadata files.
    if (validRootTokens.empty()) return result;
    std::unordered_map<std::string, std::string> filtered;
    filtered.reserve(result.size());
    for (auto& [cleanName, token] : result) {
        if (token.empty() || validRootTokens.count(token) || CloudIntercept::IsInternalMetadataFile(cleanName)) {
            filtered[cleanName] = token;
        }