/*
* Author:
* Guido Draheim <guidod@gmx.de>
*
* Copyright (c) 1999,2000,2001,2002 Guido Draheim
* All rights reserved,
* use under the restrictions of the
* Lesser GNU General Public License
* note the additional license information
* that can be found in COPYING.ZZIP
*/
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif
#include <zzip.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 "__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;
dir->dirent.d_flags = 0;
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;
dir->dirent.d_flags = dir->hdr->d_flags;
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);
}
}
#if defined ZZIP_LARGEFILE_RENAME && defined EOVERFLOW && defined PIC
#undef zzip_seekdir /* zzip_seekdir64 */
#undef zzip_telldir /* zzip_telldir64 */
long zzip_telldir(ZZIP_DIR* dir)
{
off_t off = zzip_telldir64 (dir);
long offs = off;
if (offs != off) { errno = EOVERFLOW; return -1; }
return offs;
}
void zzip_seekdir(ZZIP_DIR* dir, long offset)
{
zzip_seekdir64 (dir, offset);
}
#endif
/**
* This function is the equivalent of => opendir(3) for a realdir or zipfile.
* <p>
* 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.
* <p>
* 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.
* <p>
* 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:
*/