/*

* GRP support routines for PhysicsFS.

*

* This driver handles BUILD engine archives ("groupfiles"). This format

* (but not this driver) was put together by Ken Silverman.

*

* The format is simple enough. In Ken's words:

*

* What's the .GRP file format?

*

* The ".grp" file format is just a collection of a lot of files stored

* into 1 big one. I tried to make the format as simple as possible: The

* first 12 bytes contains my name, "KenSilverman". The next 4 bytes is

* the number of files that were compacted into the group file. Then for

* each file, there is a 16 byte structure, where the first 12 bytes are

* the filename, and the last 4 bytes are the file's size. The rest of

* the group file is just the raw data packed one after the other in the

* same order as the list of files.

*

* (That info is from http://www.advsys.net/ken/build.htm ...)

*

*

* This file written by Ryan C. Gordon.

*/

#if (defined PHYSFS_SUPPORTS_GRP)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

typedef struct

{

char name[13];

PHYSFS_uint32 startPos;

PHYSFS_uint32 size;

} GRPentry;

typedef struct

{

PHYSFS_uint32 entryCount;

GRPentry *entries;

} GRPinfo;

typedef struct

{

} GRPfileinfo;

} /* readAll */

allocator.Free(info->entries);

allocator.Free(info);

const GRPentry *entry = finfo->entry;

const PHYSFS_uint64 bytesLeft = (PHYSFS_uint64)(entry->size-finfo->curPos);

if (bytesLeft < len)

len = bytesLeft;

} /* GRP_read */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, -1);

} /* GRP_write */

} /* GRP_tell */

GRPfileinfo *finfo = (GRPfileinfo *) io->opaque;

const GRPentry *entry = finfo->entry;

} /* GRP_seek */

GRPfileinfo *origfinfo = (GRPfileinfo *) _io->opaque;

PHYSFS_Io *io = NULL;

PHYSFS_Io *retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

GRPfileinfo *finfo = (GRPfileinfo *) allocator.Malloc(sizeof (GRPfileinfo));

GOTO_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, GRP_duplicate_failed);

GOTO_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, GRP_duplicate_failed);

io = origfinfo->io->duplicate(origfinfo->io);

GOTO_IF_MACRO(io == NULL, NULL, GRP_duplicate_failed);

finfo->io = io;

finfo->entry = origfinfo->entry;

finfo->curPos = 0;

memcpy(retval, _io, sizeof (PHYSFS_Io));

retval->opaque = finfo;

return retval;

GRP_duplicate_failed:

if (finfo != NULL) allocator.Free(finfo);

if (retval != NULL) allocator.Free(retval);

if (io != NULL) io->destroy(io);

return NULL;

} /* GRP_duplicate */

GRPfileinfo *finfo = (GRPfileinfo *) io->opaque;

finfo->io->destroy(finfo->io);

allocator.Free(finfo);

allocator.Free(io);

} /* GRP_destroy */

static const PHYSFS_Io GRP_Io =

{

GRP_read,

GRP_write,

GRP_seek,

GRP_tell,

GRP_length,

GRP_duplicate,

GRP_flush,

GRP_destroy,

NULL

};

if (one != two)

{

const GRPentry *a = (const GRPentry *) _a;

} /* if */

return 0;

if (one != two)

{

GRPentry tmp;

GRPentry *first = &(((GRPentry *) _a)[one]);

GRPentry *second = &(((GRPentry *) _a)[two]);

memcpy(&tmp, first, sizeof (GRPentry));

memcpy(first, second, sizeof (GRPentry));

memcpy(second, &tmp, sizeof (GRPentry));

} /* if */

GRPentry *entry;

char *ptr;

location += (16 * fileCount);

for (entry = info->entries; fileCount > 0; fileCount--, entry++)

{

BAIL_IF_MACRO(!readAll(io, &entry->name, 12), NULL, 0);

BAIL_IF_MACRO(!readAll(io, &entry->size, 4), NULL, 0);

entry->name[12] = '\0'; /* name isn't null-terminated in file. */

if ((ptr = strchr(entry->name, ' ')) != NULL)

*ptr = '\0'; /* trim extra spaces. */

entry->size = PHYSFS_swapULE32(entry->size);

entry->startPos = location;

} /* for */

} /* grp_load_entries */

PHYSFS_uint8 buf[12];

GRPinfo *info = NULL;

PHYSFS_uint32 val = 0;

assert(io != NULL); /* shouldn't ever happen. */

BAIL_IF_MACRO(!readAll(io, buf, sizeof (buf)), NULL, NULL);

if (memcmp(buf, "KenSilverman", sizeof (buf)) != 0)

GOTO_MACRO(ERR_NOT_AN_ARCHIVE, GRP_openArchive_failed);

info = (GRPinfo *) allocator.Malloc(sizeof (GRPinfo));

GOTO_IF_MACRO(info == NULL, ERR_OUT_OF_MEMORY, GRP_openArchive_failed);

GOTO_IF_MACRO(!readAll(io,&val,sizeof(val)), NULL, GRP_openArchive_failed);

info->entryCount = PHYSFS_swapULE32(val);

GRP_openArchive_failed:

allocator.Free(info->entries);

allocator.Free(info);

} /* if */

} /* GRP_openArchive */

int omitSymLinks, PHYSFS_EnumFilesCallback cb,

const char *origdir, void *callbackdata)

{

GRPinfo *info = (GRPinfo *) opaque;

GRPentry *entry = info->entries;

PHYSFS_uint32 max = info->entryCount;

PHYSFS_uint32 i;

} /* GRP_enumerateFiles */

char *ptr = strchr(name, '.');

GRPentry *a = info->entries;

PHYSFS_sint32 lo = 0;

PHYSFS_sint32 hi = (PHYSFS_sint32) (info->entryCount - 1);

PHYSFS_sint32 middle;

int rc;

/*

* Rule out filenames to avoid unneeded processing...no dirs,

* big filenames, or extensions > 3 chars.

*/

BAIL_IF_MACRO((ptr) && (strlen(ptr) > 4), ERR_NO_SUCH_FILE, NULL);

BAIL_IF_MACRO(strlen(name) > 12, ERR_NO_SUCH_FILE, NULL);

BAIL_IF_MACRO(strchr(name, '/') != NULL, ERR_NO_SUCH_FILE, NULL);

while (lo <= hi)

else if (rc > 0)

lo = middle + 1;

else

hi = middle - 1;

} /* while */

BAIL_MACRO(ERR_NO_SUCH_FILE, NULL);

} /* grp_find_entry */

} /* GRP_exists */

} /* GRP_isDirectory */

} /* GRP_isSymLink */

entry = grp_find_entry(info, fnm);

*fileExists = (entry != NULL);

GOTO_IF_MACRO(entry == NULL, NULL, GRP_openRead_failed);

retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));

GOTO_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, GRP_openRead_failed);

finfo->io = info->io->duplicate(info->io);

GOTO_IF_MACRO(finfo->io == NULL, NULL, GRP_openRead_failed);

if (!finfo->io->seek(finfo->io, entry->startPos))

GOTO_MACRO(NULL, GRP_openRead_failed);

finfo->curPos = 0;

finfo->entry = entry;

memcpy(retval, &GRP_Io, sizeof (*retval));

retval->opaque = finfo;

return retval;

GRP_openRead_failed:

if (finfo != NULL)

if (finfo->io != NULL)

finfo->io->destroy(finfo->io);

} /* if */

if (retval != NULL)

allocator.Free(retval);

return NULL;

} /* GRP_openRead */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);

} /* GRP_openWrite */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);

} /* GRP_openAppend */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, 0);

} /* GRP_remove */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, 0);

} /* GRP_mkdir */

PHYSFS_Stat *stat)

{

const GRPinfo *info = (const GRPinfo *) opaque;

const GRPentry *entry = grp_find_entry(info, filename);

*exists = (entry != 0);

if (!entry)

return 0;

stat->filesize = entry->size;

stat->filetype = PHYSFS_FILETYPE_REGULAR;

stat->modtime = -1;

stat->createtime = -1;

stat->accesstime = -1;

stat->readonly = 1;

} /* GRP_stat */

const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP =

{

"GRP",

GRP_ARCHIVE_DESCRIPTION,

"http://icculus.org/physfs/",

};

const PHYSFS_Archiver __PHYSFS_Archiver_GRP =

{

&__PHYSFS_ArchiveInfo_GRP,

GRP_openArchive, /* openArchive() method */

GRP_enumerateFiles, /* enumerateFiles() method */

GRP_exists, /* exists() method */

GRP_isDirectory, /* isDirectory() method */

GRP_isSymLink, /* isSymLink() method */

GRP_openRead, /* openRead() method */

GRP_openWrite, /* openWrite() method */

GRP_openAppend, /* openAppend() method */

GRP_remove, /* remove() method */

GRP_mkdir, /* mkdir() method */

GRP_dirClose, /* dirClose() method */

};

#endif /* defined PHYSFS_SUPPORTS_GRP */