void * ZIPROMReaderInit(const char * filename)
{
ZZIP_DIR * dir = zzip_opendir(filename);
ZZIP_DIRENT * dirent = zzip_readdir(dir);
if (dir != NULL)
{
char tmp1[1024];
char tmp2[1024];
memset(tmp1,0,sizeof(tmp1));
memset(tmp2,0,sizeof(tmp2));
strncpy(tmp1, filename, strlen(filename) - 4);
sprintf(tmp2, "%s/%s", tmp1, dirent->d_name);
return zzip_fopen(tmp2, "rb");
}
return NULL;
}
/**
** Generate a list of files within a specified directory
**
** @param dirname Directory to read.
** @param filter Optional xdata-filter function.
** @param flp Filelist pointer.
**
** @return Pointer to FileList struct describing Files found.
*/
global int ReadDataDirectory(const char* dirname,int (*filter)(char*,FileList *),FileList **flp)
{
#ifdef USE_ZZIPLIB
ZZIP_DIR *dirp = NULL;
ZZIP_DIRENT *dp;
// ATTENTION: valid until end of file!
#define readdir zzip_readdir
#define closedir zzip_closedir
int i;
int entvalid;
char zzbasepath[PATH_MAX];
struct stat st;
char *cp;
#else
#ifndef _MSC_VER
DIR *dirp;
struct dirent *dp;
#endif
struct stat st;
#endif
#ifdef _MSC_VER
struct _finddata_t fileinfo;
long hFile;
#endif
FileList *nfl;
FileList *fl = NULL;
int n;
int isdir = 0; // silence gcc..
char *np;
char buffer[PATH_MAX];
char *filename;
strcpy(buffer, dirname);
n = strlen(buffer);
if (!n || buffer[n - 1] != '/') {
buffer[n++] = '/';
buffer[n] = 0;
}
np = buffer + n;
n = 0;
#ifdef USE_ZZIPLIB
strcpy (zzbasepath, dirname);
/* per each slash in filename, check if it there is a zzip around */
while ((cp = strrchr(zzbasepath, '/')))
{
int fd;
zzip_error_t e;
*cp = '\0'; /* cut at path separator == possible zipfile basename */
fd = __my_zzip_open_zip(zzbasepath, O_RDONLY|O_BINARY);
if (fd != -1) {
/* found zip-file, now open it */
dirp = zzip_dir_fdopen(fd, &e);
if (e) {
errno = zzip_errno(e);
close(fd);
dirp = NULL;
}
break;
}
}
if (!dirp) {
int fd;
zzip_error_t e;
// this is tricky - we used to simply zzip_opendir(dirname) here, but
// zziplib (correctly) prefers real directories over same named zipfiles
// and we want it vice versa in this special case. Otherwise it would not
// match the path separator backtrace above, which relies on recursive
// __zip_open_dir(). __zip_open_dir() only detects zipfiles, not real dirs!
fd = __my_zzip_open_zip(dirname, O_RDONLY|O_BINARY);
if (fd == -1) {
dirp = zzip_opendir(dirname);
zzbasepath[0] = 0;
} else {
dirp = zzip_dir_fdopen(fd, &e);
if (e) {
errno = zzip_errno(e);
close(fd);
dirp = NULL;
} else {
strcpy (zzbasepath, dirname);
}
DebugLevel3Fn("zzbasepath `%s', dirname `%s'\n"
_C_ zzbasepath _C_ dirname);
}
}
#ifndef _MSC_VER
IfDebug(if (!dirp) { DebugLevel0Fn("Dir `%s' not found\n" _C_ dirname); });
//// read the directory entries of given dir/archive
static void b_zzip_read_dirent(task *tsk, pntr *argstack)
{
char *fileName;
pntr p = argstack[0];
int badtype;
CHECK_ARG(0, CELL_CONS);
if((badtype = array_to_string(p, &fileName)) >= 0){
set_error(tsk, "error1: argument is not a string (contains non-char: %s)", cell_types[badtype]);
return;
}
ZZIP_DIR * dir;
ZZIP_DIRENT * d;
dir = zzip_opendir(fileName);
if (! dir){
fprintf (stderr, "did not open %s: ", fileName);
set_error(tsk, "error1: could not handle file: %s", fileName);
return;
}
char *singleFileName;
char *compressionType;
int fSize = 20;
char fileSize[fSize];
char compressedSize[fSize];
pntr pSingleFileName, pCompressionType, pFileSize, pCompressedSize;
pntr preList, singleList;
int counter = 0;
/* read each dir entry, a list for each file */
while ((d = zzip_readdir (dir))){
counter++;
/* orignal size / compression-type / compression-ratio / filename */
singleFileName = d->d_name;
pSingleFileName = string_to_array(tsk, singleFileName); //// convert the string to cons list
// sprintf(compressionType, "%s ", zzip_compr_str(d->d_compr)); //// NOTE: executing this func will change the tsk->steamstack, very weird
//// NOTE: overflow caused here
compressionType = (char *)zzip_compr_str(d->d_compr);
pCompressionType = string_to_array(tsk, compressionType);
// snprintf(fileSize, 5, "%d ", d->st_size); //// NOTE: executing this func will change the tsk->steamstack, very weird
format_double(fileSize, fSize, d->st_size);
pFileSize = string_to_array(tsk, fileSize);
// sprintf(compressedSize, "%d ", d->d_csize);
format_double(compressedSize, fSize, d->d_csize);
pCompressedSize = string_to_array(tsk, compressedSize);
// printf("cell type: %s \t", cell_type(preList));
//// link the cons lists to form a new list
// singleList = connect_lists(tsk, &pSingleFileName, &pCompressionType);
// singleList = connect_lists(tsk, &singleList, &pFileSize);
// singleList = connect_lists(tsk, &singleList, &pCompressedSize);
//// make cons from the last element to the beginning element
singleList = make_cons(tsk, pCompressedSize, tsk->globnilpntr);
singleList = make_cons(tsk, pFileSize, singleList);
singleList = make_cons(tsk, pCompressionType, singleList);
singleList = make_cons(tsk, pSingleFileName, singleList);
if(counter == 1){
preList = make_cons(tsk, singleList, tsk->globnilpntr);
// printf("cell type: %s \t", cell_type(preList));
}else{
preList = make_cons(tsk, singleList, preList);
// printf("cell type: %s \n", cell_type(preList));
}
}
argstack[0] = preList;
// printf("cell type: %s \n", cell_type(argstack[0]));
}
