/*

 * ISO9660 support routines for PhysicsFS.

 *

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

 *

 *  This file written by Christoph Nelles.

 */

/* !!! FIXME: this file needs Ryanification. */

/*

 * Handles CD-ROM disk images (and raw CD-ROM devices).

 *

 * Not supported:

 * - RockRidge

 * - Non 2048 Sectors

 * - UDF

 *

 * Deviations from the standard

 * - Ignores mandatory sort order

 * - Allows various invalid file names

 *

 * Problems

 * - Ambiguities in the standard

 */

#if (defined PHYSFS_SUPPORTS_ISO9660)

#define __PHYSICSFS_INTERNAL__

#include "physfs_internal.h"

#include <time.h>

/* cache files smaller than this completely in memory */

#define ISO9660_FULLCACHEMAXSIZE 2048

/* !!! FIXME: this is going to cause trouble. */

#pragma pack(push)  /* push current alignment to stack */

#pragma pack(1)     /* set alignment to 1 byte boundary */

/* This is the format as defined by the standard

typedef struct

{

    PHYSFS_uint32 lsb;

    PHYSFS_uint32 msb;

} ISOBB32bit; // 32byte Both Byte type, means the value first in LSB then in MSB

typedef struct

{

    PHYSFS_uint16 lsb;

    PHYSFS_uint16 msb;

} ISOBB16bit; // 16byte Both Byte type, means the value first in LSB then in MSB

*/

/* define better ones to simplify coding (less if's) */

#if PHYSFS_BYTEORDER == PHYSFS_LIL_ENDIAN

#define ISOBB32bit(name) PHYSFS_uint32 name; PHYSFS_uint32 __dummy_##name;

#define ISOBB16bit(name) PHYSFS_uint16 name; PHYSFS_uint16 __dummy_##name;

#else

#define ISOBB32bit(name) PHYSFS_uint32 __dummy_##name; PHYSFS_uint32 name;

#define ISOBB16bit(name) PHYSFS_uint16 __dummy_##name; PHYSFS_uint16 name;

#endif

typedef struct

{

    char year[4];

    char month[2];

    char day[2];

    char hour[2];

    char minute[2];

    char second[2];

    char centisec[2];

    PHYSFS_sint8 offset; /* in 15min from GMT */

} ISO9660VolumeTimestamp;

typedef struct

{

    PHYSFS_uint8 year;

    PHYSFS_uint8 month;

    PHYSFS_uint8 day;

    PHYSFS_uint8 hour;

    PHYSFS_uint8 minute;

    PHYSFS_uint8 second;

    PHYSFS_sint8 offset;

} ISO9660FileTimestamp;

typedef struct

{

  unsigned existence:1;

  unsigned directory:1;

  unsigned associated_file:1;

  unsigned record:1;

  unsigned protection:1;

  unsigned reserved:2;

  unsigned multiextent:1;

} ISO9660FileFlags;

typedef struct

{

    PHYSFS_uint8 length;

    PHYSFS_uint8 attribute_length;

    ISOBB32bit(extent_location)

    ISOBB32bit(data_length)

    ISO9660FileTimestamp timestamp;

    ISO9660FileFlags file_flags;

    PHYSFS_uint8 file_unit_size;

    PHYSFS_uint8 gap_size;

    ISOBB16bit(vol_seq_no)

    PHYSFS_uint8 len_fi;

    char unused;

} ISO9660RootDirectoryRecord;

/* this structure is combined for all Volume descriptor types */

typedef struct

{

    PHYSFS_uint8 type;

    char identifier[5];

    PHYSFS_uint8 version;

    PHYSFS_uint8 flags;

    char system_identifier[32];

    char volume_identifier[32];

    char unused2[8];

    ISOBB32bit(space_size)

    PHYSFS_uint8 escape_sequences[32];

    ISOBB16bit(vol_set_size)

    ISOBB16bit(vol_seq_no)

    ISOBB16bit(block_size)

    ISOBB32bit(path_table_size)

/*    PHYSFS_uint32 path_table_start_lsb; // why didn't they use both byte type?

    PHYSFS_uint32 opt_path_table_start_lsb;

    PHYSFS_uint32 path_table_start_msb;

    PHYSFS_uint32 opt_path_table_start_msb;*/

#if PHYSFS_BYTEORDER == PHYSFS_LIL_ENDIAN

    PHYSFS_uint32 path_table_start;

    PHYSFS_uint32 opt_path_table_start;

    PHYSFS_uint32 unused6;

    PHYSFS_uint32 unused7;

#else

    PHYSFS_uint32 unused6;

    PHYSFS_uint32 unused7;

    PHYSFS_uint32 path_table_start;

    PHYSFS_uint32 opt_path_table_start;

#endif

    ISO9660RootDirectoryRecord rootdirectory;

    char set_identifier[128];

    char publisher_identifier[128];

    char preparer_identifer[128];

    char application_identifier[128];

    char copyright_file_identifier[37];

    char abstract_file_identifier[37];

    char bibliographic_file_identifier[37];

    ISO9660VolumeTimestamp creation_timestamp;

    ISO9660VolumeTimestamp modification_timestamp;

    ISO9660VolumeTimestamp expiration_timestamp;

    ISO9660VolumeTimestamp effective_timestamp;

    PHYSFS_uint8 file_structure_version;

    char unused4;

    char application_use[512];

    char unused5[653];

} ISO9660VolumeDescriptor;

typedef struct

{

    PHYSFS_uint8 recordlen;

    PHYSFS_uint8 extattributelen;

    ISOBB32bit(extentpos)

    ISOBB32bit(datalen)

    ISO9660FileTimestamp recordtime;

    ISO9660FileFlags flags;

    PHYSFS_uint8 file_unit_size;

    PHYSFS_uint8 interleave_gap;

    ISOBB16bit(volseqno)

    PHYSFS_uint8 filenamelen;

    char filename[222]; /* This is not exact, but makes reading easier */

} ISO9660FileDescriptor;

typedef struct

{

    ISOBB16bit(owner)

    ISOBB16bit(group)

    PHYSFS_uint16 flags; /* not implemented*/

    ISO9660VolumeTimestamp create_time; /* yes, not file timestamp */

    ISO9660VolumeTimestamp mod_time;

    ISO9660VolumeTimestamp expire_time;

    ISO9660VolumeTimestamp effective_time;

    PHYSFS_uint8 record_format;

    PHYSFS_uint8 record_attributes;

    ISOBB16bit(record_len)

    char system_identifier[32];

    char system_use[64];

    PHYSFS_uint8 version;

    ISOBB16bit(escape_len)

    char reserved[64];

    /** further fields not implemented */

} ISO9660ExtAttributeRec;

#pragma pack(pop)   /* restore original alignment from stack */

typedef struct

{

    PHYSFS_Io *io;

    PHYSFS_uint32 rootdirstart;

    PHYSFS_uint32 rootdirsize;

    PHYSFS_uint64 currpos;

    int isjoliet;

    char *path;

    void *mutex;

} ISO9660Handle;

typedef struct __ISO9660FileHandle

{

    PHYSFS_sint64 filesize;

    PHYSFS_uint64 currpos;

    PHYSFS_uint64 startblock;

    ISO9660Handle *isohandle;

    PHYSFS_uint32 (*read) (struct __ISO9660FileHandle *filehandle, void *buffer,

            PHYSFS_uint64 len);

    int (*seek)(struct __ISO9660FileHandle *filehandle,  PHYSFS_sint64 offset);

    void (*close)(struct __ISO9660FileHandle *filehandle);

    /* !!! FIXME: anonymouse union is going to cause problems. */

    union

    {

        /* !!! FIXME: just use a memory PHYSFS_Io here, unify all this code. */

        char *cacheddata; /* data of file when cached */

        PHYSFS_Io *io; /* handle to separate opened file */

    };

} ISO9660FileHandle;

/*******************************************************************************

 * Time conversion functions

 ******************************************************************************/

static PHYSFS_sint64 iso_mktime(ISO9660FileTimestamp *timestamp)

{

    struct tm tm;

    tm.tm_year = timestamp->year;

    tm.tm_mon = timestamp->month - 1;

    tm.tm_mday = timestamp->day;

    tm.tm_hour = timestamp->hour;

    tm.tm_min = timestamp->minute;

    tm.tm_sec = timestamp->second;

    /* Ignore GMT offset for now... */

    return mktime(&tm);

} /* iso_mktime */

static int iso_atoi2(char *text)

{

    return ((text[0] - 40) * 10) + (text[1] - 40);

} /* iso_atoi2 */

static int iso_atoi4(char *text)

{

    return ((text[0] - 40) * 1000) + ((text[1] - 40) * 100) +

           ((text[2] - 40) * 10) + (text[3] - 40);

} /* iso_atoi4 */

static PHYSFS_sint64 iso_volume_mktime(ISO9660VolumeTimestamp *timestamp)

{

    struct tm tm;

    tm.tm_year = iso_atoi4(timestamp->year);

    tm.tm_mon = iso_atoi2(timestamp->month) - 1;

    tm.tm_mday = iso_atoi2(timestamp->day);

    tm.tm_hour = iso_atoi2(timestamp->hour);

    tm.tm_min = iso_atoi2(timestamp->minute);

    tm.tm_sec = iso_atoi2(timestamp->second);

    /* this allows values outside the range of a unix timestamp... sanitize them */

    PHYSFS_sint64 value = mktime(&tm);

    return value == -1 ? 0 : value;

} /* iso_volume_mktime */

/*******************************************************************************

 * Filename extraction

 ******************************************************************************/

static int iso_extractfilenameISO(ISO9660FileDescriptor *descriptor,

        char *filename, int *version)

{

    *filename = '\0';

    if (descriptor->flags.directory)

    {

        strncpy(filename, descriptor->filename, descriptor->filenamelen);

        filename[descriptor->filenamelen] = '\0';

        *version = 0;

    } /* if */

    else

    {

        /* find last SEPARATOR2 */

        int pos = 0;

        int lastfound = -1;

        for(;pos < descriptor->filenamelen; pos++)

            if (descriptor->filename[pos] == ';')

                lastfound = pos;

        strncpy(filename, descriptor->filename, lastfound);

        if (filename[lastfound - 1] == '.')

            filename[lastfound - 1] = '\0'; /* consume trailing ., as done in all implementations */

        else

            filename[lastfound] = '\0';

        *version = atoi(descriptor->filename + lastfound);

    } /* else */

    return 0;

} /* iso_extractfilenameISO */

static int iso_extractfilenameUCS2(ISO9660FileDescriptor *descriptor,

        char *filename, int *version)

{

    PHYSFS_uint16 tmp[128];

    PHYSFS_uint16 *src;

    int len;

    *filename = '\0';

    *version = 1; /* Joliet does not have versions.. at least not on my images */

    src = (PHYSFS_uint16*) descriptor->filename;

    len = descriptor->filenamelen / 2;

    tmp[len] = 0;

    while(len--)

        tmp[len] = PHYSFS_swapUBE16(src[len]);

    PHYSFS_utf8FromUcs2(tmp, filename, 255);

    return 0;

} /* iso_extractfilenameUCS2 */

static int iso_extractfilename(ISO9660Handle *handle,

        ISO9660FileDescriptor *descriptor, char *filename,int *version)

{

    if (handle->isjoliet)

        return iso_extractfilenameUCS2(descriptor, filename, version);

    else

        return iso_extractfilenameISO(descriptor, filename, version);

} /* iso_extractfilename */

/*******************************************************************************

 * Basic image read functions

 ******************************************************************************/

static int iso_readimage(ISO9660Handle *handle, PHYSFS_uint64 where,

                         void *buffer, PHYSFS_uint64 len)

{

    int rc = -1;

    if (where != handle->currpos)

    rc = handle->io->read(handle->io, buffer, len);

    if (rc == -1)

    {

        handle->currpos = (PHYSFS_uint64) -1;

    } /* if */

    handle->currpos += rc;

    unlockme:

    __PHYSFS_platformReleaseMutex(handle->mutex);

    return rc;

} /* iso_readimage */

static PHYSFS_sint64 iso_readfiledescriptor(ISO9660Handle *handle,

                                            PHYSFS_uint64 where,

                                            ISO9660FileDescriptor *descriptor)

{

    PHYSFS_sint64 rc = iso_readimage(handle, where, descriptor,

                                     sizeof (descriptor->recordlen));

    if (descriptor->recordlen == 0)

        return 0; /* fill bytes at the end of a sector */

    rc = iso_readimage(handle, where + 1, &descriptor->extattributelen,

            descriptor->recordlen - sizeof(descriptor->recordlen));

    return 0;

} /* iso_readfiledescriptor */

static void iso_extractsubpath(char *path, char **subpath)

{

    *subpath = strchr(path,'/');

    if (*subpath != 0)

    {

        **subpath = 0;

        *subpath +=1;

    } /* if */

} /* iso_extractsubpath */

/*

 * Don't use path tables, they are not necessarily faster, but more complicated

 * to implement as they store only directories and not files, so searching for

 * a file needs to branch to the directory extent sooner or later.

 */

static int iso_find_dir_entry(ISO9660Handle *handle,const char *path,

                              ISO9660FileDescriptor *descriptor, int *exists)

{

    char *subpath = 0;

    PHYSFS_uint64 readpos, end_of_dir;

    char filename[255];

    char pathcopy[256];

    char *mypath;

    int version = 0;

    strcpy(pathcopy, path);

    mypath = pathcopy;

    *exists = 0;

    readpos = handle->rootdirstart;

    end_of_dir = handle->rootdirstart + handle->rootdirsize;

    iso_extractsubpath(mypath, &subpath);

    while (1)

    {

        /* recordlen = 0 -> no more entries or fill entry */

        if (!descriptor->recordlen)

        {

            /* if we are in the last sector of the directory & it's 0 -> end */

            if ((end_of_dir - 2048) <= (readpos -1))

                break; /* finished */

            /* else skip to the next sector & continue; */

            readpos = (((readpos - 1) / 2048) + 1) * 2048;

            continue;

        } /* if */

        readpos += descriptor->recordlen;

        if (descriptor->filenamelen == 1 && (descriptor->filename[0] == 0

                || descriptor->filename[0] == 1))

            continue; /* special ones, ignore */

        BAIL_IF_MACRO(

            iso_extractfilename(handle, descriptor, filename, &version),

        if (strcmp(filename, mypath) == 0)

        {

            if ( (subpath == 0) || (subpath[0] == 0) )

            {

                *exists = 1;

                return 0;  /* no subpaths left and we found the entry */

            } /* if */

            if (descriptor->flags.directory)

            {

                /* shorten the path to the subpath */

                mypath = subpath;

                iso_extractsubpath(mypath, &subpath);

                /* gosub to the new directory extent */

                readpos = descriptor->extentpos * 2048;

                end_of_dir = readpos + descriptor->datalen;

            } /* if */

            else

            {

                /* we're at a file but have a remaining subpath -> no match */

                return 0;

            } /* else */

        } /* if */

    } /* while */

    return 0;

} /* iso_find_dir_entry */

static int iso_read_ext_attributes(ISO9660Handle *handle, int block,

                                   ISO9660ExtAttributeRec *attributes)

{

    return iso_readimage(handle, block * 2048, attributes,

                         sizeof(ISO9660ExtAttributeRec));

} /* iso_read_ext_attributes */

static int ISO9660_flush(PHYSFS_Io *io) { return 1;  /* no write support. */ }

static PHYSFS_Io *ISO9660_duplicate(PHYSFS_Io *_io)

{

} /* ISO9660_duplicate */

static void ISO9660_destroy(PHYSFS_Io *io)

{

    ISO9660FileHandle *fhandle = (ISO9660FileHandle*) io->opaque;

    fhandle->close(fhandle);

    allocator.Free(io);

} /* ISO9660_destroy */

static PHYSFS_sint64 ISO9660_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)

{

    ISO9660FileHandle *fhandle = (ISO9660FileHandle*) io->opaque;

    return fhandle->read(fhandle, buf, len);

} /* ISO9660_read */

static PHYSFS_sint64 ISO9660_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 l)

{

} /* ISO9660_write */

static PHYSFS_sint64 ISO9660_tell(PHYSFS_Io *io)

{

    return ((ISO9660FileHandle*) io->opaque)->currpos;

} /* ISO9660_tell */

static int ISO9660_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

{

    ISO9660FileHandle *fhandle = (ISO9660FileHandle*) io->opaque;

    return fhandle->seek(fhandle, offset);

} /* ISO9660_seek */

static PHYSFS_sint64 ISO9660_length(PHYSFS_Io *io)