/*

* MIX support routines for PhysicsFS.

*

* This driver handles old archives used in the famous games

* Command&Conquer Tiberium Dawn and Command&Conquer Red Alert.

*

* Newer MIX files as they are used in C&C Tiberium Sun and C&C Red Alert 2

* aren't supported yet. Keep your eyes open for future updates.

*

* A MIX file has three parts:

* (1) Header

* 16bit integer -> number of files stored in this MIX

* 32bit integer -> filesize

* (2) "Directory"

* 32bit integer -> hash of the filename

* 32bit integer -> starting offset in the MIX

* 32bit integer -> end offset in the MIX

* (3) Data (BODY)

* All data comes here

*

* NOTES:

* The offsets are relative to the body. So offset 0 is directly after

* the directory.

*

* Filenames only exist as hashes. So enumerate_files() will only report all

* hashes. Searching a filename in hashes is extremly quick so I decided not

* to include any sorting routines after then opening of the archive.

*

*

* I found the structure of MIX files here:

* http://www.geocities.com/SiliconValley/8682/cncmap1f.txt

*

*

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

*

* This file written by Sebastian Steinhauer <steini@steini-welt.de>

*/

#if HAVE_CONFIG_H

# include <config.h>

#endif

#if (defined PHYSFS_SUPPORTS_MIX)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "physfs.h"

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

typedef struct

{

PHYSFS_uint16 num_files;

PHYSFS_uint32 filesize;

} MIXheader;

typedef struct

{

PHYSFS_uint32 hash;

PHYSFS_uint32 start_offset;

PHYSFS_uint32 end_offset;

} MIXentry;

typedef struct

{

char *filename; /* filename of the archive */

MIXentry *entry; /* list of entries */

MIXheader header; /* the header of the MIX file */

PHYSFS_uint32 delta; /* size of header + entries */

} MIXinfo;

typedef struct

{

PHYSFS_uint64 size; /* filesize */

PHYSFS_uint64 cur_pos; /* position in this file */

MIXentry *entry; /* pointer to the MIX entry */

MIXinfo *info; /* pointer to our MIXinfo */

void *handle; /* filehandle */

} MIXfileinfo;

static PHYSFS_uint32 MIX_hash(const char *name)

{

PHYSFS_uint32 id = 0;

PHYSFS_uint32 a = 0;

PHYSFS_uint32 i = 0;

PHYSFS_uint32 l;

PHYSFS_uint32 j;

l = strlen(name);

while (i < l)

{

a = 0;

for(j = 0; j < 4; j++)

{

a >>= 8;

if (i < l)

{

a += (unsigned int) (name[i]) << 24;

i++;

} /* if */

} /* for */

id = (id << 1 | id >> 31) + a;

} /* while */

/* a bit debuggin :)

/printf("Filename %s -> %X\n",name,id); */

return(id);

} /* MIX_hash */

free(info->entry);

free(info->filename);

} /* MIX_dirClose */

PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)

{

MIXentry *entry = finfo->entry;

PHYSFS_uint32 read;

/* set position in the archive */

__PHYSFS_platformSeek(finfo->handle,

finfo->info->delta +

entry->start_offset +

finfo->cur_pos);

/* read n bytes */

read = __PHYSFS_platformRead(finfo->handle, buffer, objSize, objCount);

/* keep filepointer up to date */

if (read)

finfo->cur_pos += read * objSize;

return(read);

} /* MIX_read */

PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)

{

BAIL_MACRO(ERR_NOT_SUPPORTED, -1);

} /* MIX_write */

return(fifo->cur_pos >= fifo->size);

} /* MIX_eof */

} /* MIX_tell */

BAIL_IF_MACRO(offset < 0, ERR_INVALID_ARGUMENT, 0);

BAIL_IF_MACRO(offset >= h->size, ERR_PAST_EOF, 0);

h->cur_pos = offset;

return(1);

} /* MIX_seek */

} /* MIX_fileLength */

__PHYSFS_platformClose(finfo->handle);

free(finfo);

return(1);

} /* MIX_fileClose */

static int MIX_isArchive(const char *filename, int forWriting)

{

write a simple detection routine for MIX files.

Unfortunaly MIX files have no ID in the header.

*/

return(1);

} /* MIX_isArchive */

/*

* Read an unsigned 32-bit int and swap to native byte order.

*/

static int readui32(void *in, PHYSFS_uint32 *val)

{

PHYSFS_uint32 v;

BAIL_IF_MACRO(__PHYSFS_platformRead(in, &v, sizeof (v), 1) != 1, NULL, 0);

*val = PHYSFS_swapULE32(v);

return(1);

} /* readui32 */

/*

* Read an unsigned 16-bit int and swap to native byte order.

*/

static int readui16(void *in, PHYSFS_uint16 *val)

{

PHYSFS_uint16 v;

BAIL_IF_MACRO(__PHYSFS_platformRead(in, &v, sizeof (v), 1) != 1, NULL, 0);

*val = PHYSFS_swapULE16(v);

return(1);

} /* readui16 */

PHYSFS_uint32 i = 0;

MIXinfo *info = NULL;

void *handle = NULL;

info = (MIXinfo *) malloc(sizeof (MIXinfo));

BAIL_IF_MACRO(info == NULL, ERR_OUT_OF_MEMORY, 0);

memset(info, '\0', sizeof (MIXinfo));

info->filename = (char *) malloc(strlen(name) + 1);

if (info->filename == NULL)

__PHYSFS_setError(ERR_OUT_OF_MEMORY);

goto MIX_openArchive_failed;

} /* if */

/* store filename */

/* open the file */

handle = __PHYSFS_platformOpenRead(name);

if (!handle)

goto MIX_openArchive_failed;

if ( (!readui16(handle, &info->header.num_files)) ||

(!readui32(handle, &info->header.filesize)) )

goto MIX_openArchive_failed;

info->delta = 6 + (info->header.num_files * 12);

/* allocate space for the entries and read the entries */

info->entry = malloc(sizeof (MIXentry) * info->header.num_files);

if (info->entry == NULL)

__PHYSFS_setError(ERR_OUT_OF_MEMORY);

goto MIX_openArchive_failed;

} /* if */

/* read the directory list */

for (i = 0; i < header.num_files; i++)

{

if ( (!readui32(handle, &info->entry[i].hash)) ||

(!readui32(handle, &info->entry[i].start_offset)) ||

(!readui32(handle, &info->entry[i].end_offset)) )

goto MIX_openArchive_failed;

} /* for */

__PHYSFS_platformClose(handle);

return(info);

MIX_openArchive_failed:

if (info != NULL)

{

if (info->filename != NULL)

free(info->filename);

if (info->entry != NULL)

free(info->entry);

free(info);

} /* if */

if (handle != NULL)

__PHYSFS_platformClose(handle);

return(NULL);

} /* MIX_openArchive */

static void MIX_enumerateFiles(dvoid *opaque, const char *dname,

int omitSymLinks, PHYSFS_StringCallback cb,

void *callbackdata)

/* no directories in MIX files. */

if (*dirname != '\0')

MIXinfo *info = (MIXinfo*) opaque;

MIXentry *entry = info->entry;

int i;

char buffer[32];

for (i = 0; i < info->header.num_files; i++, entry++)

{

sprintf(buffer, "%X", entry->hash);

cb(callbackdata, buffer);

} /* for */

} /* if */

} /* MIX_enumerateFiles */

static MIXentry *MIX_find_entry(MIXinfo *info, const char *name)

{

MIXentry *entry = info->entry;

PHYSFS_uint32 i, id;

/* create hash */

id = MIX_hash(name);

/* look for this hash */

for (i = 0; i < info->header.num_files; i++, entry++)

{

if (entry->hash == id)

return(entry);

} /* for */

/* nothing found... :( */

return(NULL);

} /* MIX_find_entry */

} /* MIX_exists */

return(0); /* never directories in a MIX */

} /* MIX_isDirectory */

return(0); /* never symlinks in a MIX. */

} /* MIX_isSymLink */

const char *name,

int *fileExists)

{

} /* MIX_getLastModTime */

MIXfileinfo *finfo;

MIXentry *entry;

/* try to find this file */

entry = MIX_find_entry(info,fnm);

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

/* allocate a MIX handle */

finfo = (MIXfileinfo *) malloc(sizeof (MIXfileinfo));

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

/* open the archive */

finfo->handle = __PHYSFS_platformOpenRead(info->filename);

if(!finfo->handle)

{

free(finfo);

return(NULL);

/* setup structures */

finfo->cur_pos = 0;

finfo->info = info;

finfo->entry = entry;

finfo->size = entry->end_offset - entry->start_offset;

} /* MIX_openRead */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);

} /* MIX_openWrite */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);

} /* MIX_openAppend */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, 0);

} /* MIX_remove */

{

BAIL_MACRO(ERR_NOT_SUPPORTED, 0);

} /* MIX_mkdir */

const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX =

{

"MIX",

"Westwood archive (Tiberian Dawn / Red Alert)",

"Sebastian Steinhauer <steini@steini-welt.de>",

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

};

const PHYSFS_Archiver __PHYSFS_Archiver_MIX =

{

&__PHYSFS_ArchiveInfo_MIX,

MIX_isArchive, /* isArchive() method */

MIX_openArchive, /* openArchive() method */

MIX_enumerateFiles, /* enumerateFiles() method */

MIX_exists, /* exists() method */

MIX_isDirectory, /* isDirectory() method */

MIX_isSymLink, /* isSymLink() method */

MIX_getLastModTime, /* getLastModTime() method */

MIX_openRead, /* openRead() method */

MIX_openWrite, /* openWrite() method */

MIX_openAppend, /* openAppend() method */

MIX_remove, /* remove() method */

MIX_mkdir, /* mkdir() method */

MIX_dirClose, /* dirClose() method */

MIX_read, /* read() method */

MIX_write, /* write() method */

MIX_eof, /* eof() method */

MIX_tell, /* tell() method */

MIX_seek, /* seek() method */

MIX_fileLength, /* fileLength() method */

MIX_fileClose /* fileClose() method */

};

#endif /* defined PHYSFS_SUPPORTS_MIX */

/* end of mix.c ... */