@@ -1,3 +1,7 @@

+Thu Nov  6 22:40:58 CET 2003 (tk)

+----------------------------------

+  * libclamav: zziplib: reverted to 0.12.83

+

 Thu Nov  6 10:36:57 IST 2003 (njh)

 ----------------------------------

   * libclamav: Not all applications (those not sent as legal attachments)

@@ -243,7 +243,7 @@ int cl_statinidir(const char *dirname, struct cl_stat *dbstat)

     while((dent = readdir(dd))) {

 	if(dent->d_ino) {

-	    if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..") && (cli_strbcasestr(dent->d_name, ".db") || cli_strbcasestr(dent->d_name, ".db2"))) {

+	    if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..") && (cli_strbcasestr(dent->d_name, ".db") || cli_strbcasestr(dent->d_name, ".db2") || cli_strbcasestr(dent->d_name, ".cvd"))) {

 		dbstat->no++;

 		dbstat->stattab = (struct stat *) realloc(dbstat->stattab, dbstat->no * sizeof(struct stat));

@@ -282,7 +282,7 @@ int cl_statchkdir(const struct cl_stat *dbstat)

     while((dent = readdir(dd))) {

 	if(dent->d_ino) {

-	    if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..") && (cli_strbcasestr(dent->d_name, ".db") || cli_strbcasestr(dent->d_name, ".db2"))) {

+	    if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..") && (cli_strbcasestr(dent->d_name, ".db") || cli_strbcasestr(dent->d_name, ".db2") || cli_strbcasestr(dent->d_name, ".cvd"))) {

                 fname = cli_calloc(strlen(dbstat->dir) + strlen(dent->d_name) + 2, sizeof(char));

 		sprintf(fname, "%s/%s", dbstat->dir, dent->d_name);

@@ -2,7 +2,7 @@

  * Author: 

  *      Guido Draheim <guidod@gmx.de>

  *

- *      Copyright (c) 2001 Guido Draheim

+ *      Copyright (c) 2001,2002,2003 Guido Draheim

  *          All rights reserved,

  *          use under the restrictions of the

  *          Lesser GNU General Public License

@@ -53,15 +53,34 @@

 #define _zzip_inline inline

 #endif

 #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

 /* 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 && _FILE_OFFSET_BITS+0 == 64

-#define  ZZIP_LARGEFILE_RENAME

-#elif defined  _LARGE_FILES /* on AIX */

-#define  ZZIP_LARGEFILE_RENAME

+#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 some were forgotten but required to have 64bit off_t largefile.. */

+

+/* 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 */

@@ -70,7 +89,12 @@

 # endif

 # ifndef      _LARGE_FILES

 #  ifdef ZZIP__LARGE_FILES /* == 1 */

-#  define     _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

@@ -141,6 +165,11 @@

 #define __attribute__(X) 

 #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

@@ -1,4 +1,3 @@

-#define USE_DIRENT 0

 /*

  * Author: 

  *	Guido Draheim <guidod@gmx.de>

@@ -24,6 +23,8 @@

 #include <stdio.h>

 #endif

+//#include "__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))

@@ -50,11 +51,13 @@ 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;

@@ -118,11 +121,12 @@ zzip_readdir(ZZIP_DIR * dir)

 {

     if (! dir) { errno=EBADF; return 0; }

+    /*

     if (USE_DIRENT && dir->realdir)

     {

         if (! real_readdir(dir))

             return 0;

-    }else

+    }else */

     {

         if (! dir->hdr) return 0;

@@ -147,10 +151,10 @@ zzip_telldir(ZZIP_DIR* dir)

 {

     if (! dir) { errno=EBADF; return -1; }

-    if (USE_DIRENT && dir->realdir)

+    /* if (USE_DIRENT && dir->realdir)

     {

         return _zzip_telldir(dir->realdir);

-    }else

+    }else*/

     {

     	return ((zzip_off_t) ((char*) dir->hdr - (char*) dir->hdr0));

     }

@@ -164,10 +168,10 @@ zzip_seekdir(ZZIP_DIR* dir, zzip_off_t offset)

 {

     if (! dir) return; 

-    if (USE_DIRENT && dir->realdir)

+    /*if (USE_DIRENT && dir->realdir)

     {

         _zzip_seekdir(dir->realdir, offset);

-    }else

+    }else*/

     {

 	dir->hdr = (struct zzip_dir_hdr*) 

 	    (dir->hdr0 ? (char*) dir->hdr0 + (size_t) offset : 0);

@@ -229,6 +233,23 @@ zzip_opendir_ext_io(zzip_char_t* filename, int o_modes,

 #  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 */

@@ -253,13 +274,13 @@ zzip_closedir(ZZIP_DIR* dir)

 {

     if (! dir) { errno = EBADF; return -1; }

-    if (USE_DIRENT && dir->realdir)

+    /*if (USE_DIRENT && dir->realdir)

     {

         _zzip_closedir(dir->realdir);

         free(dir->realname);

         free(dir);

         return 0;

-    }else

+    }else*/

     {

         zzip_dir_close(dir);

         return 0;

@@ -81,6 +81,7 @@ zzip_strerror(int errcode)

 zzip_char_t* 

 zzip_strerror_of(ZZIP_DIR* dir)

 {

+    if (! dir) return strerror (errno);

     return zzip_strerror(dir->errcode);

 }

@@ -16,6 +16,7 @@

 #include "strc.h"

+#include <sys/types.h>  /* njh@bandsman.co.uk: for icc7.0 */

 #include <string.h>

 #include <sys/stat.h>

 #include <errno.h>

@@ -23,6 +24,7 @@

 #include <ctype.h>

 #include <zzipformat.h>

+//#include "__debug.h"

 #if 0

 # if defined ZZIP_HAVE_IO_H

@@ -168,6 +170,9 @@ zzip_file_open(ZZIP_DIR * dir, zzip_char_t* name, int o_mode)

             if (n)  hdr_name = n + 1;

         }

+        //HINT4("name='%s', compr=%d, size=%d\n", 

+	  //    hdr->d_name, hdr->d_compr, hdr->d_usize);

+

         if (!cmp(hdr_name, name))

         {

             switch (hdr->d_compr)

@@ -218,11 +223,11 @@ zzip_file_open(ZZIP_DIR * dir, zzip_char_t* name, int o_mode)

             {   /* skip local header - should test tons of other info, 

 		 * but trust that those are correct */

-                int dataoff;

+                zzip_ssize_t dataoff;

                 struct zzip_file_header * p = (void*) fp->buf32k;

 		dataoff = dir->io->read(dir->fd, (void*)p, sizeof(*p));

-		if (dataoff < (int) sizeof(*p))

+		if (dataoff < (zzip_ssize_t)sizeof(*p))

 		{ err = ZZIP_DIR_READ;  goto error; }

                 if (! ZZIP_FILE_HEADER_CHECKMAGIC(p)) /* PK\3\4 */

 		{ err = ZZIP_CORRUPTED; goto error; }

@@ -319,12 +324,12 @@ zzip_close(ZZIP_FILE* fp)

  *       required just that but the latest zlib would work just fine with

  *       a smaller buffer.

  */

-int 

-zzip_file_read(ZZIP_FILE * fp, char * buf, int len)

+zzip_ssize_t 

+zzip_file_read(ZZIP_FILE * fp, char * buf, zzip_size_t len)

 {

     ZZIP_DIR * dir; 

-    int l;

-    int rv;

+    zzip_size_t l;

+    zzip_ssize_t rv;

     if (! fp || ! fp->dir) return 0;

@@ -354,14 +359,15 @@ zzip_file_read(ZZIP_FILE * fp, char * buf, int len)

          do {

              int err;

-             int startlen;

+             zzip_size_t startlen;

              if (fp->crestlen > 0 && fp->d_stream.avail_in == 0)

              {

-                 int cl = fp->crestlen > ZZIP_32K ? ZZIP_32K : fp->crestlen;

-             /*  int cl = fp->crestlen > 128? 128: fp->crestlen; */

+                 zzip_size_t cl = ( fp->crestlen < ZZIP_32K ?

+				    fp->crestlen : ZZIP_32K );

+             /*  zzip_size_t cl = fp->crestlen > 128 ? 128 : fp->crestlen; */

-                 int i = fp->io->read(dir->fd, fp->buf32k, cl);

+                 zzip_ssize_t i = fp->io->read(dir->fd, fp->buf32k, cl);

                  if (i <= 0)

                  {

                      dir->errcode = ZZIP_DIR_READ; /* or ZZIP_DIR_READ_EOF ? */

@@ -408,14 +414,14 @@ zzip_file_read(ZZIP_FILE * fp, char * buf, int len)

  * 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).

  */

-int 

-zzip_read(ZZIP_FILE * fp, char * buf, int len)

+zzip_ssize_t

+zzip_read(ZZIP_FILE * fp, char * buf, zzip_size_t len)

 {

     if (! fp) return 0;

     if (! fp->dir) 

       { return fp->io->read(fp->fd, buf, len); } /* stat fd */

     else

-    {   register int v;

+    {   register zzip_ssize_t v;

         v = zzip_file_read(fp, buf, len);

         if (v == -1) { errno = zzip_errno(fp->dir->errcode); }

         return v;

@@ -424,8 +430,8 @@ zzip_read(ZZIP_FILE * fp, char * buf, int len)

 /** => zzip_read

  */

-int 

-zzip_fread(void *ptr, int size, int nmemb, ZZIP_FILE *file)

+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;

@@ -710,7 +716,7 @@ zzip_open_shared_io (ZZIP_FILE* stream,

       /* see if we can share the same zip directory */

       if (stream && stream->dir && stream->dir->realname)

       {

-	  int len = strlen (stream->dir->realname);

+	  zzip_size_t len = strlen (stream->dir->realname);

 	  if (! memcmp (filename, stream->dir->realname, len) &&

 	      filename[len] == '/' && filename[len+1])

 	  {

@@ -860,10 +866,10 @@ zzip_rewind(ZZIP_FILE *fp)

  * how gzio implements it, so I'm not sure there is a better way

  * without using the internals of the algorithm.

  */

-int

-zzip_seek(ZZIP_FILE * fp, int offset, int whence)

+zzip_off_t

+zzip_seek(ZZIP_FILE * fp, zzip_off_t offset, int whence)

 {

-    int cur_pos, rel_ofs, read_size, ofs;

+    zzip_off_t cur_pos, rel_ofs, read_size, ofs;

     ZZIP_DIR *dir;

     if (! fp)

@@ -871,7 +877,7 @@ zzip_seek(ZZIP_FILE * fp, int offset, int whence)

     if (! fp->dir) 

     { /* stat fd */

-        return fp->io->seeks(fp->fd,offset,whence);

+        return fp->io->seeks(fp->fd, offset, whence);

     }

     cur_pos = zzip_tell(fp);

@@ -910,7 +916,7 @@ zzip_seek(ZZIP_FILE * fp, int offset, int whence)

     if (read_size < 0) /* bad offset, before beginning of file */

         return -1;

-    if (read_size + cur_pos > fp->usize) /* bad offset, past EOF */

+    if (read_size + cur_pos > (zzip_off_t)fp->usize) /* bad offset, past EOF */

         return -1;

     if (read_size == 0) /* nothing to read */

@@ -949,10 +955,10 @@ zzip_seek(ZZIP_FILE * fp, int offset, int whence)

         while (read_size > 0)  

         {

-            int size = ZZIP_32K;

-            if (read_size < ZZIP_32K) size = (int)read_size;

+            zzip_off_t size = ZZIP_32K;

+            if (read_size < size/*32K*/) size = read_size;

-            size = zzip_file_read(fp, buf, size);

+            size = zzip_file_read(fp, buf, (zzip_size_t)size);

             if (size <= 0) { free(buf); return -1; }

             read_size -= size;

@@ -975,7 +981,7 @@ zzip_seek(ZZIP_FILE * fp, int offset, int whence)

  * calculated from the amount of data left and the total uncompressed

  * size;

  */

-int

+zzip_off_t

 zzip_tell(ZZIP_FILE * fp)

 {

     if (! fp)

@@ -65,10 +65,10 @@ struct zzip_file

   struct zzip_dir* dir; 

   int fd;

   int method;

-  int restlen;

-  int crestlen;

-  int usize;

-  int csize;

+  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;

@@ -15,6 +15,7 @@

 #include <zzip-io.h>

 #include <string.h>

+#include <sys/types.h>  /* njh@bandsman.co.uk: for icc7.0 */

 #include <sys/stat.h>

 #include <errno.h>

 #include <stdlib.h>

@@ -26,9 +26,11 @@

 //#include "__mmap.h"

 //#include "__debug.h"

-//

-#include "others.h"

+#define __sizeof(X) ((zzip_ssize_t)(sizeof(X)))

+

+/* per default, we use a little hack to correct bad z_rootseek parts */

+#define ZZIP_CORRECT_ROOTSEEK 1

 /* ------------------------- fetch helpers --------------------------------- */

@@ -42,7 +44,7 @@ uint32_t __zzip_get32(unsigned char * s)

     |    ((uint32_t)s[1] << 8)  |  (uint32_t)s[0];

 }

-/** => __zzip_get16

+/** => __zzip_get32

  * This function does the same for a 16 bit value.

  */

 uint16_t __zzip_get16(unsigned char * s)

@@ -50,6 +52,88 @@ uint16_t __zzip_get16(unsigned char * s)

     return ((uint16_t)s[1] << 8) | (uint16_t)s[0];

 }

+/* ---------------------------  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_find_disk_trailer( int fd, zzip_off_t filesize, 

+			      struct zzip_disk_trailer * trailer,

+			      zzip_plugin_io_t io);

+int __zzip_parse_root_directory( int fd, 

+				 struct zzip_disk_trailer * trailer, 

+				 struct zzip_dir_hdr ** hdr_return,

+				 zzip_plugin_io_t io);

+

+_zzip_inline 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 zzip_disk_trailer* trailer)

+{

+    if (                    (zzip_off_t) ZZIP_GET32(trailer->z_rootseek) >

+	offset_of_trailer - (zzip_off_t) ZZIP_GET32(trailer->z_rootsize) &&

+	offset_of_trailer > (zzip_off_t) ZZIP_GET32(trailer->z_rootsize))

+    {

+	register zzip_off_t offset;

+	offset = offset_of_trailer -  ZZIP_GET32(trailer->z_rootsize); 

+	trailer->z_rootseek[0] = offset & 0xff;

+	trailer->z_rootseek[1] = offset >> 8 & 0xff;

+	trailer->z_rootseek[2] = offset >> 16 & 0xff;

+	trailer->z_rootseek[3] = offset >> 24 & 0xff;

+	//HINT2("new rootseek=%li", 

+	 //     (long) ZZIP_GET32(trailer->z_rootseek));

+    }

+}

+#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_root_dirent))

+    { 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 (((unsigned)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 

@@ -73,11 +157,13 @@ __zzip_find_disk_trailer(int fd, zzip_off_t filesize,

 			 struct zzip_disk_trailer * trailer,

 			 zzip_plugin_io_t io)

 {

+/*

 #ifdef DEBUG

-#define return(val) { e=val; goto cleanup; }

+#define return(val) { e=val; HINT2("%s", zzip_strerror(e)); goto cleanup; }

 #else

+*/

 #define return(val) { e=val; goto cleanup; }

-#endif

+//#endif

     register int e;

 #ifndef _LOWSTK

@@ -87,13 +173,13 @@ __zzip_find_disk_trailer(int fd, zzip_off_t filesize,

     char* buf = malloc(2*ZZIP_BUFSIZ);

 #endif

     zzip_off_t offset = 0;

-    size_t maplen = 0;

+    zzip_off_t maplen = 0; /* mmap(),read(),getpagesize() use size_t !! */

     char* fd_map = 0;

     if (!trailer)

         { return(EINVAL); }

-    if (filesize < sizeof(struct zzip_disk_trailer))

+    if (filesize < __sizeof(struct zzip_disk_trailer))

         { return(ZZIP_DIR_TOO_SHORT); }

     if (!buf)

@@ -102,8 +188,7 @@ __zzip_find_disk_trailer(int fd, zzip_off_t filesize,

     offset = filesize; /* a.k.a. old offset */

     while(1) /* outer loop */

     {

-        register unsigned char* p;

-        register unsigned char* s;

+        register unsigned char* mapped;

          if (offset <= 0) { return(ZZIP_DIR_EDH_MISSING); }

@@ -111,6 +196,34 @@ __zzip_find_disk_trailer(int fd, zzip_off_t filesize,

          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->use_mmap)

+        {

+	    zzip_off_t mapoff = offset;

+	    { 

+		zzip_off_t pagesize = _zzip_getpagesize (io->use_mmap);

+		if (pagesize < ZZIP_BUFSIZ) goto non_mmap;

+		if (mapoff == filesize && filesize > pagesize) 

+		    mapoff -= pagesize;

+		if (mapoff < pagesize) {

+		    maplen = mapoff + pagesize; mapoff = 0;

+		} else {               

+		    mapoff -= pagesize; maplen = 2*pagesize; 

+		    if (mapoff & (pagesize-1)) {

+			pagesize -= mapoff & (pagesize-1);

+			mapoff += pagesize;

+			maplen -= pagesize;

+		    }   

+		}

+		if (mapoff + maplen > filesize) maplen = filesize - mapoff;

+	    }

+

+            fd_map = _zzip_mmap(io->use_mmap, fd, mapoff, (zzip_size_t)maplen);

+            if (fd_map == MAP_FAILED) goto non_mmap;

+	    mapped = fd_map; offset = mapoff;

+	    HINT3("mapped *%p len=%li", fd_map, (long) maplen);

+        } else */ {

+        non_mmap:

 	    fd_map = 0; /* have no mmap */

 	    {

 		zzip_off_t pagesize = ZZIP_BUFSIZ;

@@ -131,50 +244,52 @@ __zzip_find_disk_trailer(int fd, zzip_off_t filesize,

             if (io->seeks(fd, offset, SEEK_SET) < 0)

                 { return(ZZIP_DIR_SEEK); }

-            if (io->read(fd, buf, maplen) < (long)maplen)

+            if (io->read(fd, buf, (zzip_size_t)maplen) < (zzip_ssize_t)maplen)

                 { return(ZZIP_DIR_READ); }

-            p = buf; /* success */

-

+            mapped = 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 */

-        for (s = p + maplen-1; (s >= p); s--)

-        {

-            if (*s == 'P'

-             && p+maplen-1-s > sizeof(*trailer)-2

-             && ZZIP_DISK_TRAILER_CHECKMAGIC(s))

-            {

-                /* if the file-comment is not present, it happens

-                   that the z_comment field often isn't either */

-                if (p+maplen-1-s > sizeof(*trailer))

-                  { memcpy (trailer, s, sizeof(*trailer)); }

-                else

-                {

-                    memcpy (trailer, s, sizeof(*trailer)-2);

-                    trailer->z_comment[0] = 0; trailer->z_comment[1] = 0;

-                }

-                    

-	       /* check for inconsistent values in trailer 

-		  (prefer lower seek value) */

-	       if ( ZZIP_GET32(trailer->z_rootseek) >

-		    offset+s-p - ZZIP_GET32(trailer->z_rootsize) 

-		    &&  offset+s-p > ZZIP_GET32(trailer->z_rootsize))

-	       {

-		  cli_errmsg("zziplib: rootseek or length information incorrect\n");

-		  offset = offset+s-p - ZZIP_GET32(trailer->z_rootsize); 

-		  trailer->z_rootseek[0] = offset & 0xff;

-		  trailer->z_rootseek[1] = offset >> 8 & 0xff;

-		  trailer->z_rootseek[2] = offset >> 16 & 0xff;

-		  trailer->z_rootseek[3] = offset >> 24 & 0xff;

-		  /* HINT2("new rootseek=%li", 

-			(long) ZZIP_GET32(trailer->z_rootseek)); */

-	       }

-	       return(0); 

-            }

+	{/* 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(*trailer)-2 &&

+		    ZZIP_DISK_TRAILER_CHECKMAGIC(tail))

+		{

+		    /* 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;

+		    }

+

+		    __fixup_rootseek (offset + tail-mapped, trailer);

+		    { return(0); }

+		}

+	    }

         }

+         /*if (USE_MMAP && fd_map) 

+	 { 

+	     HINT3("unmap *%p len=%li",  fd_map, (long) maplen);

+	     _zzip_munmap(io->use_mmap, 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->use_mmap, fd_map, (zzip_size_t)maplen); 

+    }*/

 #   ifdef _LOWSTK

     free(buf);

 #   endif

@@ -192,8 +307,8 @@ __zzip_find_disk_trailer(int fd, zzip_off_t filesize,

 _zzip_inline char* __zzip_aligned4(char* p)

 {

 #define aligned4   __zzip_aligned4

-    p += ((long)p)&1;

-    p += ((long)p)&2;

+    p += ((long)p)&1;            /* warnings about truncation of a "pointer" */

+    p += ((long)p)&2;            /* to a "long int" may be safely ignored :) */

     return p;

 }

@@ -214,34 +329,33 @@ __zzip_parse_root_directory(int fd,

     struct zzip_dir_hdr * hdr0;

     uint16_t * p_reclen = 0;

     short entries; 

-    long offset, fallback_offset;

-    char* fd_map = 0;

+    long offset;          /* offset from start of root directory */

+    char* fd_map = 0; 

     int32_t  fd_gap = 0;

     uint16_t u_entries  = ZZIP_GET16(trailer->z_entries);   

     uint32_t u_rootsize = ZZIP_GET32(trailer->z_rootsize);  

     uint32_t u_rootseek = ZZIP_GET32(trailer->z_rootseek);

+    __correct_rootseek (u_rootseek, u_rootsize, trailer);

     hdr0 = (struct zzip_dir_hdr*) malloc(u_rootsize);

     if (!hdr0) 

         return ZZIP_DIRSIZE;

-    hdr = hdr0;

+    hdr = hdr0;                  __debug_dir_hdr (hdr);

-#  ifdef DEBUG

-    if (sizeof(struct zzip_dir_hdr) > sizeof(struct zzip_root_dirent))

-    { 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 (((unsigned)hdr0)&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

-     */

-#  endif

+    /*if (USE_MMAP && io->use_mmap)

+    {

+        fd_gap = u_rootseek & (_zzip_getpagesize(io->use_mmap)-1) ;

+        HINT4(" mapseek=0x%x, maplen=%d, fd_gap=%d", 

+	      u_rootseek-fd_gap, u_rootsize+fd_gap, fd_gap);

+        fd_map = _zzip_mmap(io->use_mmap, 

+			    fd, u_rootseek-fd_gap, u_rootsize+fd_gap);

+        if (fd_map == MAP_FAILED) { 

+            NOTE2("map failed: %s",strerror(errno)); 

+            fd_map=0; 

+	}else{

+	    HINT3("mapped *%p len=%i", fd_map, u_rootsize+fd_gap);

+	}

+    }*/

     for (entries=u_entries, offset=0; entries > 0; entries--)

     {

@@ -254,55 +368,14 @@ __zzip_parse_root_directory(int fd,

         {

             if (io->seeks(fd, u_rootseek+offset, SEEK_SET) < 0)

                 return ZZIP_DIR_SEEK;

-            if (io->read(fd, &dirent, sizeof(dirent)) < sizeof(dirent))

+            if (io->read(fd, &dirent, sizeof(dirent)) < __sizeof(dirent))

                 return ZZIP_DIR_READ;

             d = &dirent;

         }

-       /* another check for corrupted files */

-       if (! ZZIP_ROOT_DIRENT_CHECKMAGIC(d))

-       { 

-	  cli_errmsg("zziplib: directory entry incorrect: %lx - search %lx...\n", 

-		   offset+u_rootseek, fallback_offset+u_rootseek);

-	  offset = fallback_offset;

-	  while (offset < u_rootsize-sizeof(dirent))

-	  {

-	     offset++;

-	     if (fd_map)

-	     { d = (void*)(fd_map+fd_gap+offset); } 

-	     else

-	     {

-		if (io->seeks(fd, u_rootseek+offset, SEEK_SET) < 0)

-		  return ZZIP_DIR_SEEK;

-		if (io->read(fd, &dirent, sizeof(dirent.z_magic)) 

-		    < sizeof(dirent.z_magic))

-		  return ZZIP_DIR_READ;

-		d = &dirent;

-	     }

-	     if (ZZIP_ROOT_DIRENT_CHECKMAGIC(d))

-	     {

-		/* HINT2("found directory entry magic at %lx", u_rootseek+offset); */

-		break;

-	     }

-	     

-	  }

-	  if (ZZIP_ROOT_DIRENT_CHECKMAGIC(d))

-	  {

-	     entries++;

-	     continue;

-	  }

-	  

-	  else

-	  {     

-	     cli_errmsg("zziplib: directory entry not found\n", 

-		   offset+u_rootseek);

-	     return ZZIP_CORRUPTED;

-	  } 

-       }

-       

-      

-       

-       

+	if (offset+sizeof(*d) > u_rootsize)

+	{ /*FAIL2("%i's entry stretches beyond root directory", entries);*/ break;}

+

 #       if 0 && defined DEBUG

         zzip_debug_xbuf ((unsigned char*) d, sizeof(*d) + 8);

 #       endif        

@@ -310,8 +383,9 @@ __zzip_parse_root_directory(int fd,

         u_extras  = ZZIP_GET16(d->z_extras); 

         u_comment = ZZIP_GET16(d->z_comment); 

         u_namlen  = ZZIP_GET16(d->z_namlen); 

-    

-    

+        //HINT5("offset=0x%lx, size %ld, dirent *%p, hdr %p\n",

+	  //    offset+u_rootseek, (long)u_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

@@ -326,38 +400,51 @@ __zzip_parse_root_directory(int fd,

         hdr->d_compr = (uint8_t)ZZIP_GET16(d->z_compr);

         if (hdr->d_compr > 255) hdr->d_compr = 255;

-        if (fd_map) 

-          { memcpy(hdr->d_name, fd_map+fd_gap+offset+sizeof(*d), u_namlen); }

-        else 

-          { io->read(fd, hdr->d_name, u_namlen); }

+	if (offset+sizeof(*d) + u_namlen > u_rootsize)

+	{ /*FAIL2("%i's name stretches beyond root directory", entries);*/ break;}

+

+	if (fd_map) 

+	{  memcpy(hdr->d_name, fd_map+fd_gap+offset+sizeof(*d), u_namlen); }

+	else { io->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 */

-        fallback_offset = offset + sizeof(*d) - 1;

         offset += sizeof(*d) + u_namlen + u_extras + u_comment;

         if (offset > (long)u_rootsize)

-            break;

-

+	{ /*FAIL2("%i's end beyond root directory", entries);*/ entries--; break;}

+

+        //HINT5("file %d { compr=%d crc32=$%x offset=%d", 

+	  //    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 = q - p;

+            *p_reclen = (uint16_t)(q - p);

             hdr = (struct zzip_dir_hdr*) q;

         }

     }/*for*/

-    if (!p_reclen)

-        return 0; /* 0 (sane) entries in zip directory... */

-    

-    *p_reclen = 0; /* mark end of list */

+    /*if (USE_MMAP && fd_map) 

+    {

+	HINT3("unmap *%p len=%i",   fd_map, u_rootsize+fd_gap);

+        _zzip_munmap(io->use_mmap, fd_map, u_rootsize+fd_gap);

+    }*/

-    if (hdr_return) 

-        *hdr_return = hdr0;

+    if (p_reclen)

+    {

+	*p_reclen = 0; /* mark end of list */

-    return 0;

+	if (hdr_return)