diff options
Diffstat (limited to 'src/lib/util/zippath.cpp')
-rw-r--r-- | src/lib/util/zippath.cpp | 436 |
1 files changed, 191 insertions, 245 deletions
diff --git a/src/lib/util/zippath.cpp b/src/lib/util/zippath.cpp index efe7c710481..edeecf80c47 100644 --- a/src/lib/util/zippath.cpp +++ b/src/lib/util/zippath.cpp @@ -8,15 +8,19 @@ ***************************************************************************/ -#include <ctype.h> -#include <stdlib.h> -#include <new> -#include <assert.h> #include "zippath.h" #include "unzip.h" #include "corestr.h" #include "osdcore.h" +#include <stdlib.h> + +#include <cassert> +#include <cctype> +#include <new> + + +namespace util { /*************************************************************************** TYPE DEFINITIONS @@ -66,7 +70,7 @@ public: /** @brief true to called zip first. */ bool called_zip_first; /** @brief The zipfile. */ - zip_file *zipfile; + archive_file::ptr zipfile; /** @brief The zipprefix. */ std::string zipprefix; /** @brief The returned dirlist. */ @@ -78,10 +82,10 @@ public: FUNCTION PROTOTYPES ***************************************************************************/ -static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const char *subpath, osd_dir_entry_type *type); -static int is_zip_file(const char *path); -static int is_zip_file_separator(char c); -static int is_7z_file(const char *path); +static int zippath_find_sub_path(archive_file &zipfile, std::string const &subpath, osd_dir_entry_type &type); +static bool is_zip_file(std::string const &path); +static bool is_zip_file_separator(char c); +static bool is_7z_file(std::string const &path); /*************************************************************************** @@ -148,29 +152,15 @@ static void parse_parent_path(const char *path, int *beginpos, int *endpos) zippath_parent - retrieves the parent directory -------------------------------------------------*/ -/** - * @fn std::string &zippath_parent(std::string &dst, const char *path) - * - * @brief Zippath parent. - * - * @param [in,out] dst Destination for the. - * @param path Full pathname of the file. - * - * @return A std::string& - */ - std::string &zippath_parent(std::string &dst, const char *path) { int pos; parse_parent_path(path, &pos, nullptr); - /* return the result */ - if (pos >= 0) { + if (pos >= 0) dst.assign(path, pos + 1); - } - else { + else dst.clear(); - } return dst; } @@ -251,42 +241,42 @@ std::string &zippath_combine(std::string &dst, const char *path1, const char *pa /*------------------------------------------------- file_error_from_zip_error - translates a - file_error to a zip_error + osd_file::error to a zip_error -------------------------------------------------*/ /** - * @fn static file_error file_error_from_zip_error(zip_error ziperr) + * @fn static osd_file::error file_error_from_zip_error(archive_file::error ziperr) * * @brief File error from zip error. * * @param ziperr The ziperr. * - * @return A file_error. + * @return A osd_file::error. */ -static file_error file_error_from_zip_error(zip_error ziperr) +static osd_file::error file_error_from_zip_error(archive_file::error ziperr) { - file_error filerr; + osd_file::error filerr; switch(ziperr) { - case ZIPERR_NONE: - filerr = FILERR_NONE; - break; - case ZIPERR_OUT_OF_MEMORY: - filerr = FILERR_OUT_OF_MEMORY; - break; - case ZIPERR_BAD_SIGNATURE: - case ZIPERR_DECOMPRESS_ERROR: - case ZIPERR_FILE_TRUNCATED: - case ZIPERR_FILE_CORRUPT: - case ZIPERR_UNSUPPORTED: - case ZIPERR_FILE_ERROR: - filerr = FILERR_INVALID_DATA; - break; - case ZIPERR_BUFFER_TOO_SMALL: - default: - filerr = FILERR_FAILURE; - break; + case archive_file::error::NONE: + filerr = osd_file::error::NONE; + break; + case archive_file::error::OUT_OF_MEMORY: + filerr = osd_file::error::OUT_OF_MEMORY; + break; + case archive_file::error::BAD_SIGNATURE: + case archive_file::error::DECOMPRESS_ERROR: + case archive_file::error::FILE_TRUNCATED: + case archive_file::error::FILE_CORRUPT: + case archive_file::error::UNSUPPORTED: + case archive_file::error::FILE_ERROR: + filerr = osd_file::error::INVALID_DATA; + break; + case archive_file::error::BUFFER_TOO_SMALL: + default: + filerr = osd_file::error::FAILURE; + break; } return filerr; } @@ -298,7 +288,7 @@ static file_error file_error_from_zip_error(zip_error ziperr) -------------------------------------------------*/ /** - * @fn static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header *header, util::core_file::ptr &file) + * @fn static osd_file::error create_core_file_from_zip(archive_file *zip, util::core_file::ptr &file) * * @brief Creates core file from zip. * @@ -309,28 +299,28 @@ static file_error file_error_from_zip_error(zip_error ziperr) * @return The new core file from zip. */ -static file_error create_core_file_from_zip(zip_file *zip, const zip_file_header *header, util::core_file::ptr &file) +static osd_file::error create_core_file_from_zip(archive_file &zip, util::core_file::ptr &file) { - file_error filerr; - zip_error ziperr; + osd_file::error filerr; + archive_file::error ziperr; void *ptr; - ptr = malloc(header->uncompressed_length); + ptr = malloc(zip.current_uncompressed_length()); if (ptr == nullptr) { - filerr = FILERR_OUT_OF_MEMORY; + filerr = osd_file::error::OUT_OF_MEMORY; goto done; } - ziperr = zip_file_decompress(zip, ptr, header->uncompressed_length); - if (ziperr != ZIPERR_NONE) + ziperr = zip.decompress(ptr, zip.current_uncompressed_length()); + if (ziperr != archive_file::error::NONE) { filerr = file_error_from_zip_error(ziperr); goto done; } - filerr = util::core_file::open_ram_copy(ptr, header->uncompressed_length, OPEN_FLAG_READ, file); - if (filerr != FILERR_NONE) + filerr = util::core_file::open_ram_copy(ptr, zip.current_uncompressed_length(), OPEN_FLAG_READ, file); + if (filerr != osd_file::error::NONE) goto done; done: @@ -345,7 +335,7 @@ done: -------------------------------------------------*/ /** - * @fn file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path) + * @fn osd_file::error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path) * * @brief Zippath fopen. * @@ -354,17 +344,16 @@ done: * @param [in,out] file [in,out] If non-null, the file. * @param [in,out] revised_path Full pathname of the revised file. * - * @return A file_error. + * @return A osd_file::error. */ -file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path) +osd_file::error zippath_fopen(const char *filename, UINT32 openflags, util::core_file::ptr &file, std::string &revised_path) { - file_error filerr = FILERR_NOT_FOUND; - zip_error ziperr; - zip_file *zip = nullptr; - const zip_file_header *header; + osd_file::error filerr = osd_file::error::NOT_FOUND; + archive_file::error ziperr; + archive_file::ptr zip; + int header; osd_dir_entry_type entry_type; - char *alloc_fullpath = nullptr; int len; /* first, set up the two types of paths */ @@ -377,56 +366,51 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file && ((openflags == OPEN_FLAG_READ) || (subpath.length() == 0))) { /* is the mainpath a ZIP path? */ - if (is_zip_file(mainpath.c_str())) + if (is_zip_file(mainpath) || is_7z_file(mainpath)) { /* this file might be a zip file - lets take a look */ - ziperr = zip_file_open(mainpath.c_str(), &zip); - if (ziperr == ZIPERR_NONE) + ziperr = is_zip_file(mainpath) ? archive_file::open_zip(mainpath, zip) : archive_file::open_7z(mainpath, zip); + if (ziperr == archive_file::error::NONE) { /* it is a zip file - error if we're not opening for reading */ if (openflags != OPEN_FLAG_READ) { - filerr = FILERR_ACCESS_DENIED; + filerr = osd_file::error::ACCESS_DENIED; goto done; } if (subpath.length() > 0) - header = zippath_find_sub_path(zip, subpath.c_str(), &entry_type); + header = zippath_find_sub_path(*zip, subpath, entry_type); else - header = zip_file_first_file(zip); + header = zip->first_file(); - if (header == nullptr) + if (header < 0) { - filerr = FILERR_NOT_FOUND; + filerr = osd_file::error::NOT_FOUND; goto done; } /* attempt to read the file */ - filerr = create_core_file_from_zip(zip, header, file); - if (filerr != FILERR_NONE) + filerr = create_core_file_from_zip(*zip, file); + if (filerr != osd_file::error::NONE) goto done; /* update subpath, if appropriate */ if (subpath.length() == 0) - subpath.assign(header->filename); + subpath.assign(zip->current_name()); /* we're done */ goto done; } } - else if (is_7z_file(mainpath.c_str())) - { - filerr = FILERR_INVALID_DATA; - goto done; - } if (subpath.length() == 0) filerr = util::core_file::open(filename, openflags, file); else - filerr = FILERR_NOT_FOUND; + filerr = osd_file::error::NOT_FOUND; /* if we errored, then go up a directory */ - if (filerr != FILERR_NONE) + if (filerr != osd_file::error::NONE) { /* go up a directory */ std::string temp; @@ -457,23 +441,19 @@ file_error zippath_fopen(const char *filename, UINT32 openflags, util::core_file done: /* store the revised path */ revised_path.clear(); - if (filerr == FILERR_NONE) + if (filerr == osd_file::error::NONE) { /* cannonicalize mainpath */ - filerr = osd_get_full_path(&alloc_fullpath, mainpath.c_str()); - if (filerr == FILERR_NONE) + std::string alloc_fullpath; + filerr = osd_get_full_path(alloc_fullpath, mainpath); + if (filerr == osd_file::error::NONE) { + revised_path = alloc_fullpath; if (subpath.length() > 0) - revised_path.assign(alloc_fullpath).append(PATH_SEPARATOR).append(subpath); - else - revised_path.assign(alloc_fullpath); + revised_path.append(PATH_SEPARATOR).append(subpath); } } - if (zip != nullptr) - zip_file_close(zip); - if (alloc_fullpath != nullptr) - osd_free(alloc_fullpath); return filerr; } @@ -528,10 +508,10 @@ static int is_root(const char *path) * @return An int. */ -static int is_7z_file(const char *path) +static bool is_7z_file(std::string const &path) { - const char *s = strrchr(path, '.'); - return (s != nullptr) && !core_stricmp(s, ".7z"); + auto const s = path.rfind('.'); + return (std::string::npos != s) && !core_stricmp(path.c_str() + s, ".7z"); } @@ -540,20 +520,10 @@ static int is_7z_file(const char *path) ZIP file -------------------------------------------------*/ -/** - * @fn static int is_zip_file(const char *path) - * - * @brief Is zip file. - * - * @param path Full pathname of the file. - * - * @return An int. - */ - -static int is_zip_file(const char *path) +static bool is_zip_file(std::string const &path) { - const char *s = strrchr(path, '.'); - return (s != nullptr) && !core_stricmp(s, ".zip"); + auto const s = path.rfind('.'); + return (std::string::npos != s) && !core_stricmp(path.c_str() + s, ".zip"); } @@ -573,7 +543,7 @@ static int is_zip_file(const char *path) * @return An int. */ -static int is_zip_file_separator(char c) +static bool is_zip_file_separator(char c) { return (c == '/') || (c == '\\'); } @@ -595,7 +565,7 @@ static int is_zip_file_separator(char c) * @return An int. */ -static int is_zip_path_separator(char c) +static bool is_zip_path_separator(char c) { return is_zip_file_separator(c) || is_path_separator(c); } @@ -618,38 +588,35 @@ static int is_zip_path_separator(char c) * @return A char. */ -static char next_path_char(const char *s, int *pos) +static char next_path_char(std::string const &s, std::string::size_type &pos) { - char result; - - /* skip over any initial separators */ - if (*pos == 0) + // skip over any initial separators + if (pos == 0) { - while(is_zip_file_separator(s[*pos])) - (*pos)++; + while ((pos < s.length()) && is_zip_file_separator(s[pos])) + pos++; } - /* are we at a path separator? */ - if (is_zip_file_separator(s[*pos])) + // are we at a path separator? + if (pos == s.length()) { - /* skip over path separators */ - while(is_zip_file_separator(s[*pos])) - (*pos)++; - - /* normalize as '/' */ - result = '/'; + // return NUL + return '\0'; } - else if (s[*pos] != '\0') + else if (is_zip_file_separator(s[pos])) { - /* return character */ - result = tolower(s[(*pos)++]); + // skip over path separators + while((pos < s.length()) && is_zip_file_separator(s[pos])) + pos++; + + // normalize as '/' + return '/'; } else { - /* return NUL */ - result = '\0'; + // return character + return std::tolower(s[pos++]); } - return result; } @@ -661,7 +628,7 @@ static char next_path_char(const char *s, int *pos) -------------------------------------------------*/ /** - * @fn static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const char *subpath, osd_dir_entry_type *type) + * @fn static const zip_file_header *zippath_find_sub_path(archive_file *zipfile, const char *subpath, osd_dir_entry_type *type) * * @brief Zippath find sub path. * @@ -672,50 +639,36 @@ static char next_path_char(const char *s, int *pos) * @return null if it fails, else a zip_file_header*. */ -static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const char *subpath, osd_dir_entry_type *type) +static int zippath_find_sub_path(archive_file &zipfile, std::string const &subpath, osd_dir_entry_type &type) { - int i, j; - char c1, c2, last_char; - const zip_file_header *header; - - for (header = zip_file_first_file(zipfile); header != nullptr; header = zip_file_next_file(zipfile)) + for (int header = zipfile.first_file(); header >= 0; header = zipfile.next_file()) { - /* special case */ - if (subpath == nullptr) + std::string::size_type i = 0, j = 0; + char c1, c2; + do { - if (type != nullptr) - *type = ENTTYPE_FILE; - return header; + c1 = next_path_char(zipfile.current_name(), i); + c2 = next_path_char(subpath, j); } + while ((c1 == c2) && c1 && c2); - i = 0; - j = 0; - last_char = '/'; - while(((c1 = next_path_char(header->filename, &i)) == (c2 = next_path_char(subpath, &j))) && - ( c1 != '\0' && c2 != '\0' )) - last_char = c2; - - - if (c2 == '\0') + if (!c2 || ((c2 == '/') && !(c2 = next_path_char(subpath, j)))) { - if (c1 == '\0') + if (!c1) { - if (type != nullptr) - *type = ENTTYPE_FILE; + type = zipfile.current_is_directory() ? ENTTYPE_DIR : ENTTYPE_FILE; return header; } - else if ((last_char == '/') || (c1 == '/')) + else if ((c1 == '/') || (i <= 1U)) { - if (type != nullptr) - *type = ENTTYPE_DIR; + type = ENTTYPE_DIR; return header; } } } - if (type != nullptr) - *type = ENTTYPE_NONE; - return nullptr; + type = ENTTYPE_NONE; + return -1; } @@ -726,7 +679,7 @@ static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const cha -------------------------------------------------*/ /** - * @fn static file_error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, zip_file *&zipfile, std::string &newpath) + * @fn static osd_file::error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, archive_file *&zipfile, std::string &newpath) * * @brief Zippath resolve. * @@ -735,97 +688,81 @@ static const zip_file_header *zippath_find_sub_path(zip_file *zipfile, const cha * @param [in,out] zipfile [in,out] If non-null, the zipfile. * @param [in,out] newpath The newpath. * - * @return A file_error. + * @return A osd_file::error. */ -static file_error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, zip_file *&zipfile, std::string &newpath) +static osd_file::error zippath_resolve(const char *path, osd_dir_entry_type &entry_type, archive_file::ptr &zipfile, std::string &newpath) { - file_error err; - osd_directory_entry *current_entry = nullptr; - osd_dir_entry_type current_entry_type; - int went_up = FALSE; - int i; - newpath.clear(); - /* be conservative */ + // be conservative entry_type = ENTTYPE_NONE; - zipfile = nullptr; + zipfile.reset(); std::string apath(path); std::string apath_trimmed; + osd_dir_entry_type current_entry_type; + bool went_up = false; do { - /* trim the path of trailing path separators */ - i = apath.length(); - while (i > 1 && is_path_separator(apath[i - 1])) + // trim the path of trailing path separators + auto i = apath.length(); + while ((i > 1) && is_path_separator(apath[i - 1])) i--; - apath = apath.substr(0, i); - apath_trimmed.assign(apath); + apath.resize(i); + apath_trimmed = apath; - /* stat the path */ - current_entry = osd_stat(apath_trimmed.c_str()); + // stat the path + std::unique_ptr<osd_directory_entry, void (*)(void *)> current_entry(osd_stat(apath_trimmed), &osd_free); - /* did we find anything? */ - if (current_entry != nullptr) + // did we find anything? + if (current_entry) { - /* get the entry type and free the stat entry */ + // get the entry type and free the stat entry current_entry_type = current_entry->type; - osd_free(current_entry); - current_entry = nullptr; } else { - /* if we have not found the file or directory, go up */ + // if we have not found the file or directory, go up current_entry_type = ENTTYPE_NONE; - went_up = TRUE; + went_up = true; std::string parent; - apath.assign(zippath_parent(parent, apath.c_str())); + apath = zippath_parent(parent, apath.c_str()); } } - while (current_entry_type == ENTTYPE_NONE && !is_root(apath.c_str())); + while ((current_entry_type == ENTTYPE_NONE) && !is_root(apath.c_str())); - /* if we did not find anything, then error out */ + // if we did not find anything, then error out if (current_entry_type == ENTTYPE_NONE) - { - err = FILERR_NOT_FOUND; - goto done; - } + return osd_file::error::NOT_FOUND; - /* is this file a ZIP file? */ - if ((current_entry_type == ENTTYPE_FILE) && is_zip_file(apath_trimmed.c_str()) - && (zip_file_open(apath_trimmed.c_str(), &zipfile) == ZIPERR_NONE)) + // is this file a ZIP file? + if ((current_entry_type == ENTTYPE_FILE) && + ((is_zip_file(apath_trimmed) && (archive_file::open_zip(apath_trimmed, zipfile) == archive_file::error::NONE)) || + (is_7z_file(apath_trimmed) && (archive_file::open_7z(apath_trimmed, zipfile) == archive_file::error::NONE)))) { - i = strlen(path + apath.length()); - while (i > 0 && is_zip_path_separator(path[apath.length() + i - 1])) + auto i = strlen(path + apath.length()); + while ((i > 0) && is_zip_path_separator(path[apath.length() + i - 1])) i--; newpath.assign(path + apath.length(), i); - /* this was a true ZIP path - attempt to identify the type of path */ - zippath_find_sub_path(zipfile, newpath.c_str(), ¤t_entry_type); + // this was a true ZIP path - attempt to identify the type of path + zippath_find_sub_path(*zipfile, newpath, current_entry_type); if (current_entry_type == ENTTYPE_NONE) - { - err = FILERR_NOT_FOUND; - goto done; - } + return osd_file::error::NOT_FOUND; } else { - /* this was a normal path */ + // this was a normal path if (went_up) - { - err = FILERR_NOT_FOUND; - goto done; - } - newpath.assign(path); + return osd_file::error::NOT_FOUND; + + newpath = path; } - /* success! */ + // success! entry_type = current_entry_type; - err = FILERR_NONE; - -done: - return err; + return osd_file::error::NONE; } @@ -834,19 +771,19 @@ done: -------------------------------------------------*/ /** - * @fn file_error zippath_opendir(const char *path, zippath_directory **directory) + * @fn osd_file::error zippath_opendir(const char *path, zippath_directory **directory) * * @brief Zippath opendir. * * @param path Full pathname of the file. * @param [in,out] directory If non-null, pathname of the directory. * - * @return A file_error. + * @return A osd_file::error. */ -file_error zippath_opendir(const char *path, zippath_directory **directory) +osd_file::error zippath_opendir(const char *path, zippath_directory **directory) { - file_error err; + osd_file::error err; /* allocate a directory */ zippath_directory *result = nullptr; @@ -856,30 +793,30 @@ file_error zippath_opendir(const char *path, zippath_directory **directory) } catch (std::bad_alloc &) { - err = FILERR_OUT_OF_MEMORY; + err = osd_file::error::OUT_OF_MEMORY; goto done; } /* resolve the path */ osd_dir_entry_type entry_type; err = zippath_resolve(path, entry_type, result->zipfile, result->zipprefix); - if (err != FILERR_NONE) + if (err != osd_file::error::NONE) goto done; /* we have to be a directory */ if (entry_type != ENTTYPE_DIR) { - err = FILERR_NOT_FOUND; + err = osd_file::error::NOT_FOUND; goto done; } /* was the result a ZIP? */ - if (result->zipfile == nullptr) + if (!result->zipfile) { /* a conventional directory */ result->directory = osd_opendir(path); - if (result->directory == nullptr) + if (!result->directory) { - err = FILERR_FAILURE; + err = osd_file::error::FAILURE; goto done; } @@ -889,7 +826,7 @@ file_error zippath_opendir(const char *path, zippath_directory **directory) } done: - if ((directory == nullptr || err != FILERR_NONE) && result != nullptr) + if ((directory == nullptr || err != osd_file::error::NONE) && result != nullptr) { zippath_closedir(result); result = nullptr; @@ -918,7 +855,7 @@ void zippath_closedir(zippath_directory *directory) osd_closedir(directory->directory); if (directory->zipfile != nullptr) - zip_file_close(directory->zipfile); + directory->zipfile.reset(); while (directory->returned_dirlist != nullptr) { @@ -948,20 +885,27 @@ void zippath_closedir(zippath_directory *directory) * @return null if it fails, else the relative path. */ -static const char *get_relative_path(zippath_directory *directory, const zip_file_header *header) +static const char *get_relative_path(zippath_directory const &directory) { - const char *result = nullptr; - int len = directory->zipprefix.length(); + auto len = directory.zipprefix.length(); + const char *prefix = directory.zipprefix.c_str(); + while (is_zip_file_separator(*prefix)) + { + len--; + prefix++; + } - if ((len <= strlen(header->filename)) - && !strncmp(directory->zipprefix.c_str(), header->filename, len)) + if ((len <= directory.zipfile->current_name().length()) && + !strncmp(prefix, directory.zipfile->current_name().c_str(), len)) { - result = &header->filename[len]; - while(is_zip_file_separator(*result)) + const char *result = &directory.zipfile->current_name().c_str()[len]; + while (is_zip_file_separator(*result)) result++; + + return *result ? result : nullptr; } - return result; + return nullptr; } @@ -982,7 +926,7 @@ static const char *get_relative_path(zippath_directory *directory, const zip_fil const osd_directory_entry *zippath_readdir(zippath_directory *directory) { const osd_directory_entry *result = nullptr; - const zip_file_header *header; + int header; const char *relpath; const char *separator; const char *s; @@ -997,7 +941,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory) directory->returned_entry.type = ENTTYPE_DIR; result = &directory->returned_entry; } - else if (directory->directory != nullptr) + else if (directory->directory) { /* a normal directory read */ do @@ -1007,7 +951,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory) while((result != nullptr) && (!strcmp(result->name, ".") || !strcmp(result->name, ".."))); /* special case - is this entry a ZIP file? if so we need to return it as a "directory" */ - if ((result != nullptr) && is_zip_file(result->name)) + if ((result != nullptr) && (is_zip_file(result->name) || is_7z_file(result->name))) { /* copy; but change the entry type */ directory->returned_entry = *result; @@ -1015,7 +959,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory) result = &directory->returned_entry; } } - else if (directory->zipfile != nullptr) + else if (directory->zipfile) { do { @@ -1023,13 +967,13 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory) do { if (!directory->called_zip_first) - header = zip_file_first_file(directory->zipfile); + header = directory->zipfile->first_file(); else - header = zip_file_next_file(directory->zipfile); + header = directory->zipfile->next_file(); directory->called_zip_first = true; relpath = nullptr; } - while((header != nullptr) && ((relpath = get_relative_path(directory, header)) == nullptr)); + while((header >= 0) && ((relpath = get_relative_path(*directory)) == nullptr)); if (relpath != nullptr) { @@ -1068,7 +1012,7 @@ const osd_directory_entry *zippath_readdir(zippath_directory *directory) memset(&directory->returned_entry, 0, sizeof(directory->returned_entry)); directory->returned_entry.name = relpath; directory->returned_entry.type = ENTTYPE_FILE; - directory->returned_entry.size = header->uncompressed_length; + directory->returned_entry.size = directory->zipfile->current_uncompressed_length(); result = &directory->returned_entry; } } @@ -1099,3 +1043,5 @@ int zippath_is_zip(zippath_directory *directory) { return directory->zipfile != nullptr; } + +} // namespace util |