summaryrefslogtreecommitdiff
path: root/Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c')
-rw-r--r--Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c582
1 files changed, 331 insertions, 251 deletions
diff --git a/Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c b/Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c
index 645c4de6d45..6fafc1163a6 100644
--- a/Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c
+++ b/Build/source/libs/zziplib/zziplib-0.13.58/zzip/mmapped.c
@@ -1,9 +1,11 @@
+
/*
* NOTE: this is part of libzzipmmapped (i.e. it is not libzzip).
+ * ==================
*
* These routines are fully independent from the traditional zzip
* implementation. They assume a readonly mmapped sharedmem block
- * representing a complete zip file. The functions show how to
+ * representing a complete zip file. The functions show how to
* parse the structure, find files and return a decoded bytestream.
*
* These routines are a bit simple and really here for documenting
@@ -13,24 +15,28 @@
* Plus varaints of drop-in stdio replacements, obfuscation routines,
* auto fileextensions, drop-in dirent replacements, and so on...
*
- * Author:
+ * Author:
* Guido Draheim <guidod@gmx.de>
*
- * Copyright (c) 2003,2004 Guido Draheim
+ * Copyright (c) 2003,2004,2006 Guido Draheim
* All rights reserved,
- * use under the restrictions of the
+ * use under the restrictions of the
* Lesser GNU General Public License
- * or alternatively the restrictions
+ * or alternatively the restrictions
* of the Mozilla Public License 1.1
*/
+#define _ZZIP_DISK_FILE_STRUCT 1
+
#ifdef __linux__
-#define _GNU_SOURCE _glibc_developers_are_idiots_to_call_this_gnu_specific_
+#define _GNU_SOURCE _glibc_developers_are_idiots_to_call_strndup_gnu_specific_
#endif
-#define _ZZIP_DISK_FILE_STRUCT 1
-
-#include <zzip/types.h>
+#include <zzip/mmapped.h>
+#include <zzip/format.h>
+#include <zzip/fetch.h>
+#include <zzip/__mmap.h>
+#include <zzip/__fnmatch.h>
#include <stdlib.h>
#include <sys/stat.h>
@@ -43,17 +49,10 @@
#if defined ZZIP_HAVE_STRING_H
#include <string.h>
-#endif
-#if defined ZZIP_HAVE_STRINGS_H
+#elif defined ZZIP_HAVE_STRINGS_H
#include <strings.h>
#endif
-#include <zlib.h>
-#include <zzip/mmapped.h>
-#include <zzip/format.h>
-#include <zzip/fetch.h>
-#include <zzip/__mmap.h>
-#include <zzip/__fnmatch.h>
#if __STDC_VERSION__+0 > 199900L
#define ___
@@ -67,10 +66,10 @@
* This function does primary initialization of a disk-buffer struct.
*/
int
-zzip_disk_init(ZZIP_DISK* disk, void* buffer, zzip_size_t buflen)
+zzip_disk_init(ZZIP_DISK * disk, void *buffer, zzip_size_t buflen)
{
- disk->buffer = (zzip_byte_t*) buffer;
- disk->endbuf = (zzip_byte_t*) buffer + buflen;
+ disk->buffer = (zzip_byte_t *) buffer;
+ disk->endbuf = (zzip_byte_t *) buffer + buflen;
disk->reserved = 0;
disk->flags = 0;
disk->mapped = 0;
@@ -82,32 +81,38 @@ zzip_disk_init(ZZIP_DISK* disk, void* buffer, zzip_size_t buflen)
/** => zzip_disk_mmap
* This function allocates a new disk-buffer with => malloc(3)
*/
-zzip__new__ ZZIP_DISK*
+zzip__new__ ZZIP_DISK *
zzip_disk_new(void)
{
- ZZIP_DISK* disk = malloc(sizeof(disk));
- if (! disk) return disk;
- zzip_disk_init (disk, 0, 0);
+ ZZIP_DISK *disk = malloc(sizeof(ZZIP_DISK));
+ if (! disk)
+ return disk;
+ zzip_disk_init(disk, 0, 0);
return disk;
}
/** turn a filehandle into a mmapped zip disk archive handle
*
- * This function uses the given file-descriptor to detect the length of the
+ * This function uses the given file-descriptor to detect the length of the
* file and calls the system => mmap(2) to put it in main memory. If it is
- * successful then a newly allocated ZZIP_DISK* is returned with
+ * successful then a newly allocated ZZIP_DISK* is returned with
* disk->buffer pointing to the mapview of the zipdisk content.
*/
-zzip__new__ ZZIP_DISK*
+zzip__new__ ZZIP_DISK *
zzip_disk_mmap(int fd)
{
struct stat st;
- if (fstat (fd, &st) || !st.st_size) return 0;
- ___ ZZIP_DISK* disk = zzip_disk_new (); if (! disk) return 0;
- disk->buffer = _zzip_mmap (& zzip->mapped, fd, 0, st.st_size);
- if (disk->buffer == MAP_FAILED) { free (disk); return 0; }
+ if (fstat(fd, &st) || ! st.st_size)
+ return 0;
+ ___ ZZIP_DISK *disk = zzip_disk_new();
+ if (! disk)
+ return 0;
+ disk->buffer = _zzip_mmap(disk->mapped, fd, 0, st.st_size);
+ if (disk->buffer == MAP_FAILED)
+ { free (disk); return 0; }
disk->endbuf = disk->buffer + st.st_size;
- return disk; ____;
+ return disk;
+ ____;
}
/** => zzip_disk_mmap
@@ -115,112 +120,161 @@ zzip_disk_mmap(int fd)
* munmap(2) on the buffer area and => free(3) on the ZZIP_DISK structure.
*/
int
-zzip_disk_munmap(ZZIP_DISK* disk)
+zzip_disk_munmap(ZZIP_DISK * disk)
{
- if (! disk) return 0;
- _zzip_munmap (disk->mapped, disk->buffer, disk->endbuf-disk->buffer);
- free (disk);
+ if (! disk)
+ return 0;
+ _zzip_munmap(disk->mapped, disk->buffer, disk->endbuf - disk->buffer);
+ free(disk);
return 0;
}
/** => zzip_disk_mmap
*
- * This function opens the given archive by name and turn the filehandle
+ * This function opens the given archive by name and turn the filehandle
* to => zzip_disk_mmap for bringing it to main memory. If it can not
* be => mmap(2)'ed then we slurp the whole file into a newly => malloc(2)'ed
* memory block. Only if that fails too then we return null. Since handling
* of disk->buffer is ambigous it should not be snatched away please.
*/
-ZZIP_DISK* zzip__new__
-zzip_disk_open(char* filename)
+zzip__new__ ZZIP_DISK *
+zzip_disk_open(char *filename)
{
# ifndef O_BINARY
# define O_BINARY 0
# endif
struct stat st;
- if (stat (filename, &st) || !st.st_size) return 0;
- ___ int fd = open (filename, O_RDONLY|O_BINARY);
- if (fd <= 0) return 0;
- ___ ZZIP_DISK* disk = zzip_disk_mmap (fd);
- if (disk) return disk;
- ___ zzip_byte_t* buffer = malloc (st.st_size);
- if (! buffer) return 0;
- if ((st.st_size == read (fd, buffer, st.st_size)) &&
- (disk = zzip_disk_new ()))
+ if (stat(filename, &st) || ! st.st_size)
+ return 0;
+ ___ int fd = open(filename, O_RDONLY | O_BINARY);
+ if (fd <= 0)
+ return 0;
+ ___ ZZIP_DISK *disk = zzip_disk_mmap(fd);
+ if (disk)
+ return disk;
+ ___ zzip_byte_t *buffer = malloc(st.st_size);
+ if (! buffer)
+ return 0;
+ if ((st.st_size == read(fd, buffer, st.st_size)) &&
+ (disk = zzip_disk_new()))
{
- disk->buffer = buffer;
- disk->endbuf = buffer+st.st_size;
- disk->mapped = -1;
- }else free (buffer);
- return disk; ____;____;____;
+ disk->buffer = buffer;
+ disk->endbuf = buffer + st.st_size;
+ disk->mapped = -1;
+ disk->flags |= ZZIP_DISK_FLAGS_OWNED_BUFFER;
+ } else {
+ free(buffer);
+ }
+ return disk;
+ ____;
+ ____;
+ ____;
}
/** => zzip_disk_mmap
- *
+ * This function will attach a buffer with a zip image
+ * that was acquired from another source than a file.
+ * Note that if zzip_disk_mmap fails then zzip_disk_open
+ * will fall back and try to read the full file to memory
+ * wrapping a ZZIP_DISK around the memory buffer just as
+ * this function will do. Note that this function will not
+ * own the buffer, it will neither be written nor free()d.
+ */
+zzip__new__ ZZIP_DISK *
+zzip_disk_buffer(void *buffer, size_t buflen) {
+ ZZIP_DISK *disk = zzip_disk_new();
+ if (disk)
+ {
+ disk->buffer = (zzip_byte_t *) buffer;
+ disk->endbuf = (zzip_byte_t *) buffer + buflen;
+ disk->mapped = -1;
+ }
+ return disk;
+}
+
+/** => zzip_disk_mmap
+ *
* This function will release all data needed to access a (mmapped)
* zip archive, including any malloc()ed blocks, sharedmem mappings
* and it dumps the handle struct as well.
*/
int
-zzip_disk_close(ZZIP_DISK* disk)
+zzip_disk_close(ZZIP_DISK * disk)
{
- if (! disk) return 0;
- if (disk->mapped != -1) return zzip_disk_munmap (disk);
- free (disk->buffer);
- free (disk);
+ if (! disk)
+ return 0;
+ if (disk->mapped != -1)
+ return zzip_disk_munmap(disk);
+ if (disk->flags & ZZIP_DISK_FLAGS_OWNED_BUFFER)
+ free(disk->buffer);
+ free(disk);
return 0;
}
/* ====================================================================== */
+
/* helper functions */
#ifdef ZZIP_HAVE_STRNDUP
#define _zzip_strndup strndup
#else
+
/* if your system does not have strndup: */
-zzip__new__ static char* _zzip_strndup(char* p, int maxlen)
+zzip__new__ static char *
+_zzip_strndup(char *p, size_t maxlen)
{
- if (! p) return 0;
- ___ zzip_byte_t* r = malloc (maxlen+1);
- if (! r) return r;
- strncpy (r, p, maxlen);
+ if (! p)
+ return 0;
+ ___ zzip_byte_t *r = malloc(maxlen + 1);
+ if (! r)
+ return r;
+ strncpy(r, p, maxlen);
r[maxlen] = '\0';
- return r; ____;
+ return r;
+ ____;
}
#endif
#if defined ZZIP_HAVE_STRCASECMP || defined strcasecmp
#define _zzip_strcasecmp strcasecmp
#else
+
/* if your system does not have strcasecmp: */
-static int _zzip_strcasecmp(char* __zzip_restrict a, char* _zzip_restrict b)
+static int
+_zzip_strcasecmp(char *__zzip_restrict a, char *_zzip_restrict b)
{
- if (! a) return (b) ? 1 : 0;
- if (! b) return -1;
- while (1)
+ if (! a)
+ return (b) ? 1 : 0;
+ if (! b)
+ return -1;
+ while (1)
{
- int v = tolower(*a) - tolower(*b);
- if (v) return v;
- if (! *a) return 1;
- if (! *b) return -1;
- a++; b++;
+ int v = tolower(*a) - tolower(*b);
+ if (v)
+ return v;
+ if (! *a)
+ return 1;
+ if (! *b)
+ return -1;
+ a++;
+ b++;
}
}
#endif
/** helper functions for (mmapped) zip access api
*
- * This function augments the other zzip_disk_entry_* helpers: here we move
+ * This function augments the other zzip_disk_entry_* helpers: here we move
* a disk_entry pointer (as returned by _find* functions) into a pointer to
* the data block right after the file_header. Only disk->buffer would be
* needed to perform the seek but we check the mmapped range end as well.
*/
-zzip_byte_t*
-zzip_disk_entry_to_data(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
+zzip_byte_t *
+zzip_disk_entry_to_data(ZZIP_DISK * disk, struct zzip_disk_entry * entry)
{
- struct zzip_file_header* file =
- zzip_disk_entry_to_file_header(disk, entry);
- if (file) return zzip_file_header_to_data (file);
+ struct zzip_file_header *file = zzip_disk_entry_to_file_header(disk, entry);
+ if (file)
+ return zzip_file_header_to_data(file);
return 0;
}
@@ -228,14 +282,14 @@ zzip_disk_entry_to_data(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
* This function does half the job of => zzip_disk_entry_to_data where it
* can augment with => zzip_file_header_to_data helper from format/fetch.h
*/
-struct zzip_file_header*
-zzip_disk_entry_to_file_header(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
+struct zzip_file_header *
+zzip_disk_entry_to_file_header(ZZIP_DISK * disk, struct zzip_disk_entry *entry)
{
- zzip_byte_t* file_header = /* (struct zzip_file_header*) */
- (disk->buffer + zzip_disk_entry_fileoffset (entry));
- if (disk->buffer > file_header || file_header >= disk->endbuf)
- return 0;
- return (struct zzip_file_header*) file_header;
+ zzip_byte_t *file_header = /* (struct zzip_file_header*) */
+ (disk->buffer + zzip_disk_entry_fileoffset(entry));
+ if (disk->buffer > file_header || file_header >= disk->endbuf)
+ return 0;
+ return (struct zzip_file_header *) file_header;
}
/** => zzip_disk_entry_to_data
@@ -245,48 +299,54 @@ zzip_disk_entry_to_file_header(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
* in the zip central directory but if not then we fallback to the filename
* given in the file_header of each compressed data portion.
*/
-zzip__new__ char*
-zzip_disk_entry_strdup_name(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
+zzip__new__ char *
+zzip_disk_entry_strdup_name(ZZIP_DISK * disk, struct zzip_disk_entry *entry)
{
- if (! disk || ! entry) return 0;
-
- ___ char* name; zzip_size_t len;
- struct zzip_file_header* file;
- if ((len = zzip_disk_entry_namlen (entry)))
- name = zzip_disk_entry_to_filename (entry);
- else if ((file = zzip_disk_entry_to_file_header (disk, entry)) &&
- (len = zzip_file_header_namlen (file)))
- name = zzip_file_header_to_filename (file);
+ if (! disk || ! entry)
+ return 0;
+
+ ___ char *name;
+ zzip_size_t len;
+ struct zzip_file_header *file;
+ if ((len = zzip_disk_entry_namlen(entry)))
+ name = zzip_disk_entry_to_filename(entry);
+ else if ((file = zzip_disk_entry_to_file_header(disk, entry)) &&
+ (len = zzip_file_header_namlen(file)))
+ name = zzip_file_header_to_filename(file);
else
- return 0;
+ return 0;
+
+ if ((zzip_byte_t *) name < disk->buffer ||
+ (zzip_byte_t *) name + len > disk->endbuf)
+ return 0;
- if ((zzip_byte_t*) name < disk->buffer ||
- (zzip_byte_t*) name+len > disk->endbuf)
- return 0;
-
- return _zzip_strndup (name, len); ____;
+ return _zzip_strndup(name, len);
+ ____;
}
/** => zzip_disk_entry_to_data
* This function is similar creating a reference to a zero terminated
* string but it can only exist in the zip central directory entry.
*/
-zzip__new__ char*
-zzip_disk_entry_strdup_comment(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
+zzip__new__ char *
+zzip_disk_entry_strdup_comment(ZZIP_DISK * disk, struct zzip_disk_entry *entry)
{
- if (! disk || ! entry) return 0;
+ if (! disk || ! entry)
+ return 0;
- ___ char* text; zzip_size_t len;
- if ((len = zzip_disk_entry_comment (entry)))
- text = zzip_disk_entry_to_comment (entry);
+ ___ char *text;
+ zzip_size_t len;
+ if ((len = zzip_disk_entry_comment(entry)))
+ text = zzip_disk_entry_to_comment(entry);
else
- return 0;
+ return 0;
- if ((zzip_byte_t*) text < disk->buffer ||
- (zzip_byte_t*) text+len > disk->endbuf)
- return 0;
-
- return _zzip_strndup (text, len); ____;
+ if ((zzip_byte_t *) text < disk->buffer ||
+ (zzip_byte_t *) text + len > disk->endbuf)
+ return 0;
+
+ return _zzip_strndup(text, len);
+ ____;
}
/* ====================================================================== */
@@ -294,62 +354,72 @@ zzip_disk_entry_strdup_comment(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
/** => zzip_disk_findfile
*
* This function is the first call of all the zip access functions here.
- * It contains the code to find the first entry of the zip central directory.
+ * It contains the code to find the first entry of the zip central directory.
* Here we require the mmapped block to represent a real zip file where the
- * disk_trailer is _last_ in the file area, so that its position would be at
- * a fixed offset from the end of the file area if not for the comment field
+ * disk_trailer is _last_ in the file area, so that its position would be at
+ * a fixed offset from the end of the file area if not for the comment field
* allowed to be of variable length (which needs us to do a little search
- * for the disk_tailer). However, in this simple implementation we disregard
+ * for the disk_tailer). However, in this simple implementation we disregard
* any disk_trailer info telling about multidisk archives, so we just return
* a pointer to the zip central directory.
- *
- * For an actual means, we are going to search backwards from the end
- * of the mmaped block looking for the PK-magic signature of a
+ *
+ * For an actual means, we are going to search backwards from the end
+ * of the mmaped block looking for the PK-magic signature of a
* disk_trailer. If we see one then we check the rootseek value to
* find the first disk_entry of the root central directory. If we find
- * the correct PK-magic signature of a disk_entry over there then we
+ * the correct PK-magic signature of a disk_entry over there then we
* assume we are done and we are going to return a pointer to that label.
*
* The return value is a pointer to the first zzip_disk_entry being checked
* to be within the bounds of the file area specified by the arguments. If
- * no disk_trailer was found then null is returned, and likewise we only
- * accept a disk_trailer with a seekvalue that points to a disk_entry and
+ * no disk_trailer was found then null is returned, and likewise we only
+ * accept a disk_trailer with a seekvalue that points to a disk_entry and
* both parts have valid PK-magic parts. Beyond some sanity check we try to
* catch a common brokeness with zip archives that still allows us to find
* the start of the zip central directory.
*/
-struct zzip_disk_entry*
-zzip_disk_findfirst(ZZIP_DISK* disk)
+struct zzip_disk_entry *
+zzip_disk_findfirst(ZZIP_DISK * disk)
{
- if (disk->buffer > disk->endbuf-sizeof(struct zzip_disk_trailer))
- return 0;
- ___ zzip_byte_t* p = disk->endbuf-sizeof(struct zzip_disk_trailer);
- for (; p >= disk->buffer ; p--)
+ if (disk->buffer > disk->endbuf - sizeof(struct zzip_disk_trailer))
+ return 0;
+ ___ zzip_byte_t *p = disk->endbuf - sizeof(struct zzip_disk_trailer);
+ for (; p >= disk->buffer; p--)
{
- zzip_byte_t* root; /* (struct zzip_disk_entry*) */
- if (zzip_disk_trailer_check_magic(p)) {
- root = disk->buffer + zzip_disk_trailer_get_rootseek (
- (struct zzip_disk_trailer*)p);
- if (root > p)
- { /* the first disk_entry is after the disk_trailer? can't be! */
- zzip_size_t rootsize = zzip_disk_trailer_get_rootsize (
- (struct zzip_disk_trailer*)p);
- if (disk->buffer+rootsize > p) continue;
- /* a common brokeness that can be fixed: we just assume the
- * central directory was written directly before the trailer:*/
- root = p - rootsize;
- }
- } else if (zzip_disk64_trailer_check_magic(p)) {
- if (sizeof(void*) < 8) return 0; /* EOVERFLOW */
- root = disk->buffer + zzip_disk64_trailer_get_rootseek (
- (struct zzip_disk64_trailer*)p);
- if (root > p) continue;
- } else continue;
-
- if (root < disk->buffer) continue;
- if (zzip_disk_entry_check_magic(root))
- return (struct zzip_disk_entry*) root;
- }____;
+ zzip_byte_t *root; /* (struct zzip_disk_entry*) */
+ if (zzip_disk_trailer_check_magic(p))
+ {
+ struct zzip_disk_trailer *trailer = (struct zzip_disk_trailer *) p;
+ root = disk->buffer + zzip_disk_trailer_get_rootseek(trailer);
+ if (root > p)
+ {
+ /* the first disk_entry is after the disk_trailer? can't be! */
+ zzip_size_t rootsize = zzip_disk_trailer_get_rootsize(trailer);
+ if (disk->buffer + rootsize > p)
+ continue;
+ /* a common brokeness that can be fixed: we just assume the
+ * central directory was written directly before the trailer:*/
+ root = p - rootsize;
+ }
+ } else if (zzip_disk64_trailer_check_magic(p))
+ {
+ struct zzip_disk64_trailer *trailer =
+ (struct zzip_disk64_trailer *) p;
+ if (sizeof(void *) < 8)
+ return 0; /* EOVERFLOW */
+ root = disk->buffer + zzip_disk64_trailer_get_rootseek(trailer);
+ if (root > p)
+ continue;
+ } else
+ {
+ continue;
+ }
+
+ if (root < disk->buffer)
+ continue;
+ if (zzip_disk_entry_check_magic(root))
+ return (struct zzip_disk_entry *) root;
+ } ____;
return 0;
}
@@ -359,53 +429,53 @@ zzip_disk_findfirst(ZZIP_DISK* disk)
* (e.g. from zzip_disk_findfirst) and returns the next entry within in
* the given bounds of the mmapped file area.
*/
-struct zzip_disk_entry*
-zzip_disk_findnext(ZZIP_DISK* disk, struct zzip_disk_entry* entry)
+struct zzip_disk_entry *
+zzip_disk_findnext(ZZIP_DISK * disk, struct zzip_disk_entry *entry)
{
- if ((zzip_byte_t*)entry < disk->buffer ||
- (zzip_byte_t*)entry > disk->endbuf-sizeof(entry) ||
- ! zzip_disk_entry_check_magic (entry) ||
- zzip_disk_entry_sizeto_end (entry) > 64*1024)
- return 0;
- entry = zzip_disk_entry_to_next_entry (entry);
- if ((zzip_byte_t*)entry > disk->endbuf-sizeof(entry) ||
- ! zzip_disk_entry_check_magic (entry) ||
- zzip_disk_entry_sizeto_end (entry) > 64*1024 ||
- zzip_disk_entry_skipto_end (entry) + sizeof(entry) > disk->endbuf)
- return 0;
+ if ((zzip_byte_t *) entry < disk->buffer ||
+ (zzip_byte_t *) entry > disk->endbuf - sizeof(entry) ||
+ ! zzip_disk_entry_check_magic(entry) ||
+ zzip_disk_entry_sizeto_end(entry) > 64 * 1024)
+ return 0;
+ entry = zzip_disk_entry_to_next_entry(entry);
+ if ((zzip_byte_t *) entry > disk->endbuf - sizeof(entry) ||
+ ! zzip_disk_entry_check_magic(entry) ||
+ zzip_disk_entry_sizeto_end(entry) > 64 * 1024 ||
+ zzip_disk_entry_skipto_end(entry) + sizeof(entry) > disk->endbuf)
+ return 0;
else
- return entry;
+ return entry;
}
/** search for files in the (mmapped) zip central directory
*
- * This function is given a filename as an additional argument, to find the
- * disk_entry matching a given filename. The compare-function is usually
- * strcmp or strcasecmp or perhaps strcoll, if null then strcmp is used.
- * - use null as argument for "after"-entry when searching the first
+ * This function is given a filename as an additional argument, to find the
+ * disk_entry matching a given filename. The compare-function is usually
+ * strcmp or strcasecmp or perhaps strcoll, if null then strcmp is used.
+ * - use null as argument for "after"-entry when searching the first
* matching entry, otherwise the last returned value if you look for other
* entries with a special "compare" function (if null then a doubled search
* is rather useless with this variant of _findfile).
*/
-struct zzip_disk_entry*
-zzip_disk_findfile(ZZIP_DISK* disk, char* filename,
- struct zzip_disk_entry* after, zzip_strcmp_fn_t compare)
+struct zzip_disk_entry *
+zzip_disk_findfile(ZZIP_DISK * disk, char *filename,
+ struct zzip_disk_entry *after, zzip_strcmp_fn_t compare)
{
- struct zzip_disk_entry* entry = (! after ? zzip_disk_findfirst (disk)
- : zzip_disk_findnext (disk, after));
- if (! compare)
- compare = (zzip_strcmp_fn_t)( (disk->flags&1) ?
- (_zzip_strcasecmp) : (strcmp));
- for (; entry ; entry = zzip_disk_findnext (disk, entry))
+ struct zzip_disk_entry *entry = (! after ? zzip_disk_findfirst(disk)
+ : zzip_disk_findnext(disk, after));
+ if (! compare)
+ compare = (zzip_strcmp_fn_t) ((disk->flags & ZZIP_DISK_FLAGS_MATCH_NOCASE) ?
+ (_zzip_strcasecmp) : (strcmp));
+ for (; entry; entry = zzip_disk_findnext(disk, entry))
{
- /* filenames within zip files are often not null-terminated! */
- char* realname = zzip_disk_entry_strdup_name (disk, entry);
- if (realname && ! compare(filename, realname))
- {
- free (realname);
- return entry;
- }
- free (realname);
+ /* filenames within zip files are often not null-terminated! */
+ char *realname = zzip_disk_entry_strdup_name(disk, entry);
+ if (realname && ! compare(filename, realname))
+ {
+ free(realname);
+ return entry;
+ }
+ free(realname);
}
return 0;
}
@@ -419,31 +489,33 @@ zzip_disk_findfile(ZZIP_DISK* disk, char* filename,
* platform has fnmatch available then null-compare will use that one
* and otherwise we fall back to mere strcmp, so if you need fnmatch
* searching then please provide an implementation somewhere else.
- * - use null as argument for "after"-entry when searching the first
+ * - use null as argument for "after"-entry when searching the first
* matching entry, or the last disk_entry return-value to find the
* next entry matching the given filespec.
*/
-struct zzip_disk_entry*
-zzip_disk_findmatch(ZZIP_DISK* disk, char* filespec,
- struct zzip_disk_entry* after,
- zzip_fnmatch_fn_t compare, int flags)
+struct zzip_disk_entry *
+zzip_disk_findmatch(ZZIP_DISK * disk, char *filespec,
+ struct zzip_disk_entry *after,
+ zzip_fnmatch_fn_t compare, int flags)
{
- struct zzip_disk_entry* entry = (! after ? zzip_disk_findfirst (disk)
- : zzip_disk_findnext (disk, after));
- if (! compare) {
- compare = (zzip_fnmatch_fn_t) _zzip_fnmatch;
- if (disk->flags&1) disk->flags |= _zzip_fnmatch_CASEFOLD;
+ struct zzip_disk_entry *entry = (! after ? zzip_disk_findfirst(disk)
+ : zzip_disk_findnext(disk, after));
+ if (! compare)
+ {
+ compare = (zzip_fnmatch_fn_t) _zzip_fnmatch;
+ if (disk->flags & ZZIP_DISK_FLAGS_MATCH_NOCASE)
+ flags |= _zzip_fnmatch_CASEFOLD;
}
- for (; entry ; entry = zzip_disk_findnext (disk, entry))
+ for (; entry; entry = zzip_disk_findnext(disk, entry))
{
- /* filenames within zip files are often not null-terminated! */
- char* realname = zzip_disk_entry_strdup_name(disk, entry);
- if (realname && ! compare(filespec, realname, flags))
- {
- free (realname);
- return entry;
- }
- free (realname);
+ /* filenames within zip files are often not null-terminated! */
+ char *realname = zzip_disk_entry_strdup_name(disk, entry);
+ if (realname && ! compare(filespec, realname, flags))
+ {
+ free(realname);
+ return entry;
+ }
+ free(realname);
}
return 0;
}
@@ -461,34 +533,37 @@ zzip_disk_findmatch(ZZIP_DISK* disk, char* filespec,
* _read() operations will be able to get the next data portion or
* return an eof condition for that file part wrapped in the zip archive.
*/
-zzip__new__ ZZIP_DISK_FILE*
-zzip_disk_entry_fopen (ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry)
+zzip__new__ ZZIP_DISK_FILE *
+zzip_disk_entry_fopen(ZZIP_DISK * disk, ZZIP_DISK_ENTRY * entry)
{
/* keep this in sync with zzip_mem_entry_fopen */
- struct zzip_file_header* header =
- zzip_disk_entry_to_file_header (disk, entry);
- if (! header) return 0;
- ___ ZZIP_DISK_FILE* file = malloc(sizeof(ZZIP_DISK_FILE));
- if (! file) return file;
+ struct zzip_file_header *header =
+ zzip_disk_entry_to_file_header(disk, entry);
+ if (! header)
+ return 0;
+ ___ ZZIP_DISK_FILE *file = malloc(sizeof(ZZIP_DISK_FILE));
+ if (! file)
+ return file;
file->buffer = disk->buffer;
file->endbuf = disk->endbuf;
- file->avail = zzip_file_header_usize (header);
+ file->avail = zzip_file_header_usize(header);
- if (! file->avail || zzip_file_header_data_stored (header))
- { file->stored = zzip_file_header_to_data (header); return file; }
+ if (! file->avail || zzip_file_header_data_stored(header))
+ { file->stored = zzip_file_header_to_data (header); return file; }
file->stored = 0;
file->zlib.opaque = 0;
file->zlib.zalloc = Z_NULL;
file->zlib.zfree = Z_NULL;
- file->zlib.avail_in = zzip_file_header_csize (header);
- file->zlib.next_in = zzip_file_header_to_data (header);
+ file->zlib.avail_in = zzip_file_header_csize(header);
+ file->zlib.next_in = zzip_file_header_to_data(header);
- if (! zzip_file_header_data_deflated (header) ||
- inflateInit2 (& file->zlib, -MAX_WBITS) != Z_OK)
- { free (file); return 0; }
+ if (! zzip_file_header_data_deflated(header) ||
+ inflateInit2(&file->zlib, -MAX_WBITS) != Z_OK)
+ { free (file); return 0; }
- return file; ____;
+ return file;
+ ____;
}
/** openening a file part wrapped within a (mmapped) zip archive
@@ -497,11 +572,14 @@ zzip_disk_entry_fopen (ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry)
* the zip central directory with => zzip_disk_findfile and whatever
* is found first is given to => zzip_disk_entry_fopen
*/
-zzip__new__ ZZIP_DISK_FILE*
-zzip_disk_fopen (ZZIP_DISK* disk, char* filename)
+zzip__new__ ZZIP_DISK_FILE *
+zzip_disk_fopen(ZZIP_DISK * disk, char *filename)
{
- ZZIP_DISK_ENTRY* entry = zzip_disk_findfile (disk, filename, 0, 0);
- if (! entry) return 0; else return zzip_disk_entry_fopen (disk, entry);
+ ZZIP_DISK_ENTRY *entry = zzip_disk_findfile(disk, filename, 0, 0);
+ if (! entry)
+ return 0;
+ else
+ return zzip_disk_entry_fopen(disk, entry);
}
@@ -513,31 +591,33 @@ zzip_disk_fopen (ZZIP_DISK* disk, char* filename)
* with => zzip_disk_feof for the difference.
*/
zzip_size_t
-zzip_disk_fread (void* ptr, zzip_size_t sized, zzip_size_t nmemb,
- ZZIP_DISK_FILE* file)
+zzip_disk_fread(void *ptr, zzip_size_t sized, zzip_size_t nmemb,
+ ZZIP_DISK_FILE * file)
{
- zzip_size_t size = sized*nmemb;
- if (size > file->avail) size = file->avail;
+ zzip_size_t size = sized * nmemb;
+ if (size > file->avail)
+ size = file->avail;
if (file->stored)
{
- memcpy (ptr, file->stored, size);
- file->stored += size;
- file->avail -= size;
- return size;
+ memcpy(ptr, file->stored, size);
+ file->stored += size;
+ file->avail -= size;
+ return size;
}
-
- file->zlib.avail_out = sized*nmemb;
+
+ file->zlib.avail_out = sized * nmemb;
file->zlib.next_out = ptr;
___ zzip_size_t total_old = file->zlib.total_out;
- ___ int err = inflate (& file->zlib, Z_NO_FLUSH);
+ ___ int err = inflate(&file->zlib, Z_NO_FLUSH);
if (err == Z_STREAM_END)
- file->avail = 0;
+ file->avail = 0;
else if (err == Z_OK)
- file->avail -= file->zlib.total_out - total_old;
+ file->avail -= file->zlib.total_out - total_old;
else
- return 0;
+ return 0;
return file->zlib.total_out - total_old;
- ____;____;
+ ____;
+ ____;
}
/** => zzip_disk_fopen
@@ -545,22 +625,22 @@ zzip_disk_fread (void* ptr, zzip_size_t sized, zzip_size_t nmemb,
* and dumps the ZZIP_DISK_FILE* then.
*/
int
-zzip_disk_fclose (ZZIP_DISK_FILE* file)
+zzip_disk_fclose(ZZIP_DISK_FILE * file)
{
if (! file->stored)
- inflateEnd (& file->zlib);
- free (file);
+ inflateEnd(&file->zlib);
+ free(file);
return 0;
}
/** => zzip_disk_fopen
*
- * This function allows to distinguish an error from an eof condition.
+ * This function allows to distinguish an error from an eof condition.
* Actually, if we found an error but we did already reach eof then we
* just keep on saying that it was an eof, so the app can just continue.
- */
+ */
int
-zzip_disk_feof (ZZIP_DISK_FILE* file)
+zzip_disk_feof(ZZIP_DISK_FILE * file)
{
return ! file || ! file->avail;
}