summaryrefslogtreecommitdiff
path: root/src/libs/uio/zip
diff options
context:
space:
mode:
Diffstat (limited to 'src/libs/uio/zip')
-rw-r--r--src/libs/uio/zip/Makeinfo2
-rw-r--r--src/libs/uio/zip/zip.c1680
-rw-r--r--src/libs/uio/zip/zip.h106
3 files changed, 1788 insertions, 0 deletions
diff --git a/src/libs/uio/zip/Makeinfo b/src/libs/uio/zip/Makeinfo
new file mode 100644
index 0000000..64ae8d5
--- /dev/null
+++ b/src/libs/uio/zip/Makeinfo
@@ -0,0 +1,2 @@
+uqm_CFILES="zip.c"
+uqm_HFILES="zip.h"
diff --git a/src/libs/uio/zip/zip.c b/src/libs/uio/zip/zip.c
new file mode 100644
index 0000000..6da462b
--- /dev/null
+++ b/src/libs/uio/zip/zip.c
@@ -0,0 +1,1680 @@
+/*
+ * Copyright (C) 2003 Serge van den Boom
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ * Nota bene: later versions of the GNU General Public License do not apply
+ * to this program.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/*
+ * This file makes use of zlib (http://www.gzip.org/zlib/)
+ *
+ * References:
+ * The .zip format description from PKWare:
+ * http://www.pkware.com/products/enterprise/white_papers/appnote.html
+ * The .zip format description from InfoZip:
+ * ftp://ftp.info-zip.org/pub/infozip/doc/appnote-011203-iz.zip
+ */
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+#include "zip.h"
+#include "../physical.h"
+#include "../uioport.h"
+#include "../paths.h"
+#include "../uioutils.h"
+#ifdef uio_MEM_DEBUG
+# include "../memdebug.h"
+#endif
+
+
+#define DIR_STRUCTURE_READ_BUFSIZE 0x10000
+
+static int zip_badFile(zip_GPFileData *gPFileData, char *fileName);
+static int zip_fillDirStructure(uio_GPDir *top, uio_Handle *handle);
+#if zip_USE_HEADERS == zip_USE_LOCAL_HEADERS
+static int zip_fillDirStructureLocal(uio_GPDir *top, uio_Handle *handle);
+static int zip_fillDirStructureLocalProcessEntry(uio_GPDir *topGPDir,
+ uio_FileBlock *fileBlock, off_t *pos);
+#endif
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+static off_t zip_findEndOfCentralDirectoryRecord(uio_Handle *handle,
+ uio_FileBlock *fileBlock);
+static int zip_fillDirStructureCentral(uio_GPDir *top, uio_Handle *handle);
+static int zip_fillDirStructureCentralProcessEntry(uio_GPDir *topGPDir,
+ uio_FileBlock *fileBlock, off_t *pos);
+static int zip_updatePFileDataFromLocalFileHeader(zip_GPFileData *gPFileData,
+ uio_FileBlock *fileBlock, int pos);
+int zip_updateFileDataFromLocalHeader(uio_Handle *handle,
+ zip_GPFileData *gPFileData);
+#endif
+static int zip_fillDirStructureProcessExtraFields(
+ uio_FileBlock *fileBlock, off_t extraFieldLength,
+ zip_GPFileData *gPFileData, const char *path, off_t pos,
+ uio_bool central);
+static inline int zip_foundFile(uio_GPDir *gPDir, const char *path,
+ zip_GPFileData *gPFileData);
+static inline int zip_foundDir(uio_GPDir *gPDir, const char *dirName,
+ zip_GPDirData *gPDirData);
+static int zip_initZipStream(z_stream *zipStream);
+static int zip_unInitZipStream(z_stream *zipStream);
+static int zip_reInitZipStream(z_stream *zipStream);
+
+static voidpf zip_alloc(voidpf opaque, uInt items, uInt size);
+static void zip_free(voidpf opaque, voidpf address);
+
+static inline zip_GPFileData * zip_GPFileData_new(void);
+static inline void zip_GPFileData_delete(zip_GPFileData *gPFileData);
+static inline zip_GPFileData *zip_GPFileData_alloc(void);
+static inline void zip_GPFileData_free(zip_GPFileData *gPFileData);
+static inline void zip_GPDirData_delete(zip_GPDirData *gPDirData);
+static inline void zip_GPDirData_free(zip_GPDirData *gPDirData);
+
+static ssize_t zip_readStored(uio_Handle *handle, void *buf, size_t count);
+static ssize_t zip_readDeflated(uio_Handle *handle, void *buf, size_t count);
+static off_t zip_seekStored(uio_Handle *handle, off_t offset);
+static off_t zip_seekDeflated(uio_Handle *handle, off_t offset);
+
+uio_FileSystemHandler zip_fileSystemHandler = {
+ /* .init = */ NULL,
+ /* .unInit = */ NULL,
+ /* .cleanup = */ NULL,
+
+ /* .mount = */ zip_mount,
+ /* .umount = */ uio_GPRoot_umount,
+
+ /* .access = */ zip_access,
+ /* .close = */ zip_close,
+ /* .fstat = */ zip_fstat,
+ /* .stat = */ zip_stat,
+ /* .mkdir = */ NULL,
+ /* .open = */ zip_open,
+ /* .read = */ zip_read,
+ /* .rename = */ NULL,
+ /* .rmdir = */ NULL,
+ /* .seek = */ zip_seek,
+ /* .write = */ NULL,
+ /* .unlink = */ NULL,
+
+ /* .openEntries = */ uio_GPDir_openEntries,
+ /* .readEntries = */ uio_GPDir_readEntries,
+ /* .closeEntries = */ uio_GPDir_closeEntries,
+
+ /* .getPDirEntryHandle = */ uio_GPDir_getPDirEntryHandle,
+ /* .deletePRootExtra = */ uio_GPRoot_delete,
+ /* .deletePDirHandleExtra = */ uio_GPDirHandle_delete,
+ /* .deletePFileHandleExtra = */ uio_GPFileHandle_delete,
+};
+
+uio_GPRoot_Operations zip_GPRootOperations = {
+ /* .fillGPDir = */ NULL,
+ /* .deleteGPRootExtra = */ NULL,
+ /* .deleteGPDirExtra = */ zip_GPDirData_delete,
+ /* .deleteGPFileExtra = */ zip_GPFileData_delete,
+};
+
+
+#define NUM_COMPRESSION_METHODS 11
+/*
+ * [0] = stored uncompressed
+ * [1] = Shrunk
+ * [2] = Reduced with compression factor 1
+ * [3] = Reduced with compression factor 2
+ * [4] = Reduced with compression factor 3
+ * [5] = Reduced with compression factor 4
+ * [6] = Imploded
+ * [7] = Reserved for Tokenizing
+ * [8] = Deflated
+ * [9] = Deflate64
+ * [10] = "PKWARE Data Compression Library Imploding"
+ */
+static const uio_bool
+ zip_compressionMethodSupported[NUM_COMPRESSION_METHODS] = {
+ true, false, false, false, false, false, false, false,
+ true, false, false };
+
+typedef ssize_t (*zip_readFunctionType)(uio_Handle *handle,
+ void *buf, size_t count);
+zip_readFunctionType zip_readMethods[NUM_COMPRESSION_METHODS] = {
+ zip_readStored, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ zip_readDeflated, NULL, NULL
+};
+typedef off_t (*zip_seekFunctionType)(uio_Handle *handle, off_t offset);
+zip_seekFunctionType zip_seekMethods[NUM_COMPRESSION_METHODS] = {
+ zip_seekStored, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ zip_seekDeflated, NULL, NULL
+};
+
+
+typedef enum {
+ zip_OSType_FAT,
+ zip_OSType_Amiga,
+ zip_OSType_OpenVMS,
+ zip_OSType_UNIX,
+ zip_OSType_VMCMS,
+ zip_OSType_AtariST,
+ zip_OSType_HPFS,
+ zip_OSType_HFS,
+ zip_OSType_ZSystem,
+ zip_OSType_CPM,
+ zip_OSType_TOPS20,
+ zip_OSType_NTFS,
+ zip_OSType_QDOS,
+ zip_OSType_Acorn,
+ zip_OSType_VFAT,
+ zip_OSType_MVS,
+ zip_OSType_BeOS,
+ zip_OSType_Tandem,
+
+ zip_numOSTypes
+} zip_OSType;
+
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+static mode_t zip_makeFileMode(zip_OSType creatorOS, uio_uint32 modeBytes);
+#endif
+
+#define zip_INPUT_BUFFER_SIZE 0x10000
+ // TODO: make this configurable a la sysctl?
+#define zip_SEEK_BUFFER_SIZE zip_INPUT_BUFFER_SIZE
+
+
+void
+zip_close(uio_Handle *handle) {
+ zip_Handle *zip_handle;
+
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "zip_close - handle=%p\n", (void *) handle);
+#endif
+ zip_handle = handle->native;
+ uio_GPFile_unref(zip_handle->file);
+ zip_unInitZipStream(&zip_handle->zipStream);
+ uio_closeFileBlock(zip_handle->fileBlock);
+ uio_free(zip_handle);
+}
+
+static void
+zip_fillStat(struct stat *statBuf, const zip_GPFileData *gPFileData) {
+ memset(statBuf, '\0', sizeof (struct stat));
+ statBuf->st_size = gPFileData->uncompressedSize;
+ statBuf->st_uid = gPFileData->uid;
+ statBuf->st_gid = gPFileData->gid;
+ statBuf->st_mode = gPFileData->mode;
+ statBuf->st_atime = gPFileData->atime;
+ statBuf->st_mtime = gPFileData->mtime;
+ statBuf->st_ctime = gPFileData->ctime;
+}
+
+int
+zip_access(uio_PDirHandle *pDirHandle, const char *name, int mode) {
+ errno = ENOSYS; // Not implemented.
+ (void) pDirHandle;
+ (void) name;
+ (void) mode;
+ return -1;
+
+#if 0
+ uio_GPDirEntry *entry;
+
+ if (name[0] == '.' && name[1] == '\0') {
+ entry = (uio_GPDirEntry *) pDirHandle->extra;
+ } else {
+ entry = uio_GPDir_getGPDirEntry(pDirHandle->extra, name);
+ if (entry == NULL) {
+ errno = ENOENT;
+ return -1;
+ }
+ }
+
+ if (mode & R_OK)
+ {
+ // Read permission is always granted. Nothing to check here.
+ }
+
+ if (mode & W_OK) {
+ errno = EACCES;
+ return -1;
+ }
+
+ if (mode & X_OK) {
+ if (uio_GPDirEntry_isDir(entry)) {
+ // Search permission on directories is always granted.
+ } else {
+ // WORK
+#error
+ }
+ }
+
+ if (mode & F_OK) {
+ // WORK
+#error
+ }
+
+ return 0;
+#endif
+}
+
+int
+zip_fstat(uio_Handle *handle, struct stat *statBuf) {
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+ if (handle->native->file->extra->fileOffset == -1) {
+ // The local header wasn't read in yet.
+ if (zip_updateFileDataFromLocalHeader(handle->root->handle,
+ handle->native->file->extra) == -1) {
+ // errno is set
+ return -1;
+ }
+ }
+#endif /* zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS */
+ zip_fillStat(statBuf, handle->native->file->extra);
+ return 0;
+}
+
+int
+zip_stat(uio_PDirHandle *pDirHandle, const char *name, struct stat *statBuf) {
+ uio_GPDirEntry *entry;
+
+ if (name[0] == '.' && name[1] == '\0') {
+ entry = (uio_GPDirEntry *) pDirHandle->extra;
+ } else {
+ entry = uio_GPDir_getGPDirEntry(pDirHandle->extra, name);
+ if (entry == NULL) {
+ errno = ENOENT;
+ return -1;
+ }
+ }
+
+ if (uio_GPDirEntry_isDir(entry) && entry->extra == NULL) {
+ // No information about this directory was stored.
+ // We'll have to make something up.
+ memset(statBuf, '\0', sizeof (struct stat));
+ statBuf->st_mode = S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR |
+ S_IRGRP | S_IWGRP | S_IXOTH |
+ S_IROTH | S_IWOTH | S_IXOTH;
+ statBuf->st_uid = 0;
+ statBuf->st_gid = 0;
+ return 0;
+ }
+
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+#ifndef zip_INCOMPLETE_STAT
+ if (((zip_GPFileData *) entry->extra)->fileOffset == -1) {
+ // The local header wasn't read in yet.
+ if (zip_updateFileDataFromLocalHeader(pDirHandle->pRoot->handle,
+ (zip_GPFileData *) entry->extra) == -1) {
+ // errno is set
+ return -1;
+ }
+ }
+#endif /* !defined(zip_INCOMPLETE_STAT) */
+#endif /* zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS */
+
+ zip_fillStat(statBuf, (zip_GPFileData *) entry->extra);
+ return 0;
+}
+
+/*
+ * Function name: zip_open
+ * Description: open a file in zip file
+ * Arguments: pDirHandle - handle to the dir where to open the file
+ * name - the name of the file to open
+ * flags - flags, as to stdio open()
+ * mode - mode, as to stdio open()
+ * Returns: handle, as from stdio open()
+ * If failed, errno is set and handle is -1.
+ */
+uio_Handle *
+zip_open(uio_PDirHandle *pDirHandle, const char *name, int flags,
+ mode_t mode) {
+ zip_Handle *handle;
+ uio_GPFile *gPFile;
+
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "zip_open - pDirHandle=%p name=%s flags=%d mode=0%o\n",
+ (void *) pDirHandle, name, flags, mode);
+#endif
+
+ if ((flags & O_ACCMODE) != O_RDONLY) {
+ errno = EACCES;
+ return NULL;
+ }
+
+ gPFile = (uio_GPFile *) uio_GPDir_getGPDirEntry(pDirHandle->extra, name);
+ if (gPFile == NULL) {
+ errno = ENOENT;
+ return NULL;
+ }
+
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+ if (gPFile->extra->fileOffset == -1) {
+ // The local header wasn't read in yet.
+ if (zip_updateFileDataFromLocalHeader(pDirHandle->pRoot->handle,
+ gPFile->extra) == -1) {
+ // errno is set
+ return NULL;
+ }
+ }
+#endif
+
+ handle = uio_malloc(sizeof (zip_Handle));
+ uio_GPFile_ref(gPFile);
+ handle->file = gPFile;
+ handle->fileBlock = uio_openFileBlock2(pDirHandle->pRoot->handle,
+ gPFile->extra->fileOffset, gPFile->extra->compressedSize);
+ if (handle->fileBlock == NULL) {
+ // errno is set
+ return NULL;
+ }
+
+ if (zip_initZipStream(&handle->zipStream) == -1) {
+ uio_GPFile_unref(gPFile);
+ uio_closeFileBlock(handle->fileBlock);
+ return NULL;
+ }
+ handle->compressedOffset = 0;
+ handle->uncompressedOffset = 0;
+
+ (void) mode;
+ return uio_Handle_new(pDirHandle->pRoot, handle, flags);
+}
+
+ssize_t
+zip_read(uio_Handle *handle, void *buf, size_t count) {
+ ssize_t result;
+
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "zip_read - handle=%p buf=%p count=%d: ", (void *) handle,
+ (void *) buf, count);
+#endif
+ result = zip_readMethods[handle->native->file->extra->compressionMethod]
+ (handle, buf, count);
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "%d\n", result);
+#endif
+ return result;
+}
+
+static ssize_t
+zip_readStored(uio_Handle *handle, void *buf, size_t count) {
+ int numBytes;
+ zip_Handle *zipHandle;
+
+ zipHandle = handle->native;
+ numBytes = uio_copyFileBlock(zipHandle->fileBlock,
+ zipHandle->uncompressedOffset, buf, count);
+ if (numBytes == -1) {
+ // errno is set
+ return -1;
+ }
+ zipHandle->uncompressedOffset += numBytes;
+ zipHandle->compressedOffset += numBytes;
+ return numBytes;
+}
+
+static ssize_t
+zip_readDeflated(uio_Handle *handle, void *buf, size_t count) {
+ zip_Handle *zipHandle;
+ int inflateResult;
+
+ zipHandle = handle->native;
+
+ if (count > ((zip_GPFileData *) (zipHandle->file->extra))->
+ uncompressedSize - zipHandle->zipStream.total_out)
+ count = ((zip_GPFileData *) (zipHandle->file->extra))->
+ uncompressedSize - zipHandle->zipStream.total_out;
+
+ zipHandle->zipStream.next_out = (Bytef *) buf;
+ zipHandle->zipStream.avail_out = count;
+ while (zipHandle->zipStream.avail_out > 0) {
+ if (zipHandle->zipStream.avail_in == 0) {
+ ssize_t numBytes;
+ numBytes = uio_accessFileBlock(zipHandle->fileBlock,
+ zipHandle->compressedOffset, zip_INPUT_BUFFER_SIZE,
+ (char **) &zipHandle->zipStream.next_in);
+ if (numBytes == -1) {
+ // errno is set
+ return -1;
+ }
+#if 0
+ if (numBytes == 0) {
+ if (zipHandle->uncompressedOffset !=
+ zipHandle->file->extra->uncompressedSize) {
+ // premature eof
+ errno = EIO;
+ return -1;
+ }
+ break;
+ }
+#endif
+ zipHandle->zipStream.avail_in = numBytes;
+ zipHandle->compressedOffset += numBytes;
+ }
+ inflateResult = inflate(&zipHandle->zipStream, Z_SYNC_FLUSH);
+ zipHandle->uncompressedOffset = zipHandle->zipStream.total_out;
+ if (inflateResult == Z_STREAM_END) {
+ // Everything is decompressed
+ break;
+ }
+ if (inflateResult != Z_OK) {
+ switch (inflateResult) {
+ case Z_VERSION_ERROR:
+ fprintf(stderr, "Error: Incompatible version problem for "
+ " decompression.\n");
+ break;
+ case Z_NEED_DICT:
+ fprintf(stderr, "Error: Decompressing requires "
+ "preset dictionary.\n");
+ break;
+ case Z_DATA_ERROR:
+ fprintf(stderr, "Error: Compressed file is corrupted.\n");
+ break;
+ case Z_STREAM_ERROR:
+ // This means zipHandle->zipStream is bad, which is
+ // most likely an error in the code using zlib.
+ fprintf(stderr, "Fatal: internal error using zlib.\n");
+ abort();
+ break;
+ case Z_MEM_ERROR:
+ fprintf(stderr, "Error: Not enough memory available "
+ "while decompressing.\n");
+ break;
+ case Z_BUF_ERROR:
+ // No progress possible. Probably caused by premature
+ // end of input file.
+ fprintf(stderr, "Error: When decompressing: premature "
+ "end of input file.\n");
+ errno = EIO;
+ return -1;
+#if 0
+ // If this happens, either the input buffer is empty
+ // or the output buffer is full. This should not happen.
+ fprintf(stderr, "Fatal: internal error using zlib: "
+ " no progress is possible in decompression.\n");
+ abort();
+ break;
+#endif
+ default:
+ fprintf(stderr, "Fatal: unknown error from inflate().\n");
+ abort();
+ }
+ if (zipHandle->zipStream.msg != NULL)
+ fprintf(stderr, "ZLib reports: %s\n",
+ zipHandle->zipStream.msg);
+ errno = EIO;
+ // Using EIO to report an error in the backend.
+ return -1;
+ }
+ }
+ return count - zipHandle->zipStream.avail_out;
+}
+
+off_t
+zip_seek(uio_Handle *handle, off_t offset, int whence) {
+ zip_Handle *zipHandle;
+
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "zip_seek - handle=%p offset=%d whence=%s\n",
+ (void *) handle, (int) offset,
+ whence == SEEK_SET ? "SEEK_SET" :
+ whence == SEEK_CUR ? "SEEK_CUR" :
+ whence == SEEK_END ? "SEEK_END" : "INVALID");
+#endif
+ zipHandle = handle->native;
+
+ assert(whence == SEEK_SET || whence == SEEK_CUR || whence == SEEK_END);
+ switch(whence) {
+ case SEEK_SET:
+ break;
+ case SEEK_CUR:
+ offset += zipHandle->uncompressedOffset;
+ break;
+ case SEEK_END:
+ offset += zipHandle->file->extra->uncompressedSize;
+ break;
+ }
+ if (offset < 0) {
+ offset = 0;
+ } else if (offset > zipHandle->file->extra->uncompressedSize) {
+ offset = zipHandle->file->extra->uncompressedSize;
+ }
+ return zip_seekMethods[handle->native->file->extra->compressionMethod]
+ (handle, offset);
+}
+
+static off_t
+zip_seekStored(uio_Handle *handle, off_t offset) {
+ zip_Handle *zipHandle;
+
+ zipHandle = handle->native;
+ if (offset > zipHandle->file->extra->uncompressedSize)
+ offset = zipHandle->file->extra->uncompressedSize;
+
+ zipHandle->compressedOffset = offset;
+ zipHandle->uncompressedOffset = offset;
+ return offset;
+}
+
+static off_t
+zip_seekDeflated(uio_Handle *handle, off_t offset) {
+ zip_Handle *zipHandle;
+
+ zipHandle = handle->native;
+
+ if (offset < zipHandle->uncompressedOffset) {
+ // The new offset is earlier than the current offset. We need to
+ // seek from the beginning.
+ if (zip_reInitZipStream(&zipHandle->zipStream) == -1) {
+ // Need to abort. Handle would get in an inconsistent state.
+ // Should not fail anyhow.
+ fprintf(stderr, "Fatal: Could not reinitialise zip stream: "
+ "%s.\n", strerror(errno));
+ abort();
+ }
+ zipHandle->compressedOffset = 0;
+ zipHandle->uncompressedOffset = 0;
+ }
+
+ if (offset == zipHandle->uncompressedOffset)
+ return offset;
+
+ // Seek from the current position.
+ {
+ char *buffer;
+ ssize_t numRead;
+ size_t toRead;
+
+ buffer = uio_malloc(zip_SEEK_BUFFER_SIZE);
+ toRead = offset - zipHandle->uncompressedOffset;
+ while (toRead > 0) {
+ numRead = zip_read(handle, buffer,
+ toRead < zip_SEEK_BUFFER_SIZE ?
+ toRead : zip_SEEK_BUFFER_SIZE);
+ if (numRead == -1) {
+ fprintf(stderr, "Warning: Could not read zipped file: %s\n",
+ strerror(errno));
+ break;
+ // The current location is returned.
+ }
+ toRead -= numRead;
+ }
+ uio_free(buffer);
+ }
+ return zipHandle->uncompressedOffset;
+}
+
+uio_PRoot *
+zip_mount(uio_Handle *handle, int flags) {
+ uio_PRoot *result;
+ uio_PDirHandle *rootDirHandle;
+
+ if ((flags & uio_MOUNT_RDONLY) != uio_MOUNT_RDONLY) {
+ errno = EACCES;
+ return NULL;
+ }
+
+ uio_Handle_ref(handle);
+ result = uio_GPRoot_makePRoot(
+ uio_getFileSystemHandler(uio_FSTYPE_ZIP), flags,
+ &zip_GPRootOperations, NULL, uio_GPRoot_PERSISTENT,
+ handle, NULL, uio_GPDir_COMPLETE);
+
+ rootDirHandle = uio_PRoot_getRootDirHandle(result);
+ if (zip_fillDirStructure(rootDirHandle->extra, handle) == -1) {
+ int savedErrno = errno;
+#ifdef DEBUG
+ fprintf(stderr, "Error: failed to read the zip directory "
+ "structure - %s.\n", strerror(errno));
+#endif
+ uio_GPRoot_umount(result);
+ errno = savedErrno;
+ return NULL;
+ }
+
+ return result;
+}
+
+static int
+zip_fillDirStructure(uio_GPDir *top, uio_Handle *handle) {
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+ return zip_fillDirStructureCentral(top, handle);
+#endif
+#if zip_USE_HEADERS == zip_USE_LOCAL_HEADERS
+ return zip_fillDirStructureLocal(top, handle);
+#endif
+}
+
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+static int
+zip_fillDirStructureCentral(uio_GPDir *top, uio_Handle *handle) {
+ uio_FileBlock *fileBlock;
+ off_t pos;
+ char *buf;
+ ssize_t numBytes;
+ uio_uint16 numEntries;
+ // TODO: use numEntries to initialise the hash table
+ // to a smart size
+ off_t eocdr;
+ off_t startCentralDir;
+
+ fileBlock = uio_openFileBlock(handle);
+ if (fileBlock == NULL) {
+ // errno is set
+ goto err;
+ }
+
+ // first find the 'End of Central Directory Record'
+ eocdr = zip_findEndOfCentralDirectoryRecord(handle, fileBlock);
+ if (eocdr == -1) {
+ // errno is set
+ goto err;
+ }
+
+ numBytes = uio_accessFileBlock(fileBlock, eocdr, 22, &buf);
+ if (numBytes == -1) {
+ // errno is set
+ goto err;
+ }
+ if (numBytes != 22) {
+ errno = EIO;
+ goto err;
+ }
+
+ numEntries = makeUInt16(buf[10], buf[11]);
+ if (numEntries == 0xffff) {
+ fprintf(stderr, "Error: Zip64 .zip files are not supported.\n");
+ errno = ENOSYS;
+ goto err;
+ }
+
+ startCentralDir = makeUInt32(buf[16], buf[17], buf[18], buf[19]);
+
+ // Enable read-ahead buffering, for speed.
+ uio_setFileBlockUsageHint(fileBlock, uio_FB_USAGE_FORWARD,
+ DIR_STRUCTURE_READ_BUFSIZE);
+
+ pos = startCentralDir;
+ while (numEntries--) {
+ if (zip_fillDirStructureCentralProcessEntry(top, fileBlock, &pos)
+ == -1) {
+ // errno is set
+ goto err;
+ }
+ }
+
+ uio_closeFileBlock(fileBlock);
+ return 0;
+
+err:
+ {
+ int savedErrno = errno;
+
+ if (fileBlock != NULL)
+ uio_closeFileBlock(fileBlock);
+ errno = savedErrno;
+ return -1;
+ }
+}
+
+static int
+zip_fillDirStructureCentralProcessEntry(uio_GPDir *topGPDir,
+ uio_FileBlock *fileBlock, off_t *pos) {
+ char *buf;
+ zip_GPFileData *gPFileData;
+ ssize_t numBytes;
+
+ uio_uint32 signature;
+ uio_uint16 lastModTime;
+ uio_uint16 lastModDate;
+ uio_uint32 crc;
+ uio_uint16 fileNameLength;
+ uio_uint16 extraFieldLength;
+ uio_uint16 fileCommentLength;
+ char *fileName;
+ zip_OSType creatorOS;
+
+ off_t nextEntryOffset;
+
+ numBytes = uio_accessFileBlock(fileBlock, *pos, 46, &buf);
+ if (numBytes != 46)
+ return zip_badFile(NULL, NULL);
+
+ signature = makeUInt32(buf[0], buf[1], buf[2], buf[3]);
+ if (signature != 0x02014b50) {
+ fprintf(stderr, "Error: Premature end of central directory.\n");
+ errno = EIO;
+ return -1;
+ }
+
+ gPFileData = zip_GPFileData_new();
+ creatorOS = (zip_OSType) buf[5];
+ gPFileData->compressionFlags = makeUInt16(buf[8], buf[9]);
+ gPFileData->compressionMethod = makeUInt16(buf[10], buf[11]);
+ lastModTime = makeUInt16(buf[12], buf[13]);
+ lastModDate = makeUInt16(buf[14], buf[15]);
+ gPFileData->atime = (time_t) 0;
+ gPFileData->mtime = dosToUnixTime(lastModDate, lastModTime);
+ gPFileData->ctime = (time_t) 0;
+ crc = makeUInt32(buf[16], buf[17], buf[18], buf[19]);
+ gPFileData->compressedSize =
+ makeUInt32(buf[20], buf[21], buf[22], buf[23]);
+ gPFileData->uncompressedSize =
+ makeUInt32(buf[24], buf[25], buf[26], buf[27]);
+ fileNameLength = makeUInt16(buf[28], buf[29]);
+ extraFieldLength = makeUInt16(buf[30], buf[31]);
+ fileCommentLength = makeUInt16(buf[32], buf[33]);
+ gPFileData->uid = 0;
+ gPFileData->gid = 0;
+ gPFileData->mode = zip_makeFileMode(creatorOS,
+ makeUInt32(buf[38], buf[39], buf[40], buf[41]));
+
+ gPFileData->headerOffset =
+ (off_t) makeSInt32(buf[42], buf[43], buf[44], buf[45]);
+ gPFileData->fileOffset = (off_t) -1;
+
+ *pos += 46;
+ nextEntryOffset = *pos + fileNameLength + extraFieldLength +
+ fileCommentLength;
+
+ numBytes = uio_accessFileBlock(fileBlock, *pos, fileNameLength, &buf);
+ if (numBytes != fileNameLength)
+ return zip_badFile(gPFileData, NULL);
+ fileName = uio_malloc(fileNameLength + 1);
+ memcpy(fileName, buf, fileNameLength);
+ fileName[fileNameLength] = '\0';
+ *pos += fileNameLength;
+
+ if (gPFileData->compressionMethod >= NUM_COMPRESSION_METHODS ||
+ !zip_compressionMethodSupported[gPFileData->compressionMethod]) {
+ fprintf(stderr, "Warning: File '%s' is compressed with "
+ "unsupported method %d - skipped.\n", fileName,
+ gPFileData->compressionMethod);
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ return 0;
+ }
+
+ if (gPFileData->compressedSize == (off_t) 0xffffffff ||
+ gPFileData->uncompressedSize == (off_t) 0xffffffff ||
+ gPFileData->headerOffset < 0) {
+ fprintf(stderr, "Warning: Skipping Zip64 file '%s'\n", fileName);
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ return 0;
+ }
+
+ if (isBitSet(gPFileData->compressionFlags, 0)) {
+ fprintf(stderr, "Warning: Skipping encrypted file '%s'\n", fileName);
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ return 0;
+ }
+
+ switch (zip_fillDirStructureProcessExtraFields(fileBlock,
+ extraFieldLength, gPFileData, fileName, *pos, true)) {
+ case 0: // file is ok
+ break;
+ case 1: // file is not acceptable - skip file
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ case -1:
+ return zip_badFile(gPFileData, fileName);
+ }
+
+ *pos += extraFieldLength;
+
+ // If ctime or atime is 0, they will be filled in when the local
+ // file header is read.
+
+ if (S_ISREG(gPFileData->mode)) {
+ if (zip_foundFile(topGPDir, fileName, gPFileData) == -1) {
+ if (errno == EISDIR) {
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ }
+ return zip_badFile(gPFileData, fileName);
+ }
+
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "Debug: Found file '%s'.\n", fileName);
+#endif
+ } else if (S_ISDIR(gPFileData->mode)) {
+ if (fileName[fileNameLength - 1] == '/')
+ fileName[fileNameLength - 1] = '\0';
+ if (zip_foundDir(topGPDir, fileName, gPFileData) == -1) {
+ if (errno == EISDIR) {
+ fprintf(stderr, "Warning: file '%s' already exists as a dir - "
+ "skipped.\n", fileName);
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ }
+ return zip_badFile(gPFileData, fileName);
+ }
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "Debug: Found dir '%s'.\n", fileName);
+#endif
+ } else {
+ fprintf(stderr, "Warning: '%s' is not a regular file, nor a "
+ "directory - skipped.\n", fileName);
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ }
+
+ uio_free(fileName);
+ return 0;
+}
+
+static off_t
+zip_findEndOfCentralDirectoryRecord(uio_Handle *handle,
+ uio_FileBlock *fileBlock) {
+ off_t fileSize;
+ off_t endPos, startPos;
+ char *buf, *bufPtr;
+ ssize_t bufLen;
+
+ struct stat statBuf;
+ if (uio_fstat(handle, &statBuf) == -1) {
+ // errno is set
+ return -1;
+ }
+ fileSize = statBuf.st_size;
+ startPos = fileSize - 0xffff - 22; // max comment and record size
+ if (startPos < 0)
+ startPos = 0;
+ endPos = fileSize - 22; // last position to be checked
+ bufLen = uio_accessFileBlock(fileBlock, startPos, endPos - startPos + 4,
+ &buf);
+ if (bufLen == -1) {
+ int savedErrno = errno;
+ fprintf(stderr, "Error: Read error while searching for "
+ "'end-of-central-directory record'.\n");
+ errno = savedErrno;
+ return -1;
+ }
+ if (bufLen != endPos - startPos + 4) {
+ fprintf(stderr, "Error: Read error while searching for "
+ "'end-of-central-directory record'.\n");
+ errno = EIO;
+ return -1;
+ }
+ bufPtr = buf + (endPos - startPos);
+ while (1) {
+ if (bufPtr < buf) {
+ fprintf(stderr, "Error: Zip file corrupt; could not find "
+ "'end-of-central-directory record'.\n");
+ errno = EIO;
+ return -1;
+ }
+ if (bufPtr[0] == 0x50 && bufPtr[1] == 0x4b && bufPtr[2] == 0x05 &&
+ bufPtr[3] == 0x06)
+ break;
+ bufPtr--;
+ }
+ return startPos + (bufPtr - buf);
+}
+
+static mode_t
+zip_makeFileMode(zip_OSType creatorOS, uio_uint32 modeBytes) {
+ switch (creatorOS) {
+ case zip_OSType_FAT:
+ case zip_OSType_NTFS:
+ case zip_OSType_VFAT: {
+ // Only the least signigicant byte is relevant.
+ mode_t mode;
+
+ if (modeBytes == 0) {
+ // File came from standard input
+ return S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
+ S_IROTH | S_IWOTH;
+ }
+ if (modeBytes & 0x10) {
+ // Directory
+ mode = S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP |
+ S_IROTH | S_IXOTH;
+ } else {
+ // Regular file
+ mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH;
+ }
+ if (modeBytes & 0x01) {
+ // readonly
+ return mode;
+ } else {
+ // Write allowed
+ return mode | S_IWUSR | S_IWGRP | S_IWOTH;
+ }
+ }
+ case zip_OSType_UNIX:
+ return (mode_t) (modeBytes >> 16);
+ default:
+ fprintf(stderr, "Warning: file created by unknown OS.\n");
+ return S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+ }
+}
+
+// If the data is read from the central directory, certain data
+// will need to be updated from the local directory when it is needed.
+// This function does that.
+// returns 0 for success, -1 for error (errno is set)
+// NB: Only the fields that may offer new information are checked.
+// the fields that were already read from the central directory
+// aren't verified.
+static int
+zip_updatePFileDataFromLocalFileHeader(zip_GPFileData *gPFileData,
+ uio_FileBlock *fileBlock, int pos) {
+ ssize_t numBytes;
+ char *buf;
+ uio_uint32 signature;
+ uio_uint16 fileNameLength;
+ uio_uint16 extraFieldLength;
+
+ numBytes = uio_accessFileBlock(fileBlock, pos, 30, &buf);
+ if (numBytes != 30) {
+ errno = EIO;
+ return -1;
+ }
+ signature = makeUInt32(buf[0], buf[1], buf[2], buf[3]);
+ if (signature != 0x04034b50) {
+ errno = EIO;
+ return -1;
+ }
+ fileNameLength = makeUInt16(buf[26], buf[27]);
+ extraFieldLength = makeUInt16(buf[28], buf[29]);
+ pos += 30 + fileNameLength;
+
+ switch (zip_fillDirStructureProcessExtraFields(fileBlock,
+ extraFieldLength, gPFileData, "<unknown>", pos, false)) {
+ case 0: // file is ok
+ break;
+ case 1:
+ // File is not acceptable (but according to the central header
+ // it was)
+ fprintf(stderr, "Warning: according to the central directory "
+ "of a zip file, some file inside is acceptable, "
+ "but according to the local header it isn't.\n");
+ errno = EIO;
+ return -1;
+ case -1:
+ errno = EIO;
+ return -1;
+ }
+ pos += extraFieldLength;
+ gPFileData->fileOffset = pos;
+ return 0;
+}
+#endif /* zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS */
+
+#if zip_USE_HEADERS == zip_USE_LOCAL_HEADERS
+static int
+zip_fillDirStructureLocal(uio_GPDir *top, uio_Handle *handle) {
+ uio_FileBlock *fileBlock;
+ off_t pos;
+ char *buf;
+ ssize_t numBytes;
+
+ pos = uio_lseek(handle, 0, SEEK_SET);
+ if (pos == -1) {
+ int savedErrno = errno;
+ errno = savedErrno;
+ return -1;
+ }
+ if (pos != 0) {
+ errno = EIO;
+ // Using EIO to report an error in the backend.
+ return -1;
+ }
+
+ // We read all the files from the beginning of the zip file to the end.
+ // (the directory record at the end of the file is ignored)
+ fileBlock = uio_openFileBlock(handle);
+ if (fileBlock == NULL) {
+ // errno is set
+ return -1;
+ }
+
+ pos = 0;
+ while (1) {
+ uio_uint32 signature;
+
+ numBytes = uio_accessFileBlock(fileBlock, pos, 4, &buf);
+ if (numBytes == -1)
+ goto err;
+ if (numBytes != 4)
+ break;
+ signature = makeUInt32(buf[0], buf[1], buf[2], buf[3]);
+ if (signature != 0x04034b50) {
+ // End of file data reached.
+ break;
+ }
+ pos += 4;
+ if (zip_fillDirStructureLocalProcessEntry(top, fileBlock, &pos) == -1)
+ goto err;
+ }
+
+ uio_closeFileBlock(fileBlock);
+ return 0;
+
+err:
+ {
+ int savedErrno = errno;
+
+ uio_closeFileBlock(fileBlock);
+ errno = savedErrno;
+ return -1;
+ }
+}
+
+static int
+zip_fillDirStructureLocalProcessEntry(uio_GPDir *topGPDir,
+ uio_FileBlock *fileBlock, off_t *pos) {
+ char *buf;
+ zip_GPFileData *gPFileData;
+ ssize_t numBytes;
+
+ uio_uint16 lastModTime;
+ uio_uint16 lastModDate;
+ uio_uint32 crc;
+ uio_uint16 fileNameLength;
+ uio_uint16 extraFieldLength;
+ char *fileName;
+
+ off_t nextEntryOffset;
+
+ numBytes = uio_accessFileBlock(fileBlock, *pos, 26, &buf);
+ if (numBytes != 26)
+ return zip_badFile(NULL, NULL);
+
+ gPFileData = zip_GPFileData_new();
+ gPFileData->compressionFlags = makeUInt16(buf[2], buf[3]);
+ gPFileData->compressionMethod = makeUInt16(buf[4], buf[5]);
+ lastModTime = makeUInt16(buf[6], buf[7]);
+ lastModDate = makeUInt16(buf[8], buf[9]);
+ gPFileData->atime = (time_t) 0;
+ gPFileData->mtime = dosToUnixTime(lastModDate, lastModTime);
+ gPFileData->ctime = (time_t) 0;
+ gPFileData->uid = 0;
+ gPFileData->gid = 0;
+ gPFileData->mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+ if (!isBitSet(gPFileData->compressionFlags, 3)) {
+ // If bit 3 is not set, this info will be in the data descriptor
+ // behind the file data.
+ crc = makeUInt32(buf[10], buf[11], buf[12], buf[13]);
+ gPFileData->compressedSize =
+ makeUInt32(buf[14], buf[15], buf[16], buf[17]);
+ gPFileData->uncompressedSize =
+ makeUInt32(buf[18], buf[19], buf[20], buf[21]);
+ }
+ fileNameLength = makeUInt16(buf[22], buf[23]);
+ extraFieldLength = makeUInt16(buf[24], buf[25]);
+ *pos += 26;
+ nextEntryOffset = *pos + fileNameLength + extraFieldLength +
+ gPFileData->compressedSize;
+ if (isBitSet(gPFileData->compressionFlags, 3)) {
+ // There's a data descriptor present behind the file data.
+ nextEntryOffset += 16;
+ }
+
+ if (gPFileData->compressionMethod >= NUM_COMPRESSION_METHODS ||
+ !zip_compressionMethodSupported[gPFileData->compressionMethod]) {
+ fprintf(stderr, "Warning: File '%s' is compressed with "
+ "unsupported method %d - skipped.\n", fileName,
+ gPFileData->compressionMethod);
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ return 0;
+ }
+
+ if (gPFileData->compressedSize == (off_t) 0xffffffff ||
+ gPFileData->uncompressedSize == (off_t) 0xffffffff) {
+ fprintf(stderr, "Warning: Skipping Zip64 file '%s'\n", fileName);
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ return 0;
+ }
+
+ if (isBitSet(gPFileData->compressionFlags, 0)) {
+ fprintf(stderr, "Warning: Skipping encrypted file '%s'\n", fileName);
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ return 0;
+ }
+
+ numBytes = uio_accessFileBlock(fileBlock, *pos, fileNameLength, &buf);
+ if (numBytes != fileNameLength)
+ return zip_badFile(gPFileData, NULL);
+ *pos += fileNameLength;
+ if (buf[fileNameLength - 1] == '/') {
+ gPFileData->mode |= S_IFDIR;
+ fileNameLength--;
+ } else
+ gPFileData->mode |= S_IFREG;
+ fileName = uio_malloc(fileNameLength + 1);
+ memcpy(fileName, buf, fileNameLength);
+ fileName[fileNameLength] = '\0';
+
+ switch (zip_fillDirStructureProcessExtraFields(fileBlock,
+ extraFieldLength, gPFileData, fileName, *pos, false)) {
+ case 0: // file is ok
+ break;
+ case 1: // file is not acceptable - skip file
+ *pos = nextEntryOffset;
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ case -1:
+ return zip_badFile(gPFileData, fileName);
+ }
+ *pos += extraFieldLength;
+
+ gPFileData->fileOffset = *pos;
+
+ *pos += gPFileData->compressedSize;
+ if (isBitSet(gPFileData->compressionFlags, 3)) {
+ // Now comes a data descriptor.
+ // The PKWare version (which was never used) misses the signature.
+ // The InfoZip version is used below.
+ uio_uint32 signature;
+
+ numBytes = uio_accessFileBlock(fileBlock, *pos, 16, &buf);
+ if (numBytes != 16)
+ return zip_badFile(gPFileData, fileName);
+
+ signature = makeUInt32(buf[0], buf[1], buf[2], buf[3]);
+ if (signature != 0x08074b50)
+ return zip_badFile(gPFileData, fileName);
+ crc = makeUInt32(buf[4], buf[5], buf[6], buf[7]);
+ gPFileData->compressedSize =
+ makeUInt32(buf[8], buf[9], buf[10], buf[11]);
+ gPFileData->uncompressedSize =
+ makeUInt32(buf[12], buf[13], buf[14], buf[15]);
+ }
+
+ if (gPFileData->ctime == (time_t) 0)
+ gPFileData->ctime = gPFileData->mtime;
+
+ if (gPFileData->atime == (time_t) 0)
+ gPFileData->atime = gPFileData->mtime;
+
+ if (S_ISREG(gPFileData->mode)) {
+ if (zip_foundFile(topGPDir, fileName, gPFileData) == -1) {
+ if (errno == EISDIR) {
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ }
+ return zip_badFile(gPFileData, fileName);
+ }
+
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "Debug: Found file '%s'.\n", fileName);
+#endif
+ } else if (S_ISDIR(gPFileData->mode)) {
+ if (fileName[fileNameLength - 1] == '/')
+ fileName[fileNameLength - 1] = '\0';
+ if (zip_foundDir(topGPDir, fileName, gPFileData) == -1) {
+ if (errno == EISDIR) {
+ fprintf(stderr, "Warning: file '%s' already exists as a dir - "
+ "skipped.\n", fileName);
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ }
+ return zip_badFile(gPFileData, fileName);
+ }
+#if defined(DEBUG) && DEBUG > 1
+ fprintf(stderr, "Debug: Found dir '%s'.\n", fileName);
+#endif
+ } else {
+ fprintf(stderr, "Warning: '%s' is not a regular file, nor a "
+ "directory - skipped.\n", fileName);
+ zip_GPFileData_delete(gPFileData);
+ uio_free(fileName);
+ return 0;
+ }
+
+ uio_free(fileName);
+ return 0;
+}
+#endif /* zip_USE_HEADERS == zip_USE_LOCAL_HEADERS */
+
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+int
+zip_updateFileDataFromLocalHeader(uio_Handle *handle,
+ zip_GPFileData *gPFileData) {
+ uio_FileBlock *fileBlock;
+
+ fileBlock = uio_openFileBlock(handle);
+ if (fileBlock == NULL) {
+ // errno is set
+ return -1;
+ }
+ if (zip_updatePFileDataFromLocalFileHeader(gPFileData,
+ fileBlock, gPFileData->headerOffset) == -1) {
+ int savedErrno = errno;
+ uio_closeFileBlock(fileBlock);
+ errno = savedErrno;
+ return -1;
+ }
+ if (gPFileData->ctime == (time_t) 0)
+ gPFileData->ctime = gPFileData->mtime;
+ if (gPFileData->atime == (time_t) 0)
+ gPFileData->atime = gPFileData->mtime;
+ uio_closeFileBlock(fileBlock);
+ return 0;
+}
+#endif
+
+// If the zip file is bad, -1 is returned (no errno set!)
+// If the file in the zip file should be skipped, 1 is returned.
+// If the file in the zip file is ok, 0 is returned.
+static int
+zip_fillDirStructureProcessExtraFields(uio_FileBlock *fileBlock,
+ off_t extraFieldLength, zip_GPFileData *gPFileData,
+ const char *fileName, off_t pos, uio_bool central) {
+ off_t posEnd;
+ uio_uint16 headerID;
+ ssize_t dataSize;
+ ssize_t numBytes;
+ char *buf;
+
+ posEnd = pos + extraFieldLength;
+ while (pos < posEnd) {
+ numBytes = uio_accessFileBlock(fileBlock, pos, 4, &buf);
+ if (numBytes != 4)
+ return -1;
+ headerID = makeUInt16(buf[0], buf[1]);
+ dataSize = (ssize_t) makeUInt16(buf[2], buf[3]);
+ pos += 4;
+ numBytes = uio_accessFileBlock(fileBlock, pos, dataSize, &buf);
+ if (numBytes != dataSize)
+ return -1;
+ switch(headerID) {
+ case 0x000d: // 'Unix0'
+ // fallthrough
+ case 0x5855: // 'Unix1'
+ gPFileData->atime = (time_t) makeUInt32(
+ buf[0], buf[1], buf[2], buf[3]);
+ gPFileData->mtime = (time_t) makeUInt32(
+ buf[4], buf[5], buf[6], buf[7]);
+ if (central)
+ break;
+ if (dataSize > 8) {
+ gPFileData->uid = (uid_t) makeUInt16(buf[8], buf[9]);
+ gPFileData->gid = (uid_t) makeUInt16(buf[10], buf[11]);
+ }
+ // Unix0 has an extra (ignored) field at the end.
+ break;
+ case 0x5455: { // 'time'
+ uio_uint8 flags;
+ const char *bufPtr;
+ flags = buf[0];
+ bufPtr = buf + 1;
+ if (isBitSet(flags, 0)) {
+ // modification time is present
+ gPFileData->mtime = (time_t) makeUInt32(
+ bufPtr[0], bufPtr[1], bufPtr[2], bufPtr[3]);
+ bufPtr += 4;
+ }
+ // The flags field, even in the central header, specifies what
+ // is present in the local header.
+ // The central header only contains a field for the mtime
+ // when it is present in the local header too, and
+ // never contains fields for other times.
+ if (central)
+ break;
+ if (isBitSet(flags, 1)) {
+ // modification time is present
+ gPFileData->atime = (time_t) makeUInt32(
+ bufPtr[0], bufPtr[1], bufPtr[2], bufPtr[3]);
+ bufPtr += 4;
+ }
+ // Creation time and possible other times are skipped.
+ break;
+ }
+ case 0x7855: // 'Unix2'
+ if (central)
+ break;
+ gPFileData->uid = (uid_t) makeUInt16(buf[0], buf[1]);
+ gPFileData->gid = (uid_t) makeUInt16(buf[2], buf[3]);
+ break;
+ case 0x756e: { // 'Unix3'
+ mode_t mode;
+ mode = (mode_t) makeUInt16(buf[4], buf[5]);
+ if (!S_ISREG(mode) && !S_ISDIR(mode)) {
+ fprintf(stderr, "Warning: Skipping '%s'; not a regular "
+ "file, nor a directory.\n", fileName);
+ return 1;
+ }
+ gPFileData->uid = (uid_t) makeUInt16(buf[10], buf[11]);
+ gPFileData->gid = (uid_t) makeUInt16(buf[12], buf[13]);
+ break;
+ }
+ default:
+#ifdef DEBUG
+ fprintf(stderr, "Debug: Extra field 0x%04x unsupported, "
+ "used for file '%s' - ignored.\n", headerID,
+ fileName);
+#endif
+ break;
+ } // switch
+ pos += dataSize;
+ } // while
+ if (pos != posEnd)
+ return -1;
+ return 0;
+}
+
+static int
+zip_badFile(zip_GPFileData *gPFileData, char *fileName) {
+ fprintf(stderr, "Error: Bad file format for .zip file.\n");
+ if (gPFileData != NULL)
+ zip_GPFileData_delete(gPFileData);
+ if (fileName != NULL)
+ uio_free(fileName);
+ errno = EINVAL; // Is this the best choice?
+ return -1;
+}
+
+static inline int
+zip_foundFile(uio_GPDir *gPDir, const char *path, zip_GPFileData *gPFileData) {
+ uio_GPFile *file;
+ size_t pathLen;
+ const char *rest;
+ const char *pathEnd;
+ const char *start, *end;
+ char *buf;
+
+ if (path[0] == '/')
+ path++;
+ pathLen = strlen(path);
+ if (path[pathLen - 1] == '/') {
+ fprintf(stderr, "Warning: '%s' is not a valid file name - skipped.\n",
+ path);
+ errno = EISDIR;
+ return -1;
+ }
+ pathEnd = path + pathLen;
+
+ switch (uio_walkGPPath(gPDir, path, pathLen, &gPDir, &rest)) {
+ case 0:
+ // The entire path was matched. The last part was not supposed
+ // to be a dir.
+ fprintf(stderr, "Warning: '%s' already exists as a dir - "
+ "skipped.\n", path);
+ errno = EISDIR;
+ return -1;
+ case ENOTDIR:
+ fprintf(stderr, "Warning: A component to '%s' is not a "
+ "directory - file skipped.\n", path);
+ errno = ENOTDIR;
+ return -1;
+ case ENOENT:
+ break;
+ }
+
+ buf = uio_malloc(pathLen + 1);
+ getFirstPathComponent(rest, pathEnd, &start, &end);
+ while (1) {
+ uio_GPDir *newGPDir;
+
+ if (end == start || (end - start == 1 && start[0] == '.') ||
+ (end - start == 2 && start[0] == '.' && start[1] == '.')) {
+ fprintf(stderr, "Warning: file '%s' has an invalid path - "
+ "skipped.\n", path);
+ uio_free(buf);
+ errno = EINVAL;
+ return -1;
+ }
+ if (end == pathEnd) {
+ // This is the last component; it should be the name of the dir.
+ rest = start;
+ break;
+ }
+ memcpy(buf, start, end - start);
+ buf[end - start] = '\0';
+ newGPDir = uio_GPDir_prepareSubDir(gPDir, buf);
+ newGPDir->flags |= uio_GPDir_COMPLETE;
+ // It will be complete when we're done adding
+ // all files, and it won't be used before that.
+ uio_GPDir_commitSubDir(gPDir, buf, newGPDir);
+
+ gPDir = newGPDir;
+ getNextPathComponent(pathEnd, &start, &end);
+ }
+
+ uio_free(buf);
+
+ file = uio_GPFile_new(gPDir->pRoot, (uio_GPFileExtra) gPFileData,
+ uio_gPFileFlagsFromPRootFlags(gPDir->pRoot->flags));
+ uio_GPDir_addFile(gPDir, rest, file);
+ return 0;
+}
+
+static inline int
+zip_foundDir(uio_GPDir *gPDir, const char *path, zip_GPDirData *gPDirData) {
+ size_t pathLen;
+ const char *pathEnd;
+ const char *rest;
+ const char *start, *end;
+ char *buf;
+
+ if (path[0] == '/')
+ path++;
+ pathLen = strlen(path);
+ pathEnd = path + pathLen;
+
+ switch (uio_walkGPPath(gPDir, path, pathLen, &gPDir, &rest)) {
+ case 0:
+ // The dir already exists. Only need to add gPDirData
+ if (gPDir->extra != NULL) {
+ fprintf(stderr, "Warning: '%s' is present more than once "
+ "in the zip file. The last entry will be used.\n",
+ path);
+ zip_GPDirData_delete(gPDir->extra);
+ }
+ gPDir->extra = gPDirData;
+ return 0;
+ case ENOTDIR:
+ fprintf(stderr, "Warning: A component of '%s' is not a "
+ "directory - file skipped.\n", path);
+ errno = ENOTDIR;
+ return -1;
+ case ENOENT:
+ break;
+ }
+
+ buf = uio_malloc(pathLen + 1);
+ getFirstPathComponent(rest, pathEnd, &start, &end);
+ while (start < pathEnd) {
+ uio_GPDir *newGPDir;
+
+ if (end == start || (end - start == 1 && start[0] == '.') ||
+ (end - start == 2 && start[0] == '.' && start[1] == '.')) {
+ fprintf(stderr, "Warning: directory '%s' has an invalid path - "
+ "skipped.\n", path);
+ uio_free(buf);
+ errno = EINVAL;
+ return -1;
+ }
+ memcpy(buf, start, end - start);
+ buf[end - start] = '\0';
+ newGPDir = uio_GPDir_prepareSubDir(gPDir, buf);
+ newGPDir->flags |= uio_GPDir_COMPLETE;
+ // It will be complete when we're done adding
+ // all files, and it won't be used before that.
+ uio_GPDir_commitSubDir(gPDir, buf, newGPDir);
+
+ gPDir = newGPDir;
+ getNextPathComponent(pathEnd, &start, &end);
+ }
+ gPDir->extra = gPDirData;
+
+ uio_free(buf);
+ return 0;
+}
+
+static int
+zip_initZipStream(z_stream *zipStream) {
+ int retVal;
+
+ zipStream->next_in = Z_NULL;
+ zipStream->avail_in = 0;
+ zipStream->zalloc = zip_alloc;
+ zipStream->zfree = zip_free;
+ zipStream->opaque = NULL;
+ retVal = inflateInit2(zipStream, -MAX_WBITS);
+ // Negative window size means that no zlib header is present.
+ // This feature is undocumented in zlib, but it's used
+ // in the minizip program from the zlib contrib dir.
+ // The absolute value is used as real Window size.
+ if (retVal != Z_OK) {
+ switch (retVal) {
+ case Z_MEM_ERROR:
+ fprintf(stderr, "Error: Not enough memory available for "
+ " decompression.\n");
+ break;
+ case Z_VERSION_ERROR:
+ fprintf(stderr, "Error: Incompatible version problem for "
+ " decompression.\n");
+ break;
+ default:
+ fprintf(stderr, "Fatal: unknown error from inflateInit().\n");
+ abort();
+ }
+ if (zipStream->msg != NULL)
+ fprintf(stderr, "ZLib reports: %s\n", zipStream->msg);
+ errno = EIO;
+ // Using EIO to report an error in the backend.
+ return -1;
+ }
+ return 0;
+}
+
+static int
+zip_unInitZipStream(z_stream *zipStream) {
+ int retVal;
+
+ retVal = inflateEnd(zipStream);
+ if (retVal != Z_OK) {
+ switch (retVal) {
+ case Z_STREAM_ERROR:
+ // This means zipStream is bad, which is most likely an
+ // error in the code using zlib.
+ fprintf(stderr, "Fatal: internal error using zlib.\n");
+ abort();
+ break;
+ default:
+ fprintf(stderr, "Fatal: unknown error from inflateEnd().\n");
+ abort();
+ }
+ if (zipStream->msg != NULL)
+ fprintf(stderr, "ZLib reports: %s\n", zipStream->msg);
+ errno = EIO;
+ // Using EIO to report an error in the backend.
+ return -1;
+ }
+ return 0;
+}
+
+static int
+zip_reInitZipStream(z_stream *zipStream) {
+ int retVal;
+
+ zipStream->next_in = Z_NULL;
+ zipStream->avail_in = 0;
+ retVal = inflateReset(zipStream);
+ if (retVal != Z_OK) {
+ switch (retVal) {
+ case Z_STREAM_ERROR:
+ // This means zipStream is bad, which is most likely an
+ // error in the code using zlib.
+ fprintf(stderr, "Fatal: internal error using zlib.\n");
+ abort();
+ break;
+ default:
+ fprintf(stderr, "Fatal: unknown error from inflateInit().\n");
+ abort();
+ }
+ if (zipStream->msg != NULL)
+ fprintf(stderr, "ZLib reports: %s\n", zipStream->msg);
+ errno = EIO;
+ // Using EIO to report an error in the backend.
+ return -1;
+ }
+ return 0;
+}
+
+
+// Used internally by zlib for allocating memory.
+static voidpf
+zip_alloc(voidpf opaque, uInt items, uInt size) {
+ (void) opaque;
+ return (voidpf) uio_calloc((size_t) items, (size_t) size);
+}
+
+// Used internally by zlib for freeing memory.
+static void
+zip_free(voidpf opaque, voidpf address) {
+ (void) opaque;
+ uio_free((void *) address);
+}
+
+static inline zip_GPFileData *
+zip_GPFileData_new(void) {
+ return zip_GPFileData_alloc();
+}
+
+static inline void
+zip_GPFileData_delete(zip_GPFileData *gPFileData) {
+ zip_GPFileData_free(gPFileData);
+}
+
+static inline zip_GPFileData *
+zip_GPFileData_alloc(void) {
+ zip_GPFileData *result = uio_malloc(sizeof (zip_GPFileData));
+#ifdef uio_MEM_DEBUG
+ uio_MemDebug_debugAlloc(zip_GPFileData, (void *) result);
+#endif
+ return result;
+}
+
+static inline void
+zip_GPFileData_free(zip_GPFileData *gPFileData) {
+#ifdef uio_MEM_DEBUG
+ uio_MemDebug_debugFree(zip_GPFileData, (void *) gPFileData);
+#endif
+ uio_free(gPFileData);
+}
+
+static inline void
+zip_GPDirData_delete(zip_GPDirData *gPDirData) {
+ zip_GPDirData_free(gPDirData);
+}
+
+static inline void
+zip_GPDirData_free(zip_GPDirData *gPDirData) {
+#ifdef uio_MEM_DEBUG
+ uio_MemDebug_debugFree(zip_GPFileData, (void *) gPDirData);
+#endif
+ uio_free(gPDirData);
+}
+
+
+
diff --git a/src/libs/uio/zip/zip.h b/src/libs/uio/zip/zip.h
new file mode 100644
index 0000000..4b2762f
--- /dev/null
+++ b/src/libs/uio/zip/zip.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2003 Serge van den Boom
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ * Nota bene: later versions of the GNU General Public License do not apply
+ * to this program.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+typedef struct zip_Handle *uio_NativeHandle;
+typedef void *uio_GPRootExtra;
+typedef struct zip_GPFileData *uio_GPFileExtra;
+typedef struct zip_GPFileData *uio_GPDirExtra;
+typedef struct uio_GPDirEntries_Iterator *uio_NativeEntriesContext;
+
+#define uio_INTERNAL_PHYSICAL
+
+#include "../gphys.h"
+#include "../iointrn.h"
+#include "../uioport.h"
+#include "../physical.h"
+#include "../types.h"
+#include "../fileblock.h"
+
+#include <zlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+// zip_USE_HEADERS determinines what header for files within a .zip file
+// is used when building the directory structure.
+// Set to 'zip_USE_CENTRAL_HEADERS' to use the central directory header,
+// set to 'zip_USE_LOCAL_HEADERS' to use the local file header.
+// Central is highly adviced: it uses much less seeking, and hence is much
+// faster.
+#define zip_USE_HEADERS zip_USE_CENTRAL_HEADERS
+#define zip_USE_CENTRAL_HEADERS 1
+#define zip_USE_LOCAL_HEADERS 2
+
+#define zip_INCOMPLETE_STAT
+ // Ignored unless zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS.
+ // If defined, extra meta-data for files in the .zip archive
+ // isn't retrieved from the local file header when zip_stat()
+ // is called. The uid, gid, file mode, and file times may be
+ // inaccurate. The advantage is that a possibly costly seek and
+ // read can be avoided.
+
+typedef struct zip_GPFileData {
+ off_t compressedSize;
+ off_t uncompressedSize;
+ uio_uint16 compressionFlags;
+ uio_uint16 compressionMethod;
+#if zip_USE_HEADERS == zip_USE_CENTRAL_HEADERS
+ off_t headerOffset; // start of the local header for this file
+#endif
+ off_t fileOffset; // start of the compressed data in the .zip file
+ uid_t uid;
+ gid_t gid;
+ mode_t mode;
+ time_t atime; // access time
+ time_t mtime; // modification time
+ time_t ctime; // change time
+} zip_GPFileData;
+
+typedef zip_GPFileData zip_GPDirData;
+// TODO: some of the fields from zip_GPFileData are not needed for
+// directories. A few bytes could be saved here by making a seperate
+// structure.
+
+typedef struct zip_Handle {
+ uio_GPFile *file;
+ z_stream zipStream;
+ uio_FileBlock *fileBlock;
+ off_t uncompressedOffset;
+ // seek location in the uncompressed stream
+ off_t compressedOffset;
+ // seek location in the compressed stream, from the start
+ // of the compressed file
+} zip_Handle;
+
+
+uio_PRoot *zip_mount(uio_Handle *handle, int flags);
+int zip_umount(struct uio_PRoot *);
+uio_Handle *zip_open(uio_PDirHandle *pDirHandle, const char *file, int flags,
+ mode_t mode);
+void zip_close(uio_Handle *handle);
+int zip_access(uio_PDirHandle *pDirHandle, const char *name, int mode);
+int zip_fstat(uio_Handle *handle, struct stat *statBuf);
+int zip_stat(uio_PDirHandle *pDirHandle, const char *name,
+ struct stat *statBuf);
+ssize_t zip_read(uio_Handle *handle, void *buf, size_t count);
+off_t zip_seek(uio_Handle *handle, off_t offset, int whence);
+
+
+
+