2006-04-11 16:33:48 +02:00
|
|
|
/*
|
|
|
|
* LZMA support routines for PhysicsFS.
|
|
|
|
*
|
|
|
|
* Please see the file LICENSE in the source's root directory.
|
|
|
|
*
|
2006-09-27 11:21:56 +02:00
|
|
|
* This file is written by Dennis Schridde, with some peeking at "7zMain.c"
|
2006-04-11 16:33:48 +02:00
|
|
|
* by Igor Pavlov.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2007-03-09 09:17:56 +01:00
|
|
|
#if (defined PHYSFS_SUPPORTS_7Z)
|
2006-04-11 16:33:48 +02:00
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "physfs.h"
|
|
|
|
|
|
|
|
#define __PHYSICSFS_INTERNAL__
|
|
|
|
#include "physfs_internal.h"
|
|
|
|
|
2007-03-10 07:32:52 +01:00
|
|
|
#ifndef _LZMA_IN_CB
|
2006-09-27 09:05:03 +02:00
|
|
|
#define _LZMA_IN_CB
|
|
|
|
/* Use callback for input data */
|
2007-03-10 07:32:52 +01:00
|
|
|
#endif
|
2006-09-27 09:05:03 +02:00
|
|
|
|
|
|
|
/* #define _LZMA_OUT_READ */
|
|
|
|
/* Use read function for output data */
|
|
|
|
|
2007-03-10 07:32:52 +01:00
|
|
|
#ifndef _LZMA_PROB32
|
2006-09-27 09:05:03 +02:00
|
|
|
#define _LZMA_PROB32
|
|
|
|
/* It can increase speed on some 32-bit CPUs,
|
|
|
|
but memory usage will be doubled in that case */
|
2007-03-10 07:32:52 +01:00
|
|
|
#endif
|
2006-09-27 09:05:03 +02:00
|
|
|
|
2007-03-10 07:32:52 +01:00
|
|
|
#ifndef _LZMA_SYSTEM_SIZE_T
|
2006-09-27 09:05:03 +02:00
|
|
|
#define _LZMA_SYSTEM_SIZE_T
|
|
|
|
/* Use system's size_t. You can use it to enable 64-bit sizes supporting */
|
2007-03-10 07:32:52 +01:00
|
|
|
#endif
|
2006-09-27 09:05:03 +02:00
|
|
|
|
|
|
|
#include "7zIn.h"
|
|
|
|
#include "7zCrc.h"
|
|
|
|
#include "7zExtract.h"
|
|
|
|
|
|
|
|
|
|
|
|
/* 7z internal from 7zIn.c */
|
|
|
|
int TestSignatureCandidate(Byte *testBytes);
|
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
typedef struct _CFileInStream
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
|
|
|
ISzInStream InStream;
|
|
|
|
void *File;
|
|
|
|
} CFileInStream;
|
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
/*
|
|
|
|
* In LZMA the archive is splited in blocks, those are called folders
|
|
|
|
* Set by LZMA_read()
|
|
|
|
*/
|
|
|
|
typedef struct _LZMAfolder
|
|
|
|
{
|
|
|
|
PHYSFS_uint8 *cache; /* Cached folder */
|
|
|
|
PHYSFS_uint32 size; /* Size of folder */
|
|
|
|
PHYSFS_uint32 index; /* Index of folder in archive */
|
|
|
|
PHYSFS_uint32 references; /* Number of files using this block */
|
|
|
|
} LZMAfolder;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set by LZMA_openArchive(), except folder which gets it's values
|
|
|
|
* in LZMA_read()
|
|
|
|
*/
|
2006-09-27 09:05:03 +02:00
|
|
|
typedef struct _LZMAarchive
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
struct _LZMAentry *firstEntry; /* Used for cleanup on shutdown */
|
2006-04-11 16:33:48 +02:00
|
|
|
struct _LZMAentry *lastEntry;
|
2006-11-05 11:06:02 +01:00
|
|
|
LZMAfolder *folder; /* Array of folders */
|
2006-09-27 09:05:03 +02:00
|
|
|
CArchiveDatabaseEx db; /* For 7z: Database */
|
|
|
|
CFileInStream stream; /* For 7z: Input file incl. read and seek callbacks */
|
2006-04-11 16:33:48 +02:00
|
|
|
} LZMAarchive;
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Set by LZMA_openRead(), except offset which is set by LZMA_read() */
|
2006-04-11 16:33:48 +02:00
|
|
|
typedef struct _LZMAentry
|
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
struct _LZMAentry *next; /* Used for cleanup on shutdown */
|
2006-04-11 16:33:48 +02:00
|
|
|
struct _LZMAentry *previous;
|
2006-09-27 09:05:03 +02:00
|
|
|
LZMAarchive *archive; /* Link to corresponding archive */
|
|
|
|
CFileItem *file; /* For 7z: File info, eg. name, size */
|
2006-11-05 11:06:02 +01:00
|
|
|
PHYSFS_uint32 fileIndex; /* Index of file in archive */
|
|
|
|
PHYSFS_uint32 folderIndex; /* Index of folder in archive */
|
|
|
|
size_t offset; /* Offset in folder */
|
2006-09-27 09:05:03 +02:00
|
|
|
PHYSFS_uint32 position; /* Current "virtual" position in file */
|
2006-04-11 16:33:48 +02:00
|
|
|
} LZMAentry;
|
|
|
|
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Memory management implementations to be passed to 7z */
|
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
static void *SzAllocPhysicsFS(size_t size)
|
|
|
|
{
|
|
|
|
return ((size == 0) ? NULL : allocator.Malloc(size));
|
|
|
|
} /* SzAllocPhysicsFS */
|
|
|
|
|
|
|
|
|
|
|
|
static void SzFreePhysicsFS(void *address)
|
|
|
|
{
|
|
|
|
if (address != NULL)
|
|
|
|
allocator.Free(address);
|
|
|
|
} /* SzFreePhysicsFS */
|
|
|
|
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Filesystem implementations to be passed to 7z */
|
|
|
|
|
|
|
|
#ifdef _LZMA_IN_CB
|
|
|
|
|
|
|
|
#define kBufferSize (1 << 12)
|
|
|
|
static Byte g_Buffer[kBufferSize]; /* !!! FIXME: not thread safe! */
|
|
|
|
|
|
|
|
SZ_RESULT SzFileReadImp(void *object, void **buffer, size_t maxReqSize,
|
|
|
|
size_t *processedSize)
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
CFileInStream *s = (CFileInStream *)object;
|
2006-04-11 16:33:48 +02:00
|
|
|
size_t processedSizeLoc;
|
2006-09-27 09:05:03 +02:00
|
|
|
if (maxReqSize > kBufferSize)
|
|
|
|
maxReqSize = kBufferSize;
|
|
|
|
processedSizeLoc = __PHYSFS_platformRead(s->File, g_Buffer, 1, maxReqSize);
|
|
|
|
*buffer = g_Buffer;
|
|
|
|
if (processedSize != 0)
|
2006-04-11 16:33:48 +02:00
|
|
|
*processedSize = processedSizeLoc;
|
2006-09-27 09:05:03 +02:00
|
|
|
return SZ_OK;
|
|
|
|
} /* SzFileReadImp */
|
|
|
|
|
|
|
|
#else
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
SZ_RESULT SzFileReadImp(void *object, void *buffer, size_t size,
|
|
|
|
size_t *processedSize)
|
|
|
|
{
|
|
|
|
CFileInStream *s = (CFileInStream *)object;
|
|
|
|
size_t processedSizeLoc = __PHYSFS_platformRead(s->File, buffer, 1, size);
|
|
|
|
if (processedSize != 0)
|
|
|
|
*processedSize = processedSizeLoc;
|
2006-04-11 16:33:48 +02:00
|
|
|
return SZ_OK;
|
|
|
|
} /* SzFileReadImp */
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
#endif
|
2006-04-11 16:33:48 +02:00
|
|
|
|
|
|
|
SZ_RESULT SzFileSeekImp(void *object, CFileSize pos)
|
|
|
|
{
|
|
|
|
CFileInStream *s = (CFileInStream *) object;
|
|
|
|
if (__PHYSFS_platformSeek(s->File, (PHYSFS_uint64) pos))
|
|
|
|
return SZ_OK;
|
|
|
|
return SZE_FAIL;
|
|
|
|
} /* SzFileSeekImp */
|
|
|
|
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/*
|
|
|
|
* Find entry 'name' in 'archive' and report the 'index' back
|
|
|
|
*/
|
|
|
|
static int lzma_find_entry(LZMAarchive *archive, const char *name,
|
|
|
|
PHYSFS_uint32 *index)
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
for (*index = 0; *index < archive->db.Database.NumFiles; (*index)++)
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
if (strcmp(archive->db.Database.Files[*index].Name, name) == 0)
|
|
|
|
return 1;
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* for */
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
BAIL_MACRO(ERR_NO_SUCH_FILE, 0);
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* lzma_find_entry */
|
|
|
|
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/*
|
|
|
|
* Report the first file index of a directory
|
|
|
|
*/
|
2006-04-11 16:33:48 +02:00
|
|
|
static PHYSFS_sint32 lzma_find_start_of_dir(LZMAarchive *archive,
|
|
|
|
const char *path,
|
|
|
|
int stop_on_first_find)
|
|
|
|
{
|
|
|
|
PHYSFS_sint32 lo = 0;
|
|
|
|
PHYSFS_sint32 hi = (PHYSFS_sint32) (archive->db.Database.NumFiles - 1);
|
|
|
|
PHYSFS_sint32 middle;
|
|
|
|
PHYSFS_uint32 dlen = strlen(path);
|
|
|
|
PHYSFS_sint32 retval = -1;
|
|
|
|
const char *name;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (*path == '\0') /* root dir? */
|
|
|
|
return(0);
|
|
|
|
|
|
|
|
if ((dlen > 0) && (path[dlen - 1] == '/')) /* ignore trailing slash. */
|
|
|
|
dlen--;
|
|
|
|
|
|
|
|
while (lo <= hi)
|
|
|
|
{
|
|
|
|
middle = lo + ((hi - lo) / 2);
|
|
|
|
name = archive->db.Database.Files[middle].Name;
|
|
|
|
rc = strncmp(path, name, dlen);
|
|
|
|
if (rc == 0)
|
|
|
|
{
|
|
|
|
char ch = name[dlen];
|
|
|
|
if ('/' < ch) /* make sure this isn't just a substr match. */
|
|
|
|
rc = -1;
|
|
|
|
else if ('/' > ch)
|
|
|
|
rc = 1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (stop_on_first_find) /* Just checking dir's existance? */
|
|
|
|
return(middle);
|
|
|
|
|
|
|
|
if (name[dlen + 1] == '\0') /* Skip initial dir entry. */
|
|
|
|
return(middle + 1);
|
|
|
|
|
|
|
|
/* there might be more entries earlier in the list. */
|
|
|
|
retval = middle;
|
|
|
|
hi = middle - 1;
|
|
|
|
} /* else */
|
|
|
|
} /* if */
|
|
|
|
|
|
|
|
if (rc > 0)
|
|
|
|
lo = middle + 1;
|
|
|
|
else
|
|
|
|
hi = middle - 1;
|
|
|
|
} /* while */
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
} /* lzma_find_start_of_dir */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrap all 7z calls in this, so the physfs error state is set appropriately.
|
|
|
|
*/
|
|
|
|
static int lzma_err(SZ_RESULT rc)
|
|
|
|
{
|
|
|
|
switch (rc)
|
|
|
|
{
|
|
|
|
case SZ_OK: /* Same as LZMA_RESULT_OK */
|
|
|
|
break;
|
|
|
|
case SZE_DATA_ERROR: /* Same as LZMA_RESULT_DATA_ERROR */
|
|
|
|
__PHYSFS_setError(ERR_DATA_ERROR);
|
|
|
|
break;
|
|
|
|
case SZE_OUTOFMEMORY:
|
|
|
|
__PHYSFS_setError(ERR_OUT_OF_MEMORY);
|
|
|
|
break;
|
|
|
|
case SZE_CRC_ERROR:
|
|
|
|
__PHYSFS_setError(ERR_CORRUPTED);
|
|
|
|
break;
|
|
|
|
case SZE_NOTIMPL:
|
|
|
|
__PHYSFS_setError(ERR_NOT_IMPLEMENTED);
|
|
|
|
break;
|
|
|
|
case SZE_FAIL:
|
|
|
|
__PHYSFS_setError(ERR_UNKNOWN_ERROR); /* !!! FIXME: right? */
|
|
|
|
break;
|
|
|
|
case SZE_ARCHIVE_ERROR:
|
|
|
|
__PHYSFS_setError(ERR_CORRUPTED); /* !!! FIXME: right? */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__PHYSFS_setError(ERR_UNKNOWN_ERROR);
|
|
|
|
} /* switch */
|
|
|
|
|
|
|
|
return(rc);
|
|
|
|
} /* lzma_err */
|
|
|
|
|
|
|
|
|
|
|
|
static PHYSFS_sint64 LZMA_read(fvoid *opaque, void *outBuffer,
|
|
|
|
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
|
|
|
|
{
|
|
|
|
LZMAentry *entry = (LZMAentry *) opaque;
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
PHYSFS_sint64 wantedSize = objSize*objCount;
|
|
|
|
PHYSFS_sint64 remainingSize = entry->file->Size - entry->position;
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
BAIL_IF_MACRO(wantedSize == 0, NULL, 0); /* quick rejection. */
|
|
|
|
BAIL_IF_MACRO(remainingSize == 0, ERR_PAST_EOF, 0);
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
if (remainingSize < wantedSize)
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
wantedSize = remainingSize - (remainingSize % objSize);
|
|
|
|
objCount = (PHYSFS_uint32) (remainingSize / objSize);
|
2006-04-11 16:33:48 +02:00
|
|
|
BAIL_IF_MACRO(objCount == 0, ERR_PAST_EOF, 0); /* quick rejection. */
|
2006-09-27 09:05:03 +02:00
|
|
|
__PHYSFS_setError(ERR_PAST_EOF); /* this is always true here. */
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* if */
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
size_t fileSize;
|
|
|
|
ISzAlloc allocImp;
|
|
|
|
ISzAlloc allocTempImp;
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Prepare callbacks for 7z */
|
|
|
|
allocImp.Alloc = SzAllocPhysicsFS;
|
|
|
|
allocImp.Free = SzFreePhysicsFS;
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
allocTempImp.Alloc = SzAllocPhysicsFS;
|
|
|
|
allocTempImp.Free = SzFreePhysicsFS;
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
/* Only decompress the folder if it is not allready cached */
|
|
|
|
if (entry->archive->folder[entry->folderIndex].cache == NULL)
|
2007-03-10 07:26:11 +01:00
|
|
|
{
|
|
|
|
size_t tmpsize = entry->archive->folder[entry->folderIndex].size;
|
|
|
|
int rc = lzma_err(SzExtract(
|
2006-11-05 11:06:02 +01:00
|
|
|
&entry->archive->stream.InStream, /* compressed data */
|
|
|
|
&entry->archive->db,
|
|
|
|
entry->fileIndex,
|
|
|
|
/* Index of cached folder, will be changed by SzExtract */
|
|
|
|
&entry->archive->folder[entry->folderIndex].index,
|
|
|
|
/* Cache for decompressed folder, allocated/freed by SzExtract */
|
|
|
|
&entry->archive->folder[entry->folderIndex].cache,
|
|
|
|
/* Size of cache, will be changed by SzExtract */
|
2007-03-10 07:26:11 +01:00
|
|
|
&tmpsize,
|
2006-11-05 11:06:02 +01:00
|
|
|
/* Offset of this file inside the cache, set by SzExtract */
|
|
|
|
&entry->offset,
|
|
|
|
&fileSize, /* Size of this file */
|
|
|
|
&allocImp,
|
2007-03-10 07:26:11 +01:00
|
|
|
&allocTempImp));
|
|
|
|
|
|
|
|
entry->archive->folder[entry->folderIndex].size = tmpsize;
|
|
|
|
if (rc != SZ_OK)
|
2006-11-05 11:06:02 +01:00
|
|
|
return -1;
|
2007-03-10 07:26:11 +01:00
|
|
|
} /* if */
|
2006-09-27 09:05:03 +02:00
|
|
|
|
|
|
|
/* Copy wanted bytes over from cache to outBuffer */
|
|
|
|
strncpy(outBuffer,
|
2006-11-05 11:06:02 +01:00
|
|
|
(void*) (entry->archive->folder[entry->folderIndex].cache +
|
|
|
|
entry->offset + entry->position),
|
2006-09-27 09:05:03 +02:00
|
|
|
wantedSize);
|
|
|
|
entry->position += wantedSize;
|
|
|
|
return objCount;
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_read */
|
|
|
|
|
|
|
|
|
|
|
|
static PHYSFS_sint64 LZMA_write(fvoid *opaque, const void *buf,
|
|
|
|
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
|
|
|
|
{
|
|
|
|
BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
|
|
|
|
} /* LZMA_write */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_eof(fvoid *opaque)
|
|
|
|
{
|
|
|
|
LZMAentry *entry = (LZMAentry *) opaque;
|
2006-09-27 09:05:03 +02:00
|
|
|
return (entry->position >= entry->file->Size);
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_eof */
|
|
|
|
|
|
|
|
|
|
|
|
static PHYSFS_sint64 LZMA_tell(fvoid *opaque)
|
|
|
|
{
|
|
|
|
LZMAentry *entry = (LZMAentry *) opaque;
|
|
|
|
return (entry->position);
|
|
|
|
} /* LZMA_tell */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_seek(fvoid *opaque, PHYSFS_uint64 offset)
|
|
|
|
{
|
|
|
|
LZMAentry *entry = (LZMAentry *) opaque;
|
|
|
|
|
|
|
|
BAIL_IF_MACRO(offset < 0, ERR_SEEK_OUT_OF_RANGE, 0);
|
|
|
|
BAIL_IF_MACRO(offset > entry->file->Size, ERR_PAST_EOF, 0);
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
entry->position = offset;
|
|
|
|
return 1;
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_seek */
|
|
|
|
|
|
|
|
|
|
|
|
static PHYSFS_sint64 LZMA_fileLength(fvoid *opaque)
|
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
LZMAentry *entry = (LZMAentry *) opaque;
|
|
|
|
return (entry->file->Size);
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_fileLength */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_fileClose(fvoid *opaque)
|
|
|
|
{
|
|
|
|
LZMAentry *entry = (LZMAentry *) opaque;
|
|
|
|
|
|
|
|
/* Fix archive */
|
|
|
|
if (entry == entry->archive->firstEntry)
|
|
|
|
entry->archive->firstEntry = entry->next;
|
|
|
|
if (entry == entry->archive->lastEntry)
|
|
|
|
entry->archive->lastEntry = entry->previous;
|
|
|
|
|
|
|
|
/* Fix neighbours */
|
|
|
|
if (entry->previous != NULL)
|
|
|
|
entry->previous->next = entry->next;
|
|
|
|
if (entry->next != NULL)
|
|
|
|
entry->next->previous = entry->previous;
|
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
entry->archive->folder[entry->folderIndex].references--;
|
|
|
|
if (entry->archive->folder[entry->folderIndex].references == 0)
|
|
|
|
{
|
|
|
|
allocator.Free(entry->archive->folder[entry->folderIndex].cache);
|
|
|
|
entry->archive->folder[entry->folderIndex].cache = NULL;
|
|
|
|
}
|
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
allocator.Free(entry);
|
2006-09-27 09:05:03 +02:00
|
|
|
entry = NULL;
|
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
return(1);
|
|
|
|
} /* LZMA_fileClose */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_isArchive(const char *filename, int forWriting)
|
|
|
|
{
|
|
|
|
PHYSFS_uint8 sig[k7zSignatureSize];
|
|
|
|
PHYSFS_uint8 res;
|
|
|
|
void *in;
|
|
|
|
|
|
|
|
BAIL_IF_MACRO(forWriting, ERR_ARC_IS_READ_ONLY, 0);
|
|
|
|
|
|
|
|
in = __PHYSFS_platformOpenRead(filename);
|
|
|
|
BAIL_IF_MACRO(in == NULL, NULL, 0);
|
|
|
|
|
|
|
|
if (__PHYSFS_platformRead(in, sig, k7zSignatureSize, 1) != 1)
|
|
|
|
BAIL_MACRO(NULL, 0);
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Test whether sig is the 7z signature */
|
2006-04-11 16:33:48 +02:00
|
|
|
res = TestSignatureCandidate(sig);
|
2006-09-27 09:05:03 +02:00
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
__PHYSFS_platformClose(in);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
} /* LZMA_isArchive */
|
|
|
|
|
|
|
|
|
|
|
|
static void *LZMA_openArchive(const char *name, int forWriting)
|
|
|
|
{
|
2006-11-05 11:06:02 +01:00
|
|
|
PHYSFS_uint64 len;
|
2006-09-27 11:21:56 +02:00
|
|
|
LZMAarchive *archive = NULL;
|
2006-04-11 16:33:48 +02:00
|
|
|
ISzAlloc allocImp;
|
|
|
|
ISzAlloc allocTempImp;
|
|
|
|
|
|
|
|
BAIL_IF_MACRO(forWriting, ERR_ARC_IS_READ_ONLY, NULL);
|
2006-11-05 11:06:02 +01:00
|
|
|
BAIL_IF_MACRO(!LZMA_isArchive(name,forWriting), ERR_UNSUPPORTED_ARCHIVE, 0);
|
2006-09-27 09:05:03 +02:00
|
|
|
|
|
|
|
archive = (LZMAarchive *) allocator.Malloc(sizeof (LZMAarchive));
|
|
|
|
BAIL_IF_MACRO(archive == NULL, ERR_OUT_OF_MEMORY, NULL);
|
|
|
|
|
|
|
|
archive->firstEntry = NULL;
|
|
|
|
archive->lastEntry = NULL;
|
2006-04-11 16:33:48 +02:00
|
|
|
|
|
|
|
if ((archive->stream.File = __PHYSFS_platformOpenRead(name)) == NULL)
|
|
|
|
{
|
|
|
|
allocator.Free(archive);
|
|
|
|
return NULL;
|
|
|
|
} /* if */
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Prepare structs for 7z */
|
2006-04-11 16:33:48 +02:00
|
|
|
archive->stream.InStream.Read = SzFileReadImp;
|
|
|
|
archive->stream.InStream.Seek = SzFileSeekImp;
|
|
|
|
|
|
|
|
allocImp.Alloc = SzAllocPhysicsFS;
|
|
|
|
allocImp.Free = SzFreePhysicsFS;
|
|
|
|
|
|
|
|
allocTempImp.Alloc = SzAllocPhysicsFS;
|
|
|
|
allocTempImp.Free = SzFreePhysicsFS;
|
|
|
|
|
|
|
|
InitCrcTable();
|
|
|
|
SzArDbExInit(&archive->db);
|
|
|
|
if (lzma_err(SzArchiveOpen(&archive->stream.InStream, &archive->db,
|
|
|
|
&allocImp, &allocTempImp)) != SZ_OK)
|
|
|
|
{
|
|
|
|
__PHYSFS_platformClose(archive->stream.File);
|
|
|
|
allocator.Free(archive);
|
|
|
|
return NULL;
|
|
|
|
} /* if */
|
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
len = archive->db.Database.NumFolders * sizeof (LZMAfolder);
|
|
|
|
archive->folder = (LZMAfolder *) allocator.Malloc(len);
|
|
|
|
BAIL_IF_MACRO(archive->folder == NULL, ERR_OUT_OF_MEMORY, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Init with 0 so we know when a folder is already cached
|
|
|
|
* Values will be set by LZMA_read()
|
|
|
|
*/
|
|
|
|
memset(archive->folder, 0, len);
|
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
return(archive);
|
|
|
|
} /* LZMA_openArchive */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Moved to seperate function so we can use alloca then immediately throw
|
|
|
|
* away the allocated stack space...
|
|
|
|
*/
|
|
|
|
static void doEnumCallback(PHYSFS_EnumFilesCallback cb, void *callbackdata,
|
|
|
|
const char *odir, const char *str, PHYSFS_sint32 ln)
|
|
|
|
{
|
|
|
|
char *newstr = alloca(ln + 1);
|
|
|
|
if (newstr == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memcpy(newstr, str, ln);
|
|
|
|
newstr[ln] = '\0';
|
|
|
|
cb(callbackdata, odir, newstr);
|
|
|
|
} /* doEnumCallback */
|
|
|
|
|
|
|
|
|
|
|
|
static void LZMA_enumerateFiles(dvoid *opaque, const char *dname,
|
|
|
|
int omitSymLinks, PHYSFS_EnumFilesCallback cb,
|
|
|
|
const char *origdir, void *callbackdata)
|
|
|
|
{
|
|
|
|
LZMAarchive *archive = (LZMAarchive *) opaque;
|
|
|
|
PHYSFS_sint32 dlen;
|
|
|
|
PHYSFS_sint32 dlen_inc;
|
|
|
|
PHYSFS_sint32 max;
|
|
|
|
PHYSFS_sint32 i;
|
|
|
|
|
|
|
|
i = lzma_find_start_of_dir(archive, dname, 0);
|
|
|
|
if (i == -1) /* no such directory. */
|
|
|
|
return;
|
|
|
|
|
|
|
|
dlen = strlen(dname);
|
|
|
|
if ((dlen > 0) && (dname[dlen - 1] == '/')) /* ignore trailing slash. */
|
|
|
|
dlen--;
|
|
|
|
|
|
|
|
dlen_inc = ((dlen > 0) ? 1 : 0) + dlen;
|
|
|
|
max = (PHYSFS_sint32) archive->db.Database.NumFiles;
|
|
|
|
while (i < max)
|
|
|
|
{
|
|
|
|
char *add;
|
|
|
|
char *ptr;
|
|
|
|
PHYSFS_sint32 ln;
|
|
|
|
char *e = archive->db.Database.Files[i].Name;
|
|
|
|
if ((dlen) && ((strncmp(e, dname, dlen)) || (e[dlen] != '/')))
|
|
|
|
break; /* past end of this dir; we're done. */
|
|
|
|
|
|
|
|
add = e + dlen_inc;
|
|
|
|
ptr = strchr(add, '/');
|
|
|
|
ln = (PHYSFS_sint32) ((ptr) ? ptr-add : strlen(add));
|
|
|
|
doEnumCallback(cb, callbackdata, origdir, add, ln);
|
|
|
|
ln += dlen_inc; /* point past entry to children... */
|
|
|
|
|
|
|
|
/* increment counter and skip children of subdirs... */
|
|
|
|
while ((++i < max) && (ptr != NULL))
|
|
|
|
{
|
|
|
|
char *e_new = archive->db.Database.Files[i].Name;
|
|
|
|
if ((strncmp(e, e_new, ln) != 0) || (e_new[ln] != '/'))
|
|
|
|
break;
|
|
|
|
} /* while */
|
|
|
|
} /* while */
|
|
|
|
} /* LZMA_enumerateFiles */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_exists(dvoid *opaque, const char *name)
|
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
LZMAarchive *archive = (LZMAarchive *) opaque;
|
|
|
|
PHYSFS_uint32 index = 0;
|
|
|
|
return(lzma_find_entry(archive, name, &index));
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_exists */
|
|
|
|
|
|
|
|
|
|
|
|
static PHYSFS_sint64 LZMA_getLastModTime(dvoid *opaque,
|
2006-09-27 09:05:03 +02:00
|
|
|
const char *name,
|
|
|
|
int *fileExists)
|
2006-04-11 16:33:48 +02:00
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
/* !!! FIXME: Lacking support in the LZMA C SDK. */
|
|
|
|
BAIL_MACRO(ERR_NOT_IMPLEMENTED, -1);
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_getLastModTime */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_isDirectory(dvoid *opaque, const char *name, int *fileExists)
|
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
LZMAarchive *archive = (LZMAarchive *) opaque;
|
|
|
|
PHYSFS_uint32 index = 0;
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
*fileExists = lzma_find_entry(archive, name, &index);
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
return(archive->db.Database.Files[index].IsDirectory);
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_isDirectory */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_isSymLink(dvoid *opaque, const char *name, int *fileExists)
|
|
|
|
{
|
|
|
|
BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
|
|
|
|
} /* LZMA_isSymLink */
|
|
|
|
|
|
|
|
|
|
|
|
static fvoid *LZMA_openRead(dvoid *opaque, const char *name, int *fileExists)
|
|
|
|
{
|
|
|
|
LZMAarchive *archive = (LZMAarchive *) opaque;
|
2006-09-27 11:21:56 +02:00
|
|
|
LZMAentry *entry = NULL;
|
2006-11-05 11:06:02 +01:00
|
|
|
PHYSFS_uint32 fileIndex = 0;
|
|
|
|
PHYSFS_uint32 folderIndex = 0;
|
2006-09-27 09:05:03 +02:00
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
*fileExists = lzma_find_entry(archive, name, &fileIndex);
|
2006-09-27 09:05:03 +02:00
|
|
|
BAIL_IF_MACRO(!*fileExists, ERR_NO_SUCH_FILE, NULL);
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
folderIndex = archive->db.FileIndexToFolderIndexMap[fileIndex];
|
|
|
|
BAIL_IF_MACRO(folderIndex == (PHYSFS_uint32)-1, ERR_UNKNOWN_ERROR, NULL);
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
entry = (LZMAentry *) allocator.Malloc(sizeof (LZMAentry));
|
|
|
|
BAIL_IF_MACRO(entry == NULL, ERR_OUT_OF_MEMORY, NULL);
|
2006-09-27 11:21:56 +02:00
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
entry->fileIndex = fileIndex;
|
|
|
|
entry->folderIndex = folderIndex;
|
2006-04-11 16:33:48 +02:00
|
|
|
entry->archive = archive;
|
2006-11-05 11:06:02 +01:00
|
|
|
entry->file = archive->db.Database.Files + entry->fileIndex;
|
2006-09-27 09:05:03 +02:00
|
|
|
entry->offset = 0; /* Offset will be set by LZMA_read() */
|
2006-04-11 16:33:48 +02:00
|
|
|
entry->position = 0;
|
|
|
|
|
2006-11-05 11:06:02 +01:00
|
|
|
archive->folder[folderIndex].references++;
|
|
|
|
|
2006-04-11 16:33:48 +02:00
|
|
|
entry->next = NULL;
|
|
|
|
entry->previous = entry->archive->lastEntry;
|
|
|
|
if (entry->previous != NULL)
|
|
|
|
entry->previous->next = entry;
|
|
|
|
entry->archive->lastEntry = entry;
|
|
|
|
if (entry->archive->firstEntry == NULL)
|
|
|
|
entry->archive->firstEntry = entry;
|
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
return(entry);
|
2006-04-11 16:33:48 +02:00
|
|
|
} /* LZMA_openRead */
|
|
|
|
|
|
|
|
|
|
|
|
static fvoid *LZMA_openWrite(dvoid *opaque, const char *filename)
|
|
|
|
{
|
|
|
|
BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
|
|
|
|
} /* LZMA_openWrite */
|
|
|
|
|
|
|
|
|
|
|
|
static fvoid *LZMA_openAppend(dvoid *opaque, const char *filename)
|
|
|
|
{
|
|
|
|
BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
|
|
|
|
} /* LZMA_openAppend */
|
|
|
|
|
|
|
|
|
|
|
|
static void LZMA_dirClose(dvoid *opaque)
|
|
|
|
{
|
2006-09-27 09:05:03 +02:00
|
|
|
LZMAarchive *archive = (LZMAarchive *) opaque;
|
|
|
|
LZMAentry *entry = archive->firstEntry;
|
|
|
|
LZMAentry *tmpEntry = entry;
|
|
|
|
|
|
|
|
while (entry != NULL)
|
|
|
|
{
|
|
|
|
tmpEntry = entry->next;
|
|
|
|
LZMA_fileClose(entry);
|
|
|
|
entry = tmpEntry;
|
|
|
|
} /* while */
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
SzArDbExFree(&archive->db, SzFreePhysicsFS);
|
|
|
|
__PHYSFS_platformClose(archive->stream.File);
|
2006-04-11 16:33:48 +02:00
|
|
|
|
2006-09-27 09:05:03 +02:00
|
|
|
/* Free the cache which might have been allocated by LZMA_read() */
|
2006-11-05 11:06:02 +01:00
|
|
|
allocator.Free(archive->folder);
|
2006-04-11 16:33:48 +02:00
|
|
|
allocator.Free(archive);
|
|
|
|
} /* LZMA_dirClose */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_remove(dvoid *opaque, const char *name)
|
|
|
|
{
|
|
|
|
BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
|
|
|
|
} /* LZMA_remove */
|
|
|
|
|
|
|
|
|
|
|
|
static int LZMA_mkdir(dvoid *opaque, const char *name)
|
|
|
|
{
|
|
|
|
BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
|
|
|
|
} /* LZMA_mkdir */
|
|
|
|
|
|
|
|
|
|
|
|
const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_LZMA =
|
|
|
|
{
|
|
|
|
"7Z",
|
|
|
|
LZMA_ARCHIVE_DESCRIPTION,
|
|
|
|
"Dennis Schridde <devurandom@gmx.net>",
|
|
|
|
"http://icculus.org/physfs/",
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
const PHYSFS_Archiver __PHYSFS_Archiver_LZMA =
|
|
|
|
{
|
|
|
|
&__PHYSFS_ArchiveInfo_LZMA,
|
|
|
|
LZMA_isArchive, /* isArchive() method */
|
|
|
|
LZMA_openArchive, /* openArchive() method */
|
|
|
|
LZMA_enumerateFiles, /* enumerateFiles() method */
|
|
|
|
LZMA_exists, /* exists() method */
|
|
|
|
LZMA_isDirectory, /* isDirectory() method */
|
|
|
|
LZMA_isSymLink, /* isSymLink() method */
|
|
|
|
LZMA_getLastModTime, /* getLastModTime() method */
|
|
|
|
LZMA_openRead, /* openRead() method */
|
|
|
|
LZMA_openWrite, /* openWrite() method */
|
|
|
|
LZMA_openAppend, /* openAppend() method */
|
|
|
|
LZMA_remove, /* remove() method */
|
|
|
|
LZMA_mkdir, /* mkdir() method */
|
|
|
|
LZMA_dirClose, /* dirClose() method */
|
|
|
|
LZMA_read, /* read() method */
|
|
|
|
LZMA_write, /* write() method */
|
|
|
|
LZMA_eof, /* eof() method */
|
|
|
|
LZMA_tell, /* tell() method */
|
|
|
|
LZMA_seek, /* seek() method */
|
|
|
|
LZMA_fileLength, /* fileLength() method */
|
|
|
|
LZMA_fileClose /* fileClose() method */
|
|
|
|
};
|
|
|
|
|
2007-03-09 09:17:56 +01:00
|
|
|
#endif /* defined PHYSFS_SUPPORTS_7Z */
|
2006-04-11 16:33:48 +02:00
|
|
|
|
|
|
|
/* end of lzma.c ... */
|
|
|
|
|