Slic3r::anonymous_namespace{PluginFsUtils.cpp} Namespace Reference

Classes
struct	ZipReaderGuard
struct	MzHeapFree

Enumerations
enum class	TomlSection { Root , OrcaPlugin , OrcaPluginSettings , InDepsArray }

Functions
void	assign_discovered_plugin_key (PluginDescriptor &descriptor, const boost::filesystem::path &name_source)
void	scan_plugin_directory (const std::string &dir_path, std::vector< PluginDescriptor > &out)
bool	is_safe_archive_entry_path (const boost::filesystem::path &path)
std::string	decode_zip_entry_extra_path (const std::string &extra, const std::string &fallback)
std::string	zip_entry_name (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
std::string	normalize_zip_entry_name (std::string entry_name)
bool	read_zip_text_file (mz_zip_archive &archive, const char *filename, std::string &out, std::string &error)
std::string	unquote_toml_string (const std::string &val)
std::vector< std::string >	parse_toml_inline_array (const std::string &val)
bool	parse_pep723_toml (const std::string &toml_content, std::vector< std::string > &out_deps, std::string &out_requires_python, std::string &out_name, std::string &out_description, std::string &out_author, std::string &out_version, std::string &error)
std::string	normalize_package_name (const std::string &name)
void	parse_metadata_rfc822 (const std::string &content, std::string &out_name, std::string &out_version, std::string &out_summary, std::string &out_author, std::string &out_requires_python, std::string &out_import_name, std::vector< std::string > &out_requires_dist, std::string &error)
void	apply_install_metadata (PluginInstallState &state, const PluginDescriptor &entry)

Enumeration Type Documentation

TomlSection

enum class Slic3r::anonymous_namespace{PluginFsUtils.cpp}::TomlSection

strong

Enumerator
Root
OrcaPlugin
OrcaPluginSettings
InDepsArray

{ Root, OrcaPlugin, OrcaPluginSettings, InDepsArray };

Function Documentation

apply_install_metadata()

void Slic3r::anonymous_namespace{PluginFsUtils.cpp}::apply_install_metadata	(	PluginInstallState &	state,
		const PluginDescriptor &	entry )

{
    state.installed_from    = entry.is_cloud_plugin() ? "cloud" : "local";
    state.installed_version = !entry.installed_version.empty() ? entry.installed_version : entry.version;
    state.plugin_name       = entry.name;
    state.cloud_uuid        = entry.cloud_uuid();
}

References apply_install_metadata(), Slic3r::PluginDescriptor::cloud_uuid(), Slic3r::PluginInstallState::cloud_uuid, Slic3r::PluginInstallState::installed_from, Slic3r::PluginDescriptor::installed_version, Slic3r::PluginInstallState::installed_version, Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::PluginDescriptor::name, Slic3r::PluginInstallState::plugin_name, and Slic3r::PluginDescriptor::version.

Referenced by apply_install_metadata().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_discovered_plugin_key()

void Slic3r::anonymous_namespace{PluginFsUtils.cpp}::assign_discovered_plugin_key	(	PluginDescriptor &	descriptor,
		const boost::filesystem::path &	name_source )

{
    if (descriptor.is_cloud_plugin())
        descriptor.plugin_key = descriptor.cloud_uuid();
    else
        descriptor.plugin_key = make_local_plugin_key(name_source.stem().string());
}

References assign_discovered_plugin_key(), Slic3r::PluginDescriptor::cloud_uuid(), Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::make_local_plugin_key(), and Slic3r::PluginDescriptor::plugin_key.

Referenced by assign_discovered_plugin_key(), and scan_plugin_directory().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_zip_entry_extra_path()

std::string Slic3r::anonymous_namespace{PluginFsUtils.cpp}::decode_zip_entry_extra_path	(	const std::string &	extra,
		const std::string &	fallback )

{
    const char* p = extra.data();
    const char* e = p + extra.length();
    while (p + 4 <= e) {
        const auto len = static_cast<std::uint16_t>(static_cast<unsigned char>(p[2])) |
                         static_cast<std::uint16_t>(static_cast<unsigned char>(p[3]) << 8);
        if (p[0] == '\x75' && p[1] == '\x70' && len >= 5 && p + 4 + len <= e && p[4] == '\x01')
            return std::string(p + 9, p + 4 + len);
        p += 4 + len;
    }
 
    return decode_path(fallback.c_str());
}

References Slic3r::decode_path(), and decode_zip_entry_extra_path().

Referenced by decode_zip_entry_extra_path(), and zip_entry_name().

Here is the call graph for this function:

Here is the caller graph for this function:

is_safe_archive_entry_path()

bool Slic3r::anonymous_namespace{PluginFsUtils.cpp}::is_safe_archive_entry_path

(

const boost::filesystem::path &

path

)

{
    if (!is_safe_relative_path(path))
        return false;
 
    for (const auto& part : path) {
        const std::string token = part.string();
        if (token.empty() || token == "." || token == "..")
            return false;
    }
 
    return true;
}

References is_safe_archive_entry_path(), and Slic3r::is_safe_relative_path().

Referenced by is_safe_archive_entry_path().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_package_name()

std::string Slic3r::anonymous_namespace{PluginFsUtils.cpp}::normalize_package_name

(

const std::string &

name

)

{
    std::string result;
    result.reserve(name.size());
    for (unsigned char ch : name) {
        if (ch == '-' || ch == '.')
            result += '_';
        else
            result += static_cast<char>(std::tolower(ch));
    }
    return result;
}

References normalize_package_name().

Referenced by normalize_package_name().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_zip_entry_name()

std::string Slic3r::anonymous_namespace{PluginFsUtils.cpp}::normalize_zip_entry_name

(

std::string

entry_name

)

{
    std::replace(entry_name.begin(), entry_name.end(), '\\', '/');
    while (!entry_name.empty() && entry_name.back() == '/')
        entry_name.pop_back();
    return entry_name;
}

References normalize_zip_entry_name().

Referenced by normalize_zip_entry_name().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_metadata_rfc822()

void Slic3r::anonymous_namespace{PluginFsUtils.cpp}::parse_metadata_rfc822	(	const std::string &	content,
		std::string &	out_name,
		std::string &	out_version,
		std::string &	out_summary,
		std::string &	out_author,
		std::string &	out_requires_python,
		std::string &	out_import_name,
		std::vector< std::string > &	out_requires_dist,
		std::string &	error )

{
    std::istringstream stream(content);
    std::string line;
    std::string current_header;
    std::string current_value;
 
    auto flush = [&]() {
        if (current_header.empty())
            return;
        std::string lower = current_header;
        std::transform(lower.begin(), lower.end(), lower.begin(),
                       [](unsigned char c) { return std::tolower(c); });
 
        if (lower == "name")
            out_name = current_value;
        else if (lower == "version")
            out_version = current_value;
        else if (lower == "summary")
            out_summary = current_value;
        else if (lower == "author")
            out_author = current_value;
        else if (lower == "requires-python")
            out_requires_python = current_value;
        else if (lower == "import-name")
            out_import_name = current_value;
        else if (lower == "requires-dist")
            out_requires_dist.push_back(current_value);
 
        current_header.clear();
        current_value.clear();
    };
 
    while (std::getline(stream, line)) {
        // Blank line after headers marks the start of the body.
        if (line.empty() && current_header.empty())
            continue;
        if (line.empty()) {
            flush();
            // Remaining content is the body (description); stop parsing headers.
            break;
        }
 
        // Continuation line.
        if (line[0] == ' ' || line[0] == '\t') {
            if (!current_value.empty())
                current_value += '\n';
            size_t pos = line.find_first_not_of(" \t");
            current_value += (pos != std::string::npos) ? line.substr(pos) : "";
            continue;
        }
 
        flush();
 
        size_t colon = line.find(':');
        if (colon == std::string::npos)
            continue;
 
        current_header = line.substr(0, colon);
        size_t val_start = colon + 1;
        while (val_start < line.size() && (line[val_start] == ' ' || line[val_start] == '\t'))
            ++val_start;
        current_value = line.substr(val_start);
    }
 
    flush();
}

References parse_metadata_rfc822().

Referenced by parse_metadata_rfc822().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_pep723_toml()

bool Slic3r::anonymous_namespace{PluginFsUtils.cpp}::parse_pep723_toml	(	const std::string &	toml_content,
		std::vector< std::string > &	out_deps,
		std::string &	out_requires_python,
		std::string &	out_name,
		std::string &	out_description,
		std::string &	out_author,
		std::string &	out_version,
		std::string &	error )

{
    out_deps.clear();
    out_requires_python.clear();
    out_name.clear();
    out_description.clear();
    out_author.clear();
    out_version.clear();
 
    TomlSection section = TomlSection::Root;
 
    std::istringstream stream(toml_content);
    std::string line;
 
    while (std::getline(stream, line)) {
        // Trim leading/trailing whitespace.
        size_t start = 0;
        while (start < line.size() && (line[start] == ' ' || line[start] == '\t'))
            ++start;
        size_t end = line.size();
        while (end > start && (line[end - 1] == ' ' || line[end - 1] == '\t'))
            --end;
        std::string trimmed = line.substr(start, end - start);
 
        if (trimmed.empty() || trimmed[0] == '#')
            continue;
 
        // TOML section header.
        if (trimmed[0] == '[') {
            if (trimmed == "[tool.orcaslicer.plugin]") {
                section = TomlSection::OrcaPlugin;
            } else if (trimmed == "[tool.orcaslicer.plugin.settings]") {
                // Legacy table, superseded by PluginConfig. Recognized so its keys are ignored
                // rather than falling through to Root, where a stray dependencies/requires-python
                // key inside it would be parsed as package metadata.
                section = TomlSection::OrcaPluginSettings;
            } else {
                section = TomlSection::Root; // Unknown section — skip.
            }
            continue;
        }
 
        if (section == TomlSection::InDepsArray) {
            if (trimmed == "]") {
                section = TomlSection::Root;
                continue;
            }
            std::string val = trimmed;
            if (!val.empty() && val.back() == ',')
                val.pop_back();
            val = unquote_toml_string(val);
            if (!val.empty())
                out_deps.push_back(val);
            continue;
        }
 
        // Look for key = value.
        size_t eq = trimmed.find('=');
        if (eq == std::string::npos)
            continue;
 
        std::string key = trimmed.substr(0, eq);
        while (!key.empty() && (key.back() == ' ' || key.back() == '\t'))
            key.pop_back();
 
        std::string val = trimmed.substr(eq + 1);
        while (!val.empty() && (val.front() == ' ' || val.front() == '\t'))
            val.erase(0, 1);
        // Trim trailing.
        while (!val.empty() && (val.back() == ' ' || val.back() == '\t'))
            val.pop_back();
 
        if (section == TomlSection::Root) {
            if (key == "requires-python") {
                out_requires_python = unquote_toml_string(val);
            } else if (key == "dependencies") {
                if (val == "[") {
                    section = TomlSection::InDepsArray;
                } else {
                    // Inline array: dependencies = ["a", "b"]
                    out_deps = parse_toml_inline_array(val);
                }
            }
        } else if (section == TomlSection::OrcaPlugin) {
            if (key == "name")         out_name = unquote_toml_string(val);
            else if (key == "description")  out_description = unquote_toml_string(val);
            else if (key == "author")       out_author = unquote_toml_string(val);
            else if (key == "version")      out_version = unquote_toml_string(val);
        }
    }
 
    // Check for unclosed arrays.
    if (section == TomlSection::InDepsArray) {
        error = "PEP 723 metadata: unclosed dependencies array";
        return false;
    }
    return true;
}

References InDepsArray, OrcaPlugin, OrcaPluginSettings, parse_pep723_toml(), parse_toml_inline_array(), Root, and unquote_toml_string().

Referenced by parse_pep723_toml().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_toml_inline_array()

std::vector< std::string > Slic3r::anonymous_namespace{PluginFsUtils.cpp}::parse_toml_inline_array

(

const std::string &

val

)

{
    std::vector<std::string> result;
    std::string inner = val;
    // Strip outer brackets.
    if (!inner.empty() && inner.front() == '[')
        inner.erase(0, 1);
    if (!inner.empty() && inner.back() == ']')
        inner.pop_back();
 
    // Simple split by comma, strip quotes and whitespace.
    std::istringstream ss(inner);
    std::string item;
    while (std::getline(ss, item, ',')) {
        // Trim whitespace.
        size_t s = 0, e = item.size();
        while (s < e && (item[s] == ' ' || item[s] == '\t')) ++s;
        while (e > s && (item[e - 1] == ' ' || item[e - 1] == '\t')) --e;
        item = item.substr(s, e - s);
        if (!item.empty())
            result.push_back(unquote_toml_string(item));
    }
    return result;
}

References parse_toml_inline_array(), and unquote_toml_string().

Referenced by parse_pep723_toml(), and parse_toml_inline_array().

Here is the call graph for this function:

Here is the caller graph for this function:

read_zip_text_file()

bool Slic3r::anonymous_namespace{PluginFsUtils.cpp}::read_zip_text_file	(	mz_zip_archive &	archive,
		const char *	filename,
		std::string &	out,
		std::string &	error )

{
    size_t size = 0;
    void* data = mz_zip_reader_extract_file_to_heap(&archive, filename, &size, 0);
    if (!data) {
        error = std::string("Wheel does not contain ") + filename;
        return false;
    }
    MzHeapFree guard{data};
    out.assign(static_cast<const char*>(data), size);
    return true;
}

References read_zip_text_file().

Referenced by read_zip_text_file().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_plugin_directory()

void Slic3r::anonymous_namespace{PluginFsUtils.cpp}::scan_plugin_directory	(	const std::string &	dir_path,
		std::vector< PluginDescriptor > &	out )

{
    namespace fs = boost::filesystem;
 
    if (!fs::exists(dir_path) || !fs::is_directory(dir_path))
        return;
 
    BOOST_LOG_TRIVIAL(debug) << "Scanning plugin directory: " << dir_path;
 
    try {
        for (fs::directory_iterator it(dir_path); it != fs::directory_iterator(); ++it) {
            if (!fs::is_directory(it->status()))
                continue;
 
            const fs::path plugin_dir = it->path();
            if (is_ignored_plugin_directory(plugin_dir))
                continue;
 
            PluginDescriptor descriptor;
            descriptor.plugin_root = plugin_dir.string();
 
            std::string    entry_error;
            const fs::path entry_path = find_installed_plugin_entry(plugin_dir, entry_error);
 
            // No usable entry file: keep the package as an invalid row so the UI can show it and
            // its error, rather than dropping it silently.
            if (entry_path.empty()) {
                descriptor.set_error(entry_error);
                descriptor.install_state_valid = read_install_state(plugin_dir, descriptor);
                assign_discovered_plugin_key(descriptor, plugin_dir);
                out.push_back(std::move(descriptor));
                BOOST_LOG_TRIVIAL(warning) << "Invalid plugin package: " << plugin_dir.string() << " - " << out.back().error;
                continue;
            }
 
            std::string meta_error;
            const bool  is_wheel = entry_path.extension() == ".whl";
            const bool  parsed   = is_wheel ? read_wheel_plugin_metadata(entry_path, descriptor, meta_error) :
                                              read_python_plugin_metadata(entry_path, descriptor, meta_error);
            if (!parsed) {
                descriptor.set_error(meta_error);
                descriptor.install_state_valid = read_install_state(plugin_dir, descriptor);
                assign_discovered_plugin_key(descriptor, entry_path);
                out.push_back(std::move(descriptor));
                BOOST_LOG_TRIVIAL(warning) << (is_wheel ? "Invalid wheel plugin: " : "Invalid .py plugin: ")
                                           << plugin_dir.string() << " - " << out.back().error;
                continue;
            }
 
            descriptor.entry_path = entry_path.string();
            descriptor.set_metadata_valid(true);
            descriptor.clear_error();
 
            // Cloud identity and the package-level auto-load flag. plugin_key is always derived
            // below, never read from the sidecar.
            descriptor.install_state_valid = read_install_state(plugin_dir, descriptor);
            assign_discovered_plugin_key(descriptor, entry_path);
 
            out.push_back(std::move(descriptor));
            BOOST_LOG_TRIVIAL(info) << "Discovered plugin: " << out.back().name << " (version: " << out.back().version << ")";
        }
    } catch (const std::exception& ex) {
        BOOST_LOG_TRIVIAL(error) << "Error scanning directory " << dir_path << ": " << ex.what();
    }
}

References assign_discovered_plugin_key(), Slic3r::PluginDescriptor::clear_error(), Slic3r::PluginDescriptor::entry_path, Slic3r::find_installed_plugin_entry(), Slic3r::PluginDescriptor::install_state_valid, Slic3r::is_ignored_plugin_directory(), Slic3r::PluginDescriptor::plugin_root, Slic3r::read_install_state(), Slic3r::read_python_plugin_metadata(), Slic3r::read_wheel_plugin_metadata(), scan_plugin_directory(), Slic3r::PluginDescriptor::set_error(), and Slic3r::PluginDescriptor::set_metadata_valid().

Referenced by scan_plugin_directory().

Here is the call graph for this function:

Here is the caller graph for this function:

unquote_toml_string()

std::string Slic3r::anonymous_namespace{PluginFsUtils.cpp}::unquote_toml_string

(

const std::string &

val

)

{
    if (val.size() >= 2 && ((val.front() == '"' && val.back() == '"') || (val.front() == '\'' && val.back() == '\'')))
        return val.substr(1, val.size() - 2);
    return val;
}

References unquote_toml_string().

Referenced by parse_pep723_toml(), parse_toml_inline_array(), and unquote_toml_string().

Here is the call graph for this function:

Here is the caller graph for this function:

zip_entry_name()

std::string Slic3r::anonymous_namespace{PluginFsUtils.cpp}::zip_entry_name	(	mz_zip_archive &	archive,
		const mz_zip_archive_file_stat &	stat )

{
    if (stat.m_is_utf8)
        return stat.m_filename;
 
    std::string extra(1024, 0);
    const size_t n = mz_zip_reader_get_extra(&archive, stat.m_file_index, extra.data(), extra.size());
    return decode_zip_entry_extra_path(extra.substr(0, n), stat.m_filename);
}

References decode_zip_entry_extra_path(), and zip_entry_name().

Referenced by zip_entry_name().

Here is the call graph for this function:

Here is the caller graph for this function: