Slic3r::anonymous_namespace{miniz_extension.cpp} Namespace Reference

Functions
std::string	decode_zip_unicode_path_extra_field (const std::string &extra, const std::string &path)
bool	open_zip (mz_zip_archive *zip, const char *fname, bool isread)
bool	close_zip (mz_zip_archive *zip, bool isread)

Function Documentation

close_zip()

bool Slic3r::anonymous_namespace{miniz_extension.cpp}::close_zip	(	mz_zip_archive *	zip,
		bool	isread )

{
    bool ret = false;
    if (zip) {
        FILE *f = mz_zip_get_cfile(zip);
        ret     = bool(isread ? mz_zip_reader_end(zip)
                          : mz_zip_writer_end(zip));
        if (f) fclose(f);
    }
    return ret;
}

References close_zip(), and Slic3r::f().

Referenced by close_zip().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_zip_unicode_path_extra_field()

std::string Slic3r::anonymous_namespace{miniz_extension.cpp}::decode_zip_unicode_path_extra_field	(	const std::string &	extra,
		const std::string &	path )

{
    size_t offset = 0;
    const mz_uint32 path_crc = mz_crc32(0, reinterpret_cast<const unsigned char*>(path.data()), path.size());
 
    while (offset + 4 <= extra.size()) {
        const unsigned char* field = reinterpret_cast<const unsigned char*>(extra.data() + offset);
        const std::uint16_t len = field[2] | (static_cast<std::uint16_t>(field[3]) << 8);
        if (offset + 4 + len > extra.size())
            break;
 
        if (field[0] == 0x75 && field[1] == 0x70 && len >= 5 && field[4] == 0x01) {
            const mz_uint32 stored_crc =
                static_cast<mz_uint32>(field[5]) |
                (static_cast<mz_uint32>(field[6]) << 8) |
                (static_cast<mz_uint32>(field[7]) << 16) |
                (static_cast<mz_uint32>(field[8]) << 24);
            if (stored_crc == path_crc)
                return std::string(extra.data() + offset + 9, extra.data() + offset + 4 + len);
        }
 
        offset += 4 + len;
    }
 
    return Slic3r::decode_path(path.c_str());
}

References Slic3r::decode_path(), decode_zip_unicode_path_extra_field(), and Slic3r::offset().

Referenced by decode_zip_unicode_path_extra_field().

Here is the call graph for this function:

Here is the caller graph for this function:

open_zip()

bool Slic3r::anonymous_namespace{miniz_extension.cpp}::open_zip	(	mz_zip_archive *	zip,
		const char *	fname,
		bool	isread )

{
    if (!zip) return false;
    const char *mode = isread ? "rb" : "wb";
 
    FILE *f = nullptr;
#if defined(_MSC_VER) || defined(__MINGW64__)
    // fname is UTF-8 (the nowide contract). Route it through the shared extended-path helper so an
    // archive stored past MAX_PATH opens even with LongPathsEnabled off.
    const std::wstring wide_path = boost::nowide::widen(fname);
    const std::string  extended  = boost::nowide::narrow(Slic3r::extended_path(boost::filesystem::path(wide_path)).wstring());
    f = boost::nowide::fopen(extended.c_str(), mode);
#elif defined(__GNUC__) && defined(_LARGEFILE64_SOURCE)
    f = fopen64(fname, mode);
#else
    f = fopen(fname, mode);
#endif
 
    if (!f) {
        zip->m_last_error = MZ_ZIP_FILE_OPEN_FAILED;
        return false;
    }
 
    bool res = false;
    if (isread)
    {
        res = mz_zip_reader_init_cfile(zip, f, 0, 0);
        if (!res)
            // if we get here it means we tried to open a non-zip file
            // we need to close the file here because the call to mz_zip_get_cfile() made into close_zip() returns a null pointer
            // see: https://github.com/prusa3d/PrusaSlicer/issues/3536
            fclose(f);
    }
    else
        res = mz_zip_writer_init_cfile(zip, f, 0);
 
    return res;
}

References Slic3r::extended_path(), Slic3r::f(), and open_zip().

Referenced by open_zip().

Here is the call graph for this function:

Here is the caller graph for this function: