diff options
Diffstat (limited to 'Build/source/libs/zziplib/zziplib-0.13.59/zzip')
41 files changed, 9516 insertions, 0 deletions
diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/Makefile.am b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/Makefile.am new file mode 100644 index 00000000000..9b4089df98f --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/Makefile.am @@ -0,0 +1,198 @@ +AUTOMAKE_OPTIONS = 1.5 foreign +AUTOTOOL_VERSION=autoconf-2.52 automake-1.5 libtool-1.4.2 +DEFAULT_INCLUDES = # nothing - no default of -I. -I$(srcdir) +DEFS = @DEFS@ -I$(top_builddir) -I$(top_srcdir) # also for automake 1.4 + +lib_LTLIBRARIES = libzzip.la libzzipmmapped.la libzzipfseeko.la +zzipdir = ${includedir}/zzip +zzip_HEADERS = $(libzzip_la_headers) \ + $(libzzipmmapped_la_headers) \ + $(libzzipfseeko_la_headers) +noinst_HEADERS = __debug.h __hints.h __mmap.h __dirent.h __fnmatch.h +# +VERSION_INFO=@VERSION_INFO@ +RELEASE_INFO=@RELEASE_INFO@ +THREAD_SAFE=@THREAD_SAFE@ +# + +libzzip_la_SOURCES = \ + zip.c \ + file.c \ + dir.c \ + stat.c \ + info.c \ + err.c \ + plugin.c \ + write.c \ + fetch.c +libzzip_la_headers = \ + stdint.h \ + file.h \ + plugin.h \ + lib.h \ + zzip.h \ + zzip32.h \ + write.h \ + fetch.h \ + format.h \ + info.h \ + autoconf.h \ + types.h \ + conf.h \ + _config.h \ + _msvc.h +libzzip_la_LDFLAGS= @ZZIPLIB_LDFLAGS@ $(RELEASE_INFO) $(VERSION_INFO) \ + $(THREAD_SAFE) +libzzip_la_LIBADD= -lz @RESOLVES@ + +libzzipmmapped_la_SOURCES = mmapped.c memdisk.c fetch.c +libzzipmmapped____headers = mmapped.h memdisk.h fetch.h +libzzipmmapped_la_headers = mmapped.h memdisk.h +libzzipmmapped_la_LDFLAGS= @ZZIPLIB_LDFLAGS@ $(RELEASE_INFO) $(VERSION_INFO) \ + $(THREAD_SAFE) +libzzipmmapped_la_LIBADD= -lz @RESOLVES@ + +libzzipfseeko_la_SOURCES = fseeko.c fetch.c +libzzipfseeko____headers = fseeko.h fetch.h +libzzipfseeko_la_headers = fseeko.h +libzzipfseeko_la_LDFLAGS= @ZZIPLIB_LDFLAGS@ $(RELEASE_INFO) $(VERSION_INFO) \ + $(THREAD_SAFE) +libzzipfseeko_la_LIBADD= -lz @RESOLVES@ + +WCC10_DIST = zziplib.wpj +WCC10_CLEAN = *.obj *.lk1 *.mk1 *.mk *.sym *.tgt + +EXTRA_DIST = $(WCC10_DIST) _msvc.sed +CONFIG_CLEAN_FILES = _config.h +MAINTAINERCLEANFILES = _msvc.h +CLEANFILES = $(WCC10_CLEAN) *.pc *.omf *~ *.tmp *.tmp.* + +# here is some backward compatibility with version 0.10.* of zziplib +install-data-hook : install-zzipHEADERS + echo '#ifndef ZZIP_WARNING' > $(DESTDIR)$(includedir)/zzip.h + echo '#define ZZIP_WARNING 1' >>$(DESTDIR)$(includedir)/zzip.h + echo '#ifdef __GNUC__' >>$(DESTDIR)$(includedir)/zzip.h + echo '#warning do no not use <zzip.h>, update to include <zzip/lib.h>'\ + >>$(DESTDIR)$(includedir)/zzip.h + echo '#else' >>$(DESTDIR)$(includedir)/zzip.h + echo '#error do no not use <zzip.h>, update to include <zzip/lib.h>'\ + >>$(DESTDIR)$(includedir)/zzip.h + echo '#endif' >>$(DESTDIR)$(includedir)/zzip.h + echo '#endif' >>$(DESTDIR)$(includedir)/zzip.h + echo '#include "zzip/lib.h"' >>$(DESTDIR)$(includedir)/zzip.h + sed -e 's|zzip.h|zziplib.h|' -e 's|zzip/lib.h|zzip/zzip.h|' \ + $(DESTDIR)$(includedir)/zzip.h >$(DESTDIR)$(includedir)/zziplib.h + sed -e 's|zzip.h|zzip-io.h|' -e 's|zzip/lib.h|zzip/plugin.h|' \ + $(DESTDIR)$(includedir)/zzip.h >$(DESTDIR)$(includedir)/zzip-io.h + +install-exec-hook: + @ for i in . $(DESTDIR)$(libdir)/libzzip*.so.13 \ + ; do test -d $$i && continue ; lib=`basename "$$i" .so.13` \ + ; echo "$(DESTDIR)$(libdir): ln -s $$lib.so.13 $$lib.so.10" \ + ; (cd $(DESTDIR)$(libdir) && ln -s $$lib.so.13 $$lib.so.10) \ + ; echo "$(DESTDIR)$(libdir): ln -s $$lib.so.13 $$lib.so.11" \ + ; (cd $(DESTDIR)$(libdir) && ln -s $$lib.so.13 $$lib.so.11) \ + ; echo "$(DESTDIR)$(libdir): ln -s $$lib.so.13 $$lib.so.12" \ + ; (cd $(DESTDIR)$(libdir) && ln -s $$lib.so.13 $$lib.so.12) \ + ; done ; true + +uninstall-local : + (cd $(DESTDIR)$(includedir) && rm zziplib.h zzip.h zzip-io.h) + + +INDENT = indent +INDENTFLAGS = \ +--blank-lines-after-procedures \ +--blank-lines-before-block-comments \ +--brace-indent0 \ +--braces-after-if-line \ +--case-indentation0 \ +--cuddle-else \ +--space-after-cast \ +--honour-newlines \ +--indent-level4 \ +--line-length80 \ +--continue-at-parentheses \ +--leave-preprocessor-space \ +--dont-break-function-decl-args \ +--dont-cuddle-do-while \ +--dont-format-first-column-comments \ +--no-space-after-function-call-names \ +--no-space-after-parentheses \ +--no-tabs \ +--ignore-profile \ +--procnames-start-lines \ +--space-after-for \ +--space-after-if \ +--space-after-while \ +--space-special-semicolon + +DIFF_U0 = diff -U0 +# __indent1 = "s|^\\([^{};]*if[^{};]*\\)\\(return[^{};]*;\\)|\\1 { \\2 }|" +__indent1 = ":begin" +__indent2 = "s|^\\([^{}';]*\\)\\({[^{}']*}\\)\\([^{}';]*\\)$$|\\1(' \\2 ');\\3|" +__indent3 = "s|___+[;].*|/*&*/|" +__indent4 = ":end" +__indent6 = "s|!\\([^ !=)]\\)|! \\1|g" +__indent7 = "s|(' \\({[^{}']*}\\) ');|\\1|" +__indent8 = "s|/[*]\\(___+[;].*\\)[*]/$$|\\1|" +__indent9 = ":end" +indent-check: + for file in $(srcdir)/*.c ; do f=`basename "$$file"` \ + ; sed -e $(__indent1) -e $(__indent2) -e $(__indent3) -e $(__indent4) \ + $(INDENTBEFORE) $$file \ + | $(INDENT) $(INDENTFLAGS) $(INDENTOPTS) -st - \ + | sed -e $(__indent6) -e $(__indent7) -e $(__indent8) -e $(__indent9) \ + $(INDENTAFTER) > $$f.tmp \ + ; echo $(DIFF_U0) "$$file" "$$f.tmp" \ + ; $(DIFF_U0) "$$file" "$$f.tmp" ; done + +i: + @ f=`basename $(file) .tmp` \ + ; echo cp $(file) $(srcdir)/$$f ; sleep 2 \ + ; cp $(file) $(srcdir)/$$f + +# ---------------------------------------------------------------------- +pkgconfigdir=$(libdir)/pkgconfig +pkgconfig_HEADERS= zzip-zlib-config.pc zziplib.pc \ + zzipmmapped.pc zzipfseeko.pc + +zziplib.pc : Makefile + (cd .. && sh config.status zzip/zziplib.pc) + +zzip-zlib-config.pc : Makefile + @ echo "zlib_libs=@ZLIB_LDIR@ -lz" >$@ + @ echo "zlib_cflags=@ZLIB_INCL@" >>$@ + @ echo " " >>$@ + @ echo "Name: zzip-zlib-config" >>$@ + @ echo "Version: @ZLIB_VERSION@" >>$@ + @ echo "Description: ZLib Config (for ZZipLib)" >>$@ + echo 'Libs: $${zlib_libs}' >>$@ + echo 'Cflags: $${zlib_cflags}' >>$@ + +zzipmmapped.pc : zziplib.pc + sed -e 's/-lzzip/-lzzipmmapped/' -e 's/zziplib/zzipmmapped/' \ + zziplib.pc >$@ +zzipfseeko.pc : zziplib.pc + sed -e 's/-lzzip/-lzzipfseeko/' -e 's/zziplib/zzipfseeko/' \ + zziplib.pc >$@ + +__zziplib.pc : Makefile + @ echo "prefix=$(prefix)" >$@ + @ echo "libdir=$(libdir)" >>$@ + @ echo "includedir=$(includedir)" >>$@ + @ echo "largefile=$(LARGEFILE_CFLAGS)" >>$@ + @ echo "zlib_libs=@ZLIB_LDIR@ -lz" >>$@ + @ echo "zlib_cflags=@ZLIB_INCL@" >>$@ + @ echo " " >>$@ + @ echo "Name: zziplib" >>$@ + @ echo "Version: $(VERSION)" >>$@ + @ head $(top_srcdir)/$(PACKAGE).spec \ + | grep Summary | sed -e s,Summary,Description, >> $@ + echo 'Requires: zzip-zlib-config' >>$@ + echo 'Libs: -L$${libdir} -lzzip' >>$@ + echo 'Cflags: $${largefile} -I$${includedir}' >>$@ + +# ---------------------------------------------------------------------- +.c.i : + $(COMPILE) -E $< >$@ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/Makefile.in b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/Makefile.in new file mode 100644 index 00000000000..8bf9c810d07 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/Makefile.in @@ -0,0 +1,847 @@ +# Makefile.in generated by automake 1.11 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +target_triplet = @target@ +subdir = zzip +DIST_COMMON = $(noinst_HEADERS) $(pkgconfig_HEADERS) \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in $(zzip_HEADERS) +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_compile_check_sizeof.m4 \ + $(top_srcdir)/m4/ac_set_default_paths_system.m4 \ + $(top_srcdir)/m4/ac_sys_largefile_sensitive.m4 \ + $(top_srcdir)/m4/acx_restrict.m4 \ + $(top_srcdir)/m4/ax_cflags_gcc_option.m4 \ + $(top_srcdir)/m4/ax_cflags_no_writable_strings.m4 \ + $(top_srcdir)/m4/ax_cflags_strict_prototypes.m4 \ + $(top_srcdir)/m4/ax_cflags_warn_all.m4 \ + $(top_srcdir)/m4/ax_check_aligned_access_required.m4 \ + $(top_srcdir)/m4/ax_configure_args.m4 \ + $(top_srcdir)/m4/ax_create_pkgconfig_info.m4 \ + $(top_srcdir)/m4/ax_enable_builddir_uname.m4 \ + $(top_srcdir)/m4/ax_expand_prefix.m4 \ + $(top_srcdir)/m4/ax_maintainer_mode_auto_silent.m4 \ + $(top_srcdir)/m4/ax_not_enable_frame_pointer.m4 \ + $(top_srcdir)/m4/ax_pax_tar.m4 \ + $(top_srcdir)/m4/ax_prefix_config_h.m4 \ + $(top_srcdir)/m4/ax_set_version_info.m4 \ + $(top_srcdir)/m4/ax_spec_file.m4 \ + $(top_srcdir)/m4/ax_spec_package_version.m4 \ + $(top_srcdir)/m4/ax_warning_default_aclocaldir.m4 \ + $(top_srcdir)/m4/ax_warning_default_pkgconfig.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 \ + $(top_srcdir)/m4/patch_libtool_on_darwin_zsh_overquoting.m4 \ + $(top_srcdir)/m4/patch_libtool_sys_lib_search_path_spec.m4 \ + $(top_srcdir)/m4/patch_libtool_to_add_host_cc.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(SHELL) $(top_srcdir)/uses/mkinstalldirs +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" \ + "$(DESTDIR)$(zzipdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +libzzip_la_DEPENDENCIES = +am_libzzip_la_OBJECTS = zip.lo file.lo dir.lo stat.lo info.lo err.lo \ + plugin.lo write.lo fetch.lo +libzzip_la_OBJECTS = $(am_libzzip_la_OBJECTS) +libzzip_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(libzzip_la_LDFLAGS) $(LDFLAGS) -o $@ +libzzipfseeko_la_DEPENDENCIES = +am_libzzipfseeko_la_OBJECTS = fseeko.lo fetch.lo +libzzipfseeko_la_OBJECTS = $(am_libzzipfseeko_la_OBJECTS) +libzzipfseeko_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(libzzipfseeko_la_LDFLAGS) $(LDFLAGS) -o $@ +libzzipmmapped_la_DEPENDENCIES = +am_libzzipmmapped_la_OBJECTS = mmapped.lo memdisk.lo fetch.lo +libzzipmmapped_la_OBJECTS = $(am_libzzipmmapped_la_OBJECTS) +libzzipmmapped_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(libzzipmmapped_la_LDFLAGS) $(LDFLAGS) -o $@ +depcomp = $(SHELL) $(top_srcdir)/uses/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +SOURCES = $(libzzip_la_SOURCES) $(libzzipfseeko_la_SOURCES) \ + $(libzzipmmapped_la_SOURCES) +DIST_SOURCES = $(libzzip_la_SOURCES) $(libzzipfseeko_la_SOURCES) \ + $(libzzipmmapped_la_SOURCES) +HEADERS = $(noinst_HEADERS) $(pkgconfig_HEADERS) $(zzip_HEADERS) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AS = @AS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CONFIG_FILES = @CONFIG_FILES@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ -I$(top_builddir) -I$(top_srcdir) # also for automake 1.4 +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GNUTAR = @GNUTAR@ +GREP = @GREP@ +GTAR = @GTAR@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LARGEFILE_CFLAGS = @LARGEFILE_CFLAGS@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +MKZIP = @MKZIP@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PAX = @PAX@ +PAX_TAR_CREATE = @PAX_TAR_CREATE@ +PAX_TAR_EXTRACT = @PAX_TAR_EXTRACT@ +PERL = @PERL@ +PKG_CONFIG = @PKG_CONFIG@ +PYTHON = @PYTHON@ +RANLIB = @RANLIB@ +RELEASE_INFO = @RELEASE_INFO@ +RESOLVES = @RESOLVES@ +SDL = @SDL@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TAR = @TAR@ +THREAD_SAFE = @THREAD_SAFE@ +VERSION = @VERSION@ +# +VERSION_INFO = @VERSION_INFO@ +XMLTO = @XMLTO@ +ZIPTESTS = @ZIPTESTS@ +ZLIB_INCL = @ZLIB_INCL@ +ZLIB_LDIR = @ZLIB_LDIR@ +ZLIB_VERSION = @ZLIB_VERSION@ +ZZIPLIB_LDFLAGS = @ZZIPLIB_LDFLAGS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +aclocaldir = @aclocaldir@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +ax_enable_builddir_sed = @ax_enable_builddir_sed@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +lt_ECHO = @lt_ECHO@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgconfig_libdir = @pkgconfig_libdir@ +pkgconfig_libfile = @pkgconfig_libfile@ + +# ---------------------------------------------------------------------- +pkgconfigdir = $(libdir)/pkgconfig +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target = @target@ +target_alias = @target_alias@ +target_cpu = @target_cpu@ +target_os = @target_os@ +target_vendor = @target_vendor@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AUTOMAKE_OPTIONS = 1.5 foreign +AUTOTOOL_VERSION = autoconf-2.52 automake-1.5 libtool-1.4.2 +DEFAULT_INCLUDES = # nothing - no default of -I. -I$(srcdir) +lib_LTLIBRARIES = libzzip.la libzzipmmapped.la libzzipfseeko.la +zzipdir = ${includedir}/zzip +zzip_HEADERS = $(libzzip_la_headers) \ + $(libzzipmmapped_la_headers) \ + $(libzzipfseeko_la_headers) + +noinst_HEADERS = __debug.h __hints.h __mmap.h __dirent.h __fnmatch.h +# +libzzip_la_SOURCES = \ + zip.c \ + file.c \ + dir.c \ + stat.c \ + info.c \ + err.c \ + plugin.c \ + write.c \ + fetch.c + +libzzip_la_headers = \ + stdint.h \ + file.h \ + plugin.h \ + lib.h \ + zzip.h \ + zzip32.h \ + write.h \ + fetch.h \ + format.h \ + info.h \ + autoconf.h \ + types.h \ + conf.h \ + _config.h \ + _msvc.h + +libzzip_la_LDFLAGS = @ZZIPLIB_LDFLAGS@ $(RELEASE_INFO) $(VERSION_INFO) \ + $(THREAD_SAFE) + +libzzip_la_LIBADD = -lz @RESOLVES@ +libzzipmmapped_la_SOURCES = mmapped.c memdisk.c fetch.c +libzzipmmapped____headers = mmapped.h memdisk.h fetch.h +libzzipmmapped_la_headers = mmapped.h memdisk.h +libzzipmmapped_la_LDFLAGS = @ZZIPLIB_LDFLAGS@ $(RELEASE_INFO) $(VERSION_INFO) \ + $(THREAD_SAFE) + +libzzipmmapped_la_LIBADD = -lz @RESOLVES@ +libzzipfseeko_la_SOURCES = fseeko.c fetch.c +libzzipfseeko____headers = fseeko.h fetch.h +libzzipfseeko_la_headers = fseeko.h +libzzipfseeko_la_LDFLAGS = @ZZIPLIB_LDFLAGS@ $(RELEASE_INFO) $(VERSION_INFO) \ + $(THREAD_SAFE) + +libzzipfseeko_la_LIBADD = -lz @RESOLVES@ +WCC10_DIST = zziplib.wpj +WCC10_CLEAN = *.obj *.lk1 *.mk1 *.mk *.sym *.tgt +EXTRA_DIST = $(WCC10_DIST) _msvc.sed +CONFIG_CLEAN_FILES = _config.h +MAINTAINERCLEANFILES = _msvc.h +CLEANFILES = $(WCC10_CLEAN) *.pc *.omf *~ *.tmp *.tmp.* +INDENT = indent +INDENTFLAGS = \ +--blank-lines-after-procedures \ +--blank-lines-before-block-comments \ +--brace-indent0 \ +--braces-after-if-line \ +--case-indentation0 \ +--cuddle-else \ +--space-after-cast \ +--honour-newlines \ +--indent-level4 \ +--line-length80 \ +--continue-at-parentheses \ +--leave-preprocessor-space \ +--dont-break-function-decl-args \ +--dont-cuddle-do-while \ +--dont-format-first-column-comments \ +--no-space-after-function-call-names \ +--no-space-after-parentheses \ +--no-tabs \ +--ignore-profile \ +--procnames-start-lines \ +--space-after-for \ +--space-after-if \ +--space-after-while \ +--space-special-semicolon + +DIFF_U0 = diff -U0 +# __indent1 = "s|^\\([^{};]*if[^{};]*\\)\\(return[^{};]*;\\)|\\1 { \\2 }|" +__indent1 = ":begin" +__indent2 = "s|^\\([^{}';]*\\)\\({[^{}']*}\\)\\([^{}';]*\\)$$|\\1(' \\2 ');\\3|" +__indent3 = "s|___+[;].*|/*&*/|" +__indent4 = ":end" +__indent6 = "s|!\\([^ !=)]\\)|! \\1|g" +__indent7 = "s|(' \\({[^{}']*}\\) ');|\\1|" +__indent8 = "s|/[*]\\(___+[;].*\\)[*]/$$|\\1|" +__indent9 = ":end" +pkgconfig_HEADERS = zzip-zlib-config.pc zziplib.pc \ + zzipmmapped.pc zzipfseeko.pc + +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .i .lo .o .obj +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign zzip/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign zzip/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)" + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done +libzzip.la: $(libzzip_la_OBJECTS) $(libzzip_la_DEPENDENCIES) + $(libzzip_la_LINK) -rpath $(libdir) $(libzzip_la_OBJECTS) $(libzzip_la_LIBADD) $(LIBS) +libzzipfseeko.la: $(libzzipfseeko_la_OBJECTS) $(libzzipfseeko_la_DEPENDENCIES) + $(libzzipfseeko_la_LINK) -rpath $(libdir) $(libzzipfseeko_la_OBJECTS) $(libzzipfseeko_la_LIBADD) $(LIBS) +libzzipmmapped.la: $(libzzipmmapped_la_OBJECTS) $(libzzipmmapped_la_DEPENDENCIES) + $(libzzipmmapped_la_LINK) -rpath $(libdir) $(libzzipmmapped_la_OBJECTS) $(libzzipmmapped_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dir.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/err.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fetch.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/file.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fseeko.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/info.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memdisk.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mmapped.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/plugin.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stat.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/write.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/zip.Plo@am__quote@ + +.c.o: +@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c $< + +.c.obj: +@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +install-pkgconfigHEADERS: $(pkgconfig_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(pkgconfigdir)" || $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" + @list='$(pkgconfig_HEADERS)'; test -n "$(pkgconfigdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkgconfigdir)'"; \ + $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \ + done + +uninstall-pkgconfigHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(pkgconfig_HEADERS)'; test -n "$(pkgconfigdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(pkgconfigdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(pkgconfigdir)" && rm -f $$files +install-zzipHEADERS: $(zzip_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(zzipdir)" || $(MKDIR_P) "$(DESTDIR)$(zzipdir)" + @list='$(zzip_HEADERS)'; test -n "$(zzipdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(zzipdir)'"; \ + $(INSTALL_HEADER) $$files "$(DESTDIR)$(zzipdir)" || exit $$?; \ + done + +uninstall-zzipHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(zzip_HEADERS)'; test -n "$(zzipdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(zzipdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(zzipdir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(HEADERS) +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(zzipdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." + -test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES) +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-pkgconfigHEADERS install-zzipHEADERS + @$(NORMAL_INSTALL) + $(MAKE) $(AM_MAKEFLAGS) install-data-hook +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + @$(NORMAL_INSTALL) + $(MAKE) $(AM_MAKEFLAGS) install-exec-hook +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES uninstall-local \ + uninstall-pkgconfigHEADERS uninstall-zzipHEADERS + +.MAKE: install-am install-data-am install-exec-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool ctags distclean \ + distclean-compile distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am \ + install-data-hook install-dvi install-dvi-am install-exec \ + install-exec-am install-exec-hook install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-man install-pdf install-pdf-am \ + install-pkgconfigHEADERS install-ps install-ps-am \ + install-strip install-zzipHEADERS installcheck installcheck-am \ + installdirs maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \ + uninstall-am uninstall-libLTLIBRARIES uninstall-local \ + uninstall-pkgconfigHEADERS uninstall-zzipHEADERS + + +# here is some backward compatibility with version 0.10.* of zziplib +install-data-hook : install-zzipHEADERS + echo '#ifndef ZZIP_WARNING' > $(DESTDIR)$(includedir)/zzip.h + echo '#define ZZIP_WARNING 1' >>$(DESTDIR)$(includedir)/zzip.h + echo '#ifdef __GNUC__' >>$(DESTDIR)$(includedir)/zzip.h + echo '#warning do no not use <zzip.h>, update to include <zzip/lib.h>'\ + >>$(DESTDIR)$(includedir)/zzip.h + echo '#else' >>$(DESTDIR)$(includedir)/zzip.h + echo '#error do no not use <zzip.h>, update to include <zzip/lib.h>'\ + >>$(DESTDIR)$(includedir)/zzip.h + echo '#endif' >>$(DESTDIR)$(includedir)/zzip.h + echo '#endif' >>$(DESTDIR)$(includedir)/zzip.h + echo '#include "zzip/lib.h"' >>$(DESTDIR)$(includedir)/zzip.h + sed -e 's|zzip.h|zziplib.h|' -e 's|zzip/lib.h|zzip/zzip.h|' \ + $(DESTDIR)$(includedir)/zzip.h >$(DESTDIR)$(includedir)/zziplib.h + sed -e 's|zzip.h|zzip-io.h|' -e 's|zzip/lib.h|zzip/plugin.h|' \ + $(DESTDIR)$(includedir)/zzip.h >$(DESTDIR)$(includedir)/zzip-io.h + +install-exec-hook: + @ for i in . $(DESTDIR)$(libdir)/libzzip*.so.13 \ + ; do test -d $$i && continue ; lib=`basename "$$i" .so.13` \ + ; echo "$(DESTDIR)$(libdir): ln -s $$lib.so.13 $$lib.so.10" \ + ; (cd $(DESTDIR)$(libdir) && ln -s $$lib.so.13 $$lib.so.10) \ + ; echo "$(DESTDIR)$(libdir): ln -s $$lib.so.13 $$lib.so.11" \ + ; (cd $(DESTDIR)$(libdir) && ln -s $$lib.so.13 $$lib.so.11) \ + ; echo "$(DESTDIR)$(libdir): ln -s $$lib.so.13 $$lib.so.12" \ + ; (cd $(DESTDIR)$(libdir) && ln -s $$lib.so.13 $$lib.so.12) \ + ; done ; true + +uninstall-local : + (cd $(DESTDIR)$(includedir) && rm zziplib.h zzip.h zzip-io.h) +indent-check: + for file in $(srcdir)/*.c ; do f=`basename "$$file"` \ + ; sed -e $(__indent1) -e $(__indent2) -e $(__indent3) -e $(__indent4) \ + $(INDENTBEFORE) $$file \ + | $(INDENT) $(INDENTFLAGS) $(INDENTOPTS) -st - \ + | sed -e $(__indent6) -e $(__indent7) -e $(__indent8) -e $(__indent9) \ + $(INDENTAFTER) > $$f.tmp \ + ; echo $(DIFF_U0) "$$file" "$$f.tmp" \ + ; $(DIFF_U0) "$$file" "$$f.tmp" ; done + +i: + @ f=`basename $(file) .tmp` \ + ; echo cp $(file) $(srcdir)/$$f ; sleep 2 \ + ; cp $(file) $(srcdir)/$$f + +zziplib.pc : Makefile + (cd .. && sh config.status zzip/zziplib.pc) + +zzip-zlib-config.pc : Makefile + @ echo "zlib_libs=@ZLIB_LDIR@ -lz" >$@ + @ echo "zlib_cflags=@ZLIB_INCL@" >>$@ + @ echo " " >>$@ + @ echo "Name: zzip-zlib-config" >>$@ + @ echo "Version: @ZLIB_VERSION@" >>$@ + @ echo "Description: ZLib Config (for ZZipLib)" >>$@ + echo 'Libs: $${zlib_libs}' >>$@ + echo 'Cflags: $${zlib_cflags}' >>$@ + +zzipmmapped.pc : zziplib.pc + sed -e 's/-lzzip/-lzzipmmapped/' -e 's/zziplib/zzipmmapped/' \ + zziplib.pc >$@ +zzipfseeko.pc : zziplib.pc + sed -e 's/-lzzip/-lzzipfseeko/' -e 's/zziplib/zzipfseeko/' \ + zziplib.pc >$@ + +__zziplib.pc : Makefile + @ echo "prefix=$(prefix)" >$@ + @ echo "libdir=$(libdir)" >>$@ + @ echo "includedir=$(includedir)" >>$@ + @ echo "largefile=$(LARGEFILE_CFLAGS)" >>$@ + @ echo "zlib_libs=@ZLIB_LDIR@ -lz" >>$@ + @ echo "zlib_cflags=@ZLIB_INCL@" >>$@ + @ echo " " >>$@ + @ echo "Name: zziplib" >>$@ + @ echo "Version: $(VERSION)" >>$@ + @ head $(top_srcdir)/$(PACKAGE).spec \ + | grep Summary | sed -e s,Summary,Description, >> $@ + echo 'Requires: zzip-zlib-config' >>$@ + echo 'Libs: -L$${libdir} -lzzip' >>$@ + echo 'Cflags: $${largefile} -I$${includedir}' >>$@ + +# ---------------------------------------------------------------------- +.c.i : + $(COMPILE) -E $< >$@ + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__debug.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__debug.h new file mode 100644 index 00000000000..13c7d895443 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__debug.h @@ -0,0 +1,89 @@ +#ifndef __ZZIP_INTERNAL_DEBUG_H +#define __ZZIP_INTERNAL_DEBUG_H + +#include <zzip/conf.h> +#include <zzip/__hints.h> + +/* perhaps want to show on syslog(3) ?? */ + +#ifdef DEBUG +#include <stdio.h> +#define DBG1(X1) ZZIP_FOR1 { \ + fprintf(stderr,"\n%s:%i:"X1"\n", ZZIP_FUNC,__LINE__ \ + ); } ZZIP_END1 +#define DBG2(X1,X2) ZZIP_FOR1 { \ + fprintf(stderr,"\n%s:%i:"X1"\n", ZZIP_FUNC,__LINE__ \ + ,X2);} ZZIP_END1 +#define DBG3(X1,X2,X3) ZZIP_FOR1 { \ + fprintf(stderr,"\n%s:%i:"X1"\n", ZZIP_FUNC,__LINE__ \ + ,X2,X3); } ZZIP_END1 +#define DBG4(X1,X2,X3,X4) ZZIP_FOR1 { \ + fprintf(stderr,"\n%s:%i:"X1"\n", ZZIP_FUNC,__LINE__ \ + ,X2,X3,X4); } ZZIP_END1 +#define DBG5(X1,X2,X3,X4,X5) ZZIP_FOR1 { \ + fprintf(stderr,"\n%s:%i:"X1"\n", ZZIP_FUNC,__LINE__ \ + ,X2,X3,X4,X5); } ZZIP_END1 +#define DBG6(X1,X2,X3,X4,X5,X6) ZZIP_FOR1 { \ + fprintf(stderr,"\n%s:%i:"X1"\n", ZZIP_FUNC,__LINE__ \ + ,X2,X3,X4,X5,X6); } ZZIP_END1 + +#else +#define DBG1(X1) {} +#define DBG2(X1,X2) {} +#define DBG3(X1,X2,X3) {} +#define DBG4(X1,X2,X3,X4) {} +#define DBG5(X1,X2,X3,X4,X5) {} +#define DBG6(X1,X2,X3,X4,X5,X6) {} +#endif + +#define HINT1(X1) DBG1("HINT: " X1) +#define HINT2(X1,X2) DBG2("HINT: " X1,X2) +#define HINT3(X1,X2,X3) DBG3("HINT: " X1,X2,X3) +#define HINT4(X1,X2,X3,X4) DBG4("HINT: " X1,X2,X3,X4) +#define HINT5(X1,X2,X3,X4,X5) DBG5("HINT: " X1,X2,X3,X4,X5) +#define HINT6(X1,X2,X3,X4,X5,X6) DBG6("HINT: " X1,X2,X3,X4,X5,X6) + +#define NOTE1(X1) DBG1("NOTE: " X1) +#define NOTE2(X1,X2) DBG2("NOTE: " X1,X2) +#define NOTE3(X1,X2,X3) DBG3("NOTE: " X1,X2,X3) +#define NOTE4(X1,X2,X3,X4) DBG4("NOTE: " X1,X2,X3,X4) +#define NOTE5(X1,X2,X3,X4,X5) DBG5("NOTE: " X1,X2,X3,X4,X5) +#define NOTE6(X1,X2,X3,X4,X5,X6) DBG6("NOTE: " X1,X2,X3,X4,X5,X6) + +#define WARN1(X1) DBG1("WARN: " X1) +#define WARN2(X1,X2) DBG2("WARN: " X1,X2) +#define WARN3(X1,X2,X3) DBG3("WARN: " X1,X2,X3) +#define WARN4(X1,X2,X3,X4) DBG4("WARN: " X1,X2,X3,X4) +#define WARN5(X1,X2,X3,X4,X5) DBG5("WARN: " X1,X2,X3,X4,X5) +#define WARN6(X1,X2,X3,X4,X5,X6) DBG6("WARN: " X1,X2,X3,X4,X5,X6) + +#define FAIL1(X1) DBG1("FAIL: " X1) +#define FAIL2(X1,X2) DBG2("FAIL: " X1,X2) +#define FAIL3(X1,X2,X3) DBG3("FAIL: " X1,X2,X3) +#define FAIL4(X1,X2,X3,X4) DBG4("FAIL: " X1,X2,X3,X4) +#define FAIL5(X1,X2,X3,X4,X5) DBG5("FAIL: " X1,X2,X3,X4,X5) +#define FAIL6(X1,X2,X3,X4,X5,X6) DBG6("FAIL: " X1,X2,X3,X4,X5,X6) + + + +#ifdef DEBUG +_zzip_inline static void zzip_debug_xbuf (unsigned char* p, int l) + /* ZZIP_GNUC_UNUSED */ +{ +# define q(a) ((a&0x7F)<32?32:(a&0x7F)) + while (l > 0) + { + fprintf (stderr, + "%02x %02x %02x %02x " + "%02x %02x %02x %02x " + "%c%c%c%c %c%c%c%c\n", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], + q(p[0]), q(p[1]), q(p[2]), q(p[3]), + q(p[4]), q(p[5]), q(p[6]), q(p[7])); + p += 8; l -= 8; + } +# undef q +} +#endif + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__dirent.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__dirent.h new file mode 100644 index 00000000000..fc3e08f03d1 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__dirent.h @@ -0,0 +1,393 @@ +#ifndef ZZIP_INTERNAL_DIRENT_H +#define ZZIP_INTERNAL_DIRENT_H +#include <zzip/conf.h> + +/* + * DO NOT USE THIS CODE. + * + * It is an internal header file for zziplib that carries some inline + * functions (or just static members) and a few defines, simply to be + * able to reuse these across - and have everything in a specific place. + * + * Copyright (c) 2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#ifdef ZZIP_HAVE_DIRENT_H +#define USE_DIRENT 1 + +#define _zzip_opendir opendir +#define _zzip_readdir readdir +#define _zzip_closedir closedir +#define _zzip_rewinddir rewinddir +#define _zzip_telldir telldir +#define _zzip_seekdir seekdir +#define _zzip_DIR DIR + +#include <dirent.h> + +#elif defined ZZIP_HAVE_WINBASE_H +#define USE_DIRENT 2 + +#define _zzip_opendir win32_opendir +#define _zzip_readdir win32_readdir +#define _zzip_closedir win32_closedir +#define _zzip_rewinddir win32_rewinddir +#define _zzip_telldir win32_telldir +#define _zzip_seekdir win32_seekdir +#define _zzip_DIR DIR + +/* + * DIRENT.H (formerly DIRLIB.H) + * + * by M. J. Weinstein Released to public domain 1-Jan-89 + * + * Because I have heard that this feature (opendir, readdir, closedir) + * it so useful for programmers coming from UNIX or attempting to port + * UNIX code, and because it is reasonably light weight, I have included + * it in the Mingw32 package. I have also added an implementation of + * rewinddir, seekdir and telldir. + * - Colin Peters <colin@bird.fu.is.saga-u.ac.jp> + * + * This code is distributed in the hope that is will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAMED. This includeds but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + */ + +#include <io.h> + +struct dirent +{ + long d_ino; /* Always zero. */ + unsigned short d_reclen; /* Always zero. */ + unsigned short d_namlen; /* Length of name in d_name. */ + char* d_name; /* File name. */ + /* NOTE: The name in the dirent structure points to the name in the + * finddata_t structure in the DIR. */ +}; + +/* + * This is an internal data structure. Good programmers will not use it + * except as an argument to one of the functions below. + */ +typedef struct +{ + /* disk transfer area for this dir */ + struct _finddata_t dd_dta; + + /* dirent struct to return from dir (NOTE: this makes this thread + * safe as long as only one thread uses a particular DIR struct at + * a time) */ + struct dirent dd_dir; + + /* _findnext handle */ + long dd_handle; + + /* + * Status of search: + * 0 = not started yet (next entry to read is first entry) + * -1 = off the end + * positive = 0 based index of next entry + */ + short dd_stat; + + /* given path for dir with search pattern (struct is extended) */ + char dd_name[1]; +} DIR; + +/* + * dirent.c + * + * Derived from DIRLIB.C by Matt J. Weinstein + * This note appears in the DIRLIB.H + * DIRLIB.H by M. J. Weinstein Released to public domain 1-Jan-89 + * + * Updated by Jeremy Bettis <jeremy@hksys.com> + * Significantly revised and rewinddir, seekdir and telldir added by Colin + * Peters <colin@fu.is.saga-u.ac.jp> + */ + +#include <direct.h> +#include <errno.h> +#include <io.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +#define win32_SUFFIX "*" +#define win32_SLASH "\\" + +#ifndef S_ISDIR +#define S_ISDIR(m) ((m & S_IFMT) == S_IFDIR) /* is a directory */ +#endif S_ISDIR + + +/* + opendir + + Returns a pointer to a DIR structure appropriately filled in to begin + searching a directory. +*/ +static DIR* +win32_opendir (const char *szPath) +{ + DIR *nd; + struct _stat statDir; + + errno = 0; + + if (!szPath) { + errno = EFAULT; + return (DIR *) 0; + } + + if (szPath[0] == '\0') { + errno = ENOTDIR; + return (DIR *) 0; + } + + /* Attempt to determine if the given path really is a directory. */ + if (_stat (szPath, &statDir)) { + /* Error, stat should have set an error value. */ + return (DIR *) 0; + } + + if (!S_ISDIR (statDir.st_mode)) { + /* Error, stat reports not a directory. */ + errno = ENOTDIR; + return (DIR *) 0; + } + + /* Allocate enough space to store DIR structure and the complete * + directory path given. */ + nd = (DIR *) calloc (1, sizeof (DIR) + strlen (szPath) + + strlen (win32_SLASH) + strlen (win32_SUFFIX)); + + if (!nd) { + /* Error, out of memory. */ + errno = ENOMEM; + return (DIR *) 0; + } + + /* Create the search expression. */ + strcpy (nd->dd_name, szPath); + + /* Add on a slash if the path does not end with one. */ + if (nd->dd_name[0] != '\0' && + nd->dd_name[strlen (nd->dd_name) - 1] != '/' && + nd->dd_name[strlen (nd->dd_name) - 1] != '\\') { + strcat (nd->dd_name, win32_SLASH); + } + + /* Add on the search pattern */ + strcat (nd->dd_name, win32_SUFFIX); + + /* Initialize handle to -1 so that a premature closedir doesn't try * to + call _findclose on it. */ + nd->dd_handle = -1; + + /* Initialize the status. */ + nd->dd_stat = 0; + + /* Initialize the dirent structure. ino and reclen are invalid under * + Win32, and name simply points at the appropriate part of the * + findfirst_t structure. */ + nd->dd_dir.d_ino = 0; + nd->dd_dir.d_reclen = 0; + nd->dd_dir.d_namlen = 0; + nd->dd_dir.d_name = nd->dd_dta.name; + + return nd; +} + +/* + readdir + + Return a pointer to a dirent structure filled with the information on the + next entry in the directory. +*/ +static struct dirent * +win32_readdir (DIR * dirp) +{ + errno = 0; + + /* Check for valid DIR struct. */ + if (!dirp) { + errno = EFAULT; + return (struct dirent *) 0; + } + + if (dirp->dd_dir.d_name != dirp->dd_dta.name) { + /* The structure does not seem to be set up correctly. */ + errno = EINVAL; + return (struct dirent *) 0; + } + + if (dirp->dd_stat < 0) { + /* We have already returned all files in the directory * (or the + structure has an invalid dd_stat). */ + return (struct dirent *) 0; + } else if (dirp->dd_stat == 0) { + /* We haven't started the search yet. */ + /* Start the search */ + dirp->dd_handle = _findfirst (dirp->dd_name, &(dirp->dd_dta)); + + if (dirp->dd_handle == -1) { + /* Whoops! Seems there are no files in that * directory. */ + dirp->dd_stat = -1; + } else { + dirp->dd_stat = 1; + } + } else { + /* Get the next search entry. */ + if (_findnext (dirp->dd_handle, &(dirp->dd_dta))) { + /* We are off the end or otherwise error. */ + _findclose (dirp->dd_handle); + dirp->dd_handle = -1; + dirp->dd_stat = -1; + } else { + /* Update the status to indicate the correct * number. */ + dirp->dd_stat++; + } + } + + if (dirp->dd_stat > 0) { + /* Successfully got an entry. Everything about the file is * already + appropriately filled in except the length of the * file name. */ + dirp->dd_dir.d_namlen = (unsigned short) strlen (dirp->dd_dir.d_name); + return &dirp->dd_dir; + } + + return (struct dirent *) 0; +} + +/* + closedir + + Frees up resources allocated by opendir. +*/ +static int +win32_closedir (DIR * dirp) +{ + int rc; + + errno = 0; + rc = 0; + + if (!dirp) { + errno = EFAULT; + return -1; + } + + if (dirp->dd_handle != -1) { + rc = _findclose (dirp->dd_handle); + } + + /* Delete the dir structure. */ + free (dirp); + + return rc; +} + +/* + rewinddir + + Return to the beginning of the directory "stream". We simply call findclose + and then reset things like an opendir. +*/ +static void +win32_rewinddir (DIR * dirp) +{ + errno = 0; + + if (!dirp) { + errno = EFAULT; + return; + } + + if (dirp->dd_handle != -1) { + _findclose (dirp->dd_handle); + } + + dirp->dd_handle = -1; + dirp->dd_stat = 0; +} + +/* + telldir + + Returns the "position" in the "directory stream" which can be used with + seekdir to go back to an old entry. We simply return the value in stat. +*/ +static long +win32_telldir (DIR * dirp) +{ + errno = 0; + + if (!dirp) { + errno = EFAULT; + return -1; + } + return dirp->dd_stat; +} + +/* + seekdir + + Seek to an entry previously returned by telldir. We rewind the directory + and call readdir repeatedly until either dd_stat is the position number + or -1 (off the end). This is not perfect, in that the directory may + have changed while we weren't looking. But that is probably the case with + any such system. +*/ +static void +win32_seekdir (DIR * dirp, long lPos) +{ + errno = 0; + + if (!dirp) { + errno = EFAULT; + return; + } + + if (lPos < -1) { + /* Seeking to an invalid position. */ + errno = EINVAL; + return; + } else if (lPos == -1) { + /* Seek past end. */ + if (dirp->dd_handle != -1) { + _findclose (dirp->dd_handle); + } + dirp->dd_handle = -1; + dirp->dd_stat = -1; + } else { + /* Rewind and read forward to the appropriate index. */ + win32_rewinddir (dirp); + + while ((dirp->dd_stat < lPos) && win32_readdir (dirp)); + } +} + +#else +#define USE_DIRENT 0 + +#define _zzip_opendir(_N_) 0 +#define _zzip_readdir(_D_) 0 +#define _zzip_closedir(_D_) /* omit return code */ +#define _zzip_rewinddir(_D_) +#define _zzip_telldir(_D_) 0 +#define _zzip_seekdir(_D_,_V_) /* omit return code */ +#define _zzip_DIR void* + +/* end of DIRENT implementation */ +#endif + +/* once */ +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__fnmatch.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__fnmatch.h new file mode 100644 index 00000000000..55d96b6d1ef --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__fnmatch.h @@ -0,0 +1,29 @@ +#ifndef __ZZIP_INTERNAL_FNMATCH_H +#define __ZZIP_INTERNAL_FNMATCH_H +/** included by fseeko.c, mmapped.c, memdisk.c */ + +#include <zzip/conf.h> +#include <stdio.h> + +#ifdef ZZIP_HAVE_FNMATCH_H +#include <fnmatch.h> +#endif + +#ifdef ZZIP_HAVE_FNMATCH_H +#define _zzip_fnmatch fnmatch +# ifdef FNM_CASEFOLD +# define _zzip_fnmatch_CASEFOLD FNM_CASEFOLD +# else +# define _zzip_fnmatch_CASEFOLD 0 +# endif +#else +# define _zzip_fnmatch_CASEFOLD 0 +/* if your system does not have fnmatch, we fall back to strcmp: */ +static int _zzip_fnmatch(char* pattern, char* string, int flags) +{ + fprintf (stderr, "<zzip:mmapped:strcmp>"); + return strcmp (pattern, string); +} +#endif + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__hints.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__hints.h new file mode 100644 index 00000000000..d071c4ebd7f --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__hints.h @@ -0,0 +1,195 @@ +#ifndef __ZZIP_INTERNAL_HINTS_H +#define __ZZIP_INTERNAL_HINTS_H +#include <zzip/conf.h> + +#ifndef ZZIP_GNUC_ATLEAST +# if defined __GNUC__ && defined __GNUC_MINOR__ +# define ZZIP_GNUC_ATLEAST(_M_,_N_) \ + ((__GNUC__ << 10) + __GNUC_MINOR__ >= ((_M_) << 10) + (_N_)) +# elif defined __GNUC__ +# define ZZIP_GNUC_ATLEAST(_M_,_N_) \ + ((__GNUC__ << 10) >= ((_M_) << 10)) +# else +# define ZZIP_GNUC_ATLEAST(_M_, _N_) 0 +# endif +#endif + +#ifndef ZZIP_GNUC_EXTENSION +# if ZZIP_GNUC_ATLEAST(2,8) +# define ZZIP_GNUC_EXTENSION __extension__ +# else +# define ZZIP_GNUC_EXTENSION +# endif +#endif + +/* func has no side effects, return value depends only on params and globals */ +#ifndef ZZIP_GNUC_PURE +# if ZZIP_GNUC_ATLEAST(2,8) +# define ZZIP_GNUC_PURE __attribute__((__pure__)) +# else +# define ZZIP_GNUC_PURE +# endif +#endif + +/* func has no side effects, return value depends only on params */ +#ifndef ZZIP_GNUC_CONST +# if ZZIP_GNUC_ATLEAST(2,4) +# define ZZIP_GNUC_CONST __attribute__((__const__)) +# else +# define ZZIP_GNUC_CONST +# endif +#endif + +/* typename / variable / function possibly unused */ +#ifndef ZZIP_GNUC_UNUSED +# if ZZIP_GNUC_ATLEAST(2,4) +# define ZZIP_GNUC_UNUSED __attribute__((__unused__)) +# else +# define ZZIP_GNUC_UNUSED +# endif +#endif + +/* obvious. btw, a noreturn-func should return void */ +#ifndef ZZIP_GNUC_NORETURN +# if ZZIP_GNUC_ATLEAST(2,5) +# define ZZIP_GNUC_NORETURN __attribute__((__noreturn__)) +# else +# define ZZIP_GNUC_NORETURN +# endif +#endif + +/* omit function from profiling with -finstrument-functions */ +#ifndef ZZIP_GNUC_NO_INSTRUMENT +# if ZZIP_GNUC_ATLEAST(2,4) +# define ZZIP_GNUC_NO_INSTRUMENT __attribute__((__no_instrument_function__)) +# else +# define ZZIP_GNUC_NO_INSTRUMENT +# endif +#endif + +/* all pointer args must not be null, and allow optimiztons based on the fact*/ +#ifndef ZZIP_GNUC_NONNULL +# if ZZIP_GNUC_ATLEAST(3,1) +# define ZZIP_GNUC_NONNULL __attribute__((nonnull)) +# else +# define ZZIP_GNUC_NONNULL +# endif +#endif + +/* the function can not throw - the libc function are usually nothrow */ +#ifndef ZZIP_GNUC_NOTHROW +# if ZZIP_GNUC_ATLEAST(3,2) +# define ZZIP_GNUC_NOTHROW __attribute__((nothrow)) +# else +# define ZZIP_GNUC_NOTHROW +# endif +#endif + +/* typename / function / variable is obsolete but still listed in headers */ +#ifndef ZZIP_GNUC_DEPRECATED +# if ZZIP_GNUC_ATLEAST(3,1) +# define ZZIP_GNUC_DEPRECATED __attribute__((deprecated)) +# else +# define ZZIP_GNUC_DEPRECATED +# endif +#endif + +/* resolve references to this function during pre-linking the libary */ +#ifndef ZZIP_GNUC_LIB_PROTECTED +# if ZZIP_GNUC_ATLEAST(3,1) +# define ZZIP_GNUC_LIB_PROTECTED __attribute__((visiblity("protected"))) +# else +# define ZZIP_GNUC_LIB_PROTECTED +# endif +#endif + +/* func shall only be usable within the same lib (so, no entry in lib symtab)*/ +#ifndef ZZIP_GNUC_LIB_PRIVATE +# if ZZIP_GNUC_ATLEAST(3,1) +# define ZZIP_GNUC_LIB_PRIVATE __attribute__((visiblity("hidden"))) +# else +# define ZZIP_GNUC_LIB_PRIVATE +# endif +#endif + +/* ... and not even passed as a function pointer reference to outside the lib*/ +#ifndef ZZIP_GNUC_LIB_INTERNAL +# if ZZIP_GNUC_ATLEAST(3,1) +# define ZZIP_GNUC_LIB_INTERNAL __attribute__((visiblity("internal"))) +# else +# define ZZIP_GNUC_LIB_INTERNAL +# endif +#endif + + +#ifndef ZZIP_GNUC_FORMAT +# if ZZIP_GNUC_ATLEAST(2,4) +# define ZZIP_GNUC_FORMAT(_X_) __attribute__((__format_arg__(_X_))) +# else +# define ZZIP_GNUC_FORMAT(_X_) +# endif +#endif + +#ifndef ZZIP_GNUC_SCANF +# if ZZIP_GNUC_ATLEAST(2,4) +# define ZZIP_GNUC_SCANF(_S_,_X_) __attribute__((__scanf__(_S_,_X_))) +# else +# define ZZIP_GNUC_SCANF(_S_,_X_) +# endif +#endif + +#ifndef ZZIP_GNUC_PRINTF +# if ZZIP_GNUC_ATLEAST(2,4) +# define ZZIP_GNUC_PRINTF(_S_,_X_) __attribute__((__printf__(_S_,_X_))) +# else +# define ZZIP_GNUC_PRINTF(_S_,_X_) +# endif +#endif + +#ifdef __GNUC__ +#define ZZIP_GNUC_PACKED __attribute__((packed)) +#else +#define ZZIP_GNUC_PACKED +#endif + +#ifndef ZZIP_FUNCTION +# if ZZIP_GNUC_ATLEAST(2,6) +# define ZZIP_FUNC __FUNCTION__ +# define ZZIP_FUNCTION __FUNCTION__ +# elif defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L +# define ZZIP_FUNC __func__ +# define ZZIP_FUNCTION "" +# else +# define ZZIP_FUNC 0 +# define ZZIP_FUNCTION "" +# endif +#endif + +#ifndef ZZIP_STRING +#define ZZIP_STRING(_X_) ZZIP_STRING_(_X_) +#define ZZIP_STRING_(_Y_) #_Y_ +#endif + +#ifndef ZZIP_DIM +#define ZZIP_DIM(_A_) (sizeof(_A_) / sizeof ((_A_)[0])) +#endif + +#if !(defined ZZIP_FOR1 && defined ZZIP_END1) +# if defined sun || defined __sun__ +# define ZZIP_FOR1 if (1) +# define ZZIP_END1 else (void)0 +# else +# define ZZIP_FOR1 do +# define ZZIP_END1 while (0) +# endif +#endif + +#ifndef ZZIP_BRANCH_OVER +# if ZZIP_GNUC_ATLEAST(2,96) +# define ZZIP_BRANCH_OVER(_X_) __builtin_expect((_X_),0) +# else +# define ZZIP_BRANCH_OVER(_X_) (_X_) +# endif +#endif + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__mmap.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__mmap.h new file mode 100644 index 00000000000..d70419dcb02 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/__mmap.h @@ -0,0 +1,107 @@ +#ifndef __ZZIP_INTERNAL_MMAP_H +#define __ZZIP_INTERNAL_MMAP_H +#include <zzip/types.h> + +/* + * DO NOT USE THIS CODE. + * + * It is an internal header file for zziplib that carries some inline + * functions (or just static members) and a few defines, simply to be + * able to reuse these across - and have everything in a specific place. + * + * Copyright (c) 2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#ifdef _USE_MMAP +#if defined ZZIP_HAVE_SYS_MMAN_H +#include <sys/mman.h> +#define USE_POSIX_MMAP 1 +#elif defined ZZIP_HAVE_WINBASE_H || defined WIN32 +#include <windows.h> +#define USE_WIN32_MMAP 1 +#else +#undef _USE_MMAP +#endif +#endif + +/* -------------- specify MMAP function imports --------------------------- */ + +#if defined USE_POSIX_MMAP +#define USE_MMAP 1 + +#define _zzip_mmap(user, fd, offs, len) \ + mmap (0, len, PROT_READ, MAP_SHARED, fd, offs) +#define _zzip_munmap(user, ptr, len) \ + munmap (ptr, len) +#define _zzip_getpagesize(user) getpagesize() + +#ifndef MAP_FAILED /* hpux10.20 does not have it */ +#define MAP_FAILED ((void*)(-1)) +#endif + +#elif defined USE_WIN32_MMAP +#define USE_MMAP 1 +#ifndef MAP_FAILED +#define MAP_FAILED 0 +#endif +/* we (ab)use the "*user" variable to store the FileMapping handle */ + /* which assumes (sizeof(long) == sizeof(HANDLE)) */ + +static size_t win32_getpagesize (void) +{ + SYSTEM_INFO si; GetSystemInfo (&si); + return si.dwAllocationGranularity; +} +static void* win32_mmap (long* user, int fd, zzip_off_t offs, size_t len) +{ + if (! user || *user != 1) /* || offs % getpagesize() */ + return 0; + { + HANDLE hFile = (HANDLE)_get_osfhandle(fd); + if (hFile) + *user = (int) CreateFileMapping (hFile, 0, PAGE_READONLY, 0, 0, NULL); + if (*user) + { + char* p = 0; + p = MapViewOfFile(*(HANDLE*)user, FILE_MAP_READ, 0, offs, len); + if (p) return p + offs; + CloseHandle (*(HANDLE*)user); *user = 1; + } + return MAP_FAILED; + } +} +static void win32_munmap (long* user, char* fd_map, size_t len) +{ + UnmapViewOfFile (fd_map); + CloseHandle (*(HANDLE*)user); *user = 1; +} + +#define _zzip_mmap(user, fd, offs, len) \ + win32_mmap ((long*) &(user), fd, offs, len) +#define _zzip_munmap(user, ptr, len) \ + win32_munmap ((long*) &(user), ptr, len) +#define _zzip_getpagesize(user) win32_getpagesize() + +#else /* disable */ +#define USE_MMAP 0 +/* USE_MAP is intentional: we expect the compiler to do some "code removal" + * on any source code enclosed in if (USE_MMAP) {...} i.e. the unreachable + * branch of an if (0) {....} is not emitted to the final object binary. */ + +#ifndef MAP_FAILED +#define MAP_FAILED 0 +#endif + +#define _zzip_mmap(user, fd, offs, len) (MAP_FAILED) +#define _zzip_munmap(user, ptr, len) {} +#define _zzip_getpagesize(user) 1 + +#endif /* USE_MMAP defines */ + + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/_msvc.sed b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/_msvc.sed new file mode 100644 index 00000000000..ec1fcbba192 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/_msvc.sed @@ -0,0 +1,26 @@ +s:undef *HAVE_MEMORY_H *$:define HAVE_MEMORY_H 1: +s:undef *HAVE_STDLIB_H *$:define HAVE_STDLIB_H 1: +s:undef *HAVE_STRING_H *$:define HAVE_STRING_H 1: +s:undef *HAVE_SYS_STAT_H *$:define HAVE_SYS_STAT_H 1: +s:undef *HAVE_SYS_TYPES_H *$:define HAVE_SYS_TYPES_H 1: +s:undef *HAVE_DIRECT_H *$:define HAVE_DIRECT_H 1: +s:undef *HAVE_IO_H *$:define HAVE_IO_H 1: +s:undef *HAVE_WINDOWS_H *$:define HAVE_WINDOWS_H 1 /* yes, this is windows */: +s:undef *HAVE_WINBASE_H *$:define HAVE_WINBASE_H 1 /* hmm, is that win32 ? */: +s:undef *HAVE_WINNT_H *$:define HAVE_WINNT_H 1 /* is that always true? */: +s:undef *HAVE_ZLIB_H *$:define HAVE_ZLIB_H 1 /* you do have it, right? */: +s:undef *PACKAGE *$:define PACKAGE "zziplib-msvc" /* yes, make it known */: +s:undef *SIZEOF_INT *$:define SIZEOF_INT 4: +s:undef *SIZEOF_LONG *$:define SIZEOF_LONG 4: +s:undef *SIZEOF_SHORT *$:define SIZEOF_SHORT 2: +s:undef *STDC_HEADERS *$:define STDC_HEADERS 1: +s:undef *inline *$:define inline __inline: +s:undef *off_t *$:define off_t long: +s:undef *off64_t *$:define off64_t __int64: +s:undef *ssize_t *$:define ssize_t int: +s:undef restrict *$:define restrict: +s:undef VERSION:define VERSION "0.13.x": +s:^ *# *undef.*$:/* & */: +/Generated automatically .* by autoheader/a\ +/* config values have been automatically set by zzip/_msvc.sed */ + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/autoconf.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/autoconf.h new file mode 100644 index 00000000000..f0d6841454a --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/autoconf.h @@ -0,0 +1,45 @@ +#ifndef _ZZIP_AUTOCONF_H_ +#define _ZZIP_AUTOCONF_H_ 1 + +/* + * This file is trying to override configure time checks of zzip with + * definitions at compile time. This is not used by zzip sources themselves + * but it may be really helpful with thirdparty software that happens to + * include zzip headers from a central place but running on a different host. + */ + +#include "conf.h" /* <zzip/conf.h> : <zzip/_config.h> */ + +#if defined HAVE_ENDIAN_H || defined ZZIP_HAVE_ENDIAN_H +#include <endian.h> /* glibc */ +#elif defined HAVE_SYS_PARAM_H || defined ZZIP_HAVE_SYS_PARAM_H +#include <sys/param.h> /* solaris */ +#endif + +#if defined __BYTE_ORDER +#define ZZIP_BYTE_ORDER __BYTE_ORDER +#elif defined BYTE_ORDER +#define ZZIP_BYTE_ORDER BYTE_ORDER +#elif defined _LITTLE_ENDIAN +#define ZZIP_BYTE_ORDER 1234 +#elif defined _BIG_ENDIAN +#define ZZIP_BYTE_ORDER 4321 +#elif defined __i386__ +#define ZZIP_BYTE_ORDER 1234 +#elif defined WORDS_BIGENDIAN || defined ZZIP_WORDS_BIGENDIAN +#define ZZIP_BYTE_ORDER 4321 +#else +#define ZZIP_BYTE_ORDER 1234 +#endif + +/* override ZZIP_WORDS_BIGENDIAN : macros ZZIP_GET16 / ZZIP_GET32 */ +#ifdef ZZIP_BYTE_ORDER+0 == 1234 +#undef ZZIP_WORDS_BIGENDIAN +#endif +#ifdef ZZIP_BYTE_ORDER+0 == 4321 +#ifndef ZZIP_WORDS_BIGENDIAN +#define ZZIP_WORDS_BIGENDIAN 1 +#endif +#endif + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/conf.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/conf.h new file mode 100644 index 00000000000..52b33e287ce --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/conf.h @@ -0,0 +1,264 @@ +/* + * Here we postprocess autoconf generated prefix-config.h entries. + * This is generally for things like "off_t" which is left undefined + * in plain config.h if the host system does already have it but we do + * need the prefix variant - so we add here a #define _zzip_off_t off_t + * + * This file is supposed to only carry '#define's. + * See <zzip/types.h> for definitions that might be seen by the compiler. + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2001,2002,2003,2004 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#ifndef _ZZIP_CONF_H +#define _ZZIP_CONF_H 1 + +#if !defined ZZIP_OMIT_CONFIG_H +# if defined _MSC_VER || defined __BORLANDC__ || defined __WATCOMC__ +# include <zzip/_msvc.h> +# elif defined ZZIP_1_H +# include "zzip-1.h" +# elif defined ZZIP_2_H +# include "zzip-2.h" +# elif defined ZZIP_3_H +# include "zzip-3.h" +# elif defined ZZIP_4_H +# include "zzip-4.h" +# elif defined ZZIP_5_H +# include "zzip-5.h" +# else /* autoconf generated */ +# include <zzip/_config.h> +# endif +#endif + +/* especially win32 platforms do not declare off_t so far - see zzip-msvc.h */ +#ifndef _zzip_off_t +#ifdef ZZIP_off_t +#define _zzip_off_t ZZIP_off_t +#else +#define _zzip_off_t off_t +#endif +#endif + +#ifndef _zzip_off64_t +#ifdef ZZIP_off64_t +#define _zzip_off64_t ZZIP_off64_t +#else +#define _zzip_off64_t off64_t +#endif +#endif + +/* currently unused, all current zziplib-users do have ansi-C94 compilers. */ +#ifndef _zzip_const +#ifdef ZZIP_const +#define _zzip_const ZZIP_const +#else +#define _zzip_const const +#endif +#endif +#ifndef _zzip_inline +#ifdef ZZIP_inline +#define _zzip_inline ZZIP_inline +#else +#define _zzip_inline inline +#endif +#endif +#ifndef _zzip_restrict +#ifdef ZZIP_restrict +#define _zzip_restrict ZZIP_restrict +#else +#define _zzip_restrict restrict +#endif +#endif +#if defined __linux__ && __GNUC__+0 >= 4 +#define zzip__new__ __attribute__((malloc)) +#elif defined __linux__ && __GNUC__+0 >= 3 && __GNUC_MINOR_+0 >= 3 +#define zzip__new__ __attribute__((malloc)) +#else +#define zzip__new__ +#endif + +#ifndef _zzip_size_t +#ifdef ZZIP_size_t +#define _zzip_size_t ZZIP_size_t +#else +#define _zzip_size_t size_t +#endif +#endif +#ifndef _zzip_ssize_t +#ifdef ZZIP_ssize_t +#define _zzip_ssize_t ZZIP_ssize_t +#else +#define _zzip_ssize_t ssize_t +#endif +#endif +#ifndef _zzip___int64 +#ifdef ZZIP___int64 +#define _zzip___int64 ZZIP___int64 +#else +#define _zzip___int64 long long +#endif +#endif + +/* whether this library shall use a 64bit off_t largefile variant in 64on32: */ +/* (some exported names must be renamed to avoid bad calls after linking) */ +#if defined ZZIP_LARGEFILE_SENSITIVE +# if _FILE_OFFSET_BITS+0 == 64 +# define ZZIP_LARGEFILE_RENAME +# elif defined _LARGE_FILES /* used on older AIX to get at 64bit off_t */ +# define ZZIP_LARGEFILE_RENAME +# elif defined _ZZIP_LARGEFILE /* or simply use this one for zzip64 runs */ +# define ZZIP_LARGEFILE_RENAME +# endif +#endif + +/* if the environment did not setup these for 64bit off_t largefile... */ +#ifdef ZZIP_LARGEFILE_RENAME +# ifndef _FILE_OFFSET_BITS +# ifdef ZZIP__FILE_OFFSET_BITS /* == 64 */ +# define _FILE_OFFSET_BITS ZZIP__FILE_OFFSET_BITS +# endif +# endif +# ifndef _LARGE_FILES +# ifdef ZZIP__LARGE_FILES /* == 1 */ +# define _LARGE_FILES ZZIP__LARGE_FILES +# endif +# endif +# ifndef _LARGEFILE_SOURCE +# ifdef ZZIP__LARGEFILE_SOURCE /* == 1 */ +# define _LARGEFILE_SOURCE ZZIP__LARGEFILE_SOURCE +# endif +# endif +#endif + +#include <errno.h> + +/* mingw32msvc errno : would be in winsock.h */ +#ifndef EREMOTE +#define EREMOTE ESPIPE +#endif + +#ifndef ELOOP +#if defined EILSEQ +#define ELOOP EILSEQ +#else +#define ELOOP ENOEXEC +#endif +#endif + +#if defined __WATCOMC__ +#undef _zzip_inline +#define _zzip_inline static +#endif + +#if defined _MSC_VER || defined __WATCOMC__ +#include <io.h> +#endif + +#ifdef _MSC_VER +# if !__STDC__ +# ifndef _zzip_lseek +# define _zzip_lseek _lseek +# endif +# ifndef _zzip_read +# define _zzip_read _read +# endif +# ifndef _zzip_write +# define _zzip_write _write +# endif +# if 0 +# ifndef _zzip_stat +# define _zzip_stat _stat +# endif +# endif +# endif /* !__STDC__ */ +#endif + /*MSVC*/ + +#if defined _MSC_VER || defined __WATCOMC__ +# ifndef strcasecmp +# define strcasecmp _stricmp +# endif +#endif + +# ifndef _zzip_lseek +# define _zzip_lseek lseek +# endif + +# ifndef _zzip_read +# define _zzip_read read +# endif + +# ifndef _zzip_write +# define _zzip_write write +# endif + +# if 0 +# ifndef _zzip_stat +# define _zzip_stat stat +# endif +# endif + + +#if defined ZZIP_EXPORTS || defined ZZIPLIB_EXPORTS +# undef ZZIP_DLL +#define ZZIP_DLL 1 +#endif + +/* based on zconf.h : */ +/* compile with -DZZIP_DLL for Windows DLL support */ +#if defined ZZIP_DLL +# if defined _WINDOWS || defined WINDOWS || defined _WIN32 +/*# include <windows.h>*/ +# endif +# if !defined _zzip_export && defined _MSC_VER && (defined WIN32 || defined _WIN32) +# define _zzip_export __declspec(dllexport) /*WINAPI*/ +# endif +# if !defined _zzip_export && defined __BORLANDC__ +# if __BORLANDC__ >= 0x0500 && defined WIN32 +# include <windows.h> +# define _zzip_export __declspec(dllexport) /*WINAPI*/ +# else +# if defined _Windows && defined __DLL__ +# define _zzip_export _export +# endif +# endif +# endif +# if !defined _zzip_export && defined __GNUC__ +# if defined __declspec +# define _zzip_export extern __declspec(dllexport) +# else +# define _zzip_export extern +# endif +# endif +# if !defined _zzip_export && defined __BEOS__ +# define _zzip_export extern __declspec(export) +# endif +# if !defined _zzip_export && defined __WATCOMC__ +# define _zzip_export extern __declspec(dllexport) +# define ZEXPORT __syscall +# define ZEXTERN extern +# endif +#endif + +#if !defined _zzip_export +# if defined __GNUC__ /* || !defined HAVE_LIBZZIP */ +# define _zzip_export extern +# elif defined __declspec || (defined _MSC_VER && defined ZZIP_DLL) +# define _zzip_export extern __declspec(dllimport) +# else +# define _zzip_export extern +# endif +#endif + +#endif + + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/dir.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/dir.c new file mode 100644 index 00000000000..2df1bbc0fda --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/dir.c @@ -0,0 +1,332 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/lib.h> /* exported... */ +#include <zzip/file.h> +#include <stddef.h> /*offsetof */ +#include <stdlib.h> +#include <string.h> +#include <errno.h> + +#ifdef ZZIP_HAVE_SYS_STAT_H +#include <sys/stat.h> +#else +#include <stdio.h> +#endif + +#include <zzip/__dirent.h> + +#ifndef offsetof +#pragma warning had to DEFINE offsetof as it was not in stddef.h +#define offsetof(T,M) ((unsigned)(& ((T*)0)->M)) +#endif + +#ifdef ZZIP_HAVE_SYS_STAT_H + +/* MSVC does have IFbitmask but not the corresponding IStests */ +# if ! defined S_ISDIR && defined S_IFDIR +# define S_ISDIR(_X_) ((_X_) & S_IFDIR) +# endif +# if ! defined S_ISREG && defined S_IFREG +# define S_ISREG(_X_) ((_X_) & S_IFREG) +# endif +#endif + +/** + * This function is the equivalent of a => rewinddir(2) for a realdir or + * the zipfile in place of a directory. The ZZIP_DIR handle returned from + * => zzip_opendir has a flag saying realdir or zipfile. As for a zipfile, + * the filenames will include the filesubpath, so take care. + */ +void +zzip_rewinddir(ZZIP_DIR * dir) +{ + if (! dir) + return; + + if (USE_DIRENT && dir->realdir) + { + _zzip_rewinddir(dir->realdir); + return; + } + + if (dir->hdr0) + dir->hdr = dir->hdr0; + else + dir->hdr = 0; +} + +#if ! USE_DIRENT +#define real_readdir(_X_) 1 +#else +static int +real_readdir(ZZIP_DIR * dir) +{ + struct stat st = { 0 }; + char filename[PATH_MAX]; + struct dirent *dirent = _zzip_readdir(dir->realdir); + + if (! dirent) + return 0; + + dir->dirent.d_name = dirent->d_name; + strcpy(filename, dir->realname); + strcat(filename, "/"); + strcat(filename, dirent->d_name); + + if (stat(filename, &st) == -1) + return -1; + + dir->dirent.d_csize = dir->dirent.st_size = st.st_size; + + if (st.st_mode) + { + if (! S_ISREG(st.st_mode)) + { + dir->dirent.d_compr = st.st_mode; + dir->dirent.d_compr |= 0x80000000; + /* makes it effectively negative, + * but can still be fed to S_ISXXX(x) */ + } else + { + dir->dirent.d_compr = 0; /* stored */ + } + } else + { + dir->dirent.d_compr = 0; /* stored */ + } + + return 1; +} +#endif + +/** + * This function is the equivalent of a => readdir(2) for a realdir + * or a zipfile referenced by the ZZIP_DIR returned from => zzip_opendir. + * + * The ZZIP_DIR handle (as returned by => zzip_opendir) contains a few more + * entries than being copied into the ZZIP_DIRENT. The only valid fields in + * a ZZIP_DIRENT are d_name (the file name), d_compr (compression), d_csize + * (compressed size), st_size (uncompressed size). + */ +ZZIP_DIRENT * +zzip_readdir(ZZIP_DIR * dir) +{ + if (! dir) + { errno=EBADF; return 0; } + + if (USE_DIRENT && dir->realdir) + { + if (! real_readdir(dir)) + return 0; + } else + { + if (! dir->hdr) + return 0; + + dir->dirent.d_name = dir->hdr->d_name; + dir->dirent.d_compr = dir->hdr->d_compr; + + dir->dirent.d_csize = dir->hdr->d_csize; + dir->dirent.st_size = dir->hdr->d_usize; + + if (! dir->hdr->d_reclen) + dir->hdr = 0; + else + dir->hdr = (struct zzip_dir_hdr *) + ((char *) dir->hdr + dir->hdr->d_reclen); + } + return &dir->dirent; +} + +/** => zzip_rewinddir + * This function is the equivalent of => telldir(2) for a realdir or zipfile. + */ +zzip_off_t +zzip_telldir(ZZIP_DIR * dir) +{ + if (! dir) + { errno=EBADF; return -1; } + + if (USE_DIRENT && dir->realdir) + { + return _zzip_telldir(dir->realdir); + } else + { + return ((zzip_off_t) ((char *) dir->hdr - (char *) dir->hdr0)); + } +} + +/** => zzip_rewinddir + * This function is the equivalent of => seekdir(2) for a realdir or zipfile. + */ +void +zzip_seekdir(ZZIP_DIR * dir, zzip_off_t offset) +{ + if (! dir) + return; + + if (USE_DIRENT && dir->realdir) + { + _zzip_seekdir(dir->realdir, offset); + } else + { + dir->hdr = (struct zzip_dir_hdr *) + (dir->hdr0 ? (char *) dir->hdr0 + (size_t) offset : 0); + } +} + +#ifndef EOVERFLOW +#define EOVERFLOW EFBIG +#endif + +/** => zzip_rewinddir + * This function is provided for users who can not use any largefile-mode. + */ +long +zzip_telldir32(ZZIP_DIR * dir) +{ + if (sizeof(zzip_off_t) == sizeof(long)) + { + return zzip_telldir(dir); + } else + { + off_t off = zzip_telldir(dir); + if (off >= 0) { + register long off32 = off; + if (off32 == off) return off32; + errno = EOVERFLOW; + } + return -1; + } +} + +/** => zzip_rewinddir + * This function is provided for users who can not use any largefile-mode. + */ +void +zzip_seekdir32(ZZIP_DIR * dir, long offset) +{ + zzip_seekdir(dir, offset); +} + +#if defined ZZIP_LARGEFILE_RENAME && defined EOVERFLOW && defined PIC +#undef zzip_seekdir /* zzip_seekdir64 */ +#undef zzip_telldir /* zzip_telldir64 */ + +/* DLL compatibility layer - so that 32bit code can link with a 64on32 too */ +long zzip_telldir(ZZIP_DIR * dir) { return zzip_telldir32(dir); } +void zzip_seekdir(ZZIP_DIR * dir, long offset) { zzip_seekdir32(dir, offset); } +#endif + +/** + * This function is the equivalent of => opendir(3) for a realdir or zipfile. + * + * This function has some magic - if the given argument-path + * is a directory, it will wrap a real => opendir(3) into the ZZIP_DIR + * structure. Otherwise it will divert to => zzip_dir_open which + * can also attach a ".zip" extension if needed to find the archive. + * + * the error-code is mapped to => errno(3). + */ +ZZIP_DIR * +zzip_opendir(zzip_char_t * filename) +{ + return zzip_opendir_ext_io(filename, 0, 0, 0); +} + +/** => zzip_opendir + * This function uses explicit ext and io instead of the internal + * defaults, setting them to zero is equivalent to => zzip_opendir + */ +ZZIP_DIR * +zzip_opendir_ext_io(zzip_char_t * filename, int o_modes, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + zzip_error_t e; + ZZIP_DIR *dir; + +# ifdef ZZIP_HAVE_SYS_STAT_H + struct stat st; +# endif + + if (o_modes & (ZZIP_PREFERZIP | ZZIP_ONLYZIP)) + goto try_zzip; + try_real: + +# ifdef ZZIP_HAVE_SYS_STAT_H + if (stat(filename, &st) >= 0 && S_ISDIR(st.st_mode)) + { + if (USE_DIRENT) + { + _zzip_DIR *realdir = _zzip_opendir(filename); + + if (realdir) + { + if (! (dir = (ZZIP_DIR *) calloc(1, sizeof(*dir)))) + { + _zzip_closedir(realdir); + return 0; + } else + { + dir->realdir = realdir; + dir->realname = strdup(filename); + return dir; + } + } + } + return 0; + } +# endif /* HAVE_SYS_STAT_H */ + + try_zzip: + dir = zzip_dir_open_ext_io(filename, &e, ext, io); + if (! dir && (o_modes & ZZIP_PREFERZIP)) + goto try_real; + if (e) + errno = zzip_errno(e); + return dir; +} + +/** + * This function is the equivalent of => closedir(3) for a realdir or zipfile. + * + * This function is magic - if the given arg-ZZIP_DIR + * is a real directory, it will call the real => closedir(3) and then + * free the wrapping ZZIP_DIR structure. Otherwise it will divert + * to => zzip_dir_close which will free the ZZIP_DIR structure. + */ +int +zzip_closedir(ZZIP_DIR * dir) +{ + if (! dir) + { errno = EBADF; return -1; } + + if (USE_DIRENT && dir->realdir) + { + _zzip_closedir(dir->realdir); + free(dir->realname); + free(dir); + return 0; + } else + { + zzip_dir_close(dir); + return 0; + } +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/err.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/err.c new file mode 100644 index 00000000000..1ba869bd9af --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/err.c @@ -0,0 +1,168 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <Tomi.Ollila@iki.fi> + * + * Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/lib.h> /* exported... */ +#include <zlib.h> + +#include <string.h> +#include <errno.h> + +#include <zzip/file.h> + +/* *INDENT-OFF* */ +static struct errlistentry { int code; const char* mesg; } +errlist[] = +{ + { ZZIP_NO_ERROR, "No error" }, + { ZZIP_OUTOFMEM, + "could not get temporary memory for internal structures" }, + { ZZIP_DIR_OPEN, "Failed to open zip-file %s" }, + { ZZIP_DIR_STAT, "Failed to fstat zip-file %s" }, + { ZZIP_DIR_SEEK, "Failed to lseek zip-file %s" }, + { ZZIP_DIR_READ, "Failed to read zip-file %s"}, + { ZZIP_DIR_TOO_SHORT, "zip-file %s too short" }, + { ZZIP_DIR_EDH_MISSING, "zip-file central directory not found" }, + { ZZIP_DIRSIZE, "Directory size too big..." }, + { ZZIP_ENOENT, "No such file found in zip-file %s" }, + { ZZIP_UNSUPP_COMPR, "Unsupported compression format" }, + { ZZIP_CORRUPTED, "Zipfile corrupted" }, + { ZZIP_UNDEF, "Some undefined error occurred" }, + { ZZIP_DIR_LARGEFILE, "Directory is largefile variant" }, + { 0, 0 }, +}; +/* *INDENT-ON* */ + + +#define errlistSIZE (sizeof(errlist)/sizeof(*errlist)) + +/** + * returns the static string for the given error code. The + * error code can be either a normal system error (a + * positive error code will flag this), it can be => libz + * error code (a small negative error code will flag this) + * or it can be an error code from => libzzip, which is an + * negative value lower than => ZZIP_ERROR + */ +zzip_char_t * +zzip_strerror(int errcode) +{ + if (errcode < ZZIP_ERROR && errcode > ZZIP_ERROR - 32) + { + struct errlistentry *err = errlist; + + for (; err->mesg; err++) + { + if (err->code == errcode) + return err->mesg; + } + errcode = EINVAL; + } + + if (errcode < 0) + { + if (errcode == -1) + return strerror(errcode); + else + return zError(errcode); + } + + return strerror(errcode); +} + +/** => zzip_strerror + * This function fetches the errorcode from the => DIR-handle and + * runs it through => zzip_strerror to obtain the static string + * describing the error. + */ +zzip_char_t * +zzip_strerror_of(ZZIP_DIR * dir) +{ + if (! dir) + return strerror(errno); + return zzip_strerror(dir->errcode); +} + +/* *INDENT-OFF* */ +static struct errnolistentry { int code; int e_no; } +errnolist[] = +{ + { Z_STREAM_ERROR, EPIPE }, + { Z_DATA_ERROR, ESPIPE }, + { Z_MEM_ERROR, ENOMEM }, + { Z_BUF_ERROR, EMFILE }, + { Z_VERSION_ERROR, ENOEXEC }, + + { ZZIP_DIR_OPEN, ENOTDIR }, + { ZZIP_DIR_STAT, EREMOTE }, + { ZZIP_DIR_SEEK, ESPIPE }, +# ifdef ESTRPIPE + { ZZIP_DIR_READ, ESTRPIPE}, +# else + { ZZIP_DIR_READ, EPIPE}, +# endif + { ZZIP_DIR_TOO_SHORT, ENOEXEC }, +# ifdef ENOMEDIUM + { ZZIP_DIR_EDH_MISSING, ENOMEDIUM }, +# else + { ZZIP_DIR_EDH_MISSING, EIO }, +# endif + { ZZIP_DIRSIZE, EFBIG }, + { ZZIP_OUTOFMEM, ENOMEM }, + { ZZIP_ENOENT, ENOENT }, +# ifdef EPFNOSUPPORT + { ZZIP_UNSUPP_COMPR, EPFNOSUPPORT }, +# else + { ZZIP_UNSUPP_COMPR, EACCES }, +# endif +# ifdef EILSEQ + { ZZIP_CORRUPTED, EILSEQ }, +# else + { ZZIP_CORRUPTED, ELOOP }, +# endif + { ZZIP_UNDEF, EINVAL }, + { 0, 0 }, +}; +/* *INDENT-ON* */ + +/** + * map the error code to a system error code. This is used + * for the drop-in replacement functions to return a value + * that can be interpreted correctly by code sections that + * are unaware of the fact they their => open(2) call had been + * diverted to a file inside a zip-archive. + */ +int +zzip_errno(int errcode) +{ + if (errcode >= -1) + { + return errno; + } else + { + struct errnolistentry *err = errnolist; + + for (; err->code; err++) + { + if (err->code == errcode) + return err->e_no; + } + return EINVAL; + } +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fetch.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fetch.c new file mode 100644 index 00000000000..bd1958483ff --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fetch.c @@ -0,0 +1,126 @@ + +/* + * These routines are helpers - note that this file gets linked into all the + * zip-access variants that refer to <zzip/format.h>. On the x86 platform the + * actual definitions will be empty - fetching is done on native machine-level + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2004,2005,2006 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/fetch.h> + +/* ------------------------- fetch helpers --------------------------------- */ + +/** + * Make 32 bit value in host byteorder from little-endian mapped octet-data + * (works also on machines which SIGBUS on misaligned data access (eg. 68000)) + */ +uint32_t +__zzip_get32(unsigned char *s) +{ +#if defined __ZZIP_GET32 + return __ZZIP_GET32(s); +#else + return ((uint32_t) s[3] << 24) | ((uint32_t) s[2] << 16) + | ((uint32_t) s[1] << 8) | ((uint32_t) s[0]); +#endif +} + +/** => __zzip_get32 + * This function does the same for a 16 bit value. + */ +uint16_t +__zzip_get16(unsigned char *s) +{ +#if defined __ZZIP_GET16 + return __ZZIP_GET16(s); +#else + return ((uint16_t) s[1] << 8) | ((uint16_t) s[0]); +#endif +} + +/** => __zzip_get32 + * This function does the same for an off64_t value. + */ +uint64_t +__zzip_get64(unsigned char *s) +{ +#ifdef __GNUC__ + /* *INDENT-OFF* */ + register uint64_t v + = s[7]; v <<= 8; + v |= s[6]; v <<= 8; + v |= s[5]; v <<= 8; + v |= s[4]; v <<= 8; + v |= s[3]; v <<= 8; + v |= s[2]; v <<= 8; + v |= s[1]; v <<= 8; + v |= s[0]; return v; + /* *INDENT-ON* */ +#else + return ((uint64_t) s[7] << 56) | ((uint64_t) s[6] << 48) + | ((uint64_t) s[5] << 40) | ((uint64_t) s[4] << 32) + | ((uint64_t) s[3] << 24) | ((uint64_t) s[2] << 16) + | ((uint64_t) s[1] << 8) | ((uint64_t) s[0]); +#endif +} + +/** => __zzip_get32 + * This function pushes a 32bit value at the specified address + */ +void +__zzip_set32(unsigned char *s, uint32_t v) +{ +#if defined __ZZIP_SET32 + return __ZZIP_SET32(s, v); +#else + /* *INDENT-OFF* */ + s[0] = (unsigned char) (v); v >>= 8; + s[1] = (unsigned char) (v); v >>= 8; + s[2] = (unsigned char) (v); v >>= 8; + s[3] = (unsigned char) (v); + /* *INDENT-ON* */ +#endif +} + +/** => __zzip_get32 + * This function does the same for a 16 bit value. + */ +void +__zzip_set16(unsigned char *s, uint16_t v) +{ +#if defined __ZZIP_SET16 + return __ZZIP_SET16(s, v); +#else + /* *INDENT-OFF* */ + s[0] = (unsigned char) (v); v >>= 8; + s[1] = (unsigned char) (v); + /* *INDENT-ON* */ +#endif +} + +/** => __zzip_get32 + * This function pushes a off64_t value at the specified address + */ +void +__zzip_set64(unsigned char *s, uint64_t v) +{ + /* *INDENT-OFF* */ + s[0] = (unsigned char) (v); v >>= 8; + s[1] = (unsigned char) (v); v >>= 8; + s[2] = (unsigned char) (v); v >>= 8; + s[3] = (unsigned char) (v); v >>= 8; + s[4] = (unsigned char) (v); v >>= 8; + s[5] = (unsigned char) (v); v >>= 8; + s[6] = (unsigned char) (v); v >>= 8; + s[7] = (unsigned char) (v); + /* *INDENT-ON* */ +} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fetch.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fetch.h new file mode 100644 index 00000000000..ca51a8026d9 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fetch.h @@ -0,0 +1,374 @@ +#ifndef _ZZIP_FORMATS_H +#define _ZZIP_FORMATS_H + +#include <zzip/types.h> +#include <zzip/format.h> +#include <zzip/stdint.h> +#include <zzip/__hints.h> + +/* linux knows "byteswap.h" giving us an optimized variant */ +#ifdef ZZIP_HAVE_BYTESWAP_H +#include <byteswap.h> +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* get 16/32 bits from little-endian zip-file to host byteorder */ +extern uint32_t __zzip_get32(zzip_byte_t * s) ZZIP_GNUC_CONST; +extern uint16_t __zzip_get16(zzip_byte_t * s) ZZIP_GNUC_CONST; +extern void __zzip_set32(zzip_byte_t * s, uint32_t v); +extern void __zzip_set16(zzip_byte_t * s, uint16_t v); + +extern uint64_t __zzip_get64(zzip_byte_t * s) ZZIP_GNUC_CONST; +extern void __zzip_set64(zzip_byte_t * s, uint64_t v); + +/* just in case that you use a non-configure-d setup (e.g. MSVC) */ +#ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED +# if defined __mips__ || defined __sparc__ || defined __powerpc__ || defined __arm__ || defined __ia64__ +# define ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED 11 +# endif +#endif + +/* on linux with a cisc processor we can use the bswap for some extra speed */ +#ifdef ZZIP_WORDS_BIGENDIAN +# ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED +# if defined bswap_16 && defined bswap_32 && defined bswap_64 /* i.e. linux */ +# define _ZZIP_USE_BSWAP +# endif +# endif +#endif + +/* little endian on intel cisc processors is the original zip format byteorder */ +#ifndef ZZIP_WORDS_BIGENDIAN +# ifndef ZZIP_HAVE_ALIGNED_ACCESS_REQUIRED +# if defined __i386__ || defined __x86_64__ || defined _M_X86 || defined _M_X64 +# define _ZZIP_USE_DEREF +# endif +#endif + +#ifdef _ZZIP_USE_BSWAP +#define ZZIP_GET16(__p) bswap_16(*(uint16_t*)(__p)) +#define ZZIP_GET32(__p) bswap_32(*(uint32_t*)(__p)) +#define ZZIP_GET64(__p) bswap_64(*(uint64_t*)(__p)) +#define ZZIP_SET16(__p,__x) (*(uint16_t*)(__p) = bswap_16((uint16_t)(__x))) +#define ZZIP_SET32(__p,__x) (*(uint32_t*)(__p) = bswap_32((uint32_t)(__x))) +#define ZZIP_SET64(__p,__x) (*(uint64_t*)(__p) = bswap_64((uint64_t)(__x))) +#elif defined _ZZIP_USE_DEREF +#define ZZIP_GET16(__p) (*(uint16_t*)(__p)) +#define ZZIP_GET32(__p) (*(uint32_t*)(__p)) +#define ZZIP_GET64(__p) (*(uint64_t*)(__p)) +#define ZZIP_SET16(__p,__x) (*(uint16_t*)(__p) = (uint16_t)(__x)) +#define ZZIP_SET32(__p,__x) (*(uint32_t*)(__p) = (uint32_t)(__x)) +#define ZZIP_SET64(__p,__x) (*(uint64_t*)(__p) = (uint64_t)(__x)) +#else +#define ZZIP_GET64(__p) (__zzip_get64((__p))) +#define ZZIP_GET32(__p) (__zzip_get32((__p))) +#define ZZIP_GET16(__p) (__zzip_get16((__p))) +#define ZZIP_SET64(__p,__x) (__zzip_set64((__p),(__x))) +#define ZZIP_SET32(__p,__x) (__zzip_set32((__p),(__x))) +#define ZZIP_SET16(__p,__x) (__zzip_set16((__p),(__x))) +#endif +#endif + +/* ..................... bitcorrect physical access .................... */ + +/* zzip_file_header - the local file header */ +#define zzip_file_header_get_magic(__p) ZZIP_GET32((__p)->z_magic) +#define zzip_file_header_set_magic(__p,__x) ZZIP_SET32((__p)->z_magic,(__x)) +#define zzip_file_header_get_flags(__p) ZZIP_GET16((__p)->z_flags) +#define zzip_file_header_set_flags(__p,__x) ZZIP_SET16((__p)->z_flags,(__x)) +#define zzip_file_header_get_compr(__p) ZZIP_GET16((__p)->z_compr) +#define zzip_file_header_set_compr(__p,__x) ZZIP_SET16((__p)->z_compr,(__x)) +#define zzip_file_header_get_crc32(__p) ZZIP_GET32((__p)->z_crc32) +#define zzip_file_header_set_crc32(__p,__x) ZZIP_SET32((__p)->z_crc32,(__x)) +#define zzip_file_header_get_csize(__p) ZZIP_GET32((__p)->z_csize) +#define zzip_file_header_set_csize(__p,__x) ZZIP_SET32((__p)->z_csize,(__x)) +#define zzip_file_header_get_usize(__p) ZZIP_GET32((__p)->z_usize) +#define zzip_file_header_set_usize(__p,__x) ZZIP_SET32((__p)->z_usize,(__x)) +#define zzip_file_header_get_namlen(__p) ZZIP_GET16((__p)->z_namlen) +#define zzip_file_header_set_namlen(__p,__x) ZZIP_SET16((__p)->z_namlen,(__x)) +#define zzip_file_header_get_extras(__p) ZZIP_GET16((__p)->z_extras) +#define zzip_file_header_set_extras(__p,__x) ZZIP_SET16((__p)->z_extras,(__x)) +#define zzip_file_header_sizeof_tails(__p) (zzip_file_header_get_namlen(__p)+\ + zzip_file_header_get_extras(__p) ) +#define zzip_file_header_check_magic(__p) ZZIP_FILE_HEADER_CHECKMAGIC((__p)) + +/* zzip_file_trailer - data descriptor per file block */ +#define zzip_file_trailer_get_magic(__p) ZZIP_GET32((__p)->z_magic) +#define zzip_file_trailer_set_magic(__p,__x) ZZIP_SET32((__p)->z_magic,(__x)) +#define zzip_file_header_get_crc32(__p) ZZIP_GET32((__p)->z_crc32) +#define zzip_file_trailer_set_crc32(__p,__x) ZZIP_SET32((__p)->z_crc32,(__x)) +#define zzip_file_trailer_get_csize(__p) ZZIP_GET32((__p)->z_csize) +#define zzip_file_trailer_set_csize(__p,__x) ZZIP_SET32((__p)->z_csize,(__x)) +#define zzip_file_trailer_get_usize(__p) ZZIP_GET32((__p)->z_usize) +#define zzip_file_trailer_set_usize(__p,__x) ZZIP_SET32((__p)->z_usize,(__x)) +#define zzip_file_trailer_sizeof_tails(__p) 0 +#define zzip_file_trailer_check_magic(__p) ZZIP_FILE_TRAILER_CHECKMAGIC((__p)) +/* zzip_disk_entry (currently named zzip_root_dirent) */ +#define zzip_disk_entry_get_magic(__p) ZZIP_GET32((__p)->z_magic) +#define zzip_disk_entry_set_magic(__p,__x) ZZIP_SET32((__p)->z_magic,(__x)) +#define zzip_disk_entry_get_flags(__p) ZZIP_GET16((__p)->z_flags) +#define zzip_disk_entry_set_flags(__p,__x) ZZIP_SET16((__p)->z_flags,(__x)) +#define zzip_disk_entry_get_compr(__p) ZZIP_GET16((__p)->z_compr) +#define zzip_disk_entry_set_compr(__p,__x) ZZIP_SET16((__p)->z_compr,(__x)) +#define zzip_disk_entry_get_crc32(__p) ZZIP_GET32((__p)->z_crc32) +#define zzip_disk_entry_set_crc32(__p,__x) ZZIP_SET32((__p)->z_crc32,(__x)) +#define zzip_disk_entry_get_csize(__p) ZZIP_GET32((__p)->z_csize) +#define zzip_disk_entry_set_csize(__p,__x) ZZIP_SET32((__p)->z_csize,(__x)) +#define zzip_disk_entry_get_usize(__p) ZZIP_GET32((__p)->z_usize) +#define zzip_disk_entry_set_usize(__p,__x) ZZIP_SET32((__p)->z_usize,(__x)) +#define zzip_disk_entry_get_namlen(__p) ZZIP_GET16((__p)->z_namlen) +#define zzip_disk_entry_set_namlen(__p,__x) ZZIP_SET16((__p)->z_namlen,(__x)) +#define zzip_disk_entry_get_extras(__p) ZZIP_GET16((__p)->z_extras) +#define zzip_disk_entry_set_extras(__p,__x) ZZIP_SET16((__p)->z_extras,(__x)) +#define zzip_disk_entry_get_comment(__p) ZZIP_GET16((__p)->z_comment) +#define zzip_disk_entry_set_comment(__p,__x) ZZIP_SET16((__p)->z_comment,(__x)) +#define zzip_disk_entry_get_diskstart(__p) ZZIP_GET16((__p)->z_diskstart) +#define zzip_disk_entry_set_diskstart(__p,__x) ZZIP_SET16((__p)->z_diskstart,(__x)) +#define zzip_disk_entry_get_filetype(__p) ZZIP_GET16((__p)->z_filetype) +#define zzip_disk_entry_set_filetype(__p,__x) ZZIP_SET16((__p)->z_filetype,(__x)) +#define zzip_disk_entry_get_filemode(__p) ZZIP_GET32((__p)->z_filemode) +#define zzip_disk_entry_set_filemode(__p,__x) ZZIP_SET32((__p)->z_filemode,(__x)) +#define zzip_disk_entry_get_offset(__p) ZZIP_GET32((__p)->z_offset) +#define zzip_disk_entry_set_offset(__p,__x) ZZIP_SET32((__p)->z_offset,(__x)) +#define zzip_disk_entry_sizeof_tails(__p) (zzip_disk_entry_get_namlen(__p) +\ + zzip_disk_entry_get_extras(__p) +\ + zzip_disk_entry_get_comment(__p) ) +#define zzip_disk_entry_check_magic(__p) ZZIP_DISK_ENTRY_CHECKMAGIC((__p)) + +/* zzip_disk_trailer - the zip archive entry point */ +#define zzip_disk_trailer_get_magic(__p) ZZIP_GET32((__p)->z_magic) +#define zzip_disk_trailer_set_magic(__p,__x) ZZIP_SET32((__p)->z_magic,(__x)) +#define zzip_disk_trailer_get_disk(__p) ZZIP_GET16((__p)->z_disk) +#define zzip_disk_trailer_set_disk(__p,__x) ZZIP_SET16((__p)->z_disk,(__x)) +#define zzip_disk_trailer_get_finaldisk(__p) ZZIP_GET16((__p)->z_finaldisk) +#define zzip_disk_trailer_set_finaldisk(__p,__x) ZZIP_SET16((__p)->z_finaldisk,(__x)) +#define zzip_disk_trailer_get_entries(__p) ZZIP_GET16((__p)->z_entries) +#define zzip_disk_trailer_set_entries(__p,__x) ZZIP_SET16((__p)->z_entries,(__x)) +#define zzip_disk_trailer_get_finalentries(__p) ZZIP_GET16((__p)->z_finalentries) +#define zzip_disk_trailer_set_finalentries(__p,__x) ZZIP_SET16((__p)->z_finalentries,(__x)) +#define zzip_disk_trailer_get_rootsize(__p) ZZIP_GET32((__p)->z_rootsize) +#define zzip_disk_trailer_set_rootsize(__p,__x) ZZIP_SET32((__p)->z_rootsize,(__x)) +#define zzip_disk_trailer_get_rootseek(__p) ZZIP_GET32((__p)->z_rootseek) +#define zzip_disk_trailer_set_rootseek(__p,__x) ZZIP_SET32((__p)->z_rootseek,(__x)) +#define zzip_disk_trailer_get_comment(__p) ZZIP_GET16((__p)->z_comment) +#define zzip_disk_trailer_set_comment(__p,__x) ZZIP_SET16((__p)->z_comment,(__x)) +#define zzip_disk_trailer_sizeof_tails(__p) ( zzip_disk_entry_get_comment(__p)) +#define zzip_disk_trailer_check_magic(__p) ZZIP_DISK_TRAILER_CHECKMAGIC((__p)) + +/* extra field should be type + size + data + type + size + data ... */ +#define zzip_extra_block_get_datatype(__p) ZZIP_GET16((zzip_byte_t*)(__p)) +#define zzip_extra_block_set_datatype(__p,__x) ZZIP_SET16((zzip_byte_t*)(__p),__x) +#define zzip_extra_block_get_datasize(__p) ZZIP_GET16((zzip_byte_t*)(__p)+2) +#define zzip_extra_block_set_datasize(__p,__x) ZZIP_SET16((zzip_byte_t*)(__p)+2,__x) + +/* zzip64_disk_trailer - the zip64 archive entry point */ +#define zzip_disk64_trailer_get_magic(__p) ZZIP_GET32((__p)->z_magic) +#define zzip_disk64_trailer_set_magic(__p,__x) ZZIP_SET32((__p)->z_magic,(__x)) +#define zzip_disk64_trailer_get_size(__p) ZZIP_GET64((__p)->z_size) +#define zzip_disk64_trailer_set_size(__p,__x) ZZIP_SET64((__p)->z_size,(__x)) +#define zzip_disk64_trailer_get_disk(__p) ZZIP_GET32((__p)->z_disk) +#define zzip_disk64_trailer_set_disk(__p,__x) ZZIP_SET32((__p)->z_disk,(__x)) +#define zzip_disk64_trailer_get_finaldisk(__p) ZZIP_GET32((__p)->z_finaldisk) +#define zzip_disk64_trailer_set_finaldisk(__p,__x) ZZIP_SET32((__p)->z_finaldisk,(__x)) +#define zzip_disk64_trailer_get_entries(__p) ZZIP_GET64((__p)->z_entries) +#define zzip_disk64_trailer_set_entries(__p,__x) ZZIP_SET64((__p)->z_entries,(__x)) +#define zzip_disk64_trailer_get_finalentries(__p) ZZIP_GET64((__p)->z_finalentries) +#define zzip_disk64_trailer_set_finalentries(__p,__x) ZZIP_SET64((__p)->z_finalentries,(__x)) +#define zzip_disk64_trailer_get_rootsize(__p) ZZIP_GET64((__p)->z_rootsize) +#define zzip_disk64_trailer_set_rootsize(__p,__x) ZZIP_SET64((__p)->z_rootsize,(__x)) +#define zzip_disk64_trailer_get_rootseek(__p) ZZIP_GET64((__p)->z_rootseek) +#define zzip_disk64_trailer_set_rootseek(__p,__x) ZZIP_SET64((__p)->z_rootseek,(__x)) +#define zzip_disk64_trailer_check_magic(__p) ZZIP_DISK64_TRAILER_CHECKMAGIC((__p)) + +/* .............. some logical typed access wrappers ....................... */ + +/* zzip_file_header - the local file header */ +#define zzip_file_header_csize(__p) ((zzip_size_t) \ + zzip_file_header_get_csize(__p)) +#define zzip_file_header_usize(__p) ((zzip_size_t) \ + zzip_file_header_get_usize(__p)) +#define zzip_file_header_namlen(__p) ((zzip_size_t) \ + zzip_file_header_get_namlen(__p)) +#define zzip_file_header_extras(__p) ((zzip_size_t) \ + zzip_file_header_get_extras(__p)) +#define zzip_file_header_sizeof_tail(__p) ((zzip_size_t) \ + zzip_file_header_sizeof_tails(__p)) +#define zzip_file_header_sizeto_end(__p) ((zzip_size_t) \ + (zzip_file_header_sizeof_tail(__p) + zzip_file_header_headerlength)) +#define zzip_file_header_skipto_end(__p) ((void*) (__p) + \ + (zzip_file_header_sizeof_tail(__p) + zzip_file_header_headerlength)) + +#define zzip_file_header_to_filename(__p) ((char*) \ + ((char*)(__p) + zzip_file_header_headerlength)) +#define zzip_file_header_to_extras(__p) ((char*) \ + (zzip_file_header_to_filename(__p) + zzip_file_header_namlen(__p))) +#define zzip_file_header_to_data(__p) ((zzip_byte_t*) \ + (zzip_file_header_to_extras(__p) + zzip_file_header_extras(__p))) +#define zzip_file_header_to_trailer(__p) ((struct zzip_file_trailer*) \ + (zzip_file_header_to_data(__p) + zzip_file_header_csize(__p))) + +/* zzip_file_trailer - data descriptor per file block */ +#define zzip_file_trailer_csize(__p) ((zzip_size_t) \ + zzip_file_trailer_get_csize(__p)) +#define zzip_file_trailer_usize(__p) ((zzip_size_t) \ + zzip_file_trailer_get_usize(__p)) +#define zzip_file_trailer_sizeof_tail(__p) ((zzip_size_t) \ + zzip_file_trailer_sizeof_tails(__p)) +#define zzip_file_trailer_sizeto_end(__p) ((zzip_size_t) \ + (zzip_file_trailer_sizeof_tail(__p) + zzip_file_trailer_headerlength)) +#define zzip_file_trailer_skipto_end(__p) ((void*) (__p) + \ + (zzip_file_trailer_sizeof_tail(__p) + zzip_file_trailer_headerlength)) + +/* zzip_disk_entry (currently named zzip_root_dirent) */ +#define zzip_disk_entry_csize(__p) ((zzip_size_t) \ + zzip_disk_entry_get_csize(__p)) +#define zzip_disk_entry_usize(__p) ((zzip_size_t) \ + zzip_disk_entry_get_usize(__p)) +#define zzip_disk_entry_namlen(__p) ((zzip_size_t) \ + zzip_disk_entry_get_namlen(__p)) +#define zzip_disk_entry_extras(__p) ((zzip_size_t) \ + zzip_disk_entry_get_extras(__p)) +#define zzip_disk_entry_comment(__p) ((zzip_size_t) \ + zzip_disk_entry_get_comment(__p)) +#define zzip_disk_entry_diskstart(__p) ((int) \ + zzip_disk_entry_get_diskstart(__p)) +#define zzip_disk_entry_filetype(__p) ((int) \ + zzip_disk_entry_get_filetype(__p)) +#define zzip_disk_entry_filemode(__p) ((int) \ + zzip_disk_entry_get_filemode(__p)) +#define zzip_disk_entry_fileoffset(__p) ((zzip_off_t) \ + zzip_disk_entry_get_offset(__p)) +#define zzip_disk_entry_sizeof_tail(__p) ((zzip_size_t) \ + zzip_disk_entry_sizeof_tails(__p)) +#define zzip_disk_entry_sizeto_end(__p) ((zzip_size_t) \ + (zzip_disk_entry_sizeof_tail(__p) + zzip_disk_entry_headerlength)) +#define zzip_disk_entry_skipto_end(__p) ((zzip_byte_t*) (__p) + \ + (zzip_disk_entry_sizeof_tail(__p) + zzip_disk_entry_headerlength)) + +#define zzip_disk_entry_to_filename(__p) ((char*) \ + ((char*)(__p) + zzip_disk_entry_headerlength)) +#define zzip_disk_entry_to_extras(__p) ((char*) \ + (zzip_disk_entry_to_filename(__p) + zzip_disk_entry_namlen(__p))) +#define zzip_disk_entry_to_comment(__p) ((char*) \ + (zzip_disk_entry_to_extras(__p) + zzip_disk_entry_extras(__p))) +#define zzip_disk_entry_to_next_entry(__p) ((struct zzip_disk_entry*) \ + (zzip_disk_entry_to_comment(__p) + zzip_disk_entry_comment(__p))) + +/* zzip_disk_trailer - the zip archive entry point */ +#define zzip_disk_trailer_localdisk(__p) ((int) \ + zzip_disk_trailer_get_disk(__p)) +#define zzip_disk_trailer_finaldisk(__p) ((int) \ + zzip_disk_trailer_get_finaldisk(__p)) +#define zzip_disk_trailer_localentries(__p) ((int) \ + zzip_disk_trailer_get_entries(__p)) +#define zzip_disk_trailer_finalentries(__p) ((int) \ + zzip_disk_trailer_get_finalentries(__p)) +#define zzip_disk_trailer_rootsize(__p) ((zzip_off_t) \ + zzip_disk_trailer_get_rootsize(__p)) +#define zzip_disk_trailer_rootseek(__p) ((zzip_off_t) \ + zzip_disk_trailer_get_rootseek(__p)) +#define zzip_disk_trailer_comment(__p) ((zzip_size_t) \ + zzip_disk_trailer_get_comment(__p)) +#define zzip_disk_trailer_sizeof_tail(__p) ((zzip_size_t) \ + zzip_disk_trailer_sizeof_tails(__p)) +#define zzip_disk_trailer_sizeto_end(__p) ((zzip_size_t) \ + (zzip_disk_trailer_sizeof_tail(__p) + zzip_disk_trailer_headerlength)) +#define zzip_disk_trailer_skipto_end(__p) ((void*) (__p) \ + (zzip_disk_trailer_sizeof_tail(__p) + zzip_disk_trailer_headerlength)) + +#define zzip_disk_trailer_to_comment(__p) ((char*) \ + ((char*)(__p) + zzip_disk_trailer_headerlength)) +#define zzip_disk_trailer_to_endoffile(__p) ((void*) \ + (zzip_disk_trailer_to_comment(__p) + zzip_disk_trailer_comment(__p))) + +/* zzip_disk64_trailer - the zip archive entry point */ +#define zzip_disk64_trailer_localdisk(__p) ((int) \ + zzip_disk64_trailer_get_disk(__p)) +#define zzip_disk64_trailer_finaldisk(__p) ((int) \ + zzip_disk64_trailer_get_finaldisk(__p)) +#define zzip_disk64_trailer_localentries(__p) ((int) \ + zzip_disk64_trailer_get_entries(__p)) +#define zzip_disk64_trailer_finalentries(__p) ((int) \ + zzip_disk64_trailer_get_finalentries(__p)) +#define zzip_disk64_trailer_rootsize(__p) ((zzip_off64_t) \ + zzip_disk64_trailer_get_rootsize(__p)) +#define zzip_disk64_trailer_rootseek(__p) ((zzip_off64_t) \ + zzip_disk64_trailer_get_rootseek(__p)) +#define zzip_disk64_trailer_sizeof_tail(__p) ((zzip_size_t) \ + zzip_disk64_trailer_get_size(__p) - zzip_disk64_trailer_headerlength) +#define zzip_disk64_trailer_sizeto_end(__p) ((zzip_size_t) \ + zzip_disk64_trailer_get_size(__p)) +#define zzip_disk64_trailer_skipto_end(__p) ((void*) \ + ((char*)(__p) + zzip_disk64_sizeto_end(__p))) + +/* extra field should be type + size + data + type + size + data ... */ +#define zzip_extra_block_sizeof_tail(__p) ((zzip_size_t) \ + (zzip_extra_block_get_datasize(__p))) +#define zzip_extra_block_sizeto_end(__p) ((zzip_size_t) \ + (zzip_extra_block_sizeof_tail(__p) + zzip_extra_block_headerlength)) +#define zzip_extra_block_skipto_end(__p) ((void*) (__p) \ + (zzip_extra_block_sizeof_tail(__p) + zzip_extra_block_headerlength)) + +/* ................... and put these to the next level ................ */ + +#define zzip_file_header_data_encrypted(__p) \ + ZZIP_IS_ENCRYPTED( zzip_file_header_get_flags(__p) ) +#define zzip_file_header_data_comprlevel(__p) \ + ZZIP_IS_COMPRLEVEL( zzip_file_header_get_flags(__p) ) +#define zzip_file_header_data_streamed(__p) \ + ZZIP_IS_STREAMED( zzip_file_header_get_flags(__p) ) +#define zzip_file_header_data_stored(__p) \ + ( ZZIP_IS_STORED == zzip_file_header_get_compr(__p) ) +#define zzip_file_header_data_deflated(__p) \ + ( ZZIP_IS_DEFLATED == zzip_file_header_get_compr(__p) ) + +#define zzip_disk_entry_data_encrypted(__p) \ + ZZIP_IS_ENCRYPTED( zzip_disk_entry_get_flags(__p) ) +#define zzip_disk_entry_data_comprlevel(__p) \ + ZZIP_IS_COMPRLEVEL( zzip_disk_entry_get_flags(__p) ) +#define zzip_disk_entry_data_streamed(__p) \ + ZZIP_IS_STREAMED( zzip_disk_entry_get_flags(__p) ) +#define zzip_disk_entry_data_stored(__p) \ + ( ZZIP_IS_STORED == zzip_disk_entry_get_compr(__p) ) +#define zzip_disk_entry_data_deflated(__p) \ + ( ZZIP_IS_DEFLATED == zzip_disk_entry_get_compr(__p) ) +#define zzip_disk_entry_data_ascii(__p) \ + ( zzip_disk_entry_get_filetype(__p) & 1) + +#define zzip_file_header_data_not_deflated(__p) \ + (zzip_file_header_data_stored(__p)) +#define zzip_file_header_data_std_deflated(__p) \ + (zzip_file_header_data_deflated(__p) && \ + zzip_file_header_data_comprlevel(__p) == ZZIP_DEFLATED_STD_COMPR) +#define zzip_file_header_data_max_deflated(__p) \ + (zzip_file_header_data_deflated(__p) && \ + zzip_file_header_data_comprlevel(__p) == ZZIP_DEFLATED_MAX_COMPR) +#define zzip_file_header_data_low_deflated(__p) \ + (zzip_file_header_data_deflated(__p) && \ + zzip_file_header_data_comprlevel(__p) == ZZIP_DEFLATED_LOW_COMPR) +#define zzip_file_header_data_min_deflated(__p) \ + (zzip_file_header_data_deflated(__p) && \ + zzip_file_header_data_comprlevel(__p) == ZZIP_DEFLATED_MIN_COMPR) + +#define zzip_disk_entry_data_not_deflated(__p) \ + (zzip_disk_entry_data_stored(__p)) +#define zzip_disk_entry_data_std_deflated(__p) \ + (zzip_disk_entry_data_deflated(__p) && \ + zzip_disk_entry_data_comprlevel(__p) == ZZIP_DEFLATED_STD_COMPR) +#define zzip_disk_entry_data_max_deflated(__p) \ + (zzip_disk_entry_data_deflated(__p) && \ + zzip_disk_entry_data_comprlevel(__p) == ZZIP_DEFLATED_MAX_COMPR) +#define zzip_disk_entry_data_low_deflated(__p) \ + (zzip_disk_entry_data_deflated(__p) && \ + zzip_disk_entry_data_comprlevel(__p) == ZZIP_DEFLATED_LOW_COMPR) +#define zzip_disk_entry_data_min_deflated(__p) \ + (zzip_disk_entry_data_deflated(__p) && \ + zzip_disk_entry_data_comprlevel(__p) == ZZIP_DEFLATED_MIN_COMPR) + +#ifdef __cplusplus +} +#endif +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/file.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/file.c new file mode 100644 index 00000000000..37d72ed1427 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/file.c @@ -0,0 +1,1177 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <Tomi.Ollila@iki.fi> + * + * Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/lib.h> /* exported... */ +#include <zzip/file.h> + +#include <string.h> +#include <sys/stat.h> +#include <errno.h> +#include <stdlib.h> +#include <ctype.h> + +#include <zzip/format.h> +#include <zzip/fetch.h> +#include <zzip/__debug.h> + +#if 0 +# if defined ZZIP_HAVE_IO_H +# include <io.h> /* tell */ +# else +# define tell(fd) lseek(fd,0,SEEK_CUR) +# endif +#else +#define tells(fd) seeks(fd,0,SEEK_CUR) +#endif + +/** + * the direct function of => zzip_close(fp). it will cleanup the + * inflate-portion of => zlib and free the structure given. + * + * it is called quite from the error-cleanup parts + * of the various => _open functions. + * + * the .refcount is decreased and if zero the fp->dir is closed just as well. + */ +int +zzip_file_close(ZZIP_FILE * fp) +{ + auto int self; + ZZIP_DIR *dir = fp->dir; + + if (fp->method) + inflateEnd(&fp->d_stream); /* inflateEnd() can be called many times */ + + if (dir->cache.locked == NULL) + dir->cache.locked = &self; + + if (fp->buf32k) + { + if (dir->cache.locked == &self && dir->cache.buf32k == NULL) + dir->cache.buf32k = fp->buf32k; + else + free(fp->buf32k); + } + + if (dir->currentfp == fp) + dir->currentfp = NULL; + + dir->refcount--; + /* ease to notice possible dangling reference errors */ + memset(fp, 0, sizeof(*fp)); + + if (dir->cache.locked == &self && dir->cache.fp == NULL) + dir->cache.fp = fp; + else + free(fp); + + if (dir->cache.locked == &self) + dir->cache.locked = NULL; + + if (! dir->refcount) + return zzip_dir_close(dir); + else + return 0; +} + + +static int +zzip_file_saveoffset(ZZIP_FILE * fp) +{ + if (fp) + { + int fd = fp->dir->fd; + zzip_off_t off = fp->io->fd.seeks(fd, 0, SEEK_CUR); + + if (off < 0) + return -1; + + fp->offset = off; + } + return 0; +} + + +/* user-definition */ +#ifndef ZZIP_BACKSLASH_DIRSEP +#if defined HAVE_WINDOWS_H || defined ZZIP_HAVE_WINDOWS_H || defined _WIN32 +#define ZZIP_BACKSLASH_DIRSEP 1 +#elif defined ZZIP_CHECK_BACKSLASH_DIRSEPARATOR +#define ZZIP_BACKSLASH_DIRSEP 1 +#else +#define ZZIP_BACKSLASH_DIRSEP 0 +#endif +#endif + +static zzip_char_t* +strrchr_basename(zzip_char_t* name) +{ + register zzip_char_t *n = strrchr(name, '/'); + if (n) return n + 1; + return name; +} + +static zzip_char_t* +dirsep_basename(zzip_char_t* name) +{ + register zzip_char_t *n = strrchr(name, '/'); + + if (ZZIP_BACKSLASH_DIRSEP) + { + register zzip_char_t *m = strrchr(name, '\\'); + if (!n || (m && n < m)) + n = m; + } + + if (n) return n + 1; + return name; +} + +#if defined strcasecmp +#define dirsep_strcasecmp strcasecmp +#else +static int +dirsep_strcasecmp(zzip_char_t * s1, zzip_char_t * s2) +{ + /* ASCII tolower - including mapping of backslash in normal slash */ + static const char mapping[] = "@abcdefghijklmnopqrstuvwxyz[/]^_"; + int c1, c2; + + while (*s1 && *s2) + { + c1 = (int) (unsigned char) *s1; + c2 = (int) (unsigned char) *s2; + if ((c1 & 0xE0) == 0x40) + c1 = mapping[c1 & 0x1f]; + if ((c2 & 0xE0) == 0x40) + c2 = mapping[c2 & 0x1f]; + if (c1 != c2) + return (c1 - c2); + s1++; + s2++; + } + + return (((int) (unsigned char) *s1) - ((int) (unsigned char) *s2)); +} +#endif + +static int zzip_inflate_init(ZZIP_FILE *, struct zzip_dir_hdr *); + +/** + * open an => ZZIP_FILE from an already open => ZZIP_DIR handle. Since + * we have a chance to reuse a cached => buf32k and => ZZIP_FILE memchunk + * this is the best choice to unpack multiple files. + * + * Note: the zlib supports 2..15 bit windowsize, hence we provide a 32k + * memchunk here... just to be safe. + * + * On error it returns null and sets errcode in the ZZIP_DIR. + */ +ZZIP_FILE * +zzip_file_open(ZZIP_DIR * dir, zzip_char_t * name, int o_mode) +{ + auto int self; + zzip_error_t err = 0; + struct zzip_file *fp = 0; + struct zzip_dir_hdr *hdr = dir->hdr0; + int (*filename_strcmp) (zzip_char_t *, zzip_char_t *); + zzip_char_t* (*filename_basename)(zzip_char_t*); + + filename_strcmp = (o_mode & ZZIP_CASELESS) ? dirsep_strcasecmp : strcmp; + filename_basename = (o_mode & ZZIP_CASELESS) ? dirsep_basename : strrchr_basename; + + if (! dir) + return NULL; + if (! dir->fd || dir->fd == -1) + { dir->errcode = EBADF; return NULL; } + if (! hdr) + { dir->errcode = ENOENT; return NULL; } + + if (o_mode & ZZIP_NOPATHS) + name = filename_basename(name); + + while (1) + { + register zzip_char_t *hdr_name = hdr->d_name; + + if (o_mode & ZZIP_NOPATHS) + hdr_name = filename_basename(hdr_name); + + HINT4("name='%s', compr=%d, size=%d\n", + hdr->d_name, hdr->d_compr, hdr->d_usize); + + if (! filename_strcmp(hdr_name, name)) + { + switch (hdr->d_compr) + { + case 0: /* store */ + case 8: /* inflate */ + break; + default: + { err = ZZIP_UNSUPP_COMPR; goto error; } + } + + if (dir->cache.locked == NULL) + dir->cache.locked = &self; + + if (dir->cache.locked == &self && dir->cache.fp) + { + fp = dir->cache.fp; + dir->cache.fp = NULL; + /* memset(zfp, 0, sizeof *fp); cleared in zzip_file_close() */ + } else + { + if (! (fp = (ZZIP_FILE *) calloc(1, sizeof(*fp)))) + { err = ZZIP_OUTOFMEM; goto error; } + } + + fp->dir = dir; + fp->io = dir->io; + dir->refcount++; + + if (dir->cache.locked == &self && dir->cache.buf32k) + { + fp->buf32k = dir->cache.buf32k; + dir->cache.buf32k = NULL; + } else + { + if (! (fp->buf32k = (char *) malloc(ZZIP_32K))) + { err = ZZIP_OUTOFMEM; goto error; } + } + + if (dir->cache.locked == &self) + dir->cache.locked = NULL; + /* + * In order to support simultaneous open files in one zip archive + * we'll fix the fd offset when opening new file/changing which + * file to read... + */ + + if (zzip_file_saveoffset(dir->currentfp) < 0) + { err = ZZIP_DIR_SEEK; goto error; } + + fp->offset = hdr->d_off; + dir->currentfp = fp; + + if (dir->io->fd.seeks(dir->fd, hdr->d_off, SEEK_SET) < 0) + { err = ZZIP_DIR_SEEK; goto error; } + + { + /* skip local header - should test tons of other info, + * but trust that those are correct */ + zzip_ssize_t dataoff; + struct zzip_file_header *p = (void *) fp->buf32k; + + dataoff = dir->io->fd.read(dir->fd, (void *) p, sizeof(*p)); + if (dataoff < (zzip_ssize_t) sizeof(*p)) + { err = ZZIP_DIR_READ; goto error; } + if (! zzip_file_header_check_magic(p)) /* PK\3\4 */ + { err = ZZIP_CORRUPTED; goto error; } + + dataoff = zzip_file_header_sizeof_tail(p); + + if (dir->io->fd.seeks(dir->fd, dataoff, SEEK_CUR) < 0) + { err = ZZIP_DIR_SEEK; goto error; } + + fp->dataoffset = dir->io->fd.tells(dir->fd); + fp->usize = hdr->d_usize; + fp->csize = hdr->d_csize; + } + + err = zzip_inflate_init(fp, hdr); + if (err) + goto error; + + return fp; + } else + { + if (hdr->d_reclen == 0) + break; + hdr = (struct zzip_dir_hdr *) ((char *) hdr + hdr->d_reclen); + } /*filename_strcmp */ + } /*forever */ + dir->errcode = ZZIP_ENOENT; + return NULL; + error: + if (fp) + zzip_file_close(fp); + dir->errcode = err; + return NULL; +} + +/** + * call => inflateInit and setup fp's iterator variables, + * used by lowlevel => _open functions. + */ +static int +zzip_inflate_init(ZZIP_FILE * fp, struct zzip_dir_hdr *hdr) +{ + int err; + + fp->method = hdr->d_compr; + fp->restlen = hdr->d_usize; + + if (fp->method) + { + memset(&fp->d_stream, 0, sizeof(fp->d_stream)); + + err = inflateInit2(&fp->d_stream, -MAX_WBITS); + if (err != Z_OK) + goto error; + + fp->crestlen = hdr->d_csize; + } + return 0; + error: + if (fp) + zzip_file_close(fp); + return err; +} + +/** + * This function closes the given ZZIP_FILE handle. + * + * If the ZZIP_FILE wraps a normal stat'fd then it is just that int'fd + * that is being closed and the otherwise empty ZZIP_FILE gets freed. + */ +int +zzip_fclose(ZZIP_FILE * fp) +{ + if (! fp) + return 0; + if (! fp->dir) /* stat fd */ + { int r = fp->io->fd.close(fp->fd); free(fp); return r; } + else + return zzip_file_close(fp); +} + +/** => zzip_fclose + */ +int +zzip_close(ZZIP_FILE * fp) +{ + return zzip_fclose(fp); +} + +/** + * This functions read data from zip-contained file. + * + * It works like => read(2) and will fill the given buffer with bytes from + * the opened file. It will return the number of bytes read, so if the => EOF + * is encountered you will be prompted with the number of bytes actually read. + * + * This is the routines that needs the => buf32k buffer, and it would have + * need for much more polishing but it does already work quite well. + * + * Note: the 32K buffer is rather big. The original inflate-algorithm + * required just that but the latest zlib would work just fine with + * a smaller buffer. + */ +zzip_ssize_t +zzip_file_read(ZZIP_FILE * fp, void *buf, zzip_size_t len) +{ + ZZIP_DIR *dir; + zzip_size_t l; + zzip_ssize_t rv; + + if (! fp || ! fp->dir) + return 0; + + dir = fp->dir; + l = fp->restlen > len ? len : fp->restlen; + if (fp->restlen == 0) + return 0; + + /* + * If this is other handle than previous, save current seek pointer + * and read the file position of `this' handle. + */ + if (dir->currentfp != fp) + { + if (zzip_file_saveoffset(dir->currentfp) < 0 + || fp->io->fd.seeks(dir->fd, fp->offset, SEEK_SET) < 0) + { dir->errcode = ZZIP_DIR_SEEK; return -1; } + else + { dir->currentfp = fp; } + } + + /* if more methods is to be supported, change this to `switch ()' */ + if (fp->method) /* method != 0 == 8, inflate */ + { + fp->d_stream.avail_out = l; + fp->d_stream.next_out = (unsigned char *) buf; + + do + { + int err; + zzip_size_t startlen; + + if (fp->crestlen > 0 && fp->d_stream.avail_in == 0) + { + zzip_size_t cl = (fp->crestlen < ZZIP_32K ? + fp->crestlen : ZZIP_32K); + /* zzip_size_t cl = + * fp->crestlen > 128 ? 128 : fp->crestlen; + */ + zzip_ssize_t i = fp->io->fd.read(dir->fd, fp->buf32k, cl); + + if (i <= 0) + { + dir->errcode = ZZIP_DIR_READ; + /* or ZZIP_DIR_READ_EOF ? */ + return -1; + } + fp->crestlen -= i; + fp->d_stream.avail_in = i; + fp->d_stream.next_in = (unsigned char *) fp->buf32k; + } + + startlen = fp->d_stream.total_out; + err = inflate(&fp->d_stream, Z_NO_FLUSH); + + if (err == Z_STREAM_END) + { fp->restlen = 0; } + else if (err == Z_OK) + { fp->restlen -= (fp->d_stream.total_out - startlen); } + else + { dir->errcode = err; return -1; } + } + while (fp->restlen && fp->d_stream.avail_out); + + return l - fp->d_stream.avail_out; + } else + { /* method == 0 -- unstore */ + rv = fp->io->fd.read(dir->fd, buf, l); + if (rv > 0) + { fp->restlen-= rv; } + else if (rv < 0) + { dir->errcode = ZZIP_DIR_READ; } + return rv; + } +} + +/** + * This function will read(2) data from a real/zipped file. + * + * the replacement for => read(2) will fill the given buffer with bytes from + * the opened file. It will return the number of bytes read, so if the EOF + * is encountered you will be prompted with the number of bytes actually read. + * + * If the file-handle is wrapping a stat'able file then it will actually just + * perform a normal => read(2)-call, otherwise => zzip_file_read is called + * to decompress the data stream and any error is mapped to => errno(3). + */ +zzip_ssize_t +zzip_read(ZZIP_FILE * fp, void *buf, zzip_size_t len) +{ + if (! fp) + return 0; + if (! fp->dir) + { return fp->io->fd.read(fp->fd, buf, len); } /* stat fd */ + else + { + register zzip_ssize_t v; + + v = zzip_file_read(fp, buf, len); + if (v == -1) + { errno = zzip_errno(fp->dir->errcode); } + return v; + } +} + +/** => zzip_read + */ +zzip_size_t +zzip_fread(void *ptr, zzip_size_t size, zzip_size_t nmemb, ZZIP_FILE * file) +{ + if (! size) + size = 1; + return zzip_read(file, ptr, size * nmemb) / size; +} + + +#define ZZIP_WRONLY O_WRONLY +#define ZZIP_EXCL O_EXCL + +#if defined O_SYNC +#define ZZIP_SYNC O_SYNC +#else +#define ZZIP_SYNC 0 +#endif + +#if defined O_NONBLOCK +#define ZZIP_NONBLOCK O_NONBLOCK +#elif defined O_NDELAY +#define ZZIP_NOCTTY O_NDELAY +#else +#define ZZIP_NOCTTY 0 +#endif + +/* ------------------------------------------------------------------- */ + +/** also: fopen(2) + * This function will => fopen(3) a real/zipped file. + * + * It has some magic functionality builtin - it will first try to open + * the given <em>filename</em> as a normal file. If it does not + * exist, the given path to the filename (if any) is split into + * its directory-part and the file-part. A ".zip" extension is + * then added to the directory-part to create the name of a + * zip-archive. That zip-archive (if it exists) is being searched + * for the file-part, and if found a zzip-handle is returned. + * + * Note that if the file is found in the normal fs-directory the + * returned structure is mostly empty and the => zzip_read call will + * use the libc => read(2) to obtain data. Otherwise a => zzip_file_open + * is performed and any error mapped to => errno(3). + * + * unlike the posix-wrapper => zzip_open the mode-argument is + * a string which allows for more freedom to support the extra + * zzip modes called ZZIP_CASEINSENSITIVE and ZZIP_IGNOREPATH. + * Currently, this => zzip_fopen call will convert the following + * characters in the mode-string into their corrsponding mode-bits: + * * <code> "r" : O_RDONLY : </code> read-only + * * <code> "b" : O_BINARY : </code> binary (win32 specific) + * * <code> "f" : O_NOCTTY : </code> no char device (unix) + * * <code> "i" : ZZIP_CASELESS : </code> inside zip file + * * <code> "*" : ZZIP_NOPATHS : </code> inside zip file only + * all other modes will be ignored for zip-contained entries + * but they are transferred for compatibility and portability, + * including these extra sugar bits: + * * <code> "x" : O_EXCL :</code> fail if file did exist + * * <code> "s" : O_SYNC :</code> synchronized access + * * <code> "n" : O_NONBLOCK :</code> nonblocking access + * * <code> "z#" : compression level :</code> for zlib + * * <code> "g#" : group access :</code> unix access bits + * * <code> "u#" : owner access :</code> unix access bits + * * <code> "o#" : world access :</code> unix access bits + * ... the access bits are in traditional unix bit format + * with 7 = read/write/execute, 6 = read/write, 4 = read-only. + * + * The default access mode is 0664, and the compression level + * is ignored since the lib can not yet write zip files, otherwise + * it would be the initialisation value for the zlib deflateInit + * where 0 = no-compression, 1 = best-speed, 9 = best-compression. + * + * This function returns a new zzip-handle (use => zzip_close to return + * it). On error this function will return null setting => errno(3). + */ +ZZIP_FILE * +zzip_fopen(zzip_char_t * filename, zzip_char_t * mode) +{ + return zzip_freopen(filename, mode, 0); +} + +/** => zzip_fopen + * + * This function receives an additional argument pointing to + * a ZZIP_FILE* being already in use. If this extra argument is + * null then this function is identical with calling => zzip_fopen + * + * Per default, the old file stream is closed and only the internal + * structures associated with it are kept. These internal structures + * may be reused for the return value, and this is a lot quicker when + * the filename matches a zipped file that is incidently in the very + * same zip arch as the old filename wrapped in the stream struct. + * + * That's simply because the zip arch's central directory does not + * need to be read again. As an extension for this function, if the + * mode-string contains a "q" then the old stream is not closed but + * left untouched, instead it is only given as a hint that a new + * file handle may share/copy the zip arch structures of the old file + * handle if that is possible, i.e when they are in the same zip arch. + * + * This function returns a new zzip-handle (use => zzip_close to return + * it). On error this function will return null setting => errno(3). + */ +ZZIP_FILE * +zzip_freopen(zzip_char_t * filename, zzip_char_t * mode, ZZIP_FILE * stream) +{ + int o_flags = 0; + int o_modes = 0664; + + if (! mode) + mode = "rb"; + +# ifndef O_BINARY +# define O_BINARY 0 +# endif +# ifndef O_NOCTTY +# define O_NOCTTY 0 +# endif +# ifndef O_SYNC +# define O_SYNC 0 +# endif +# ifndef O_NONBLOCK +# define O_NONBLOCK 0 +# endif + + for (; *mode; mode++) + { + switch (*mode) + { + /* *INDENT-OFF* */ + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + continue; /* ignore if not attached to other info */ + case 'r': o_flags |= mode[1] == '+' ? O_RDWR : O_RDONLY; break; + case 'w': o_flags |= mode[1] == '+' ? O_RDWR : O_WRONLY; + o_flags |= O_TRUNC; break; + case 'b': o_flags |= O_BINARY; break; + case 'f': o_flags |= O_NOCTTY; break; + case 'i': o_modes |= ZZIP_CASELESS; break; + case '*': o_modes |= ZZIP_NOPATHS; break; + case 'x': o_flags |= O_EXCL; break; + case 's': o_flags |= O_SYNC; break; + case 'n': o_flags |= O_NONBLOCK; break; + case 'o': o_modes &=~ 07; + o_modes |= ((mode[1] - '0')) & 07; continue; + case 'g': o_modes &=~ 070; + o_modes |= ((mode[1] - '0') << 3) & 070; continue; + case 'u': o_modes &=~ 0700; + o_modes |= ((mode[1] - '0') << 6) & 0700; continue; + case 'q': o_modes |= ZZIP_FACTORY; break; + case 'z': /* compression level */ + continue; /* currently ignored, just for write mode */ + /* *INDENT-ON* */ + } + } + + { + ZZIP_FILE *fp = + zzip_open_shared_io(stream, filename, o_flags, o_modes, 0, 0); + + if (! (o_modes & ZZIP_FACTORY) && stream) + zzip_file_close(stream); + + return fp; + } +} + +/** + * This function will => open(2) a real/zipped file + * + * It has some magic functionality builtin - it will first try to open + * the given <em>filename</em> as a normal file. If it does not + * exist, the given path to the filename (if any) is split into + * its directory-part and the file-part. A ".zip" extension is + * then added to the directory-part to create the name of a + * zip-archive. That zip-archive (if it exists) is being searched + * for the file-part, and if found a zzip-handle is returned. + * + * Note that if the file is found in the normal fs-directory the + * returned structure is mostly empty and the => zzip_read call will + * use the libc => read(2) to obtain data. Otherwise a => zzip_file_open + * is performed and any error mapped to => errno(3). + * + * There was a possibility to transfer zziplib-specific openmodes + * through o_flags but you should please not use them anymore and + * look into => zzip_open_ext_io to submit them down. This function + * is shallow in that it just extracts the zzipflags and calls + * * <code>zzip_open_ext_io(filename, o_flags, zzipflags|0664, 0, 0) </code> + * you must stop using this extra functionality (not well known anyway) + * since zzip_open might be later usable to open files for writing + * in which case the _EXTRAFLAGS will get in conflict. + * + * compare with => open(2) and => zzip_fopen + */ +ZZIP_FILE * +zzip_open(zzip_char_t * filename, int o_flags) +{ + /* backward compatibility */ + int o_modes = 0664; + + if (o_flags & ZZIP_CASEINSENSITIVE) + { o_flags ^= ZZIP_CASEINSENSITIVE; o_modes |= ZZIP_CASELESS; } + if (o_flags & ZZIP_IGNOREPATH) + { o_flags ^= ZZIP_IGNOREPATH; o_modes |= ZZIP_NOPATHS; } + return zzip_open_ext_io(filename, o_flags, o_modes, 0, 0); +} + +/* ZZIP_ONLYZIP won't work on platforms with sizeof(int) == 16bit */ +#if ZZIP_SIZEOF_INT+0 == 2 +#undef ZZIP_ONLYZIP +#endif + +/** => zzip_open + * + * This function uses explicit ext and io instead of the internal + * defaults, setting them to zero is equivalent to => zzip_open + * + * note that the two flag types have been split into an o_flags + * (for fcntl-like openflags) and o_modes where the latter shall + * carry the zzip_flags and possibly accessmodes for unix filesystems. + * Since this version of zziplib can not write zipfiles, it is not + * yet used for anything else than zzip-specific modeflags. + * + * This function returns a new zzip-handle (use => zzip_close to return + * it). On error this function will return null setting => errno(3). + */ +ZZIP_FILE * +zzip_open_ext_io(zzip_char_t * filename, int o_flags, int o_modes, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + return zzip_open_shared_io(0, filename, o_flags, o_modes, ext, io); +} + +/** => zzip_open + * + * This function takes an extra stream argument - if a handle has been + * then ext/io can be left null and the new stream handle will pick up + * the ext/io. This should be used only in specific environment however + * since => zzip_file_real does not store any ext-sequence. + * + * The benefit for this function comes in when the old file handle + * was openened from a file within a zip archive. When the new file + * is in the same zip archive then the internal zzip_dir structures + * will be shared. It is even quicker, as no check needs to be done + * anymore trying to guess the zip archive place in the filesystem, + * here we just check whether the zip archive's filepath is a prefix + * part of the filename to be opened. + * + * Note that this function is also used by => zzip_freopen that + * will unshare the old handle, thereby possibly closing the handle. + * + * This function returns a new zzip-handle (use => zzip_close to return + * it). On error this function will return null setting => errno(3). + */ +ZZIP_FILE * +zzip_open_shared_io(ZZIP_FILE * stream, + zzip_char_t * filename, int o_flags, int o_modes, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + if (stream && stream->dir) + { + if (! ext) + ext = stream->dir->fileext; + if (! io) + io = stream->dir->io; + } + if (! io) + io = zzip_get_default_io(); + + if (o_modes & (ZZIP_PREFERZIP | ZZIP_ONLYZIP)) + goto try_zzip; + try_real: + /* prefer an existing real file */ + { + zzip_plugin_io_t os = (o_modes & ZZIP_ALLOWREAL) + ? zzip_get_default_io() : io; + int fd = os->fd.open(filename, o_flags); /* io->fd.open */ + + if (fd != -1) + { + ZZIP_FILE *fp = calloc(1, sizeof(ZZIP_FILE)); + + if (! fp) + { os->fd.close(fd); return 0; } /* io->fd.close */ + + fp->fd = fd; + fp->io = os; + return fp; + } + if (o_modes & ZZIP_PREFERZIP) + return 0; + } + try_zzip: + + /* if the user had it in place of a normal xopen, then + * we better defend this lib against illegal usage */ + if (o_flags & (O_CREAT | O_WRONLY)) + { errno = EINVAL; return 0; } + if (o_flags & (O_RDWR)) + { o_flags ^= O_RDWR; o_flags |= O_RDONLY; } + + /* this is just for backward compatibility -and strictly needed to + * prepare ourselves for more options and more options later on... */ + /*# if (o_modes & ZZIP_CASELESS) { o_flags |= ZZIP_CASEINSENSITIVE; } */ + /*# if (o_modes & ZZIP_NOPATHS) { o_flags |= ZZIP_IGNOREPATH; } */ + + /* see if we can open a file that is a zip file */ + { + char basename[PATH_MAX]; + char *p; + int filename_len = strlen(filename); + + if (filename_len >= PATH_MAX) + { errno = ENAMETOOLONG; return 0; } + memcpy(basename, filename, filename_len + 1); + + /* see if we can share the same zip directory */ + if (stream && stream->dir && stream->dir->realname) + { + zzip_size_t len = strlen(stream->dir->realname); + + if (! memcmp(filename, stream->dir->realname, len) && + filename[len] == '/' && filename[len + 1]) + { + ZZIP_FILE *fp = + zzip_file_open(stream->dir, filename + len + 1, o_modes); + if (! fp) + { errno = zzip_errno (stream->dir->errcode); } + return fp; + } + } + + /* per each slash in filename, check if it there is a zzip around */ + while ((p = strrchr(basename, '/'))) + { + zzip_error_t e = 0; + ZZIP_DIR *dir; + ZZIP_FILE *fp; + int fd; + + *p = '\0'; + /* i.e. cut at path separator == possible zipfile basename */ + fd = __zzip_try_open(basename, o_flags | O_RDONLY | O_BINARY, + ext, io); + if (fd == -1) + { continue; } + + /* found zip-file .... now try to parse it */ + dir = zzip_dir_fdopen_ext_io(fd, &e, ext, io); + if (e) + { errno = zzip_errno(e); io->fd.close(fd); return 0; } + + /* (p - basename) is the lenghtof zzip_dir part of the filename */ + fp = zzip_file_open(dir, filename + (p - basename) + 1, o_modes); + if (! fp) + { errno = zzip_errno(dir->errcode); } + else + { if (! dir->realname) dir->realname = strdup (basename); } + + zzip_dir_close(dir); + /* note: since (fp) is attached that (dir) will survive */ + /* but (dir) is implicitly closed on next zzip_close(fp) */ + + return fp; + } + + if (o_modes & ZZIP_PREFERZIP) + goto try_real; + else + { errno = ENOENT; return 0; } + } +} + +#if defined ZZIP_LARGEFILE_RENAME && defined EOVERFLOW && defined PIC +#undef zzip_open_shared_io /* zzip_open_shared_io64 */ +#undef zzip_open_ext_io /* zzip_open_ext_io64 */ +#undef zzip_opendir_ext_io /* zzip_opendir_ext_io64 */ + +ZZIP_FILE *zzip_open_shared_io(ZZIP_FILE * stream, + zzip_char_t * name, int o_flags, + int o_modes, zzip_strings_t * ext, + zzip_plugin_io_t io); +ZZIP_FILE *zzip_open_ext_io(zzip_char_t * name, int o_flags, + int o_modes, zzip_strings_t * ext, + zzip_plugin_io_t io); +ZZIP_DIR *zzip_opendir_ext_io(zzip_char_t * name, int o_modes, + zzip_strings_t * ext, zzip_plugin_io_t io); + +/* DLL compatibility layer - so that 32bit code can link with this lib too */ + +ZZIP_FILE * +zzip_open_shared_io(ZZIP_FILE * stream, + zzip_char_t * name, int o_flags, + int o_modes, zzip_strings_t * ext, zzip_plugin_io_t io) +{ + if (! io) + return zzip_open_shared_io64(stream, name, o_flags, o_modes, ext, io); + errno = EOVERFLOW; + return NULL; +} + +ZZIP_FILE * +zzip_open_ext_io(zzip_char_t * name, int o_flags, int o_modes, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + if (! io) + return zzip_open_ext_io64(name, o_flags, o_modes, ext, io); + errno = EOVERFLOW; + return NULL; +} + +ZZIP_DIR * +zzip_opendir_ext_io(zzip_char_t * name, int o_modes, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + if (! io) + return zzip_opendir_ext_io64(name, o_modes, ext, io); + else + { errno = EOVERFLOW; return NULL; } +} + +#endif /* ZZIP_LARGEFILE_RENAME && EOVERFLOW && PIC */ + +/* ------------------------------------------------------------------- */ + +/** + * This function will rewind a real/zipped file. + * + * It seeks to the beginning of this file's data in the zip, + * or the beginning of the file for a stat'fd. + */ +int +zzip_rewind(ZZIP_FILE * fp) +{ + ZZIP_DIR *dir; + int err; + + if (! fp) + return -1; + + if (! fp->dir) + { /* stat fd */ + fp->io->fd.seeks(fp->fd, 0, SEEK_SET); + return 0; + } + + dir = fp->dir; + /* + * If this is other handle than previous, save current seek pointer + */ + if (dir->currentfp != fp) + { + if (zzip_file_saveoffset(dir->currentfp) < 0) + { dir->errcode = ZZIP_DIR_SEEK; return -1; } + else + { dir->currentfp = fp; } + } + + /* seek to beginning of this file */ + if (fp->io->fd.seeks(dir->fd, fp->dataoffset, SEEK_SET) < 0) + return -1; + + /* reset the inflate init stuff */ + fp->restlen = fp->usize; + fp->offset = fp->dataoffset; + + if (fp->method) + { /* method == 8, deflate */ + err = inflateReset(&fp->d_stream); + if (err != Z_OK) + goto error; + + /* start over at next inflate with a fresh read() */ + fp->d_stream.avail_in = 0; + fp->crestlen = fp->csize; + } + + return 0; + + error: + if (fp) + zzip_file_close(fp); + return err; +} + +/** + * This function will perform a => lseek(2) operation on a real/zipped file + * + * It will try to seek to the offset specified by offset, relative to whence, + * which is one of SEEK_SET, SEEK_CUR or SEEK_END. + * + * If the file-handle is wrapping a stat'able file then it will actually just + * perform a normal => lseek(2)-call. Otherwise the relative offset + * is calculated, negative offsets are transformed into positive ones + * by rewinding the file, and then data is read until the offset is + * reached. This can make the function terribly slow, but this is + * how gzio implements it, so I'm not sure there is a better way + * without using the internals of the algorithm. + */ +zzip_off_t +zzip_seek(ZZIP_FILE * fp, zzip_off_t offset, int whence) +{ + zzip_off_t cur_pos, rel_ofs, read_size, ofs; + ZZIP_DIR *dir; + + if (! fp) + return -1; + + if (! fp->dir) + { /* stat fd */ + return fp->io->fd.seeks(fp->fd, offset, whence); + } + + cur_pos = zzip_tell(fp); + + /* calculate relative offset */ + switch (whence) + { + case SEEK_SET: /* from beginning */ + rel_ofs = offset - cur_pos; + break; + case SEEK_CUR: /* from current */ + rel_ofs = offset; + break; + case SEEK_END: /* from end */ + rel_ofs = fp->usize + offset - cur_pos; + break; + default: /* something wrong */ + return -1; + } + + if (rel_ofs == 0) + return cur_pos; /* don't have to move */ + + if (rel_ofs < 0) + { /* convert backward into forward */ + if (zzip_rewind(fp) == -1) + return -1; + + read_size = cur_pos + rel_ofs; + cur_pos = 0; + } else + { /* amount to read is positive relative offset */ + read_size = rel_ofs; + } + + if (read_size < 0) /* bad offset, before beginning of file */ + return -1; + + if (read_size + cur_pos > (zzip_off_t) fp->usize) /* bad offset, past EOF */ + return -1; + + if (read_size == 0) /* nothing to read */ + return cur_pos; + + dir = fp->dir; + /* + * If this is other handle than previous, save current seek pointer + * and read the file position of `this' handle. + */ + if (dir->currentfp != fp) + { + if (zzip_file_saveoffset(dir->currentfp) < 0 + || fp->io->fd.seeks(dir->fd, fp->offset, SEEK_SET) < 0) + { dir->errcode = ZZIP_DIR_SEEK; return -1; } + else + { dir->currentfp = fp; } + } + + if (fp->method == 0) + { /* unstore, just lseek relatively */ + ofs = fp->io->fd.tells(dir->fd); + ofs = fp->io->fd.seeks(dir->fd, read_size, SEEK_CUR); + if (ofs > 0) + { /* readjust from beginning of file */ + ofs -= fp->dataoffset; + fp->restlen = fp->usize - ofs; + } + return ofs; + } else + { /* method == 8, inflate */ + char *buf; + + /*FIXME: use a static buffer! */ + buf = (char *) malloc(ZZIP_32K); + if (! buf) + return -1; + + while (read_size > 0) + { + zzip_off_t size = ZZIP_32K; + + if (read_size < size /*32K */ ) + size = read_size; + + size = zzip_file_read(fp, buf, (zzip_size_t) size); + if (size <= 0) + { free(buf); return -1; } + + read_size -= size; + } + + free(buf); + } + + return zzip_tell(fp); +} + +/** + * This function will => tell(2) the current position in a real/zipped file + * + * It will return the current offset within the real/zipped file, + * measured in uncompressed bytes for the zipped-file case. + * + * If the file-handle is wrapping a stat'able file then it will actually just + * perform a normal => tell(2)-call, otherwise the offset is + * calculated from the amount of data left and the total uncompressed + * size; + */ +zzip_off_t +zzip_tell(ZZIP_FILE * fp) +{ + if (! fp) + return -1; + + if (! fp->dir) /* stat fd */ + return fp->io->fd.tells(fp->fd); + + /* current uncompressed offset is uncompressed size - data left */ + return (fp->usize - fp->restlen); +} + +#ifndef EOVERFLOW +#define EOVERFLOW EFBIG +#endif + +/** => zzip_tell + * This function is provided for users who can not use any largefile-mode. + */ +long +zzip_tell32(ZZIP_FILE * fp) +{ + if (sizeof(zzip_off_t) == sizeof(long)) + { + return zzip_tell(fp); + } else + { + off_t off = zzip_tell(fp); + if (off >= 0) { + register long off32 = off; + if (off32 == off) return off32; + errno = EOVERFLOW; + } + return -1; + } +} + +/** => zzip_seek + * This function is provided for users who can not use any largefile-mode. + */ +long +zzip_seek32(ZZIP_FILE * fp, long offset, int whence) +{ + if (sizeof(zzip_off_t) == sizeof(long)) + { + return zzip_seek(fp, offset, whence); + } else + { + off_t off = zzip_seek(fp, offset, whence); + if (off >= 0) { + register long off32 = off; + if (off32 == off) return off32; + errno = EOVERFLOW; + } + return -1; + } +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/file.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/file.h new file mode 100644 index 00000000000..fcff276bb23 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/file.h @@ -0,0 +1,81 @@ +/* + * this is an internal header file - the structure contains two off_t + * atleast making it LARGEFILE_SENSITIVE on linux2 and solaris systems + * whereas about all functions just return a ZZIP_FILE* in zzip/zzip.h + * + * and so, this structure should be handled version-specific and + * subject to change - it had been kept binary-compatible for quite + * a while now so perhaps some program sources have errnously taken + * advantage of this file. + * + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <Tomi.Ollila@tfi.net> + * + * Copyright (c) 1999,2000,2001,2002 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#ifndef _ZZIP_FILE_H /* zzip-file.h */ +#define _ZZIP_FILE_H 1 + +#ifndef ZZIP_32K +#ifdef __GNUC__ +/* include zzip/lib.h beforehand in order to suppress the following warning */ +#warning zzip/file.h is an internal header, do not use it freely +#endif +#endif + +#include <zzip/lib.h> +#include <zlib.h> + +#ifdef ZZIP_HAVE_UNISTD_H +#include <unistd.h> +#else +#include <stdio.h> +# ifdef ZZIP_HAVE_SYS_TYPES_H +# include <sys/types.h> +# endif +#endif + +#ifdef ZZIP_HAVE_SYS_PARAM_H +#include <sys/param.h> /* PATH_MAX */ +#endif + +#ifndef PATH_MAX +# ifdef MAX_PATH /* windows */ +# define PATH_MAX MAX_PATH +# else +# define PATH_MAX 512 +# endif +#endif +/* + * ZZIP_FILE structure... currently no need to unionize, since structure needed + * for inflate is superset of structure needed for unstore. + * + * Don't make this public. Instead, create methods for needed operations. + */ + +struct zzip_file +{ + struct zzip_dir* dir; + int fd; + int method; + zzip_size_t restlen; + zzip_size_t crestlen; + zzip_size_t usize; + zzip_size_t csize; + /* added dataoffset member - data offset from start of zipfile*/ + zzip_off_t dataoffset; + char* buf32k; + zzip_off_t offset; /* offset from the start of zipfile... */ + z_stream d_stream; + zzip_plugin_io_t io; +}; + +#endif /* _ZZIP_FILE_H */ + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/format.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/format.h new file mode 100644 index 00000000000..0881479c167 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/format.h @@ -0,0 +1,234 @@ +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2000,2001,2002,2003 Guido Draheim + * All rights reserved + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * The information was taken from appnote-981119-iz.zip + * at http://www.freesoftware.com/pub/infozip/doc/ + * which in turn is based on PKWARE's appnote.txt + * (newer link: ftp://ftp.info-zip.org/pub/infozip/doc/) + */ +#ifndef _ZZIP_FORMAT_H /* zzipformat.h */ +#define _ZZIP_FORMAT_H + +#include <zzip/types.h> +#include <zzip/__hints.h> +/* we have ICO C 9X types defined */ + +/* + * Overall zipfile format + * [local file header + file data stream + checksum descriptor] ... + * ... [disk central directory] [disk trailer record] + */ + +# ifdef _MSC_VER +# pragma pack(push, 1) +# endif + +struct zzip_version +{ + zzip_byte_t version[1]; + zzip_byte_t ostype[1]; +} ZZIP_GNUC_PACKED; + +struct zzip_dostime +{ + zzip_byte_t time[2]; + zzip_byte_t date[2]; +} ZZIP_GNUC_PACKED; + +#ifdef ZZIP_NEED_PACKED +/* if your compiler does interesting things about struct packing... */ +typedef zzip_byte_t zzip_version_t[2]; +typedef zzip_byte_t zzip_dostime_t[4]; +#else +typedef struct zzip_version zzip_version_t; +typedef struct zzip_dostime zzip_dostime_t; +#endif + +#define ZZIP_CHECKMAGIC(__p,__A,__B,__C,__D) \ + ( (((zzip_byte_t*)(__p))[0]==(__A)) && \ + (((zzip_byte_t*)(__p))[1]==(__B)) && \ + (((zzip_byte_t*)(__p))[2]==(__C)) && \ + (((zzip_byte_t*)(__p))[3]==(__D)) ) + +/* A. Local file header */ +struct zzip_file_header +{ +# define ZZIP_FILE_HEADER_MAGIC 0x04034b50 +# define ZZIP_FILE_HEADER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\3','\4') + zzip_byte_t z_magic[4]; /* local file header signature (0x04034b50) */ + zzip_version_t z_extract; /* version needed to extract */ + zzip_byte_t z_flags[2]; /* general purpose bit flag */ + zzip_byte_t z_compr[2]; /* compression method */ + zzip_dostime_t z_dostime; /* last mod file time (dos format) */ + zzip_byte_t z_crc32[4]; /* crc-32 */ + zzip_byte_t z_csize[4]; /* compressed size */ + zzip_byte_t z_usize[4]; /* uncompressed size */ + zzip_byte_t z_namlen[2]; /* filename length (null if stdin) */ + zzip_byte_t z_extras[2]; /* extra field length */ + /* followed by filename (of variable size) */ + /* followed by extra field (of variable size) */ +} ZZIP_GNUC_PACKED; +#define zzip_file_header_headerlength (4+2+2+2+4+4+4+4+2+2) + +/* B. data descriptor + * the data descriptor exists only if bit 3 of z_flags is set. It is byte aligned + * and immediately follows the last byte of compressed data. It is only used if + * the output media of the compressor was not seekable, eg. standard output. + */ +struct zzip_file_trailer +{ +# define ZZIP_FILE_TRAILER_MAGIC 0x08074B50 +# define ZZIP_FILE_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\7','\8') + zzip_byte_t z_magic[4]; /* data descriptor signature (0x08074b50) */ + zzip_byte_t z_crc32[4]; /* crc-32 */ + zzip_byte_t z_csize[4]; /* compressed size */ + zzip_byte_t z_usize[4]; /* uncompressed size */ +} ZZIP_GNUC_PACKED; +#define zzip_file_trailer_headerlength (4+4+4+4) + +/* C. central directory structure: + [file header] . . . end of central dir record +*/ + +/* directory file header + * - a single entry including filename, extras and comment may not exceed 64k. + */ + +struct zzip_disk_entry +{ +# define ZZIP_DISK_ENTRY_MAGIC 0x02014b50 +# define ZZIP_DISK_ENTRY_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\1','\2') + zzip_byte_t z_magic[4]; /* central file header signature (0x02014b50) */ + zzip_version_t z_encoder; /* version made by */ + zzip_version_t z_extract; /* version need to extract */ + zzip_byte_t z_flags[2]; /* general purpose bit flag */ + zzip_byte_t z_compr[2]; /* compression method */ + zzip_dostime_t z_dostime; /* last mod file time&date (dos format) */ + zzip_byte_t z_crc32[4]; /* crc-32 */ + zzip_byte_t z_csize[4]; /* compressed size */ + zzip_byte_t z_usize[4]; /* uncompressed size */ + zzip_byte_t z_namlen[2]; /* filename length (null if stdin) */ + zzip_byte_t z_extras[2]; /* extra field length */ + zzip_byte_t z_comment[2]; /* file comment length */ + zzip_byte_t z_diskstart[2]; /* disk number of start (if spanning zip over multiple disks) */ + zzip_byte_t z_filetype[2]; /* internal file attributes, bit0 = ascii */ + zzip_byte_t z_filemode[4]; /* extrnal file attributes, eg. msdos attrib byte */ + zzip_byte_t z_offset[4]; /* relative offset of local file header, seekval if singledisk */ + /* followed by filename (of variable size) */ + /* followed by extra field (of variable size) */ + /* followed by file comment (of variable size) */ +} ZZIP_GNUC_PACKED; +#define zzip_disk_entry_headerlength (4+2+2+2+2+4+4+4+4+2+2+2+2+2+4+4) + + +struct zzip_root_dirent +{ /* the old name of the structure above */ +# define ZZIP_ROOT_DIRENT_MAGIC 0x02014b50 +# define ZZIP_ROOT_DIRENT_CHECKMAGIC(__p) ZZIP_DISK_ENTRY_CHECKMAGIC(__p) + zzip_byte_t z_magic[4]; + zzip_version_t z_encoder; + zzip_version_t z_extract; + zzip_byte_t z_flags[2]; + zzip_byte_t z_compr[2]; + zzip_dostime_t z_dostime; + zzip_byte_t z_crc32[4]; + zzip_byte_t z_csize[4]; + zzip_byte_t z_usize[4]; + zzip_byte_t z_namlen[2]; + zzip_byte_t z_extras[2]; + zzip_byte_t z_comment[2]; + zzip_byte_t z_diskstart[2]; + zzip_byte_t z_filetype[2]; + zzip_byte_t z_filemode[4]; + zzip_byte_t z_off[4]; +} ZZIP_GNUC_PACKED; + + +/* end of central dir record */ +struct zzip_disk_trailer +{ +# define ZZIP_DISK_TRAILER_MAGIC 0x06054b50 +# define ZZIP_DISK_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\5','\6') + zzip_byte_t z_magic[4]; /* end of central dir signature (0x06054b50) */ + zzip_byte_t z_disk[2]; /* number of this disk */ + zzip_byte_t z_finaldisk[2]; /* number of the disk with the start of the central dir */ + zzip_byte_t z_entries[2]; /* total number of entries in the central dir on this disk */ + zzip_byte_t z_finalentries[2]; /* total number of entries in the central dir */ + zzip_byte_t z_rootsize[4]; /* size of the central directory */ + zzip_byte_t z_rootseek[4]; /* offset of start of central directory with respect to * + * the starting disk number */ + zzip_byte_t z_comment[2]; /* zipfile comment length */ + /* followed by zipfile comment (of variable size) */ +} ZZIP_GNUC_PACKED; +#define zzip_disk_trailer_headerlength (4+2+2+2+2+4+4+2) + +/* extra field should be type + size + data + type + size + data ... */ +struct zzip_extra_block +{ /* fetch.h macros do not need this struct */ + zzip_byte_t z_datatype[2]; /* as input type - a mere <char*> is okay */ + zzip_byte_t z_datasize[2]; /* being returned by xx_to_extras usually */ +} ZZIP_GNUC_PACKED; +#define zzip_extra_block_headerlength (2+2) + +/* Zip64 end of central dir record */ +struct zzip_disk64_trailer +{ +# define ZZIP_DISK64_TRAILER_MAGIC 0x06064b50 +# define ZZIP_DISK64_TRAILER_CHECKMAGIC(__p) ZZIP_CHECKMAGIC(__p,'P','K','\6','\6') + zzip_byte_t z_magic[4]; /* end of central dir signature (0x06054b50) */ + zzip_byte_t z_size[8]; /* size of this central directory record */ + zzip_version_t z_encoder; /* version made by */ + zzip_version_t z_extract; /* version need to extract */ + zzip_byte_t z_disk[4]; /* number of this disk */ + zzip_byte_t z_finaldisk[4]; /* number of the disk with the start of the central dir */ + zzip_byte_t z_entries[8]; /* total number of entries in the central dir on this disk */ + zzip_byte_t z_finalentries[8]; /* total number of entries in the central dir */ + zzip_byte_t z_rootsize[8]; /* size of the central directory */ + zzip_byte_t z_rootseek[8]; /* offset of start of central directory with respect to * + * the starting disk number */ + /* followed by zip64 extensible data sector (of variable size) */ +} ZZIP_GNUC_PACKED; +#define zzip_disk64_trailer_headerlength (4+8+2+2+4+4+8+8+8+8) + +/* z_flags */ +#define ZZIP_IS_ENCRYPTED(p) ((*(zzip_byte_t*)p)&1) +#define ZZIP_IS_COMPRLEVEL(p) (((*(zzip_byte_t*)p)>>1)&3) +#define ZZIP_IS_STREAMED(p) (((*(zzip_byte_t*)p)>>3)&1) +#define ZZIP_IS_PATCHED(p) (((*(zzip_byte_t*)p)>>5)&1) + +/* z_compr */ +#define ZZIP_IS_STORED 0 +#define ZZIP_IS_SHRUNK 1 +#define ZZIP_IS_REDUCEDx1 2 +#define ZZIP_IS_REDUCEDx2 3 +#define ZZIP_IS_REDUCEDx3 4 +#define ZZIP_IS_REDUCEDx4 5 +#define ZZIP_IS_IMPLODED 6 +#define ZZIP_IS_TOKENIZED 7 +#define ZZIP_IS_DEFLATED 8 +#define ZZIP_IS_DEFLATED_BETTER 9 +#define ZZIP_IS_IMPLODED_BETTER 10 + +/* deflated comprlevel */ +#define ZZIP_DEFLATED_STD_COMPR 0 +#define ZZIP_DEFLATED_MAX_COMPR 1 +#define ZZIP_DEFLATED_LOW_COMPR 2 +#define ZZIP_DEFLATED_MIN_COMPR 3 + +# ifdef _MSC_VER +# pragma pack(pop) +# endif + +#endif /* _ZZIPFORMAT_H */ + + + + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fseeko.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fseeko.c new file mode 100644 index 00000000000..d99067a0b4f --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fseeko.c @@ -0,0 +1,685 @@ + +/* + * NOTE: this is part of libzzipfseeko (i.e. it is not libzzip). + * ================== + * + * These routines are fully independent from the traditional zzip + * implementation. They assume a readonly seekable stdio handle + * 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 + * the way to access a zip file. The complexity of zip access comes + * from staggered reading of bytes and reposition of a filepointer in + * a big archive with lots of files and long compressed datastreams. + * Plus varaints of drop-in stdio replacements, obfuscation routines, + * auto fileextensions, drop-in dirent replacements, and so on... + * + * btw, we can _not_ use fgetpos/fsetpos since an fpos_t has no asserted + * relation to a linear seek value as specified in zip info headers. In + * general it is not a problem if your system has no fseeko/ftello pair + * since we can fallback to fseek/ftell which limits the zip disk size + * to 2MiBs but the zip-storable seek values are 32bit limited anyway. + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2003,2004 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#define _LARGEFILE_SOURCE 1 +#define _ZZIP_ENTRY_STRUCT 1 + +#include <zzip/fseeko.h> + +#include <zzip/fetch.h> +#include <zzip/__mmap.h> +#include <zzip/__fnmatch.h> + +#include <assert.h> +#include <stdlib.h> +#include <sys/stat.h> + +#if defined ZZIP_HAVE_STRING_H +#include <string.h> +#elif defined ZZIP_HAVE_STRINGS_H +#include <strings.h> +#endif + +#if defined ZZIP_HAVE_STDINT_H +#include <stdint.h> +#endif + +#if __STDC_VERSION__+0 > 199900L +#define ___ +#define ____ +#else +#define ___ { +#define ____ } +#endif + +#ifndef ZZIP_HAVE_FSEEKO +#define fseeko fseek +#define ftello ftell +#endif + +/* note that the struct zzip_entry inherits the zzip_disk_entry values + * and usually carries a copy of its values (in disk format!). To make the + * following code more readable, we use a shorthand notation for the + * upcast needed in C (not needed in C++) as "disk_(entry)". + */ +#ifdef __zzip_entry_extends_zzip_disk_entry +#define disk_(_entry_) _entry_ +#else +#define disk_(_entry_) (& (_entry_)->head) +#endif + +/* we try to round all seeks to the pagesize - since we do not use + * the sys/mmap interface we have to guess a good value here: */ +#define PAGESIZE 8192 + +/* ====================================================================== */ + +/* helper functions */ + +/** => zzip_entry_data_offset + * This functions read the correspoding struct zzip_file_header from + * the zip disk of the given "entry". The returned off_t points to the + * end of the file_header where the current fseek pointer has stopped. + * This is used to immediatly parse out any filename/extras block following + * the file_header. The return value is null on error. + */ +static zzip_off_t +zzip_entry_fread_file_header(ZZIP_ENTRY * entry, + struct zzip_file_header *file_header) +{ + if (! entry || ! file_header) + return 0; + ___ zzip_off_t offset = zzip_disk_entry_fileoffset(disk_(entry)); + if (0 > offset || offset >= entry->disksize) + return 0; + + if (fseeko(entry->diskfile, offset, SEEK_SET) == -1) return 0; + return (fread(file_header, sizeof(*file_header), 1, entry->diskfile) + ? offset + sizeof(*file_header) : 0); + ____; +} + +/** helper functions for (fseeko) zip access api + * + * This functions returns the seekval offset of the data portion of the + * file referenced by the given zzip_entry. It requires an intermediate + * check of the file_header structure (i.e. it reads it from disk). After + * this call, the contained diskfile readposition is already set to the + * data_offset returned here. On error -1 is returned. + */ +zzip_off_t +zzip_entry_data_offset(ZZIP_ENTRY * entry) +{ + struct zzip_file_header file_header; + if (! entry) + return -1; + ___ zzip_off_t offset = zzip_entry_fread_file_header(entry, &file_header); + if (! offset) + return -1; + offset += zzip_file_header_sizeof_tails(&file_header); + if (fseeko(entry->diskfile, offset, SEEK_SET) == -1) + return -1; + return offset; + ____; +} + +/** => zzip_entry_data_offset + * This function is a big helper despite its little name: in a zip file the + * encoded filenames are usually NOT zero-terminated but for common usage + * with libc we need it that way. Secondly, the filename SHOULD be present + * 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_entry_strdup_name(ZZIP_ENTRY * entry) +{ + if (! entry) + return 0; + + ___ zzip_size_t len; + if ((len = zzip_disk_entry_namlen(disk_(entry)))) + { + char *name = malloc(len + 1); + if (! name) + return 0; + memcpy(name, entry->tail, len); + name[len] = '\0'; + return name; + } + ___ auto struct zzip_file_header header; + if (zzip_entry_fread_file_header(entry, &header) + && (len = zzip_file_header_namlen(&header))) + { + char *name = malloc(len + 1); + if (! name) { + return 0; + } else { + zzip_size_t n = fread(name, 1, len, entry->diskfile); + if (n != len) { + free (name); + return 0; + } + name[n] = '\0'; + return name; + } + } + return 0; + ____; + ____; +} + +static int +prescan_entry(ZZIP_ENTRY * entry) +{ + assert(entry); + ___ zzip_off_t tailsize = zzip_disk_entry_sizeof_tails(disk_(entry)); + if (tailsize + 1 > entry->tailalloc) + { + char *newtail = realloc(entry->tail, tailsize + 1); + if (! newtail) + return ENOMEM; + entry->tail = newtail; + entry->tailalloc = tailsize + 1; + } +# ifdef SIZE_MAX /* from stdint.h */ + if (tailsize > (zzip_off_t)(SIZE_MAX)) { return EFBIG; } +# endif + ___ zzip_size_t readsize = fread(entry->tail, 1, tailsize, entry->diskfile); + /* name + comment + extras */ + if ((zzip_off_t)readsize != tailsize) { + return errno; + } else { + return 0; + } ____; ____; +} + +static void +prescan_clear(ZZIP_ENTRY * entry) +{ + assert(entry); + if (entry->tail) + free(entry->tail); + entry->tail = 0; + entry->tailalloc = 0; +} + +/* ====================================================================== */ + +/** => zzip_entry_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. + * Here we require the stdio handle 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 + * 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 + * any disk_trailer info telling about multidisk archives, so we just return + * a pointer to the first entry in the zip central directory of that file. + * + * 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 + * 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 + * 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. + */ +zzip__new__ ZZIP_ENTRY * +zzip_entry_findfirst(FILE * disk) +{ + if (! disk) + return 0; + if (fseeko(disk, 0, SEEK_END) == -1) + return 0; + ___ zzip_off_t disksize = ftello(disk); + if (disksize < (zzip_off_t) sizeof(struct zzip_disk_trailer)) + return 0; + /* we read out chunks of 8 KiB in the hope to match disk granularity */ + ___ zzip_off_t pagesize = PAGESIZE; /* getpagesize() */ + ___ ZZIP_ENTRY *entry = malloc(sizeof(*entry)); + if (! entry) + return 0; + ___ unsigned char *buffer = malloc(pagesize); + if (! buffer) + goto nomem; + + assert(pagesize / 2 > (zzip_off_t) sizeof(struct zzip_disk_trailer)); + /* at each step, we will fread a pagesize block which overlaps with the + * previous read by means of pagesize/2 step at the end of the while(1) */ + ___ zzip_off_t mapoffs = disksize & ~(pagesize - 1); + ___ zzip_off_t mapsize = disksize - mapoffs; + if (mapoffs && mapsize < pagesize / 2) + { + mapoffs -= pagesize / 2; + mapsize += pagesize / 2; + } + assert(mapsize < 3*8192); + while (1) + { + if (fseeko(disk, mapoffs, SEEK_SET) == -1) + goto error; + if (fread(buffer, 1, mapsize, disk) != (zzip_size_t)mapsize) + goto error; + ___ unsigned char *p = + buffer + mapsize - sizeof(struct zzip_disk_trailer); + for (; p >= buffer; p--) + { + zzip_off_t root; /* (struct zzip_disk_entry*) */ + if (zzip_disk_trailer_check_magic(p)) + { + root = zzip_disk_trailer_rootseek((struct zzip_disk_trailer *) + p); + if (root > disksize - (long) sizeof(struct zzip_disk_trailer)) + { + /* first disk_entry is after the disk_trailer? can't be! */ + struct zzip_disk_trailer *trailer = + (struct zzip_disk_trailer *) p; + zzip_off_t rootsize = zzip_disk_trailer_rootsize(trailer); + if (rootsize > mapoffs) + continue; + /* a common brokeness that can be fixed: we just assume the + * central directory was written directly before : */ + root = mapoffs - rootsize; + } + } else if (zzip_disk64_trailer_check_magic(p)) + { + struct zzip_disk64_trailer *trailer = + (struct zzip_disk64_trailer *) p; + if (sizeof(zzip_off_t) < 8) + return 0; + root = zzip_disk64_trailer_rootseek(trailer); + } else + continue; + + assert(0 <= root && root < mapsize); + if (fseeko(disk, root, SEEK_SET) == -1) + goto error; + if (fread(disk_(entry), 1, sizeof(*disk_(entry)), disk) + != sizeof(*disk_(entry))) goto error; + if (zzip_disk_entry_check_magic(entry)) + { + free(buffer); + entry->headseek = root; + entry->diskfile = disk; + entry->disksize = disksize; + if (prescan_entry(entry)) + goto nomem; + return entry; + } + } + ____; + if (! mapoffs) + break; + assert(mapsize >= pagesize / 2); + mapoffs -= pagesize / 2; /* mapsize += pagesize/2; */ + mapsize = pagesize; /* if (mapsize > pagesize) ... */ + if (disksize - mapoffs > 64 * 1024) + break; + } + error: + free(buffer); + nomem: + free(entry); + ____; + ____; + ____; + ____; + ____; + ____; + return 0; +} + +/** => zzip_entry_findfile + * + * This function takes an existing "entry" in the central root directory + * (e.g. from zzip_entry_findfirst) and moves it to point to the next entry. + * On error it returns 0, otherwise the old entry. If no further match is + * found then null is returned and the entry already free()d. If you want + * to stop searching for matches before that case then please call + * => zzip_entry_free on the cursor struct ZZIP_ENTRY. + */ +zzip__new__ ZZIP_ENTRY * +zzip_entry_findnext(ZZIP_ENTRY * _zzip_restrict entry) +{ + if (! entry) + return entry; + if (! zzip_disk_entry_check_magic(entry)) + goto err; + ___ zzip_off_t seek = + entry->headseek + zzip_disk_entry_sizeto_end(disk_(entry)); + if (seek + (zzip_off_t) sizeof(*disk_(entry)) > entry->disksize) + goto err; + + if (fseeko(entry->diskfile, seek, SEEK_SET) == -1) + goto err; + if (fread(disk_(entry), 1, sizeof(*disk_(entry)), entry->diskfile) + != sizeof(*disk_(entry))) goto err; + entry->headseek = seek; + if (! zzip_disk_entry_check_magic(entry)) + goto err; + if (prescan_entry(entry)) + goto err; + return entry; + err: + zzip_entry_free(entry); + return 0; + ____; +} + +/** => zzip_entry_findfile + * this function releases the malloc()ed areas needed for zzip_entry, the + * pointer is invalid afterwards. This function has #define synonyms of + * zzip_entry_findlast(), zzip_entry_findlastfile(), zzip_entry_findlastmatch() + */ +int +zzip_entry_free(ZZIP_ENTRY * entry) +{ + if (! entry) + return 0; + prescan_clear(entry); + free(entry); + return 1; +} + +/** search for files in the (fseeko) 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 "old"-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). If no further entry is + * found then null is returned and any "old"-entry gets already free()d. + */ +zzip__new__ ZZIP_ENTRY * +zzip_entry_findfile(FILE * disk, char *filename, + ZZIP_ENTRY * _zzip_restrict entry, zzip_strcmp_fn_t compare) +{ + if (! filename || ! disk) + return 0; + if (! entry) + entry = zzip_entry_findfirst(disk); + else + entry = zzip_entry_findnext(entry); + + if (! compare) + compare = (zzip_strcmp_fn_t) (strcmp); + + for (; entry; entry = zzip_entry_findnext(entry)) + { + /* filenames within zip files are often not null-terminated! */ + char *realname = zzip_entry_strdup_name(entry); + if (! realname) + continue; + if (! compare(filename, realname)) + { + free(realname); + return entry; + } else + { + free(realname); + continue; + } + } + return 0; +} + +/** => zzip_entry_findfile + * + * This function uses a compare-function with an additional argument + * and it is called just like fnmatch(3) from POSIX.2 AD:1993), i.e. + * the argument filespec first and the ziplocal filename second with + * the integer-flags put in as third to the indirect call. If the + * 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 + * matching entry, or the last disk_entry return-value to find the + * next entry matching the given filespec. If no further entry is + * found then null is returned and any "old"-entry gets already free()d. + */ +zzip__new__ ZZIP_ENTRY * +zzip_entry_findmatch(FILE * disk, char *filespec, + ZZIP_ENTRY * _zzip_restrict entry, + zzip_fnmatch_fn_t compare, int flags) +{ + if (! filespec || ! disk) + return 0; + if (! entry) + entry = zzip_entry_findfirst(disk); + else + entry = zzip_entry_findnext(entry); + + if (! compare) + compare = (zzip_fnmatch_fn_t) _zzip_fnmatch; + + for (; entry; entry = zzip_entry_findnext(entry)) + { + /* filenames within zip files are often not null-terminated! */ + char *realname = zzip_entry_strdup_name(entry); + if (! realname) + continue; + if (! compare(filespec, realname, flags)) + { + free(realname); + return entry; + } else + { + free(realname); + continue; + } + } + return 0; +} + +/* ====================================================================== */ + +/** + * typedef struct zzip_disk_file ZZIP_ENTRY_FILE; + */ +struct zzip_entry_file /* : zzip_file_header */ +{ + struct zzip_file_header header; /* fopen detected header */ + ZZIP_ENTRY *entry; /* fopen entry */ + zzip_off_t data; /* for stored blocks */ + zzip_size_t avail; /* memorized for checks on EOF */ + zzip_size_t compressed; /* compressed flag and datasize */ + zzip_size_t dataoff; /* offset from data start */ + z_stream zlib; /* for inflated blocks */ + unsigned char buffer[PAGESIZE]; /* work buffer for inflate algorithm */ +}; + +/** open a file within a zip disk for reading + * + * This function does take an "entry" argument and copies it (or just takes + * it over as owner) to a new ZZIP_ENTRY_FILE handle structure. That + * structure contains also a zlib buffer for decoding. This function does + * seek to the file_header of the given "entry" and validates it for the + * data buffer following it. We do also prefetch some data from the data + * buffer thereby trying to match the disk pagesize for faster access later. + * The => zzip_entry_fread will then read in chunks of pagesizes which is + * the size of the internal readahead buffer. If an error occurs then null + * is returned. + */ +zzip__new__ ZZIP_ENTRY_FILE * +zzip_entry_fopen(ZZIP_ENTRY * entry, int takeover) +{ + if (! entry) + return 0; + if (! takeover) + { + ZZIP_ENTRY *found = malloc(sizeof(*entry)); + if (! found) + return 0; + memcpy(found, entry, sizeof(*entry)); /* prescan_copy */ + found->tail = malloc(found->tailalloc); + if (! found->tail) + { free (found); return 0; } + memcpy(found->tail, entry->tail, entry->tailalloc); + entry = found; + } + ___ ZZIP_ENTRY_FILE *file = malloc(sizeof(*file)); + if (! file) + goto fail1; + file->entry = entry; + if (! zzip_entry_fread_file_header(entry, &file->header)) + goto fail2; + file->avail = zzip_file_header_usize(&file->header); + file->data = zzip_entry_data_offset(entry); + file->dataoff = 0; + + if (! file->avail || zzip_file_header_data_stored(&file->header)) + { file->compressed = 0; return file; } + + file->compressed = zzip_file_header_csize(&file->header); + file->zlib.opaque = 0; + file->zlib.zalloc = Z_NULL; + file->zlib.zfree = Z_NULL; + + ___ zzip_off_t seek = file->data; + seek += sizeof(file->buffer); + seek -= seek & (sizeof(file->buffer) - 1); + assert(file->data < seek); /* pre-read to next PAGESIZE boundary... */ + if (fseeko(file->entry->diskfile, file->data + file->dataoff, SEEK_SET) == -1) + goto fail2; + file->zlib.next_in = file->buffer; + file->zlib.avail_in = fread(file->buffer, 1, seek - file->data, + file->entry->diskfile); + file->dataoff += file->zlib.avail_in; + ____; + + if (! zzip_file_header_data_deflated(&file->header) + || inflateInit2(&file->zlib, -MAX_WBITS) != Z_OK) + goto fail2; + + return file; + fail2: + free(file); + fail1: + zzip_entry_free(entry); + return 0; + ____; +} + +/** => zzip_entry_fopen + * + * This function opens a file found by name, so it does a search into + * the zip central directory with => zzip_entry_findfile and whatever + * is found first is given to => zzip_entry_fopen + */ +zzip__new__ ZZIP_ENTRY_FILE * +zzip_entry_ffile(FILE * disk, char *filename) +{ + ZZIP_ENTRY *entry = zzip_entry_findfile(disk, filename, 0, 0); + if (! entry) + return 0; + return zzip_entry_fopen(entry, 1); +} + + +/** => zzip_entry_fopen + * + * This function reads more bytes into the output buffer specified as + * arguments. The return value is null on eof or error, the stdio-like + * interface can not distinguish between these so you need to check + * with => zzip_entry_feof for the difference. + */ +zzip_size_t +zzip_entry_fread(void *ptr, zzip_size_t sized, zzip_size_t nmemb, + ZZIP_ENTRY_FILE * file) +{ + if (! file) + return 0; + ___ zzip_size_t size = sized * nmemb; + if (! file->compressed) + { + if (size > file->avail) + size = file->avail; + if (fread(ptr, 1, size, file->entry->diskfile) != size) return 0; + file->dataoff += size; + file->avail -= size; + return size; + } + + file->zlib.avail_out = size; + file->zlib.next_out = ptr; + ___ zzip_size_t total_old = file->zlib.total_out; + while (1) + { + if (! file->zlib.avail_in) + { + size = file->compressed - file->dataoff; + if (size > sizeof(file->buffer)) + size = sizeof(file->buffer); + /* fseek (file->data + file->dataoff, file->entry->diskfile); */ + file->zlib.avail_in = fread(file->buffer, 1, size, + file->entry->diskfile); + file->zlib.next_in = file->buffer; + file->dataoff += file->zlib.avail_in; + } + if (! file->zlib.avail_in) + return 0; + + ___ int err = inflate(&file->zlib, Z_NO_FLUSH); + if (err == Z_STREAM_END) + file->avail = 0; + else if (err == Z_OK) + file->avail -= file->zlib.total_out - total_old; + else + return 0; + ____; + if (file->zlib.avail_out && ! file->zlib.avail_in) + continue; + return file->zlib.total_out - total_old; + } + ____; + ____; +} + +/** => zzip_entry_fopen + * This function releases any zlib decoder info needed for decompression + * and dumps the ZZIP_ENTRY_FILE struct then. + */ +int +zzip_entry_fclose(ZZIP_ENTRY_FILE * file) +{ + if (! file) + return 0; + if (file->compressed) + inflateEnd(&file->zlib); + zzip_entry_free(file->entry); + free(file); + return 0; +} + +/** => zzip_entry_fopen + * + * 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_entry_feof(ZZIP_ENTRY_FILE * file) +{ + return ! file || ! file->avail; +} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fseeko.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fseeko.h new file mode 100644 index 00000000000..9abade7452c --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/fseeko.h @@ -0,0 +1,129 @@ +#ifndef _ZZIP_FSEEKO_H_ +#define _ZZIP_FSEEKO_H_ +/* + * NOTE: this is part of libzzipfseeko (i.e. it is not libzzip). + * + * simplified zip disk access using fseeko on a stdio FILE handle + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2003,2004 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + + +#include <zzip/types.h> +#include <stdio.h> + +#ifdef _ZZIP_ENTRY_STRUCT +#include <zlib.h> +#include <zzip/format.h> +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct zzip_entry ZZIP_ENTRY; +typedef struct zzip_entry_file ZZIP_ENTRY_FILE; + +typedef int (*zzip_strcmp_fn_t)(char*, char*); +typedef int (*zzip_fnmatch_fn_t)(char*, char*, int); + +#ifndef zzip_entry_extern +#define zzip_entry_extern extern +#endif + +zzip_entry_extern zzip_off_t +zzip_entry_data_offset(ZZIP_ENTRY* entry); + +zzip__new__ +zzip_entry_extern ZZIP_ENTRY* +zzip_entry_findfirst(FILE* file); + +zzip__new__ +zzip_entry_extern ZZIP_ENTRY* +zzip_entry_findnext(ZZIP_ENTRY* _zzip_restrict entry); + +#define zzip_entry_findlast zzip_entry_free +#define zzip_entry_findlastfile zzip_entry_free +#define zzip_entry_findlastmatch zzip_entry_free + +zzip_entry_extern int +zzip_entry_free(ZZIP_ENTRY* entry); + +zzip__new__ +zzip_entry_extern char* +zzip_entry_strdup_name(ZZIP_ENTRY* entry); +zzip_entry_extern char* +zzip_entry_to_data(ZZIP_ENTRY* entry); + +zzip__new__ +zzip_entry_extern ZZIP_ENTRY* +zzip_entry_findfile(FILE* disk, char* filename, + ZZIP_ENTRY* _zzip_restrict old, + zzip_strcmp_fn_t compare); +zzip__new__ +zzip_entry_extern ZZIP_ENTRY* +zzip_entry_findmatch(FILE* disk, char* filespec, + ZZIP_ENTRY* _zzip_restrict old, + zzip_fnmatch_fn_t compare, int flags); +zzip__new__ +zzip_entry_extern ZZIP_ENTRY_FILE* +zzip_entry_fopen (ZZIP_ENTRY* entry, int takeover); + +zzip__new__ +zzip_entry_extern ZZIP_ENTRY_FILE* +zzip_entry_ffile (FILE* disk, char* filename); + +zzip_entry_extern _zzip_size_t +zzip_entry_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb, + ZZIP_ENTRY_FILE* file); +zzip_entry_extern int +zzip_entry_fclose (ZZIP_ENTRY_FILE* file); +int +zzip_entry_feof (ZZIP_ENTRY_FILE* file); + +# ifdef _ZZIP_ENTRY_STRUCT +# ifdef __cplusplus +# define __zzip_entry_extends_zzip_disk_entry +struct zzip_entry : public struct zzip_disk_entry +{ + char* _zzip_restrict tail; + zzip_off_t tailalloc; /* the allocated size of tail */ + FILE* diskfile; /* a file reference */ + zzip_off_t disksize; /* the size of the file */ + zzip_off_t headseek; /* the offset within the file */ + zzip_off_t zz_usize; + zzip_off_t zz_csize; /* items scanned from header */ + zzip_off_t zz_offset; /* or zip64 extension block */ + int zz_diskstart; +}; +# else +struct zzip_entry /* : struct zzip_disk_entry */ +{ + struct zzip_disk_entry head; + char* _zzip_restrict tail; + zzip_off_t tailalloc; /* the allocated size of tail */ + FILE* diskfile; /* a file reference */ + zzip_off_t disksize; /* the size of the file */ + zzip_off_t headseek; /* the offset within the file */ + zzip_off_t zz_usize; + zzip_off_t zz_csize; /* items scanned from header */ + zzip_off_t zz_offset; /* or zip64 extension block */ + int zz_diskstart; +}; +# endif /* __cplusplus */ +# endif /* _ZZIP_MEM_ENTRY_PRIVATE */ + +#ifdef __cplusplus +extern "C" { +} +#endif +#endif + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/info.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/info.c new file mode 100644 index 00000000000..0c50600ff24 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/info.c @@ -0,0 +1,163 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/lib.h> /* exported... */ +#include <zzip/file.h> +#include <zzip/format.h> + +#ifdef ZZIP_HAVE_SYS_STAT_H +#include <sys/stat.h> +#else +#include <stdlib.h> +#include <stdio.h> +#endif + +/** + * just returns dir->errcode of the ZZIP_DIR handle + * see: => zzip_dir_open, => zzip_dir_open, => zzip_readdir, => zzip_dir_read + */ +int +zzip_error(ZZIP_DIR * dir) +{ + return dir->errcode; +} + +/** => zzip_error + * This function just does dir->errcode = errcode + */ +void +zzip_seterror(ZZIP_DIR * dir, int errcode) { dir->errcode = errcode; } + +/** + * This function will just return fp->dir + * + * If a ZZIP_FILE is contained within a zip-file that one will be a valid + * pointer, otherwise a NULL is returned and the ZZIP_FILE wraps a real file. + */ +ZZIP_DIR * +zzip_dirhandle(ZZIP_FILE * fp) +{ + return fp->dir; +} + +/** => zzip_dirhandle + * This function will just return dir->fd + * + * If a ZZIP_DIR does point to a zipfile then the file-descriptor of that + * zipfile is returned, otherwise a NULL is returned and the ZZIP_DIR wraps + * a real directory DIR (if you have dirent on your system). + */ +int +zzip_dirfd(ZZIP_DIR * dir) +{ + return dir->fd; +} + +/** + * return static const string of the known compression methods, + * otherwise just "zipped" is returned + */ +zzip_char_t * +zzip_compr_str(int compr) +{ + switch (compr) + { + /* *INDENT-OFF* */ + case ZZIP_IS_STORED: return "stored"; + case ZZIP_IS_SHRUNK: return "shrunk"; + case ZZIP_IS_REDUCEDx1: + case ZZIP_IS_REDUCEDx2: + case ZZIP_IS_REDUCEDx3: + case ZZIP_IS_REDUCEDx4: return "reduced"; + case ZZIP_IS_IMPLODED: return "imploded"; + case ZZIP_IS_TOKENIZED: return "tokenized"; + case ZZIP_IS_DEFLATED: return "deflated"; + case ZZIP_IS_DEFLATED_BETTER: return "deflatedX"; + case ZZIP_IS_IMPLODED_BETTER: return "implodedX"; + default: + if (0 < compr && compr < 256) return "zipped"; + else + { +# ifdef S_ISDIR + if (S_ISDIR(compr)) return "directory"; +# endif +# ifdef S_ISCHR + if (S_ISCHR(compr)) return "is/chr"; +# endif +# ifdef S_ISBLK + if (S_ISBLK(compr)) return "is/blk"; +# endif +# ifdef S_ISFIFO + if (S_ISFIFO(compr)) return "is/fifo"; +# endif +# ifdef S_ISSOCK + if (S_ISSOCK(compr)) return "is/sock"; +# endif +# ifdef S_ISLNK + if (S_ISLNK(compr)) return "is/lnk"; +# endif + return "special"; + } + /* *INDENT-ON* */ + } /*switch */ +} + +/** => zzip_file_real + * This function checks if the ZZIP_DIR-handle is wrapping + * a real directory or a zip-archive. + * Returns 1 for a stat'able directory, and 0 for a handle to zip-archive. + */ +int +zzip_dir_real(ZZIP_DIR * dir) +{ + return dir->realdir != 0; +} + +/** + * This function checks if the ZZIP_FILE-handle is wrapping + * a real file or a zip-contained file. + * Returns 1 for a stat'able file, and 0 for a file inside a zip-archive. + */ +int +zzip_file_real(ZZIP_FILE * fp) +{ + return fp->dir == 0; /* ie. not dependent on a zip-arch-dir */ +} + +/** => zzip_file_real + * This function returns the posix DIR* handle (if one exists). + * Check before with => zzip_dir_real if the + * the ZZIP_DIR points to a real directory. + */ +void * +zzip_realdir(ZZIP_DIR * dir) +{ + return dir->realdir; +} + +/** => zzip_file_real + * This function returns the posix file descriptor (if one exists). + * Check before with => zzip_file_real if the + * the ZZIP_FILE points to a real file. + */ +int +zzip_realfd(ZZIP_FILE * fp) +{ + return fp->fd; +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/info.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/info.h new file mode 100644 index 00000000000..0ab6edab561 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/info.h @@ -0,0 +1,25 @@ +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#ifdef ZZIP_USE_INTERNAL +/* do not make these public, they are for internal use only */ + +#define ZZIP_error(__dir) __dir->errcode +#define ZZIP_seterror(__dir, __code) __dir->errcode = __code +#define ZZIP_dirhandle(__fp) __fp->dir +#define ZZIP_dirfd(__dir) __dir->fd +#define ZZIP_dir_real(__dir) __dir->realdir != 0 +#define ZZIP_file_real(__fp) __fp->dir == 0 +#define ZZIP_realdir(__dir) __dir->realdir +#define ZZIP_reafd(__fp) __fp->fd + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/lib.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/lib.h new file mode 100644 index 00000000000..28b5311d655 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/lib.h @@ -0,0 +1,91 @@ +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <Tomi.Ollila@iki.fi> + * + * Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim + * All rights reserved + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * This is the private header containing definitions that are not + * use by a libzzip user application. Writing an extension lib that + * uses libzzip will still want to include this. The extension + * write should make way to have the ISO C9X integer types defined. + */ +#ifndef _ZZIP_LIB_H /* zzip.h */ +#define _ZZIP_LIB_H + +#include <zzip/zzip.h> +#include <zzip/plugin.h> +#include <zzip/stdint.h> +#include <zzip/zzip32.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * this structure cannot be wildly enlarged... (see zzip-zip.c) + */ +struct zzip_dir_hdr +{ + uint32_t d_usize; /* uncompressed size */ + uint32_t d_csize; /* compressed size */ + uint32_t d_crc32; /* the adler32-checksum */ + uint32_t d_off; /* offset of file in zipfile */ + uint16_t d_reclen; /* next dir_hdr structure offset */ + uint16_t d_namlen; /* explicit namelen of d_name */ + uint8_t d_compr; /* the compression type, 0 = store, 8 = inflate */ + char d_name[1]; /* the actual name of the entry, may contain DIRSEPs */ +}; +#define _ZZIP_DIRENT_HAVE_D_NAMLEN +#define _ZZIP_DIRENT_HAVE_D_OFF +#define _ZZIP_DIRENT_HAVE_D_RECLEN + +/* + * you shall not use this struct anywhere else than in zziplib sources. + */ +struct zzip_dir +{ + int fd; + int errcode; /* zzip_error_t */ + long refcount; + struct { /* reduce a lot of alloc/deallocations by caching these: */ + int * volatile locked; + struct zzip_file * volatile fp; + char * volatile buf32k; + } cache; + struct zzip_dir_hdr * hdr0; /* zfi; */ + struct zzip_dir_hdr * hdr; /* zdp; directory pointer, for dirent stuff */ + struct zzip_file * currentfp; /* last fp used... */ + struct zzip_dirent dirent; + void* realdir; /* e.g. DIR* from posix dirent.h */ + char* realname; + zzip_strings_t* fileext; /* list of fileext to test for */ + zzip_plugin_io_t io; /* vtable for io routines */ +}; + +#define ZZIP_32K 32768 + +/* try to open a zip-basename with default_fileext */ +int __zzip_try_open (zzip_char_t* filename, int filemode, + zzip_strings_t* ext, zzip_plugin_io_t io); + +ZZIP_DIR * +zzip_dir_fdopen(int fd, zzip_error_t * errcode_p); + +ZZIP_DIR* +zzip_dir_fdopen_ext_io(int fd, zzip_error_t * errorcode_p, + zzip_strings_t* ext, const zzip_plugin_io_t io); + +ZZIP_DIR* /*depracated*/ +zzip_dir_alloc_ext_io (zzip_strings_t* ext, const zzip_plugin_io_t io); + +#ifdef __cplusplus +} +#endif +#endif /* _ZZIP_H */ + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/memdisk.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/memdisk.c new file mode 100644 index 00000000000..dc00ea86508 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/memdisk.c @@ -0,0 +1,466 @@ + +/* + * NOTE: this is part of libzzipmmapped (i.e. it is not libzzip). + * ================== + * + * The mem_disk cache will parse the central information of a zip archive + * and store it internally. One the one hand it allows to find files + * faster - no disk access is required and endian conversion is not + * needed. If zzip is compiled with zip extensions then it is about + * the only way to build maintainable code around the zip format. + * + * Note that 64bit support is almost entirely living in extension + * blocks as well as different character encodings and file access + * control bits that are mostly platform specific. + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ +#define _ZZIP_DISK_FILE_STRUCT 1 + +#include <zzip/types.h> + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <time.h> + +#include <zlib.h> +#include <zzip/format.h> +#include <zzip/fetch.h> +#include <zzip/mmapped.h> +#include <zzip/memdisk.h> +#include <zzip/__fnmatch.h> + +#define ___ { +#define ____ } + +static const char *error[] = { + "Ok", +# define _zzip_mem_disk_open_fail 1 + "zzip_mem_disk_open: zzip_disk_open did fail", +# define _zzip_mem_disk_fdopen_fail 2 + "zzip_mem_disk_fdopen: zzip_disk_mmap did fail" +# define _zzip_mem_disk_buffer_fail 3 + "zzip_mem_disk_buffer: zzip_disk_buffer did fail", + 0 +}; + +#define ZZIP_EXTRA_zip64 0x0001 +typedef struct _zzip_extra_zip64 +{ /* ZIP64 extended information extra field */ + zzip_byte_t z_datatype[2]; /* Tag for this "extra" block type */ + zzip_byte_t z_datasize[2]; /* Size of this "extra" block */ + zzip_byte_t z_usize[8]; /* Original uncompressed file size */ + zzip_byte_t z_csize[8]; /* Size of compressed data */ + zzip_byte_t z_offset[8]; /* Offset of local header record */ + zzip_byte_t z_diskstart[4]; /* Number of the disk for file start */ +} zzip_extra_zip64; + +/*forward*/ + +static zzip__new__ ZZIP_MEM_ENTRY * +zzip_mem_entry_new(ZZIP_DISK * disk, ZZIP_DISK_ENTRY * entry); +static void +zzip_mem_entry_free(ZZIP_MEM_ENTRY * _zzip_restrict item); + +zzip__new__ ZZIP_MEM_DISK * +zzip_mem_disk_new(void) +{ + return calloc(1, sizeof(ZZIP_MEM_DISK)); +} + +/** create new diskdir handle. + * wraps underlying zzip_disk_open. */ +zzip__new__ ZZIP_MEM_DISK * +zzip_mem_disk_open(char *filename) +{ + ZZIP_DISK *disk = zzip_disk_open(filename); + if (! disk) + { perror(error[_zzip_mem_disk_open_fail]); return 0; } + ___ ZZIP_MEM_DISK *dir = zzip_mem_disk_new(); + zzip_mem_disk_load(dir, disk); + return dir; + ____; +} + +/** create new diskdir handle. + * wraps underlying zzip_disk_open. */ +zzip__new__ ZZIP_MEM_DISK * +zzip_mem_disk_fdopen(int fd) +{ + ZZIP_DISK *disk = zzip_disk_mmap(fd); + if (! disk) + { perror(error[_zzip_mem_disk_fdopen_fail]); return 0; } + ___ ZZIP_MEM_DISK *dir = zzip_mem_disk_new(); + zzip_mem_disk_load(dir, disk); + return dir; + ____; +} + +/** create new diskdir handle. + * wraps underlying zzip_disk_buffer. */ +zzip__new__ ZZIP_MEM_DISK * +zzip_mem_disk_buffer(char *buffer, size_t buflen) +{ + ZZIP_DISK *disk = zzip_disk_buffer(buffer, buflen); + if (! disk) + { perror(error[_zzip_mem_disk_buffer_fail]); return 0; } + ___ ZZIP_MEM_DISK *dir = zzip_mem_disk_new(); + zzip_mem_disk_load(dir, disk); + return dir; + ____; +} + +/** parse central dir. + * creates an internal copy of each entry converted to the local platform. + * returns: number of entries, or -1 on error (setting errno) + */ +long +zzip_mem_disk_load(ZZIP_MEM_DISK * dir, ZZIP_DISK * disk) +{ + if (! dir || ! disk) + { errno=EINVAL; return -1; } + if (dir->list) + zzip_mem_disk_unload(dir); + ___ long count = 0; + ___ struct zzip_disk_entry *entry = zzip_disk_findfirst(disk); + for (; entry; entry = zzip_disk_findnext(disk, entry)) + { + ZZIP_MEM_ENTRY *item = zzip_mem_entry_new(disk, entry); + if (! item) + goto error; + if (dir->last) + { + dir->last->zz_next = item; /* chain last */ + } else + { + dir->list = item; + } + dir->last = item; /* to earlier */ + count++; + } + ____; + dir->disk = disk; + return count; + ____; + error: + zzip_mem_disk_unload(dir); + return -1; +} + +/** convert a zip disk entry to internal format. + * creates a new item parsing the information out of the various places + * in the zip archive. This is a good place to extend functionality if + * you have a project with extra requirements as you can push more bits + * right into the diskdir_entry for later usage in higher layers. + * returns: new item, or null on error (setting errno) + */ +zzip__new__ ZZIP_MEM_ENTRY * +zzip_mem_entry_new(ZZIP_DISK * disk, ZZIP_DISK_ENTRY * entry) +{ + if (! disk || ! entry) + { errno=EINVAL; return 0; } + ___ ZZIP_MEM_ENTRY *item = calloc(1, sizeof(*item)); + if (! item) + return 0; /* errno=ENOMEM; */ + ___ struct zzip_file_header *header = + zzip_disk_entry_to_file_header(disk, entry); + /* there is a number of duplicated information in the file header + * or the disk entry block. Theoretically some part may be missing + * that exists in the other, ... but we will prefer the disk entry. + */ + item->zz_comment = zzip_disk_entry_strdup_comment(disk, entry); + item->zz_name = zzip_disk_entry_strdup_name(disk, entry); + item->zz_data = zzip_file_header_to_data(header); + item->zz_flags = zzip_disk_entry_get_flags(entry); + item->zz_compr = zzip_disk_entry_get_compr(entry); + item->zz_mktime = zzip_disk_entry_get_mktime(entry); + item->zz_crc32 = zzip_disk_entry_get_crc32(entry); + item->zz_csize = zzip_disk_entry_get_csize(entry); + item->zz_usize = zzip_disk_entry_get_usize(entry); + item->zz_diskstart = zzip_disk_entry_get_diskstart(entry); + item->zz_filetype = zzip_disk_entry_get_filetype(entry); + + { /* copy the extra blocks to memory as well */ + int /* */ ext1 = zzip_disk_entry_get_extras(entry); + char *_zzip_restrict ptr1 = zzip_disk_entry_to_extras(entry); + int /* */ ext2 = zzip_file_header_get_extras(header); + char *_zzip_restrict ptr2 = zzip_file_header_to_extras(header); + + if (ext1) + { + void *mem = malloc(ext1 + 2); + item->zz_ext[1] = mem; + memcpy(mem, ptr1, ext1); + ((char *) (mem))[ext1 + 0] = 0; + ((char *) (mem))[ext1 + 1] = 0; + } + if (ext2) + { + void *mem = malloc(ext2 + 2); + item->zz_ext[2] = mem; + memcpy(mem, ptr2, ext2); + ((char *) (mem))[ext2 + 0] = 0; + ((char *) (mem))[ext2 + 1] = 0; + } + } + { + /* override sizes/offsets with zip64 values for largefile support */ + zzip_extra_zip64 *block = (zzip_extra_zip64 *) + zzip_mem_entry_extra_block(item, ZZIP_EXTRA_zip64); + if (block) + { + item->zz_usize = __zzip_get64(block->z_usize); + item->zz_csize = __zzip_get64(block->z_csize); + item->zz_offset = __zzip_get64(block->z_offset); + item->zz_diskstart = __zzip_get32(block->z_diskstart); + } + } + /* NOTE: + * All information from the central directory entry is now in memory. + * Effectivly that allows us to modify it and write it back to disk. + */ + return item; + ____; + ____; +} + +/* find an extra block for the given datatype code. + * We assume that the central directory has been preparsed to memory. + */ +ZZIP_EXTRA_BLOCK * +zzip_mem_entry_extra_block(ZZIP_MEM_ENTRY * entry, short datatype) +{ + int i = 2; + while (1) + { + ZZIP_EXTRA_BLOCK *ext = entry->zz_ext[i]; + if (ext) + { + while (*(short *) (ext->z_datatype)) + { + if (datatype == zzip_extra_block_get_datatype(ext)) + { + return ext; + } + ___ char *e = (char *) ext; + e += zzip_extra_block_headerlength; + e += zzip_extra_block_get_datasize(ext); + ext = (void *) e; + ____; + } + } + if (! i) + return 0; + i--; + } +} + +void +zzip_mem_entry_free(ZZIP_MEM_ENTRY * _zzip_restrict item) +{ + if (item) + { + /* *INDENT-OFF* */ + if (item->zz_ext[0]) free (item->zz_ext[0]); + if (item->zz_ext[1]) free (item->zz_ext[1]); + if (item->zz_ext[2]) free (item->zz_ext[2]); + if (item->zz_comment) free (item->zz_comment); + if (item->zz_name) free (item->zz_name); + free (item); + /* *INDENT-ON* */ + } +} + +void +zzip_mem_disk_unload(ZZIP_MEM_DISK * dir) +{ + ZZIP_MEM_ENTRY *item = dir->list; + while (item) + { + ZZIP_MEM_ENTRY *next = item->zz_next; + zzip_mem_entry_free(item); + item = next; + } + dir->list = dir->last = 0; + zzip_disk_close(dir->disk); + dir->disk = 0; +} + +void +zzip_mem_disk_close(ZZIP_MEM_DISK * _zzip_restrict dir) +{ + if (dir) + { + zzip_mem_disk_unload(dir); + zzip_disk_close(dir->disk); + free(dir); + } +} + +#if 0 +static void +foo(short zz_datatype) +{ + switch (zz_datatype) + { + /* *INDENT-OFF* */ + case 0x0001: /* ZIP64 extended information extra field */ + case 0x0007: /* AV Info */ + case 0x0008: /* Reserved for future Unicode file name data (PFS) */ + case 0x0009: /* OS/2 */ + case 0x000a: /* NTFS */ + case 0x000c: /* OpenVMS */ + case 0x000d: /* Unix */ + case 0x000e: /* Reserved for file stream and fork descriptors */ + case 0x000f: /* Patch Descriptor */ + case 0x0014: /* PKCS#7 Store for X.509 Certificates */ + case 0x0015: /* X.509 Certificate ID and Signature for file */ + case 0x0016: /* X.509 Certificate ID for Central Directory */ + case 0x0017: /* Strong Encryption Header */ + case 0x0018: /* Record Management Controls */ + case 0x0019: /* PKCS#7 Encryption Recipient Certificate List */ + case 0x0065: /* IBM S/390, AS/400 attributes - uncompressed */ + case 0x0066: /* Reserved for IBM S/390, AS/400 attr - compressed */ + case 0x07c8: /* Macintosh */ + case 0x2605: /* ZipIt Macintosh */ + case 0x2705: /* ZipIt Macintosh 1.3.5+ */ + case 0x2805: /* ZipIt Macintosh 1.3.5+ */ + case 0x334d: /* Info-ZIP Macintosh */ + case 0x4341: /* Acorn/SparkFS */ + case 0x4453: /* Windows NT security descriptor (binary ACL) */ + case 0x4704: /* VM/CMS */ + case 0x470f: /* MVS */ + case 0x4b46: /* FWKCS MD5 (see below) */ + case 0x4c41: /* OS/2 access control list (text ACL) */ + case 0x4d49: /* Info-ZIP OpenVMS */ + case 0x4f4c: /* Xceed original location extra field */ + case 0x5356: /* AOS/VS (ACL) */ + case 0x5455: /* extended timestamp */ + case 0x554e: /* Xceed unicode extra field */ + case 0x5855: /* Info-ZIP Unix (original, also OS/2, NT, etc) */ + case 0x6542: /* BeOS/BeBox */ + case 0x756e: /* ASi Unix */ + case 0x7855: /* Info-ZIP Unix (new) */ + case 0xfd4a: /* SMS/QDOS */ + /* *INDENT-ON* */ + } +} +#endif + +ZZIP_MEM_ENTRY * +zzip_mem_disk_findfile(ZZIP_MEM_DISK * dir, + char *filename, ZZIP_MEM_ENTRY * after, + zzip_strcmp_fn_t compare) +{ + ZZIP_MEM_ENTRY *entry = (! after ? dir->list : after->zz_next); + if (! compare) + compare = (zzip_strcmp_fn_t) (strcmp); + for (; entry; entry = entry->zz_next) + { + if (! compare(filename, entry->zz_name)) + { + return entry; + } + } + return 0; +} + +ZZIP_MEM_ENTRY * +zzip_mem_disk_findmatch(ZZIP_MEM_DISK * dir, + char *filespec, ZZIP_MEM_ENTRY * after, + zzip_fnmatch_fn_t compare, int flags) +{ + ZZIP_MEM_ENTRY *entry = (! after ? dir->list : after->zz_next); + if (! compare) + compare = (zzip_fnmatch_fn_t) _zzip_fnmatch; + for (; entry; entry = entry->zz_next) + { + if (! compare(filespec, entry->zz_name, flags)) + { + return entry; + } + } + return 0; +} + +zzip__new__ ZZIP_MEM_DISK_FILE * +zzip_mem_entry_fopen(ZZIP_MEM_DISK * dir, ZZIP_MEM_ENTRY * entry) +{ + /* keep this in sync with zzip_disk_entry_fopen */ + ZZIP_DISK_FILE *file = malloc(sizeof(ZZIP_MEM_DISK_FILE)); + if (! file) + return file; + file->buffer = dir->disk->buffer; + file->endbuf = dir->disk->endbuf; + file->avail = zzip_mem_entry_usize(entry); + + if (! file->avail || zzip_mem_entry_data_stored(entry)) + { file->stored = zzip_mem_entry_to_data (entry); return file; } + + file->stored = 0; + file->zlib.opaque = 0; + file->zlib.zalloc = Z_NULL; + file->zlib.zfree = Z_NULL; + file->zlib.avail_in = zzip_mem_entry_csize(entry); + file->zlib.next_in = zzip_mem_entry_to_data(entry); + + if (! zzip_mem_entry_data_deflated(entry) || + inflateInit2(&file->zlib, -MAX_WBITS) != Z_OK) + { free (file); return 0; } + + return file; +} + +zzip__new__ ZZIP_MEM_DISK_FILE * +zzip_mem_disk_fopen(ZZIP_MEM_DISK * dir, char *filename) +{ + ZZIP_MEM_ENTRY *entry = zzip_mem_disk_findfile(dir, filename, 0, 0); + if (! entry) + return 0; + else + return zzip_mem_entry_fopen(dir, entry); +} + +_zzip_size_t +zzip_mem_disk_fread(void *ptr, _zzip_size_t size, _zzip_size_t nmemb, + ZZIP_MEM_DISK_FILE * file) +{ + return zzip_disk_fread(ptr, size, nmemb, file); +} + +int +zzip_mem_disk_fclose(ZZIP_MEM_DISK_FILE * file) +{ + return zzip_disk_fclose(file); +} + +int +zzip_mem_disk_feof(ZZIP_MEM_DISK_FILE * file) +{ + return zzip_disk_feof(file); +} + +/* convert dostime of entry to unix time_t */ +long +zzip_disk_entry_get_mktime(ZZIP_DISK_ENTRY * entry) +{ + uint16_t dostime = ZZIP_GET16(entry->z_dostime.time); + uint16_t dosdate = ZZIP_GET16(entry->z_dostime.date); + struct tm date; + date.tm_sec = (dostime) & 0x1F; /* bits 0..4 */ + date.tm_min = (dostime >> 5) & 0x3F; /* bits 5..10 */ + date.tm_hour = (dostime >> 11); /* bits 11..15 */ + date.tm_mday = (dosdate) & 0x1F; /* bits 16..20 */ + date.tm_mon = (dosdate >> 5) & 0xF; /* bits 21..24 */ + date.tm_year = (dosdate >> 9) + 80; /* bits 25..31 */ + return mktime(&date); /* well, unix has that function... */ +} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/memdisk.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/memdisk.h new file mode 100644 index 00000000000..2411f642c5e --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/memdisk.h @@ -0,0 +1,171 @@ +#ifndef __ZZIP_MEMDISK_H +#define __ZZIP_MEMDISK_H + +/* NOTE: this is part of libzzipmmapped (i.e. it is not libzzip). */ + +#include <zzip/types.h> +#include <zzip/mmapped.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _zzip_mem_disk ZZIP_MEM_DISK; +typedef struct _zzip_mem_entry ZZIP_MEM_ENTRY; + +struct _zzip_mem_disk { + ZZIP_DISK* disk; + ZZIP_MEM_ENTRY* list; + ZZIP_MEM_ENTRY* last; +}; + +#ifndef zzip_mem_disk_extern +#define zzip_mem_disk_extern +#endif + +zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK* +zzip_mem_disk_new (void); +zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK* +zzip_mem_disk_open (char* filename); +zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK* +zzip_mem_disk_fdopen (int fd); +zzip_mem_disk_extern zzip__new__ ZZIP_MEM_DISK * +zzip_mem_disk_buffer(char *buffer, size_t buflen); +zzip_mem_disk_extern void +zzip_mem_disk_close (ZZIP_MEM_DISK* _zzip_restrict dir); + +zzip_mem_disk_extern long +zzip_mem_disk_load (ZZIP_MEM_DISK* dir, ZZIP_DISK* disk); +zzip_mem_disk_extern void +zzip_mem_disk_unload (ZZIP_MEM_DISK* dir); +ZZIP_EXTRA_BLOCK* +zzip_mem_entry_extra_block (ZZIP_MEM_ENTRY* entry, short datatype); + +#ifdef USE_INLINE +_zzip_inline ZZIP_DISK* zzip_disk (ZZIP_MEM_DISK* dir) { return dir->disk; } +#else +#define zzip_disk(_X_) ((_X_)->disk) +#endif + + +/* these functions are much faster than the orgiinal zzip_disk_ functions */ + +/* zzip_mem_entry <is similar to> zzip_disk_entry */ +struct _zzip_mem_entry { + struct _zzip_mem_entry* zz_next; + char* zz_name; /* zero-terminated (from "filename") */ + zzip_byte_t* zz_data; /* compressed content start (mmap addr) */ + int zz_flags; /* (from "z_flags") */ + int zz_compr; /* (from "z_compr") */ + long zz_mktime; /* (from "z_dostime") */ + long zz_crc32; /* (from "z_crc32") */ + zzip_off_t zz_csize; /* (from "z_csize") overridden by zip64 */ + zzip_off_t zz_usize; /* (from "z_usize") overridden by zip64 */ + zzip_off_t zz_offset; /* (from "z_offset") overridden by zip64 */ + int zz_diskstart; /* (from "z_diskstart") rridden by zip64 */ + int zz_filetype; /* (from "z_filetype") */ + char* zz_comment; /* zero-terminated (from "comment") */ + ZZIP_EXTRA_BLOCK* zz_ext[3]; /* terminated by null in z_datatype */ +}; /* the extra blocks are NOT converted */ + +#define _zzip_mem_disk_findfirst(_d_) ((_d_)->list) +#define _zzip_mem_disk_findnext(_d_,_e_) (!(_e_)?(_d_)->list:(_e_)->zz_next) +#define _zzip_mem_entry_findnext(_e_) ((_e_)->zz_next) + +#ifndef USE_INLINE +#define zzip_mem_disk_findfirst _zzip_mem_disk_findfirst +#define zzip_mem_disk_findnext _zzip_mem_disk_findnext +#define zzip_mem_entry_findnext _zzip_mem_entry_findnext +#else + +_zzip_inline ZZIP_MEM_ENTRY* +zzip_mem_disk_findfirst(ZZIP_MEM_DISK* dir) { + if (! dir) return 0; + return _zzip_mem_disk_findfirst(dir); } +_zzip_inline ZZIP_MEM_ENTRY* +zzip_mem_disk_findnext(ZZIP_MEM_DISK* dir, ZZIP_MEM_ENTRY* entry) { + if (! dir) return 0; + return _zzip_mem_disk_findnext(dir, entry); } +_zzip_inline ZZIP_MEM_ENTRY* +zzip_mem_entry_findnext(ZZIP_MEM_ENTRY* entry) { + if (! entry) return 0; + return _zzip_mem_entry_findnext(entry); } +#endif + +#define _zzip_mem_entry_to_name(_e_) ((_e_)->zz_name) +#define _zzip_mem_entry_to_comment(_e_) ((_e_)->zz_comment) +#define _zzip_mem_entry_strdup_name(_e_) (strdup((_e_)->zz_name)) +#define _zzip_mem_entry_to_data(_e_) ((_e_)->zz_data) + +#ifndef USE_INLINE +#define zzip_mem_entry_to_name _zzip_mem_entry_to_name +#define zzip_mem_entry_to_comment _zzip_mem_entry_to_comment +#define zzip_mem_entry_strdup_name _zzip_mem_entry_strdup_name +#define zzip_mem_entry_to_data _zzip_mem_entry_to_data +#else +_zzip_inline char* +zzip_mem_entry_to_name(ZZIP_MEM_ENTRY* entry) { + if (! entry) return 0; + return _zzip_mem_entry_to_name(entry); } +_zzip_inline char* +zzip_mem_entry_to_comment(ZZIP_MEM_ENTRY* entry) { + if (! entry) return 0; + return _zzip_mem_entry_to_comment(entry); } +zzip__new__ +_zzip_inline char* +zzip_mem_entry_strdup_name(ZZIP_MEM_ENTRY* entry) { + if (! entry) return 0; + return _zzip_mem_entry_strdup_name(entry); } +_zzip_inline zzip_byte_t* +zzip_mem_entry_to_data(ZZIP_MEM_ENTRY* entry) { + if (! entry) return 0; + return _zzip_mem_entry_to_data(entry); } +#endif + +ZZIP_MEM_ENTRY* +zzip_mem_disk_findfile(ZZIP_MEM_DISK* dir, + char* filename, ZZIP_MEM_ENTRY* after, + zzip_strcmp_fn_t compare); + +ZZIP_MEM_ENTRY* +zzip_mem_disk_findmatch(ZZIP_MEM_DISK* dir, + char* filespec, ZZIP_MEM_ENTRY* after, + zzip_fnmatch_fn_t compare, int flags); + +/* named access -------------------------------------------------------- */ +#define zzip_mem_entry_usize(_e_) ((_e_)->zz_usize) +#define zzip_mem_entry_csize(_e_) ((_e_)->zz_csize) +#define zzip_mem_entry_data_encrypted(_e_) ZZIP_IS_ENCRYPTED((_e_)->zz_flags) +#define zzip_mem_entry_data_streamed(_e_) ZZIP_IS_STREAMED((_e_)->zz_flags) +#define zzip_mem_entry_data_comprlevel(_e_) ((_e_)->zz_compr) +#define zzip_mem_entry_data_stored(_e_) ((_e_)->zz_compr == ZZIP_IS_STORED) +#define zzip_mem_entry_data_deflated(_e_) ((_e_)->zz_compr == ZZIP_IS_DEFLATED) + +/* zzip_mem_disk_file -------------------------------------------------- */ + +/* since only the header data is being cached, all the real data + * operations are actually the same as in mmapped.h - just fopen makes + * access to the header data in memory instead of the zip archive. + */ + +typedef ZZIP_DISK_FILE ZZIP_MEM_DISK_FILE; + +zzip__new__ ZZIP_MEM_DISK_FILE* +zzip_mem_entry_fopen (ZZIP_MEM_DISK* dir, ZZIP_MEM_ENTRY* entry); +zzip__new__ ZZIP_MEM_DISK_FILE* +zzip_mem_disk_fopen (ZZIP_MEM_DISK* dir, char* filename); +_zzip_size_t +zzip_mem_disk_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb, + ZZIP_MEM_DISK_FILE* file); +int +zzip_mem_disk_fclose (ZZIP_MEM_DISK_FILE* file); +int +zzip_mem_disk_feof (ZZIP_MEM_DISK_FILE* file); + +/* convert dostime of entry to unix time_t */ +long zzip_disk_entry_get_mktime(ZZIP_DISK_ENTRY* entry); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/mmapped.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/mmapped.c new file mode 100644 index 00000000000..6fafc1163a6 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/mmapped.c @@ -0,0 +1,646 @@ + +/* + * 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 + * parse the structure, find files and return a decoded bytestream. + * + * These routines are a bit simple and really here for documenting + * the way to access a zip file. The complexity of zip access comes + * from staggered reading of bytes and reposition of a filepointer in + * a big archive with lots of files and long compressed datastreams. + * Plus varaints of drop-in stdio replacements, obfuscation routines, + * auto fileextensions, drop-in dirent replacements, and so on... + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2003,2004,2006 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * 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_strndup_gnu_specific_ +#endif + +#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> + +#if defined ZZIP_HAVE_UNISTD_H +#include <unistd.h> +#elif defined ZZIP_HAVE_IO_H +#include <io.h> +#endif + +#if defined ZZIP_HAVE_STRING_H +#include <string.h> +#elif defined ZZIP_HAVE_STRINGS_H +#include <strings.h> +#endif + + +#if __STDC_VERSION__+0 > 199900L +#define ___ +#define ____ +#else +#define ___ { +#define ____ } +#endif + +/** => zzip_disk_mmap + * This function does primary initialization of a disk-buffer struct. + */ +int +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->reserved = 0; + disk->flags = 0; + disk->mapped = 0; + /* do not touch disk->user */ + /* do not touch disk->code */ + return 0; +} + +/** => zzip_disk_mmap + * This function allocates a new disk-buffer with => malloc(3) + */ +zzip__new__ ZZIP_DISK * +zzip_disk_new(void) +{ + 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 + * 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 + * disk->buffer pointing to the mapview of the zipdisk content. + */ +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(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; + ____; +} + +/** => zzip_disk_mmap + * This function is the inverse of => zzip_disk_mmap and using the system + * munmap(2) on the buffer area and => free(3) on the ZZIP_DISK structure. + */ +int +zzip_disk_munmap(ZZIP_DISK * 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 + * 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__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())) + { + 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) +{ + 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, size_t 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; + ____; +} +#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) +{ + 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++; + } +} +#endif + +/** helper functions for (mmapped) zip access api + * + * 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) +{ + struct zzip_file_header *file = zzip_disk_entry_to_file_header(disk, entry); + if (file) + return zzip_file_header_to_data(file); + return 0; +} + +/** => zzip_disk_entry_to_data + * 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) +{ + 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 + * This function is a big helper despite its little name: in a zip file the + * encoded filenames are usually NOT zero-terminated but for common usage + * with libc we need it that way. Secondly, the filename SHOULD be present + * 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) +{ + 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; + + if ((zzip_byte_t *) name < disk->buffer || + (zzip_byte_t *) name + len > disk->endbuf) + return 0; + + 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) +{ + 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); + else + return 0; + + if ((zzip_byte_t *) text < disk->buffer || + (zzip_byte_t *) text + len > disk->endbuf) + return 0; + + return _zzip_strndup(text, len); + ____; +} + +/* ====================================================================== */ + +/** => 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. + * 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 + * 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 + * 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 + * 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 + * 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 + * 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) +{ + 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)) + { + 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; +} + +/** => zzip_disk_findfile + * + * This function takes an existing disk_entry in the central root directory + * (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) +{ + 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; +} + +/** 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 + * 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 *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); + } + return 0; +} + +/** => zzip_disk_findfile + * + * This function uses a compare-function with an additional argument + * and it is called just like fnmatch(3) from POSIX.2 AD:1993), i.e. + * the argument filespec first and the ziplocal filename second with + * the integer-flags put in as third to the indirect call. If the + * 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 + * 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 *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)) + { + /* 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; +} + +/* ====================================================================== */ + +/** => zzip_disk_fopen + * + * the ZZIP_DISK_FILE* is rather simple in just encapsulating the + * arguments given to this function plus a zlib deflate buffer. + * Note that the ZZIP_DISK pointer does already contain the full + * mmapped file area of a zip disk, so open()ing a file part within + * that area happens to be a lookup of its bounds and encoding. That + * information is memorized on the ZZIP_DISK_FILE so that subsequent + * _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) +{ + /* 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; + file->buffer = disk->buffer; + file->endbuf = disk->endbuf; + 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; } + + 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); + + if (! zzip_file_header_data_deflated(header) || + inflateInit2(&file->zlib, -MAX_WBITS) != Z_OK) + { free (file); return 0; } + + return file; + ____; +} + +/** openening a file part wrapped within a (mmapped) zip archive + * + * This function opens a file found by name, so it does a search into + * 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_DISK_ENTRY *entry = zzip_disk_findfile(disk, filename, 0, 0); + if (! entry) + return 0; + else + return zzip_disk_entry_fopen(disk, entry); +} + + +/** => zzip_disk_fopen + * + * This function reads more bytes into the output buffer specified as + * arguments. The return value is null on eof or error, the stdio-like + * interface can not distinguish between these so you need to check + * 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_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; + } + + 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); + if (err == Z_STREAM_END) + file->avail = 0; + else if (err == Z_OK) + file->avail -= file->zlib.total_out - total_old; + else + return 0; + return file->zlib.total_out - total_old; + ____; + ____; +} + +/** => zzip_disk_fopen + * This function releases any zlib decoder info needed for decompression + * and dumps the ZZIP_DISK_FILE* then. + */ +int +zzip_disk_fclose(ZZIP_DISK_FILE * file) +{ + if (! file->stored) + inflateEnd(&file->zlib); + free(file); + return 0; +} + +/** => zzip_disk_fopen + * + * 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) +{ + return ! file || ! file->avail; +} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/mmapped.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/mmapped.h new file mode 100644 index 00000000000..ee2ba5ad8b6 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/mmapped.h @@ -0,0 +1,138 @@ +#ifndef _ZZIP_MMAPPED_H_ +#define _ZZIP_MMAPPED_H_ +/* + * NOTE: this is part of libzzipmmapped (i.e. it is not libzzip). + * + * simplified zip disk access using a mmapping of the whole archive. + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2003,2004 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + + +#include <zzip/types.h> + +#ifdef _ZZIP_DISK_FILE_STRUCT +#include <zlib.h> /* z_stream */ +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct zzip_disk_file ZZIP_DISK_FILE; +typedef struct zzip_disk ZZIP_DISK; +/* def struct zzip_disk_entry ZZIP_DISK_ENTRY; */ + +/* we expose this structure so third party applications can augment + * on them. The mmapped zip access usually just needs the two pointers + * specifying the mmapped area, whereever you have that from. + */ +struct zzip_disk +{ + zzip_byte_t* buffer; /* start of mmapped area, the base of all seekvals */ + zzip_byte_t* endbuf; /* end of mmapped area, i.e. buffer + buflen */ + void* reserved; /* - for later extensions (might be renamed) */ + void* user; /* - free for applications (use this!) */ + long flags; /* bit 0: findfile searches case-insensitive */ + long mapped; /* used for mmap() wrappers of zzip/__mmap.h */ + long unused; /* - for later extensions (might be renamed) */ + long code; /* - free for applications (use this!) */ +}; + +/* fnmatch search shall be case insensitive */ +#define ZZIP_DISK_FLAGS_MATCH_NOCASE 1 +#define ZZIP_DISK_FLAGS_OWNED_BUFFER 2 + +typedef int (*zzip_strcmp_fn_t)(char*, char*); +typedef int (*zzip_fnmatch_fn_t)(char*, char*, int); + +#define zzip_disk_extern extern + +zzip_disk_extern int +zzip_disk_init(ZZIP_DISK* disk, void* buffer, zzip_size_t buflen); + +zzip_disk_extern zzip__new__ ZZIP_DISK* +zzip_disk_new(void); + +zzip_disk_extern zzip__new__ ZZIP_DISK* +zzip_disk_mmap(int fd); + +zzip_disk_extern int +zzip_disk_munmap(ZZIP_DISK* disk); + +zzip_disk_extern zzip__new__ ZZIP_DISK* +zzip_disk_open(char* filename); + +zzip_disk_extern zzip__new__ ZZIP_DISK * +zzip_disk_buffer(void *buffer, size_t buflen); + +zzip_disk_extern int +zzip_disk_close(ZZIP_DISK* disk); + + +zzip_disk_extern ZZIP_DISK_ENTRY* +zzip_disk_findfirst(ZZIP_DISK* disk); + +zzip_disk_extern ZZIP_DISK_ENTRY* +zzip_disk_findnext(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry); + +zzip_disk_extern zzip__new__ char* +zzip_disk_entry_strdup_name(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry); +zzip_disk_extern zzip__new__ char* +zzip_disk_entry_strdup_comment(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry); +zzip_disk_extern struct zzip_file_header* +zzip_disk_entry_to_file_header(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry); +zzip_disk_extern zzip_byte_t* +zzip_disk_entry_to_data(ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry); + +zzip_disk_extern ZZIP_DISK_ENTRY* +zzip_disk_findfile(ZZIP_DISK* disk, + char* filename, ZZIP_DISK_ENTRY* after, + zzip_strcmp_fn_t compare); +zzip_disk_extern ZZIP_DISK_ENTRY* +zzip_disk_findmatch(ZZIP_DISK* disk, + char* filespec, ZZIP_DISK_ENTRY* after, + zzip_fnmatch_fn_t compare, int flags); + + +zzip_disk_extern zzip__new__ ZZIP_DISK_FILE* +zzip_disk_entry_fopen (ZZIP_DISK* disk, ZZIP_DISK_ENTRY* entry); + +zzip_disk_extern zzip__new__ ZZIP_DISK_FILE* +zzip_disk_fopen (ZZIP_DISK* disk, char* filename); + +zzip_disk_extern _zzip_size_t +zzip_disk_fread (void* ptr, _zzip_size_t size, _zzip_size_t nmemb, + ZZIP_DISK_FILE* file); +zzip_disk_extern int +zzip_disk_fclose (ZZIP_DISK_FILE* file); +int +zzip_disk_feof (ZZIP_DISK_FILE* file); + +#ifdef _ZZIP_DISK_FILE_STRUCT +/** + * typedef struct zzip_disk_file ZZIP_DISK_FILE; + */ +struct zzip_disk_file +{ + zzip_byte_t* buffer; /* fopen disk->buffer */ + zzip_byte_t* endbuf; /* fopen disk->endbuf */ + zzip_size_t avail; /* memorized for checks on EOF */ + z_stream zlib; /* for inflated blocks */ + zzip_byte_t* stored; /* for stored blocks */ +}; +#endif + +#ifdef __cplusplus +} +#endif +#endif + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/plugin.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/plugin.c new file mode 100644 index 00000000000..a7d77c060cd --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/plugin.c @@ -0,0 +1,86 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Mike Nordell <tamlin-@-algonet-se> + * + * Copyright (c) 2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/lib.h> +#include <zzip/plugin.h> + +#include <string.h> +#include <sys/stat.h> +#include <errno.h> +#include <stdlib.h> +#ifdef DEBUG +#include <stdio.h> +#endif + +#include <zzip/file.h> +#include <zzip/format.h> + +zzip_off_t +zzip_filesize(int fd) +{ + struct stat st; + + if (fstat(fd, &st) < 0) + return -1; + +# if defined DEBUG && ! defined _WIN32 + if (! st.st_size && st.st_blocks > 1) /* seen on some darwin 10.1 machines */ + fprintf(stderr, "broken fstat(2) ?? st_size=%ld st_blocks=%ld\n", + (long) st.st_size, (long) st.st_blocks); +# endif + + return st.st_size; +} + +static const struct zzip_plugin_io default_io = { + &open, + &close, + &_zzip_read, + &_zzip_lseek, + &zzip_filesize, + 1, 1, + &_zzip_write +}; + +/** => zzip_init_io + * This function returns a zzip_plugin_io_t handle to static defaults + * wrapping the posix io file functions for actual file access. + */ +zzip_plugin_io_t +zzip_get_default_io(void) +{ + return (zzip_plugin_io_t) & default_io; +} + +/** + * This function initializes the users handler struct to default values + * being the posix io functions in default configured environments. + */ +int +zzip_init_io(zzip_plugin_io_handlers_t io, int flags) +{ + if (! io) + { + return ZZIP_ERROR; + } + memcpy(io, &default_io, sizeof(default_io)); + io->fd.sys = flags; + return 0; +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/plugin.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/plugin.h new file mode 100644 index 00000000000..b6ccbe8a66f --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/plugin.h @@ -0,0 +1,96 @@ +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2002,2003 Guido Draheim + * All rights reserved + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * the interfaces for the plugin_io system + * + * Using the following you can provide your own file I/O functions to + * e.g. read data directly from memory, provide simple + * "encryption"/"decryption" of on-disk .zip-files... + * Note that this currently only provides a subset of the functionality + * in zziplib. It does not attempt to provide any directory functions, + * but if your program 1) only uses ordinary on-disk files and you + * just want this for file obfuscation, or 2) you only access your + * .zip archives using zzip_open & co., this is sufficient. + * + * Currently the default io are the POSIX functions, except + * for 'filesize' that is zziplibs own provided zzip_filesize function, + * using standard POSIX fd's. You are however free to replace this with + * whatever data type you need, so long as you provide implementations + * for all the functions, and the data type fits an int. + * + * all functions receiving ext_io are able to cope with both arguments + * set to zero which will let them default to a ZIP ext and posix io. + */ +#ifndef _ZZIP_PLUGIN_H /* zzip-io.h */ +#define _ZZIP_PLUGIN_H 1 + +#include <zzip/zzip.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* we have renamed zzip_plugin_io.use_mmap to zzip_plugin_io.sys */ +#define ZZIP_PLUGIN_IO_SYS 1 + +struct zzip_plugin_io { /* use "zzip_plugin_io_handlers" in applications !! */ + int (*open)(zzip_char_t* name, int flags, ...); + int (*close)(int fd); + zzip_ssize_t (*read)(int fd, void* buf, zzip_size_t len); + zzip_off_t (*seeks)(int fd, zzip_off_t offset, int whence); + zzip_off_t (*filesize)(int fd); + long sys; + long type; + zzip_ssize_t (*write)(int fd, _zzip_const void* buf, zzip_size_t len); +}; + +typedef union _zzip_plugin_io +{ + struct zzip_plugin_io fd; + struct { void* padding[8]; } ptr; +} zzip_plugin_io_handlers; + +#define _zzip_plugin_io_handlers zzip_plugin_io_handlers +/* for backward compatibility, and the following to your application code: + * #ifndef _zzip_plugin_io_handlers + * #define _zzip_plugin_io_handlers struct zzip_plugin_io + */ +typedef zzip_plugin_io_handlers* zzip_plugin_io_handlers_t; + +#ifdef ZZIP_LARGEFILE_RENAME +#define zzip_filesize zzip_filesize64 +#define zzip_get_default_io zzip_get_default_io64 +#define zzip_init_io zzip_init_io64 +#endif + +_zzip_export zzip_off_t +zzip_filesize(int fd); + +/* get the default file I/O functions */ +_zzip_export zzip_plugin_io_t zzip_get_default_io(void); + +/* + * Initializes a zzip_plugin_io_t to the zziplib default io. + * This is useful if you only want to override e.g. the 'read' function. + * all zzip functions that can receive a zzip_plugin_io_t can + * handle a zero pointer in that place and default to posix io. + */ +_zzip_export +int zzip_init_io(zzip_plugin_io_handlers_t io, int flags); + +/* zzip_init_io flags : */ +# define ZZIP_IO_USE_MMAP 1 + +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/stat.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/stat.c new file mode 100644 index 00000000000..33f4fdc223c --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/stat.c @@ -0,0 +1,135 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <Tomi.Ollila@iki.fi> + * + * Copyright (c) 1999,2000,2001,2002 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * Description: + * although this file is defining a function called zzip_stat it + * will not need a real stat(2) exported by the Operating System. + * It will just try to fill the fields of the ZZIP_STAT structure + * of + */ + +#include <zzip/lib.h> /* exported... */ +#include <zzip/file.h> +#include <string.h> +#if defined(_AIX) +#include <strings.h> /* for strcasecmp */ +#endif +#include <sys/stat.h> + +#define ZZIP_USE_INTERNAL +#include <zzip/info.h> + +/** + * obtain information about a filename in an opened zip-archive without + * opening that file first. Mostly used to obtain the uncompressed + * size of a file inside a zip-archive. see => zzip_dir_open. + */ +int +zzip_dir_stat(ZZIP_DIR * dir, zzip_char_t * name, ZZIP_STAT * zs, int flags) +{ + struct zzip_dir_hdr *hdr = dir->hdr0; + int (*cmp) (zzip_char_t *, zzip_char_t *); + + cmp = (flags & ZZIP_CASEINSENSITIVE) ? strcasecmp : strcmp; + + if (! hdr) + { + dir->errcode = ZZIP_ENOENT; + return -1; + } + + if (flags & ZZIP_IGNOREPATH) + { + char *n = strrchr(name, '/'); + if (n) + name = n + 1; + } + + while (1) + { + register char *hdr_name = hdr->d_name; + if (flags & ZZIP_IGNOREPATH) + { + register char *n = strrchr(hdr_name, '/'); + if (n) + hdr_name = n + 1; + } + + if (! cmp(hdr_name, name)) + break; + + if (! hdr->d_reclen) + { + dir->errcode = ZZIP_ENOENT; + return -1; + } + + hdr = (struct zzip_dir_hdr *) ((char *) hdr + hdr->d_reclen); + } + + zs->d_compr = hdr->d_compr; + zs->d_csize = hdr->d_csize; + zs->st_size = hdr->d_usize; + zs->d_name = hdr->d_name; + + return 0; +} + +/** => zzip_dir_stat + * This function will obtain information about a opened file _within_ a + * zip-archive. The file is supposed to be open (otherwise -1 is returned). + * The st_size stat-member contains the uncompressed size. The optional + * d_name is never set here. + */ +int +zzip_file_stat(ZZIP_FILE * file, ZZIP_STAT * zs) +{ + if (! file) + return -1; + zs->d_compr = file->method; + zs->d_csize = file->csize; + zs->st_size = file->usize; + zs->d_name = 0; + return 0; +} + +/** => zzip_dir_stat + * This function will obtain information about a opened file which may be + * either real/zipped. The file is supposed to be open (otherwise -1 is + * returned). The st_size stat-member contains the uncompressed size. + * The optional d_name is never set here. For a real file, we do set the + * d_csize := st_size and d_compr := 0 for meaningful defaults. + */ +int +zzip_fstat(ZZIP_FILE * file, ZZIP_STAT * zs) +{ + if (ZZIP_file_real(file)) + { + struct stat st; + if (fstat(file->fd, &st) < 0) + return -1; + zs->st_size = st.st_size; + zs->d_csize = st.st_size; + zs->d_compr = 0; + return 0; + } else + { + return zzip_file_stat(file, zs); + } +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/stdint.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/stdint.h new file mode 100644 index 00000000000..4552c5b04e0 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/stdint.h @@ -0,0 +1,45 @@ +#ifndef _ZZIP__STDINT_H /* zzip-stdint.h */ +#define _ZZIP__STDINT_H 1 +/* this file ensures that we have some kind of typedef declarations for + unsigned C9X typedefs. The ISO C 9X: 7.18 Integer types file is stdint.h + */ + +#include <zzip/conf.h> + +/* enforce use of ifdef'd C9X entries in system headers */ +#define __USE_ANSI 1 +#define __USE_ISOC9X 1 + +#ifdef ZZIP_HAVE_STDINT_H + /* ISO C 9X: 7.18 Integer types <stdint.h> */ +#include <stdint.h> +#elif defined ZZIP_HAVE_SYS_INT_TYPES_H /*solaris*/ +#include <sys/int_types.h> +#elif defined ZZIP_HAVE_INTTYPES_H /*freebsd*/ +#include <inttypes.h> +#else + typedef unsigned char uint8_t; typedef signed char int8_t; + +# if ZZIP_SIZEOF_INT && ZZIP_SIZEOF_INT == 2 + typedef unsigned int uint16_t; typedef signed int int16_t; +# elif ZZIP_SIZEOF_SHORT && ZZIP_SIZEOF_SHORT == 2 + typedef unsigned short uint16_t; typedef signed short int16_t; +# else +# error unable to typedef int16_t from either int or short + typedef unsigned short uint16_t; typedef signed short int16_t; +# endif + +# if defined ZZIP_SIZEOF_INT && ZZIP_SIZEOF_INT == 4 + typedef unsigned int uint32_t; typedef signed int int32_t; +# elif defined ZZIP_SIZEOF_LONG && ZZIP_SIZEOF_LONG == 4 + typedef unsigned long uint32_t; typedef signed long int32_t; +# else +# error unable to typedef int32_t from either int or long + typedef unsigned long uint32_t; typedef signed long int32_t; +# endif + +typedef unsigned _zzip___int64 uint64_t; typedef _zzip___int64 int64_t; +#endif + +#endif /*_ZZIP_STDINT_H*/ + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/types.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/types.h new file mode 100644 index 00000000000..6f9c6e6f983 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/types.h @@ -0,0 +1,57 @@ +/* + * unlike in <zzip/conf.h> we are allowed to make up typedefs here, + * while over there only #defines are allowed + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2003,2004 Guido Draheim + * All rights reserved, + * usage allowed under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * This file is usually the first to define some real symbols. If you do + * see some errors here then it is most likely the includepath is wrong + * or some includeheader is missing / unreadable on your system. + * (a) we include local headers with a "zzip/" prefix just to be sure + * to not actually get the wrong one. Consider to add `-I..` somewhere + * and especially VC/IDE users (who make up their own workspace files) + * should include the root source directory of this project. + * (b) size_t and ssize_t are sometimes found be `configure` but they are + * not in the usual places (ANSI C = stddef.h; UNIX = sys/types.h), so + * be sure to look for them and add the respective header as an #include. + */ + +#ifndef _ZZIP_TYPES_H_ +#define _ZZIP_TYPES_H_ + +#include <zzip/conf.h> +#include <fcntl.h> +#include <stddef.h> /* size_t and friends */ +#ifdef ZZIP_HAVE_SYS_TYPES_H +#include <sys/types.h> /* bsd (mac) has size_t here */ +#endif +/* msvc6 has neither ssize_t (we assume "int") nor off_t (assume "long") */ + +typedef unsigned char zzip_byte_t; // especially zlib decoding data + +typedef _zzip_off64_t zzip_off64_t; +typedef _zzip_off_t zzip_off_t; +typedef _zzip_size_t zzip_size_t; /* Some error here? */ +typedef _zzip_ssize_t zzip_ssize_t; /* See notes above! */ + +/* in <zzip/format.h> */ +typedef struct zzip_disk64_trailer ZZIP_DISK64_TRAILER; +typedef struct zzip_disk_trailer ZZIP_DISK_TRAILER; +typedef struct zzip_file_trailer ZZIP_FILE_TRAILER; +typedef struct zzip_root_dirent ZZIP_ROOT_DIRENT; +typedef struct zzip_file_header ZZIP_FILE_HEADER; +typedef struct zzip_disk_entry ZZIP_DISK_ENTRY; +typedef struct zzip_extra_block ZZIP_EXTRA_BLOCK; + + + +#endif + diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/write.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/write.c new file mode 100644 index 00000000000..d862fe21d21 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/write.c @@ -0,0 +1,493 @@ + +/* + * The write-support in zziplib is not a full-flegded interface to the + * internals that zip file-header or zip archive an contain. It's + * primary use goes for savegames or transfer `pack-n-go` archives + * where time-stamps are rather unimportant. Here we can create an + * archive with filenames and their data portions, possibly obfuscated. + * + * DONT USE THIS + * + * The write support is supposed to be added directly into the main + * zziplib but it has not been implemented so far. It does however + * export the relevant call entries which will return EROFS (read-only + * filesystem) in case they are being called. That allows later programs + * to start up with earlier versions of zziplib that can only read ZIPs. + * + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#define _ZZIP_WRITE_SOURCE + +#if defined DDDD || defined DDDDD || defined DDDDDD || defined DDDDDDD +#define _ZZIP_ENABLE_WRITE +#else /* per default, we add support for passthrough to posix write */ +#define _ZZIP_POSIX_WRITE +#endif + +#include <zzip/write.h> /* #includes <zzip/lib.h> */ +#include <zzip/file.h> + +#include <string.h> +#include <sys/stat.h> +#include <errno.h> +#include <stdlib.h> +#include <ctype.h> + +#ifdef ZZIP_HAVE_DIRECT_H +#include <direct.h> +#endif + +#include <zzip/format.h> +#include <zzip/plugin.h> +#include <zzip/__debug.h> + +#define ___ { +#define ____ } + +#ifndef EROFS +# ifdef ENOSYS +#define EROFS ENOSYS +# else +#define EROFS EPERM +#endif +#endif + +/* try real zlib routines for writing ? very experimental, very very ex... */ +#ifndef _ZZIP_ENABLE_WRITE +#define _ZZIP_TRY 0 +#else +#define _ZZIP_TRY 1 +#endif + +/* btw, is there any system that did define those different ? get away.. */ +# ifndef S_IWGRP +# define S_IWGRP 00020 +# endif +# ifndef S_IRWXO +# define S_IRWXO 00007 +# endif + +# ifdef ZZIP_HAVE_DIRECT_H +# define _mkdir(a,b) mkdir(a) +# else +# define _mkdir mkdir +# endif + +/** create a new zip archive for writing + * + * This function will create a new zip archive. The returned parameter + * is a new "zzip dir" handle that should be saved to a variable so it + * can be used a base argument for => zzip_mkdir and => zzip_creat calls. + * The returned handle represents a zip central directory that must be + * saved to disk using => zzip_closedir. + * + * Returns null on error and sets errno. Remember, according to posix + * the => creat(2) call is equivalent to + open (path, O_WRONLY | O_CREAT | O_TRUNC, o_mode) + * so any previous zip-archive will be overwritten unconditionally and + * EEXIST errors from => mkdir(2) are suppressed. (fixme: delete the + * given subtree? like suggested by O_TRUNC? not done so far!) + */ +ZZIP_DIR * +zzip_dir_creat(zzip_char_t * name, int o_mode) +{ + return zzip_dir_creat_ext_io(name, o_mode, 0, 0); +} + +/** => zzip_dir_creat + * + * If the third argument "ext" has another special meaning here, as it + * is used to ensure that a given zip-file is created with the first entry + * of the ext-list appended as an extension unless the file-path already + * ends with a file-extension registered in the list. Therefore {"",0} + * matches all files and creates them as zip-archives under the given + * nonmodified name. (Some magic here? If the path ends in the path + * separator then make a real directory even in the presence of ext-list?) + * + * This function is not yet implemented, check for #def ZZIP_NO_CREAT + * Write-support will extend => zzip_closedir with semantics to finalize the + * zip-archive by writing the zip-trailer and closing the archive file. + */ +ZZIP_DIR * +zzip_dir_creat_ext_io(zzip_char_t * name, int o_mode, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + if (! io) + io = zzip_get_default_io(); + + if (io != zzip_get_default_io()) + { + /* the current io-structure does not contain a "write" entry, + * and therefore this parameter is useless. Anyone to expect + * some behavior should be warned, so here we let the function + * fail bluntly - and leaving the recovery to the application + */ + errno = EINVAL; + return 0; + } + + + if (! _ZZIP_TRY) + { + /* not implemented - however, we respect that a null argument to + * zzip_mkdir and zzip_creat works, so we silently still do the mkdir + */ + if (! _mkdir(name, o_mode) || errno == EEXIST) + errno = EROFS; + return 0; + } else + { +# define MAX_EXT_LEN 10 + ZZIP_DIR *dir = zzip_dir_alloc(ext); + int name_len = strlen(name); + dir->realname = malloc(name_len + MAX_EXT_LEN); + if (! dir->realname) + goto error; + + memcpy(dir->realname, name, name_len + 1); + ___ int fd = + __zzip_try_open(dir->realname, O_EXCL | O_TRUNC | O_WRONLY, ext, + io); + if (fd != -1) + { dir->fd = fd; return dir; } + + ___ zzip_strings_t *exx = ext; + int exx_len; + for (; *exx; exx++) + { + if ((exx_len = strlen(*exx) + 1) <= name_len && + ! memcmp(dir->realname + (name_len - exx_len), *exx, exx_len)) + break; /* keep unmodified */ + exx++; + if (*exx) + continue; + + if (! (exx_len = strlen(*exx)) || exx_len >= MAX_EXT_LEN) + break; + memcpy(dir->realname + name_len, exx, exx_len); /* append! */ + } + ____; + fd = io->fd.open(dir->realname, O_CREAT | O_TRUNC | O_WRONLY, o_mode); + dir->realname[name_len] = '\0'; /* keep ummodified */ + if (fd != -1) + { dir->fd = fd; return dir; } + error: + zzip_dir_free(dir); + return 0; + ____; + } +} + +/** create a new archive area for writing + * + * This function will create a new archive area. This may either be a + * a new zip archive or a new directory in the filesystem. The returned + * parameter is a new "zzip dir" handle that should be saved to a variable + * so it can be used a base argument for => zzip_file_mkdir and + * => zzip_file_creat calls. The returned handle wraps both possibilities, + * it can be representing a zip central directory that must be + * saved to disk using => zzip_closedir or it is just a handle for the + * name of the real directory that still must be run through + * => zzip_closedir to release the wrapper around the directory name. + * + * The magic is pushed through the o_mode argument. Using a mode that + * has no group-write bit set (S_IWGRP = 0040) then the file is + * created as a zip directory. Note that this is unabridged of any + * umask value in the system where the argument to this function could + * be 0775 but with an umask of 0755 it turns out as 0755 for a real + * directory. Using 0755 directly would not create it as a real directory + * but as a zip archive handle. + * + * This function is not yet implemented, check for #def ZZIP_NO_CREAT + * Write-support will extend => zzip_closedir with semantics to finalize the + * zip-archive by writing the zip-trailer and closing the archive file. + * + * Returns null on error and sets errno. Remember, according to posix + * the => creat(2) call is equivalent to + open (path, O_WRONLY | O_CREAT | O_TRUNC, o_mode) + * so any previous zip-archive will be overwritten unconditionally and + * EEXIST errors from => mkdir(2) are suppressed. (fixme: delete the + * given subtree? like suggested by O_TRUNC? not done so far!) + */ +ZZIP_DIR * +zzip_createdir(zzip_char_t * name, int o_mode) +{ + if (o_mode & S_IWGRP) + { + if (-1 == _mkdir(name, o_mode) && errno != EEXIST) /* fail */ + return 0; + return zzip_opendir(name); + } else + return zzip_dir_creat(name, o_mode); +} + +/** => zzip_file_creat also: mkdir(2), creat(2), zzip_dir_creat + * + * This function has an additional primary argument over the posix + * mkdir(2) - if it is null then this function behaves just like + * posix mkdir(2). The zzip_dir argument can be set to the result + * of a => zzip_createdir which allows for some magic that the + * given directory name is created as an entry in the zip archive. + * + * If the given dir name argument is not within the basepath of + * the zip central directory then a real directory is created. + * Any EEXIST errors are not suppressed unlike with => zzip_createdir + * + * Standard usage accepts a global/threaded/modular ZZIP_DIR pointer + * for all zip archive operations like in: + ZZIP_DIR* zip = zzip_createdir (sysconfpath, 0755, zip); + zzip_file_mkdir (zip, filepath[i], 0755); + ZZIP_FILE* file = zzip_file_creat (zip, filename[i], 0644); + zzip_write (file, buf, len); + zzip_close (file); file = 0; + zzip_closedir (zip); zip = 0; + * + * compare with => zzip_mkdir inline macro which allows to + * collapse the examples script to + #define zzip_savefile myproject_saveconfig + #include <zzip/zzip.h> + ZZIP_DIR* zzip_savefile = zzip_createdir (sysconfpath, 0755); + zzip_mkdir (filepath[i], 0755); + ZZIP_FILE* file = zzip_creat(filepath[i], 0644); + zzip_write (file, buf, len); + zzip_close (file); file = 0; + zzip_closedir (zip_savefile); + */ +int +zzip_file_mkdir(ZZIP_DIR * dir, zzip_char_t * name, int o_mode) +{ + if (! dir) + return _mkdir(name, o_mode); + + if (! _ZZIP_TRY) + { /* not implemented */ + errno = EROFS; + return -1; + } else + { + errno = EROFS; + return -1; + } +} + +/** start next file entry in a zip archive + * + * This function will create a new file within a zzip archive, the + * one given as the primary argument and additionally to the posix + * creat(2) - just like zzip_mkdir has an additional argument over + * the posix mkdir(2) spec. For this function the primary parameter + * can be null as well thereby creating a real file instead of a new + * one inside the zip-archive otherwise given. If the primary parameter is + * not null but wraps a real directory then all new files are also real. + * + * This function is not yet implemented, check for #def ZZIP_NO_CREAT + * + * Returns NULL on an error setting errno, and opening a file _within_ + * a zip archive using O_RDONLY (and similar stuff) will surely lead to + * an error. + */ +ZZIP_FILE * +zzip_file_creat(ZZIP_DIR * dir, zzip_char_t * name, int o_mode) +{ + if (! dir) + return zzip_open(name, o_mode); + + if (! _ZZIP_TRY) + { /* not implemented */ + errno = EROFS; + return 0; + } else + { + errno = EROFS; + return 0; + } +} + +/** write to zzip storage also: write(2), zlib(3) + * + * This function will write data to a file descriptor. If the file + * descriptor represents a real file then it will be forwarded to + * call posix => write(2) directly. If it is a descriptor for a + * file within a zip directory then the data will be "deflated" + * using => zlib(3) and appended to the zip archive file. + */ +zzip_ssize_t +zzip_write(ZZIP_FILE * file, const void *ptr, zzip_size_t len) +{ + if (zzip_file_real(file)) + return write(zzip_realfd(file), ptr, len); + else + return zzip_file_write(file, ptr, len); +} + +/** => zzip_write also: zzip_file_creat + * + * This function will write data to a file descriptor inside a zip + * archive. The data will be "deflated" using => zlib(3) compression + * and appended to the end of the zip archive file. Only one file + * descriptor may be open per zzip_dir archive handle (fifo-like). + * + * This function is not yet implemented, check for #def ZZIP_NO_CREAT + * It returns immediately -1 and sets errno=EROFS for indication. + */ +zzip_ssize_t +zzip_file_write(ZZIP_FILE * file, const void *ptr, zzip_size_t len) +{ + if (! _ZZIP_TRY) + { /* not implemented */ + errno = EROFS; + return -1; + } else + { + /* add calls to zlib here... */ + errno = EROFS; + return -1; + } +} + +/** => zzip_write + * This function is the stdc variant for writing and the arguments + * are forwarded to => zzip_write - the return value is floored to + * null as for STDC spec but there is no zzip_ferror call so far + * for the zziplib (later? is it actually needed?). + * + * This function is not yet implemented, check for #def ZZIP_NO_CREAT + * Write-support extends => zzip_close with semantics to write out a + * file-trailer to the zip-archive leaving a name/offset marker in + * the (still-open) ZZIP_DIR handle. + */ +zzip_size_t +zzip_fwrite(const void *ptr, zzip_size_t len, zzip_size_t multiply, + ZZIP_FILE * file) +{ + zzip_ssize_t value = zzip_write(file, ptr, len * multiply); + if (value == -1) + value = 0; + return (zzip_size_t) value; +} + +#if 0 /* pure documentation */ + +/** create a zipped file/directory also: zzip_dir_creat, mkdir(2) + * + * This function creates a directory entry in the default zip-archive. + * If you did not specify a "#define zzip_savefile somevar" + * then the default zip-archive is null and all directories are + * created as real directories in the filesystem. This function is + * really a preprocessor macro or preferably an inline function + * around => zzip_file_mkdir, there is no such symbol generated + * into the library. The prototype is modelled after the posix + * => mkdir(2) call. + #ifndef zzip_savefile + #define zzip_savefile 0 + #endif + #define zzip_mkdir(name,mode) \ - + zzip_file_mkdir(zzip_savefile,name,mode) + * + */ +int inline +zzip_mkdir(zzip_char_t * name, int o_mode) +{ + return zzip_file_creat(zzip_savefile, name, mode); +} +#endif + +#if 0 /* pure documentation */ + +/** => zzip_mkdir also: creat(2), zzip_start + * + * This function creates a file in the default zip-archive. + * If you did not specify a "#define zzip_savefile somevar" + * then the default zip-archive is null and all files are created + * as real files. This function is really a preprocessor macro + * or preferably an inline function around => zzip_file_creat, + * there is no such symbol generated into the library. The prototype + * is modelled after the posix => creat(2) call. + #ifndef zzip_savefile + #define zzip_savefile 0 + #endif + #define zzip_creat(name,mode) \ - + zzip_file_creat(zzip_savefile,name,mode) + */ +ZZIP_FILE *inline +zzip_creat(zzip_char_t * name, int o_mode) +{ + return zzip_file_creat(zzip_savefile, name, mode); +} +#endif + + +#if 0 /* pure documentation */ + +/** start writing to the magic zzip_savefile also: zzip_creat, zzip_write + * + * open a zip archive for writing via the magic zzip_savefile macro + * variable. The name and mode are given to => zzip_createdir and + * the result is stored into => zzip_savefile - if the => zzip_savefile + * did already have a zzip_dir handle then it is automatically + * finalized with => zzip_sync and the handle closed and the + * zzip_savefile variable reused for the new zip archive just started + * with this call. - This function is really a preprocessor macro + * or preferably an inline function around => zzip_dir_create, there + * is no such symbol generated into the library. + #ifndef zzip_savefile + #define zzip_savefile 0 + #endif + #define zzip_start(name,mode,ext) \ - + { if (zzip_savefile) zzip_closedir(zzip_savefile); \ - + zzip_savefile = zzip_createdir(name,mode,ext); } + * This function returns null on error or a zzip_dir handle on + * success. It is perfectly okay to continue with a null in the + * zzip_savefile variable since it makes subsequent calls to + * => zzip_creat and => zzip_mkdir to run as => creat(2) / => mkdir(2) + * on the real filesystem. + */ +void inline +zzip_mkfifo(zzip_char_t * name, int o_mode) +{ + if (zzip_savefile) + zzip_closedir(zzip_savefile); + zzip_savefile = zzip_createdir(name, o_mode); +} +#endif + +#if 0 /* pure documentation */ + +/** => zzip_mkfifo also: zzip_closedir, sync(2) + * + * finalize a zip archive thereby writing the central directory to + * the end of the file. If it was a real directory then we do just + * nothing - even that the prototype of the call itself is modelled + * to be similar to the posix => sync(2) call. This function is + * really a preprocessor macro or preferably an inline function + * around => zzip_closedir, there is no such symbol generated + * into the library. + #ifndef zzip_savefile + #define zzip_savefile 0 + #endif + #define zzip_sync(name,mode) \ - + { zzip_closedir(zzip_savefile); zzip_savefile = 0; } + * + */ +void inline +zzip_sync(void) +{ + zzip_closedir(zzip_savefile); + zzip_savefile = 0; +} +#endif + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/write.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/write.h new file mode 100644 index 00000000000..6db6b09eed2 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/write.h @@ -0,0 +1,58 @@ +#ifndef _ZZIP_WRITE_H +#define _ZZIP_WRITE_H + +#include <zzip/lib.h> + +/* ........................................................................ + * write support is not yet implemented + * zzip/write.c + */ +#define ZZIP_NO_CREAT 1 + +ZZIP_DIR* zzip_dir_creat_ext_io(zzip_char_t* name, int o_mode, + zzip_strings_t* ext, zzip_plugin_io_t io); +ZZIP_DIR* zzip_dir_creat(zzip_char_t* name, int o_mode); +int zzip_file_mkdir(ZZIP_DIR* dir, zzip_char_t* name, int o_mode); +ZZIP_FILE* zzip_file_creat(ZZIP_DIR* dir, zzip_char_t* name, int o_mode); +zzip_ssize_t zzip_file_write(ZZIP_FILE* file, + const void* ptr, zzip_size_t len); + +ZZIP_DIR* zzip_createdir(zzip_char_t* name, int o_mode); +zzip_ssize_t zzip_write(ZZIP_FILE* file, const void* ptr, zzip_size_t len); +zzip_size_t zzip_fwrite(const void* ptr, zzip_size_t len, + zzip_size_t multiply, ZZIP_FILE* file); +#ifndef zzip_savefile +#define zzip_savefile 0 +#define zzip_savefile_is_null +#endif + +#ifdef _ZZIP_NO_INLINE +#define zzip_mkdir(_name_,_mode_) \ + zzip_file_mkdir((zzip_savefile),(_name_),(_mode_)) +#define zzip_creat(_name_,_mode_) \ + zzip_file_creat((zzip_savefile),(_name_),(_mode_)) +#define zzip_sync() \ + { zzip_closedir((zzip_savefile)); (zzip_savefile) = 0; } +#define zzip_start(_name_,_mode_,_ext_) \ + { if ((zzip_savefile)) zzip_closedir((zzip_savefile)); + zzip_savefile = zzip_dir_creat(_name_, _mode_,_ext_); } + +#else + +_zzip_inline static int zzip_mkdir(zzip_char_t* name, int o_mode) +{ return zzip_file_mkdir(zzip_savefile, name, o_mode); } +_zzip_inline static ZZIP_FILE* zzip_creat(zzip_char_t* name, int o_mode) +{ return zzip_file_creat(zzip_savefile, name, o_mode); } + +#ifndef zzip_savefile_is_null +_zzip_inline static void zzip_sync(void) +{ zzip_closedir(zzip_savefile); zzip_savefile = 0; } +_zzip_inline static void zzip_mkfifo(zzip_char_t* name, int o_mode) +{ if ((zzip_savefile)) zzip_closedir (zzip_savefile); + zzip_savefile = zzip_createdir(_name_,_mode_); } +#else +_zzip_inline static void zzip_sync(void) {} +_zzip_inline static void zzip_mkfifo(zzip_char_t* name, int o_mode) {} +#endif +#endif /* _ZZIP_NO_INLINE */ +#endif /* _ZZIP_WRITE_H */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zip.c b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zip.c new file mode 100644 index 00000000000..ff6029fb524 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zip.c @@ -0,0 +1,863 @@ + +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <too@iki.fi> + * + * Copyright (c) 1999,2000,2001,2002,2003 Guido Draheim + * All rights reserved, + * use under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + */ + +#include <zzip/lib.h> /* archive handling */ +#include <zzip/file.h> +#include <zzip/format.h> +#include <zzip/fetch.h> + +#include <ctype.h> +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#ifdef ZZIP_HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif + +#include <zzip/__mmap.h> +#include <zzip/__debug.h> + +#define __sizeof(X) ((zzip_ssize_t)(sizeof(X))) + +#ifndef ZZIP_EASY +/* per default, we use a little hack to correct bad z_rootseek parts */ +#define ZZIP_CORRECT_ROOTSEEK 1 +#endif + +#if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || (__GNUC__ >= 4) +# ifdef DEBUG +# warning suppress a warning where the compiler should have optimized instead. +# endif +#define _255 254 +#else +#define _255 255 +#endif + +#define ZZIP_DISK64_TRAILER 1 + +#ifdef ZZIP_DISK64_TRAILER +struct _disk_trailer +{ + void *zz_tail; + void *zz_for_correct_rootseek; // ZZIP_CORRECT_ROOTSEEK + zzip_off64_t zz_entries; + zzip_off64_t zz_finalentries; + zzip_off64_t zz_rootseek; + zzip_off64_t zz_rootsize; +}; +#define _disk_trailer_entries(__p) ((__p)->zz_entries) +#define _disk_trailer_localentries(__p) ((__p)->zz_entries) +#define _disk_trailer_finalentries(__p) ((__p)->zz_entries) +#define _disk_trailer_rootseek(__p) ((__p)->zz_rootseek) +#define _disk_trailer_rootsize(__p) ((__p)->zz_rootsize) +#define _disk_trailer_set_rootseek(__p,__v) ((__p)->rootseek = (__v)) + +#else +#define _disk_trailer zzip_disk_trailer +#define _disk_trailer_entries zzip_disk_trailer_entries +#define _disk_trailer_localentries zzip_disk_trailer_localentries +#define _disk_trailer_finalentries zzip_disk_trailer_finalentries +#define _disk_trailer_rootseek zzip_disk_trailer_rootseek +#define _disk_trailer_rootsize zzip_disk_trailer_rootsize +#define _disk_trailer_set_rootseek zzip_disk_trailer_set_rootseek +#define __zzip_fetch_disk_trailer __zzip_find_disk_trailer +#endif + +/* --------------------------- internals -------------------------------- */ + +/* internal functions of zziplib, avoid at all cost, changes w/o warning. + * we do export them for debugging purpose and special external tools + * which know what they do and which can adapt from version to version + */ + +int __zzip_fetch_disk_trailer(int fd, zzip_off_t filesize, + struct _disk_trailer *_zzip_restrict trailer, + zzip_plugin_io_t io); +int __zzip_parse_root_directory(int fd, + struct _disk_trailer *trailer, + struct zzip_dir_hdr **hdr_return, + zzip_plugin_io_t io); + +_zzip_inline static char *__zzip_aligned4(char *p); + +/* ------------------------ harden routines ------------------------------ */ + +#ifdef ZZIP_HARDEN + +/* + * check for inconsistent values in trailer and prefer lower seek value + * - we fix values assuming the root directory was written at the end + * and it is just before the zip trailer. Therefore, ... + */ +_zzip_inline static void +__fixup_rootseek(zzip_off_t offset_of_trailer, struct _disk_trailer *trailer) +{ + if (_disk_trailer_rootseek(trailer) > + offset_of_trailer - _disk_trailer_rootsize(trailer) && + offset_of_trailer > _disk_trailer_rootsize(trailer)) + { + register zzip_off_t offset; + offset = offset_of_trailer - _disk_trailer_rootsize(trailer); + _disk_trailer_set_rootseek(trailer, offset); + HINT2("new rootseek=%li", (long) _disk_trailer_rootseek(trailer)); + } +} + +#define __correct_rootseek(A,B,C) + +#elif defined ZZIP_CORRECT_ROOTSEEK + +/* store the seekvalue of the trailer into the "z_magic" field and with + * a 64bit off_t we overwrite z_disk/z_finaldisk as well. If you change + * anything in zziplib or dump the trailer structure then watch out that + * these are still unused, so that this code may still (ab)use those. */ +#define __fixup_rootseek(_offset_of_trailer, _trailer) \ + *(zzip_off_t*)_trailer = _offset_of_trailer; +#define __correct_rootseek( _u_rootseek, _u_rootsize, _trailer) \ + if (_u_rootseek > *(zzip_off_t*)_trailer - _u_rootsize) \ + _u_rootseek = *(zzip_off_t*)_trailer - _u_rootsize; +#else +#define __fixup_rootseek(A,B) +#define __correct_rootseek(A,B,C) +#endif + + +#ifdef DEBUG +_zzip_inline static void +__debug_dir_hdr(struct zzip_dir_hdr *hdr) +{ + if (sizeof(struct zzip_dir_hdr) > sizeof(struct zzip_disk_entry)) + { WARN1("internal sizeof-mismatch may break wreakage"); } + /* the internal directory structure is never bigger than the + * external zip central directory space had been beforehand + * (as long as the following assertion holds...) + */ + + if (((zzip_off_t) hdr) & 3) + { + NOTE1("this machine's malloc(3) returns sth. not u32-aligned"); + } + /* we assume that if this machine's malloc has returned a non-aligned + * memory block, then it is actually safe to access misaligned data, and + * since it does only affect the first hdr it should not even bring about + * too much of that cpu's speed penalty + */ +} +#else +#define __debug_dir_hdr(X) +#endif + +/* -------------------------- low-level interface -------------------------- */ + +#if defined BUFSIZ +#if BUFSIZ == 1024 || BUFSIZ == 512 || BUFSIZ == 256 +#define ZZIP_BUFSIZ BUFSIZ +#endif +#endif + +#ifndef ZZIP_BUFSIZ +#define ZZIP_BUFSIZ 512 + +/* #define ZZIP_BUFSIZ 64 / * for testing */ +#endif + +/** + * This function is used by => zzip_file_open. It tries to find + * the zip's central directory info that is usually a few + * bytes off the end of the file. + */ +int +__zzip_fetch_disk_trailer(int fd, zzip_off_t filesize, + struct _disk_trailer *_zzip_restrict trailer, + zzip_plugin_io_t io) +{ +#ifdef DEBUG +#define return(val) { e=val; HINT2("%s", zzip_strerror(e)); goto cleanup; } +#else +#define return(val) { e=val; goto cleanup; } +#endif + register int e; + +#ifndef _LOWSTK + auto char buffer[2 * ZZIP_BUFSIZ]; + char *buf = buffer; +#else + char *buf = malloc(2 * ZZIP_BUFSIZ); +#endif + zzip_off_t offset = 0; + zzip_ssize_t maplen = 0; /* mmap(),read(),getpagesize() use size_t !! */ + char *fd_map = 0; + + if (! trailer) + { return(EINVAL); } + + if (filesize < __sizeof(struct zzip_disk_trailer)) + { return(ZZIP_DIR_TOO_SHORT); } + + if (! buf) + { return(ZZIP_OUTOFMEM); } + + offset = filesize; /* a.k.a. old offset */ + while (1) /* outer loop */ + { + register unsigned char *mapped; + + if (offset <= 0) + { return(ZZIP_DIR_EDH_MISSING); } + + /* trailer cannot be farther away than 64K from fileend */ + if (filesize - offset > 64 * 1024) + { return(ZZIP_DIR_EDH_MISSING); } + + /* the new offset shall overlap with the area after the old offset! */ + if (USE_MMAP && io->fd.sys) + { + zzip_off_t mapoff = offset; + { + zzip_ssize_t pagesize = _zzip_getpagesize(io->fd.sys); + if (pagesize < ZZIP_BUFSIZ) + goto non_mmap; /* an error? */ + if (mapoff == filesize && filesize > pagesize) + mapoff -= pagesize; + if (mapoff < pagesize) + { + maplen = (zzip_ssize_t) mapoff + pagesize; + mapoff = 0; + } else + { + mapoff -= pagesize; + maplen = 2 * pagesize; + if ((zzip_ssize_t) mapoff & (pagesize - 1)) + { /*only 1. run */ + pagesize -= (zzip_ssize_t) mapoff & (pagesize - 1); + mapoff += pagesize; + maplen -= pagesize; + } + } + if (mapoff + maplen > filesize) + maplen = filesize - mapoff; + } + + fd_map = _zzip_mmap(io->fd.sys, fd, mapoff, (zzip_size_t) maplen); + if (fd_map == MAP_FAILED) + goto non_mmap; + mapped = (unsigned char *) fd_map; + offset = mapoff; /* success */ + HINT3("mapped *%p len=%li", fd_map, (long) maplen); + } else + { + non_mmap: + fd_map = 0; /* have no mmap */ + { + zzip_off_t pagesize = ZZIP_BUFSIZ; + if (offset == filesize && filesize > pagesize) + offset -= pagesize; + if (offset < pagesize) + { + maplen = (zzip_ssize_t) offset + pagesize; + offset = 0; + } else + { + offset -= pagesize; + maplen = 2 * pagesize; + if ((zzip_ssize_t) offset & (pagesize - 1)) + { /*on 1st run */ + pagesize -= (zzip_ssize_t) offset & (pagesize - 1); + offset += pagesize; + maplen -= pagesize; + } + } + if (offset + maplen > filesize) + maplen = filesize - offset; + } + + if (io->fd.seeks(fd, offset, SEEK_SET) < 0) + { return(ZZIP_DIR_SEEK); } + if (io->fd.read(fd, buf, (zzip_size_t) maplen) < maplen) + { return(ZZIP_DIR_READ); } + mapped = (unsigned char *) buf; /* success */ + HINT5("offs=$%lx len=%li filesize=%li pagesize=%i", + (long) offset, (long) maplen, (long) filesize, ZZIP_BUFSIZ); + } + + { /* now, check for the trailer-magic, hopefully near the end of file */ + register unsigned char *end = mapped + maplen; + register unsigned char *tail; + for (tail = end - 1; (tail >= mapped); tail--) + { + if ((*tail == 'P') && /* quick pre-check for trailer magic */ + end - tail >= __sizeof(struct zzip_disk_trailer) - 2 && + zzip_disk_trailer_check_magic(tail)) + { +# ifndef ZZIP_DISK64_TRAILER + /* if the file-comment is not present, it happens + that the z_comment field often isn't either */ + if (end - tail >= __sizeof(*trailer)) + { + memcpy(trailer, tail, sizeof(*trailer)); + } else + { + memcpy(trailer, tail, sizeof(*trailer) - 2); + trailer->z_comment[0] = 0; + trailer->z_comment[1] = 0; + } +# else + struct zzip_disk_trailer *orig = + (struct zzip_disk_trailer *) tail; + trailer->zz_tail = tail; + trailer->zz_entries = zzip_disk_trailer_localentries(orig); + trailer->zz_finalentries = + zzip_disk_trailer_finalentries(orig); + trailer->zz_rootseek = zzip_disk_trailer_rootseek(orig); + trailer->zz_rootsize = zzip_disk_trailer_rootsize(orig); +# endif + + __fixup_rootseek(offset + tail - mapped, trailer); + { return(0); } + } else if ((*tail == 'P') && + end - tail >= + __sizeof(struct zzip_disk64_trailer) - 2 + && zzip_disk64_trailer_check_magic(tail)) + { +# ifndef ZZIP_DISK64_TRAILER + return (ZZIP_DIR_LARGEFILE); +# else + struct zzip_disk64_trailer *orig = + (struct zzip_disk64_trailer *) tail; + trailer->zz_tail = tail; + trailer->zz_entries = + zzip_disk64_trailer_localentries(orig); + trailer->zz_finalentries = + zzip_disk64_trailer_finalentries(orig); + trailer->zz_rootseek = zzip_disk64_trailer_rootseek(orig); + trailer->zz_rootsize = zzip_disk64_trailer_rootsize(orig); + { return(0); } +# endif + } + } + } + + if (USE_MMAP && fd_map) + { + HINT3("unmap *%p len=%li", fd_map, (long) maplen); + _zzip_munmap(io->fd.sys, fd_map, (zzip_size_t) maplen); + fd_map = 0; + } + } /*outer loop */ + + cleanup: + if (USE_MMAP && fd_map) + { + HINT3("unmap *%p len=%li", fd_map, (long) maplen); + _zzip_munmap(io->fd.sys, fd_map, (zzip_size_t) maplen); + } +# ifdef _LOWSTK + free(buf); +# endif +# undef return + return e; +} + +/* + * making pointer alignments to values that can be handled as structures + * is tricky. We assume here that an align(4) is sufficient even for + * 64 bit machines. Note that binary operations are not usually allowed + * to pointer types but we do need only the lower bits in this implementation, + * so we can just cast the value to a long value. + */ +_zzip_inline static char * +__zzip_aligned4(char *p) +{ +#define aligned4 __zzip_aligned4 + p += ((long) p) & 1; /* warnings about truncation of a "pointer" */ + p += ((long) p) & 2; /* to a "long int" may be safely ignored :) */ + return p; +} + +/** + * This function is used by => zzip_file_open, it is usually called after + * => __zzip_find_disk_trailer. It will parse the zip's central directory + * information and create a zziplib private directory table in + * memory. + */ +int +__zzip_parse_root_directory(int fd, + struct _disk_trailer *trailer, + struct zzip_dir_hdr **hdr_return, + zzip_plugin_io_t io) +{ + auto struct zzip_disk_entry dirent; + struct zzip_dir_hdr *hdr; + struct zzip_dir_hdr *hdr0; + uint16_t *p_reclen = 0; + zzip_off64_t entries; + zzip_off64_t zz_offset; /* offset from start of root directory */ + char *fd_map = 0; + zzip_off64_t zz_fd_gap = 0; + zzip_off64_t zz_entries = _disk_trailer_localentries(trailer); + zzip_off64_t zz_rootsize = _disk_trailer_rootsize(trailer); + zzip_off64_t zz_rootseek = _disk_trailer_rootseek(trailer); + __correct_rootseek(zz_rootseek, zz_rootsize, trailer); + + hdr0 = (struct zzip_dir_hdr *) malloc(zz_rootsize); + if (! hdr0) + return ZZIP_DIRSIZE; + hdr = hdr0; + __debug_dir_hdr(hdr); + + if (USE_MMAP && io->fd.sys) + { + zz_fd_gap = zz_rootseek & (_zzip_getpagesize(io->fd.sys) - 1); + HINT4(" fd_gap=%ld, mapseek=0x%lx, maplen=%ld", (long) (zz_fd_gap), + (long) (zz_rootseek - zz_fd_gap), + (long) (zz_rootsize + zz_fd_gap)); + fd_map = + _zzip_mmap(io->fd.sys, fd, zz_rootseek - zz_fd_gap, + zz_rootsize + zz_fd_gap); + /* if mmap failed we will fallback to seek/read mode */ + if (fd_map == MAP_FAILED) + { + NOTE2("map failed: %s", strerror(errno)); + fd_map = 0; + } else + { + HINT3("mapped *%p len=%li", fd_map, + (long) (zz_rootsize + zz_fd_gap)); + } + } + + for (entries=0, zz_offset=0; ; entries++) + { + register struct zzip_disk_entry *d; + uint16_t u_extras, u_comment, u_namlen; + +# ifndef ZZIP_ALLOW_MODULO_ENTRIES + if (entries >= zz_entries) { + if (zz_offset + 256 < zz_rootsize) { + FAIL4("%li's entry is long before the end of directory - enable modulo_entries? (O:%li R:%li)", + (long) entries, (long) (zz_offset), (long) zz_rootsize); + } + break; + } +# endif + + if (fd_map) + { d = (void*)(fd_map+zz_fd_gap+zz_offset); } /* fd_map+fd_gap==u_rootseek */ + else + { + if (io->fd.seeks(fd, zz_rootseek + zz_offset, SEEK_SET) < 0) + return ZZIP_DIR_SEEK; + if (io->fd.read(fd, &dirent, sizeof(dirent)) < __sizeof(dirent)) + return ZZIP_DIR_READ; + d = &dirent; + } + + if (! zzip_disk_entry_check_magic(d)) { +# ifndef ZZIP_ALLOW_MODULO_ENTRIES + FAIL4("%li's entry has no disk_entry magic indicator (O:%li R:%li)", + (long) entries, (long) (zz_offset), (long) zz_rootsize); +# endif + break; + } + + if ((zzip_off64_t) (zz_offset + sizeof(*d)) > zz_rootsize || + (zzip_off64_t) (zz_offset + sizeof(*d)) < 0) + { + FAIL4("%li's entry stretches beyond root directory (O:%li R:%li)", + (long) entries, (long) (zz_offset), (long) zz_rootsize); + break; + } +# if 0 && defined DEBUG + zzip_debug_xbuf((unsigned char *) d, sizeof(*d) + 8); +# endif + + u_extras = zzip_disk_entry_get_extras(d); + u_comment = zzip_disk_entry_get_comment(d); + u_namlen = zzip_disk_entry_get_namlen(d); + HINT5("offset=0x%lx, size %ld, dirent *%p, hdr %p\n", + (long) (zz_offset + zz_rootseek), (long) zz_rootsize, d, hdr); + + /* writes over the read buffer, Since the structure where data is + copied is smaller than the data in buffer this can be done. + It is important that the order of setting the fields is considered + when filling the structure, so that some data is not trashed in + first structure read. + at the end the whole copied list of structures is copied into + newly allocated buffer */ + hdr->d_crc32 = zzip_disk_entry_get_crc32(d); + hdr->d_csize = zzip_disk_entry_get_csize(d); + hdr->d_usize = zzip_disk_entry_get_usize(d); + hdr->d_off = zzip_disk_entry_get_offset(d); + hdr->d_compr = zzip_disk_entry_get_compr(d); + if (hdr->d_compr > _255) + hdr->d_compr = 255; + + if ((zzip_off64_t) (zz_offset + sizeof(*d) + u_namlen) > zz_rootsize || + (zzip_off64_t) (zz_offset + sizeof(*d) + u_namlen) < 0) + { + FAIL4("%li's name stretches beyond root directory (O:%li N:%li)", + (long) entries, (long) (zz_offset), (long) (u_namlen)); + break; + } + + if (fd_map) + { memcpy(hdr->d_name, fd_map+zz_fd_gap + zz_offset+sizeof(*d), u_namlen); } + else + { io->fd.read(fd, hdr->d_name, u_namlen); } + hdr->d_name[u_namlen] = '\0'; + hdr->d_namlen = u_namlen; + + /* update offset by the total length of this entry -> next entry */ + zz_offset += sizeof(*d) + u_namlen + u_extras + u_comment; + + if (zz_offset > zz_rootsize) + { + FAIL3("%li's entry stretches beyond root directory (O:%li)", + (long) entries, (long) (zz_offset)); + entries ++; + break; + } + + HINT5("file %ld { compr=%d crc32=$%x offset=%d", + (long) entries, hdr->d_compr, hdr->d_crc32, hdr->d_off); + HINT5("csize=%d usize=%d namlen=%d extras=%d", + hdr->d_csize, hdr->d_usize, u_namlen, u_extras); + HINT5("comment=%d name='%s' %s <sizeof %d> } ", + u_comment, hdr->d_name, "", (int) sizeof(*d)); + + p_reclen = &hdr->d_reclen; + + { + register char *p = (char *) hdr; + register char *q = aligned4(p + sizeof(*hdr) + u_namlen + 1); + *p_reclen = (uint16_t) (q - p); + hdr = (struct zzip_dir_hdr *) q; + } + } /*for */ + + if (USE_MMAP && fd_map) + { + HINT3("unmap *%p len=%li", fd_map, (long) (zz_rootsize + zz_fd_gap)); + _zzip_munmap(io->fd.sys, fd_map, zz_rootsize + zz_fd_gap); + } + + if (p_reclen) + { + *p_reclen = 0; /* mark end of list */ + + if (hdr_return) + *hdr_return = hdr0; + } /* else zero (sane) entries */ +# ifndef ZZIP_ALLOW_MODULO_ENTRIES + return (entries != zz_entries ? ZZIP_CORRUPTED : 0); +# else + return ((entries & (unsigned)0xFFFF) != zz_entries ? ZZIP_CORRUPTED : 0); +# endif +} + +/* ------------------------- high-level interface ------------------------- */ + +#ifndef O_BINARY +#define O_BINARY 0 +#endif + +static zzip_strings_t * +zzip_get_default_ext(void) +{ + static zzip_strings_t ext[] = { + /* *INDENT-OFF* */ + ".zip", ".ZIP", /* common extension */ +# ifdef ZZIP_USE_ZIPLIKES + ".pk3", ".PK3", /* ID Software's Quake3 zipfiles */ + ".jar", ".JAR", /* Java zipfiles */ +# endif + /* *INDENT-ON* */ + 0 + }; + + return ext; +} + +/** + * allocate a new ZZIP_DIR handle and do basic + * initializations before usage by => zzip_dir_fdopen + * => zzip_dir_open => zzip_file_open or through + * => zzip_open + * (ext==null flags uses { ".zip" , ".ZIP" } ) + * (io ==null flags use of posix io defaults) + */ +ZZIP_DIR * +zzip_dir_alloc_ext_io(zzip_strings_t * ext, const zzip_plugin_io_t io) +{ + ZZIP_DIR *dir; + if ((dir = (ZZIP_DIR *) calloc(1, sizeof(*dir))) == NULL) + return 0; + + /* dir->fileext is currently unused - so what, still initialize it */ + dir->fileext = ext ? ext : zzip_get_default_ext(); + dir->io = io ? io : zzip_get_default_io(); + return dir; +} + +/** => zzip_dir_alloc_ext_io + * this function is obsolete - it was generally used for implementation + * and exported to let other code build on it. It is now advised to + * use => zzip_dir_alloc_ext_io now on explicitly, just set that second + * argument to zero to achieve the same functionality as the old style. + */ +ZZIP_DIR * +zzip_dir_alloc(zzip_strings_t * fileext) +{ + return zzip_dir_alloc_ext_io(fileext, 0); +} + +/** + * will free the zzip_dir handle unless there are still + * zzip_files attached (that may use its cache buffer). + * This is the inverse of => zzip_dir_alloc , and both + * are helper functions used implicitly in other zzipcalls + * e.g. => zzip_dir_close = zzip_close + * + * returns zero on sucess + * returns the refcount when files are attached. + */ +int +zzip_dir_free(ZZIP_DIR * dir) +{ + if (dir->refcount) + return (dir->refcount); /* still open files attached */ + + if (dir->fd >= 0) + dir->io->fd.close(dir->fd); + if (dir->hdr0) + free(dir->hdr0); + if (dir->cache.fp) + free(dir->cache.fp); + if (dir->cache.buf32k) + free(dir->cache.buf32k); + if (dir->realname) + free(dir->realname); + free(dir); + return 0; +} + +/** => zzip_dir_free + * It will also => free(2) the => ZZIP_DIR-handle given. + * the counterpart for => zzip_dir_open + * see also => zzip_dir_free + */ +int +zzip_dir_close(ZZIP_DIR * dir) +{ + dir->refcount &= ~0x10000000; /* explicit dir close */ + return zzip_dir_free(dir); +} + +/** + * used by the => zzip_dir_open and zzip_opendir(2) call. Opens the + * zip-archive as specified with the fd which points to an + * already openend file. This function then search and parse + * the zip's central directory. + * + * NOTE: refcount is zero, so an _open/_close pair will also delete + * this _dirhandle + */ +ZZIP_DIR * +zzip_dir_fdopen(int fd, zzip_error_t * errcode_p) +{ + return zzip_dir_fdopen_ext_io(fd, errcode_p, 0, 0); +} + +static zzip_error_t __zzip_dir_parse(ZZIP_DIR * dir); /* forward */ + +/** => zzip_dir_fdopen + * this function uses explicit ext and io instead of the internal + * defaults, setting these to zero is equivalent to => zzip_dir_fdopen + */ +ZZIP_DIR * +zzip_dir_fdopen_ext_io(int fd, zzip_error_t * errcode_p, + zzip_strings_t * ext, const zzip_plugin_io_t io) +{ + zzip_error_t rv; + ZZIP_DIR *dir; + + if ((dir = zzip_dir_alloc_ext_io(ext, io)) == NULL) + { rv = ZZIP_OUTOFMEM; goto error; } + + dir->fd = fd; + if ((rv = __zzip_dir_parse(dir))) + goto error; + + dir->hdr = dir->hdr0; + dir->refcount |= 0x10000000; + + if (errcode_p) + *errcode_p = rv; + return dir; + error: + if (dir) + zzip_dir_free(dir); + if (errcode_p) + *errcode_p = rv; + return NULL; +} + +static zzip_error_t +__zzip_dir_parse(ZZIP_DIR * dir) +{ + zzip_error_t rv; + zzip_off_t filesize; + struct _disk_trailer trailer; + /* if (! dir || dir->fd < 0) + * { rv = EINVAL; goto error; } + */ + + HINT2("------------------ fd=%i", (int) dir->fd); + if ((filesize = dir->io->fd.filesize(dir->fd)) < 0) + { rv = ZZIP_DIR_STAT; goto error; } + + HINT2("------------------ filesize=%ld", (long) filesize); + if ((rv = __zzip_fetch_disk_trailer(dir->fd, filesize, &trailer, + dir->io)) != 0) + { goto error; } + + HINT5("directory = { entries= %ld/%ld, size= %ld, seek= %ld } ", + (long) _disk_trailer_localentries(&trailer), + (long) _disk_trailer_finalentries(&trailer), + (long) _disk_trailer_rootsize(&trailer), + (long) _disk_trailer_rootseek(&trailer)); + + if ((rv = __zzip_parse_root_directory(dir->fd, &trailer, &dir->hdr0, + dir->io)) != 0) + { goto error; } + error: + return rv; +} + +/** + * This function will attach any of the .zip extensions then + * trying to open it the with => open(2). This is a helper + * function for => zzip_dir_open, => zzip_opendir and => zzip_open. + * + * This function returns a new system file handle or -1 on error. + * On error this function leaves the errno(3) of the underlying + * open(2) call on the last file. + */ +int +__zzip_try_open(zzip_char_t * filename, int filemode, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + auto char file[PATH_MAX]; + int fd; + zzip_size_t len = strlen(filename); + + if (len + 4 >= PATH_MAX) + { errno = ENAMETOOLONG; return -1; } + memcpy(file, filename, len + 1); + + if (! io) + io = zzip_get_default_io(); + if (! ext) + ext = zzip_get_default_ext(); + + for (; *ext; ++ext) + { + strcpy(file + len, *ext); + fd = io->fd.open(file, filemode); + if (fd != -1) + return fd; + } + return -1; +} + +/** + * Opens the zip-archive (if available). + * the two ext_io arguments will default to use posix io and + * a set of default fileext that can atleast add .zip ext itself. + */ +ZZIP_DIR * +zzip_dir_open(zzip_char_t * filename, zzip_error_t * e) +{ + return zzip_dir_open_ext_io(filename, e, 0, 0); +} + +/** => zzip_dir_open + * this function uses explicit ext and io instead of the internal + * defaults. Setting these to zero is equivalent to => zzip_dir_open + */ +ZZIP_DIR * +zzip_dir_open_ext_io(zzip_char_t * filename, zzip_error_t * e, + zzip_strings_t * ext, zzip_plugin_io_t io) +{ + int fd; + + if (! io) + io = zzip_get_default_io(); + if (! ext) + ext = zzip_get_default_ext(); + + fd = io->fd.open(filename, O_RDONLY | O_BINARY); + if (fd != -1) + { + return zzip_dir_fdopen_ext_io(fd, e, ext, io); + } else + { + fd = __zzip_try_open(filename, O_RDONLY | O_BINARY, ext, io); + if (fd != -1) + { + return zzip_dir_fdopen_ext_io(fd, e, ext, io); + } else + { + if (e) + { *e = ZZIP_DIR_OPEN; } + return 0; + } + } +} + +/** => zzip_dir_open + * fills the dirent-argument with the values and + * increments the read-pointer of the dir-argument. + * + * returns 0 if there no entry (anymore). + */ +int +zzip_dir_read(ZZIP_DIR * dir, ZZIP_DIRENT * d) +{ + if (! dir || ! dir->hdr || ! d) + return 0; + + d->d_compr = dir->hdr->d_compr; + d->d_csize = dir->hdr->d_csize; + d->st_size = dir->hdr->d_usize; + d->d_name = dir->hdr->d_name; + + if (! dir->hdr->d_reclen) + { + dir->hdr = 0; + } else + { + dir->hdr = (struct zzip_dir_hdr *) + ((char *) dir->hdr + dir->hdr->d_reclen); + } + + return 1; +} + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip-zlib-config.pc b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip-zlib-config.pc new file mode 100644 index 00000000000..62413b93bee --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip-zlib-config.pc @@ -0,0 +1,8 @@ +zlib_libs= -lz +zlib_cflags= + +Name: zzip-zlib-config +Version: 1.2.3 +Description: ZLib Config (for ZZipLib) +Libs: ${zlib_libs} +Cflags: ${zlib_cflags} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip.h new file mode 100644 index 00000000000..6f2c5169080 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip.h @@ -0,0 +1,268 @@ +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * Tomi Ollila <Tomi.Ollila@iki.fi> + * + * Copyright (c) 1999,2000,2001,2002,2003,2004 Guido Draheim + * All rights reserved, + * usage allowed under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * if you see "unknown symbol" errors, check first that `-I ..` is part of + * your compiler options - a special hint to VC/IDE users who tend to make up + * their own workspace files. All includes look like #include <zzip|*.h>, so + * you need to add an include path to the dir containing (!!) the ./zzip/ dir + */ + +#ifndef _ZZIP_ZZIP_H /* zziplib.h */ +#define _ZZIP_ZZIP_H + +#include <zzip/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* the zzip_error_t is also used to pass back ZLIB errors... */ +#define ZZIP_ERROR -4096 + +typedef enum +{ + ZZIP_NO_ERROR = 0, /* no error, may be used if user sets it. */ + ZZIP_OUTOFMEM = ZZIP_ERROR-20, /* out of memory */ + ZZIP_DIR_OPEN = ZZIP_ERROR-21, /* failed to open zipfile, see errno for details */ + ZZIP_DIR_STAT = ZZIP_ERROR-22, /* failed to fstat zipfile, see errno for details */ + ZZIP_DIR_SEEK = ZZIP_ERROR-23, /* failed to lseek zipfile, see errno for details */ + ZZIP_DIR_READ = ZZIP_ERROR-24, /* failed to read zipfile, see errno for details */ + ZZIP_DIR_TOO_SHORT = ZZIP_ERROR-25, + ZZIP_DIR_EDH_MISSING = ZZIP_ERROR-26, + ZZIP_DIRSIZE = ZZIP_ERROR-27, + ZZIP_ENOENT = ZZIP_ERROR-28, + ZZIP_UNSUPP_COMPR = ZZIP_ERROR-29, + ZZIP_CORRUPTED = ZZIP_ERROR-31, + ZZIP_UNDEF = ZZIP_ERROR-32, + ZZIP_DIR_LARGEFILE = ZZIP_ERROR-33 +} zzip_error_t; + +/* + * zzip_open flags. + */ +#define ZZIP_CASEINSENSITIVE O_APPEND /* do not use anymore. use CASLESS */ +#define ZZIP_IGNOREPATH O_TRUNC /* do not use anymore. use NOPATHS */ +#define ZZIP_EXTRAFLAGS (ZZIP_CASEINSENSITIVE|ZZIP_IGNOREPATH) + +/* zzip_open_ext_io o_modes flags : new style. use these from now on! */ +#define ZZIP_CASELESS (1<<12) /* ignore filename case inside zips */ +#define ZZIP_NOPATHS (1<<13) /* ignore subdir paths, just filename*/ +#define ZZIP_PREFERZIP (1<<14) /* try first zipped file, then real*/ +#define ZZIP_ONLYZIP (1<<16) /* try _only_ zipped file, skip real*/ +#define ZZIP_FACTORY (1<<17) /* old file handle is not closed */ +#define ZZIP_ALLOWREAL (1<<18) /* real files use default_io (magic) */ +#define ZZIP_THREADED (1<<19) /* try to be safe for multithreading */ + +/* + * zzip largefile renames + */ +#ifdef ZZIP_LARGEFILE_RENAME +#define zzip_telldir zzip_telldir64 +#define zzip_seekdir zzip_seekdir64 +#endif + +/* + * zzip typedefs + */ +/* zzip_strings_t ext[] = { ".zip", ".jar", ".pk3", 0 } */ +typedef char _zzip_const * _zzip_const zzip_strings_t; +typedef char _zzip_const zzip_char_t; +typedef struct zzip_dir ZZIP_DIR; +typedef struct zzip_file ZZIP_FILE; +typedef struct zzip_dirent ZZIP_DIRENT; +typedef struct zzip_dirent ZZIP_STAT; + +struct zzip_dirent +{ + int d_compr; /* compression method */ + int d_csize; /* compressed size */ + int st_size; /* file size / decompressed size */ + char * d_name; /* file name / strdupped name */ +}; + +/* + * Getting error strings + * zzip/err.c + */ +_zzip_export /* error in _opendir : */ +zzip_char_t* zzip_strerror(int errcode); +_zzip_export /* error in other functions : */ +zzip_char_t* zzip_strerror_of(ZZIP_DIR * dir); +_zzip_export /* error mapped to errno.h defines : */ +int zzip_errno(int errcode); + + +/* + * Functions to grab information from ZZIP_DIR/ZZIP_FILE structure + * (if ever needed) + * zzip/info.c + */ +_zzip_export +int zzip_error(ZZIP_DIR * dir); +_zzip_export +void zzip_seterror(ZZIP_DIR * dir, int errcode); +_zzip_export +zzip_char_t* zzip_compr_str(int compr); + +_zzip_export +ZZIP_DIR * zzip_dirhandle(ZZIP_FILE * fp); +_zzip_export +int zzip_dirfd(ZZIP_DIR * dir); +_zzip_export +int zzip_dir_real(ZZIP_DIR * dir); +_zzip_export +int zzip_file_real(ZZIP_FILE * fp); +_zzip_export +void* zzip_realdir(ZZIP_DIR * dir); +_zzip_export +int zzip_realfd(ZZIP_FILE * fp); + +/* + * zip handle management + * zzip/zip.c + */ +_zzip_export +ZZIP_DIR * zzip_dir_alloc(zzip_strings_t* fileext); +_zzip_export +int zzip_dir_free(ZZIP_DIR *); + +/* + * Opening/closing a zip archive + * zzip-zip.c + */ +_zzip_export +ZZIP_DIR * zzip_dir_fdopen(int fd, zzip_error_t * errcode_p); +_zzip_export +ZZIP_DIR * zzip_dir_open(zzip_char_t* filename, zzip_error_t * errcode_p); +_zzip_export +int zzip_dir_close(ZZIP_DIR * dir); +_zzip_export +int zzip_dir_read(ZZIP_DIR * dir, ZZIP_DIRENT * dirent); + + +/* + * Scanning files in zip archive + * zzip/dir.c + * zzip/zip.c + */ +_zzip_export +ZZIP_DIR * zzip_opendir(zzip_char_t* filename); +_zzip_export +int zzip_closedir(ZZIP_DIR * dir); +_zzip_export +ZZIP_DIRENT * zzip_readdir(ZZIP_DIR * dir); +_zzip_export +void zzip_rewinddir(ZZIP_DIR * dir); +_zzip_export +zzip_off_t zzip_telldir(ZZIP_DIR * dir); +_zzip_export +void zzip_seekdir(ZZIP_DIR * dir, zzip_off_t offset); + +/* + * 'opening', 'closing' and reading invidual files in zip archive. + * zzip/file.c + */ +_zzip_export +ZZIP_FILE * zzip_file_open(ZZIP_DIR * dir, zzip_char_t* name, int flags); +_zzip_export +int zzip_file_close(ZZIP_FILE * fp); +_zzip_export +zzip_ssize_t zzip_file_read(ZZIP_FILE * fp, void* buf, zzip_size_t len); + +_zzip_export +ZZIP_FILE * zzip_open(zzip_char_t* name, int flags); +_zzip_export +int zzip_close(ZZIP_FILE * fp); +_zzip_export +zzip_ssize_t zzip_read(ZZIP_FILE * fp, void * buf, zzip_size_t len); + +/* + * the stdc variant to open/read/close files. - Take note of the freopen() + * call as it may reuse an existing preparsed copy of a zip central directory + */ +_zzip_export +ZZIP_FILE* zzip_freopen(zzip_char_t* name, zzip_char_t* mode, ZZIP_FILE*); +_zzip_export +ZZIP_FILE* zzip_fopen(zzip_char_t* name, zzip_char_t* mode); +_zzip_export +zzip_size_t zzip_fread(void *ptr, zzip_size_t size, zzip_size_t nmemb, + ZZIP_FILE * file); +_zzip_export +int zzip_fclose(ZZIP_FILE * fp); + +/* + * seek and tell functions + */ +_zzip_export +int zzip_rewind(ZZIP_FILE *fp); +_zzip_export +zzip_off_t zzip_seek(ZZIP_FILE * fp, zzip_off_t offset, int whence); +_zzip_export +zzip_off_t zzip_tell(ZZIP_FILE * fp); + +/* + * reading info of a single file + * zzip/stat.c + */ +_zzip_export +int zzip_dir_stat(ZZIP_DIR * dir, zzip_char_t* name, + ZZIP_STAT * zs, int flags); +_zzip_export +int zzip_file_stat(ZZIP_FILE * fp, ZZIP_STAT * zs); +_zzip_export +int zzip_fstat(ZZIP_FILE * fp, ZZIP_STAT * zs); + +#ifdef ZZIP_LARGEFILE_RENAME +#define zzip_open_shared_io zzip_open_shared_io64 +#define zzip_open_ext_io zzip_open_ext_io64 +#define zzip_opendir_ext_io zzip_opendir_ext_io64 +#define zzip_dir_open_ext_io zzip_dir_open_ext_io64 +#define zzip_plugin_io_t zzip_plugin_io64_t +#endif + +/* + * all ext_io functions can be called with a default of ext/io == zero/zero + * which will default to a ".zip" extension and posix io of the system. + */ +typedef union _zzip_plugin_io _zzip_const * zzip_plugin_io_t; + +_zzip_export +ZZIP_FILE * zzip_open_shared_io(ZZIP_FILE* stream, + zzip_char_t* name, int o_flags, int o_modes, + zzip_strings_t* ext, zzip_plugin_io_t io); + +_zzip_export +ZZIP_FILE * zzip_open_ext_io(zzip_char_t* name, int o_flags, int o_modes, + zzip_strings_t* ext, zzip_plugin_io_t io); + +_zzip_export +ZZIP_DIR * zzip_opendir_ext_io(zzip_char_t* name, int o_modes, + zzip_strings_t* ext, zzip_plugin_io_t io); + +_zzip_export +ZZIP_DIR * zzip_dir_open_ext_io(zzip_char_t* filename, + zzip_error_t* errcode_p, + zzip_strings_t* ext, zzip_plugin_io_t io); + +/* zzip_file_open_ext_io => zzip_dir_open_ext_io + zzip_file_open */ + +#ifdef __cplusplus +}; +#endif + +#endif /* _ZZIPLIB_H */ + +/* + * Local variables: + * c-file-style: "stroustrup" + * End: + */ diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip32.h b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip32.h new file mode 100644 index 00000000000..04802507c17 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzip32.h @@ -0,0 +1,51 @@ +/* + * Author: + * Guido Draheim <guidod@gmx.de> + * + * Copyright (c) 2010 Guido Draheim + * All rights reserved, + * usage allowed under the restrictions of the + * Lesser GNU General Public License + * or alternatively the restrictions + * of the Mozilla Public License 1.1 + * + * The compat32 headers is targeted towards those poor souls who can + * not compile their application or library with _LARGEFILE_SOURCE but + * they may still need to access a libzzip compiled in largefile mode. + * In that case they can change back to calling these suffix32 functions + * which are ensured to use "long" as the parameter type - just as it used + * to be before off_t was defined as an alias for it. + */ + +#ifndef _ZZIP_ZZIP32_H +#define _ZZIP_ZZIP32_H + +#include <zzip/lib.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Scanning files in zip archive. + * Implemented in zzip/dir.c + */ +_zzip_export +long zzip_telldir32(ZZIP_DIR * dir); +_zzip_export +void zzip_seekdir32(ZZIP_DIR * dir, long offset); + +/* + * seek and tell functions. + * Implemented in zzip/file.c + */ +_zzip_export +long zzip_seek32(ZZIP_FILE * fp, long offset, int whence); +_zzip_export +long zzip_tell32(ZZIP_FILE * fp); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzipfseeko.pc b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzipfseeko.pc new file mode 100644 index 00000000000..fb7d318b0ea --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzipfseeko.pc @@ -0,0 +1,18 @@ +# generated by configure / remove this line to disable regeneration +prefix=/usr/local +exec_prefix=${prefix} +bindir=${exec_prefix}/bin +libdir=${exec_prefix}/lib +datarootdir=${prefix}/share +datadir=${datarootdir} +sysconfdir=${prefix}/etc +includedir=${prefix}/include +package=zzipfseeko +suffix= + +Name: zzipfseeko +Description: ZZipLib - libZ-based ZIP-access Library +Version: 0.13.59 +Requires: zzip-zlib-config +Libs: -L${libdir} -lzzipfseeko +Cflags: -I${includedir} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zziplib.pc b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zziplib.pc new file mode 100644 index 00000000000..891539adeb1 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zziplib.pc @@ -0,0 +1,18 @@ +# generated by configure / remove this line to disable regeneration +prefix=/usr/local +exec_prefix=${prefix} +bindir=${exec_prefix}/bin +libdir=${exec_prefix}/lib +datarootdir=${prefix}/share +datadir=${datarootdir} +sysconfdir=${prefix}/etc +includedir=${prefix}/include +package=zziplib +suffix= + +Name: zziplib +Description: ZZipLib - libZ-based ZIP-access Library +Version: 0.13.59 +Requires: zzip-zlib-config +Libs: -L${libdir} -lzzip +Cflags: -I${includedir} diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zziplib.wpj b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zziplib.wpj new file mode 100755 index 00000000000..c73aab3de56 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zziplib.wpj @@ -0,0 +1,103 @@ +40 +projectIdent +0 +VpeMain +1 +WRect +0 +0 +7680 +10240 +2 +MProject +3 +MCommand +0 +4 +MCommand +0 +4 +5 +WFileName +11 +zziplib.tgt +6 +WFileName +9 +zzcat.tgt +7 +WFileName +9 +zzdir.tgt +8 +WFileName +12 +zziptest.tgt +9 +WVList +4 +10 +VComponent +11 +WRect +0 +0 +5670 +4215 +0 +0 +12 +WFileName +11 +zziplib.tgt +0 +0 +13 +VComponent +14 +WRect +678 +665 +5670 +4215 +0 +0 +15 +WFileName +9 +zzcat.tgt +0 +0 +16 +VComponent +17 +WRect +1868 +1467 +5670 +4215 +0 +0 +18 +WFileName +9 +zzdir.tgt +0 +0 +19 +VComponent +20 +WRect +1356 +1348 +5670 +4215 +0 +0 +21 +WFileName +12 +zziptest.tgt +0 +0 +19 diff --git a/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzipmmapped.pc b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzipmmapped.pc new file mode 100644 index 00000000000..40b1073a4e7 --- /dev/null +++ b/Build/source/libs/zziplib/zziplib-0.13.59/zzip/zzipmmapped.pc @@ -0,0 +1,18 @@ +# generated by configure / remove this line to disable regeneration +prefix=/usr/local +exec_prefix=${prefix} +bindir=${exec_prefix}/bin +libdir=${exec_prefix}/lib +datarootdir=${prefix}/share +datadir=${datarootdir} +sysconfdir=${prefix}/etc +includedir=${prefix}/include +package=zzipmmapped +suffix= + +Name: zzipmmapped +Description: ZZipLib - libZ-based ZIP-access Library +Version: 0.13.59 +Requires: zzip-zlib-config +Libs: -L${libdir} -lzzipmmapped +Cflags: -I${includedir} |