/*

* LZMA support routines for PhysicsFS.

*

* Please see the file LICENSE in the source's root directory.

*

* by Igor Pavlov.

*/

#if HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdlib.h>

#include <string.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

#define _LZMA_IN_CB

/* Use callback for input data */

/* #define _LZMA_OUT_READ */

/* Use read function for output data */

#define _LZMA_PROB32

/* It can increase speed on some 32-bit CPUs,

but memory usage will be doubled in that case */

#define _LZMA_SYSTEM_SIZE_T

/* Use system's size_t. You can use it to enable 64-bit sizes supporting */

#include "7zIn.h"

#include "7zCrc.h"

#include "7zExtract.h"

/* 7z internal from 7zIn.c */

int TestSignatureCandidate(Byte *testBytes);

{

ISzInStream InStream;

void *File;

} CFileInStream;

/*

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

*/

CArchiveDatabaseEx db; /* For 7z: Database */

CFileInStream stream; /* For 7z: Input file incl. read and seek callbacks */

} LZMAarchive;

typedef struct _LZMAentry

{

LZMAarchive *archive; /* Link to corresponding archive */

CFileItem *file; /* For 7z: File info, eg. name, size */

PHYSFS_uint32 fileIndex; /* Index of file in archive */

PHYSFS_uint32 folderIndex; /* Index of folder in archive */

size_t offset; /* Offset in folder */

} LZMAentry;

/* Memory management implementations to be passed to 7z */

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

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

if (maxReqSize > kBufferSize)

maxReqSize = kBufferSize;

processedSizeLoc = __PHYSFS_platformRead(s->File, g_Buffer, 1, maxReqSize);

*buffer = g_Buffer;

if (processedSize != 0)

return SZ_OK;

} /* SzFileReadImp */

#else

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;

return SZ_OK;

} /* SzFileReadImp */

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

/*

* Find entry 'name' in 'archive' and report the 'index' back

*/

static int lzma_find_entry(LZMAarchive *archive, const char *name,

PHYSFS_uint32 *index)

if (strcmp(archive->db.Database.Files[*index].Name, name) == 0)

return 1;

} /* for */

} /* lzma_find_entry */

/*

* Report the first file index of a directory

*/

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;

PHYSFS_sint64 wantedSize = objSize*objCount;

PHYSFS_sint64 remainingSize = entry->file->Size - entry->position;

BAIL_IF_MACRO(wantedSize == 0, NULL, 0); /* quick rejection. */

BAIL_IF_MACRO(remainingSize == 0, ERR_PAST_EOF, 0);

wantedSize = remainingSize - (remainingSize % objSize);

objCount = (PHYSFS_uint32) (remainingSize / objSize);

} /* if */

size_t fileSize;

ISzAlloc allocImp;

ISzAlloc allocTempImp;

/* Prepare callbacks for 7z */

allocImp.Alloc = SzAllocPhysicsFS;

allocImp.Free = SzFreePhysicsFS;

allocTempImp.Alloc = SzAllocPhysicsFS;

allocTempImp.Free = SzFreePhysicsFS;

/* Only decompress the folder if it is not allready cached */

if (entry->archive->folder[entry->folderIndex].cache == NULL)

{

size_t tmpsize = entry->archive->folder[entry->folderIndex].size;

int rc = lzma_err(SzExtract(

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

/* Offset of this file inside the cache, set by SzExtract */

&entry->offset,

&fileSize, /* Size of this file */

&allocImp,

&allocTempImp));

entry->archive->folder[entry->folderIndex].size = tmpsize;

if (rc != SZ_OK)

/* Copy wanted bytes over from cache to outBuffer */

strncpy(outBuffer,

(void*) (entry->archive->folder[entry->folderIndex].cache +

entry->offset + entry->position),

wantedSize);

entry->position += wantedSize;

return objCount;

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

} /* 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);

entry->position = offset;

return 1;

} /* LZMA_seek */

static PHYSFS_sint64 LZMA_fileLength(fvoid *opaque)

{

LZMAentry *entry = (LZMAentry *) opaque;

return (entry->file->Size);

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

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;

}

entry = NULL;

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

__PHYSFS_platformClose(in);

return res;

} /* LZMA_isArchive */

static void *LZMA_openArchive(const char *name, int forWriting)

{

ISzAlloc allocImp;

ISzAlloc allocTempImp;

BAIL_IF_MACRO(forWriting, ERR_ARC_IS_READ_ONLY, NULL);

archive = (LZMAarchive *) allocator.Malloc(sizeof (LZMAarchive));

BAIL_IF_MACRO(archive == NULL, ERR_OUT_OF_MEMORY, NULL);

archive->firstEntry = NULL;

archive->lastEntry = NULL;

if ((archive->stream.File = __PHYSFS_platformOpenRead(name)) == NULL)

{

allocator.Free(archive);

return NULL;

} /* if */

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

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

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)

{

LZMAarchive *archive = (LZMAarchive *) opaque;

PHYSFS_uint32 index = 0;

return(lzma_find_entry(archive, name, &index));

} /* LZMA_exists */

static PHYSFS_sint64 LZMA_getLastModTime(dvoid *opaque,

const char *name,

int *fileExists)

/* !!! FIXME: Lacking support in the LZMA C SDK. */

BAIL_MACRO(ERR_NOT_IMPLEMENTED, -1);

} /* LZMA_getLastModTime */

static int LZMA_isDirectory(dvoid *opaque, const char *name, int *fileExists)

{

LZMAarchive *archive = (LZMAarchive *) opaque;

PHYSFS_uint32 index = 0;

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

PHYSFS_uint32 fileIndex = 0;

PHYSFS_uint32 folderIndex = 0;

folderIndex = archive->db.FileIndexToFolderIndexMap[fileIndex];

BAIL_IF_MACRO(folderIndex == (PHYSFS_uint32)-1, ERR_UNKNOWN_ERROR, NULL);

entry = (LZMAentry *) allocator.Malloc(sizeof (LZMAentry));

BAIL_IF_MACRO(entry == NULL, ERR_OUT_OF_MEMORY, NULL);

entry->fileIndex = fileIndex;

entry->folderIndex = folderIndex;

entry->position = 0;

archive->folder[folderIndex].references++;

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;

} /* 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)

{

LZMAarchive *archive = (LZMAarchive *) opaque;

LZMAentry *entry = archive->firstEntry;

LZMAentry *tmpEntry = entry;

while (entry != NULL)

{

tmpEntry = entry->next;

LZMA_fileClose(entry);

entry = tmpEntry;

} /* while */

SzArDbExFree(&archive->db, SzFreePhysicsFS);

__PHYSFS_platformClose(archive->stream.File);

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

};

/* end of lzma.c ... */