1 /*

     2  * ISO9660 support routines for PhysicsFS.

     3  *

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

     5  *

     6  *  This file written by Christoph Nelles.

     7  */

     8 

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

    10 

    11 /*

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

    13  *

    14  * Not supported:

    15  * - RockRidge

    16  * - Non 2048 Sectors

    17  * - UDF

    18  *

    19  * Deviations from the standard

    20  * - Ignores mandatory sort order

    21  * - Allows various invalid file names

    22  *

    23  * Problems

    24  * - Ambiguities in the standard

    25  */

    26 

    27 #define __PHYSICSFS_INTERNAL__

    28 #include "physfs_internal.h"

    29 

    30 #if PHYSFS_SUPPORTS_ISO9660

    31 

    32 #include <time.h>

    33 

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

    35 #define ISO9660_FULLCACHEMAXSIZE 2048

    36 

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

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

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

    40 

    41 /* This is the format as defined by the standard

    42 typedef struct

    43 {

    44     PHYSFS_uint32 lsb;

    45     PHYSFS_uint32 msb;

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

    47 

    48 typedef struct

    49 {

    50     PHYSFS_uint16 lsb;

    51     PHYSFS_uint16 msb;

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

    53 */

    54 

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

    56 #if PHYSFS_BYTEORDER == PHYSFS_LIL_ENDIAN

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

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

    59 #else

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

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

    62 #endif

    63 

    64 typedef struct

    65 {

    66     char year[4];

    67     char month[2];

    68     char day[2];

    69     char hour[2];

    70     char minute[2];

    71     char second[2];

    72     char centisec[2];

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

    74 } ISO9660VolumeTimestamp;

    75 

    76 typedef struct

    77 {

    78     PHYSFS_uint8 year;

    79     PHYSFS_uint8 month;

    80     PHYSFS_uint8 day;

    81     PHYSFS_uint8 hour;

    82     PHYSFS_uint8 minute;

    83     PHYSFS_uint8 second;

    84     PHYSFS_sint8 offset;

    85 } ISO9660FileTimestamp;

    86 

    87 typedef struct

    88 {

    89   unsigned existence:1;

    90   unsigned directory:1;

    91   unsigned associated_file:1;

    92   unsigned record:1;

    93   unsigned protection:1;

    94   unsigned reserved:2;

    95   unsigned multiextent:1;

    96 } ISO9660FileFlags;

    97 

    98 typedef struct

    99 {

   100     PHYSFS_uint8 length;

   101     PHYSFS_uint8 attribute_length;

   102     ISOBB32bit(extent_location)

   103     ISOBB32bit(data_length)

   104     ISO9660FileTimestamp timestamp;

   105     ISO9660FileFlags file_flags;

   106     PHYSFS_uint8 file_unit_size;

   107     PHYSFS_uint8 gap_size;

   108     ISOBB16bit(vol_seq_no)

   109     PHYSFS_uint8 len_fi;

   110     char unused;

   111 } ISO9660RootDirectoryRecord;

   112 

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

   114 typedef struct

   115 {

   116     PHYSFS_uint8 type;

   117     char identifier[5];

   118     PHYSFS_uint8 version;

   119     PHYSFS_uint8 flags;

   120     char system_identifier[32];

   121     char volume_identifier[32];

   122     char unused2[8];

   123     ISOBB32bit(space_size)

   124     PHYSFS_uint8 escape_sequences[32];

   125     ISOBB16bit(vol_set_size)

   126     ISOBB16bit(vol_seq_no)

   127     ISOBB16bit(block_size)

   128     ISOBB32bit(path_table_size)

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

   130     PHYSFS_uint32 opt_path_table_start_lsb;

   131     PHYSFS_uint32 path_table_start_msb;

   132     PHYSFS_uint32 opt_path_table_start_msb;*/

   133 #if PHYSFS_BYTEORDER == PHYSFS_LIL_ENDIAN

   134     PHYSFS_uint32 path_table_start;

   135     PHYSFS_uint32 opt_path_table_start;

   136     PHYSFS_uint32 unused6;

   137     PHYSFS_uint32 unused7;

   138 #else

   139     PHYSFS_uint32 unused6;

   140     PHYSFS_uint32 unused7;

   141     PHYSFS_uint32 path_table_start;

   142     PHYSFS_uint32 opt_path_table_start;

   143 #endif

   144     ISO9660RootDirectoryRecord rootdirectory;

   145     char set_identifier[128];

   146     char publisher_identifier[128];

   147     char preparer_identifer[128];

   148     char application_identifier[128];

   149     char copyright_file_identifier[37];

   150     char abstract_file_identifier[37];

   151     char bibliographic_file_identifier[37];

   152     ISO9660VolumeTimestamp creation_timestamp;

   153     ISO9660VolumeTimestamp modification_timestamp;

   154     ISO9660VolumeTimestamp expiration_timestamp;

   155     ISO9660VolumeTimestamp effective_timestamp;

   156     PHYSFS_uint8 file_structure_version;

   157     char unused4;

   158     char application_use[512];

   159     char unused5[653];

   160 } ISO9660VolumeDescriptor;

   161 

   162 typedef struct

   163 {

   164     PHYSFS_uint8 recordlen;

   165     PHYSFS_uint8 extattributelen;

   166     ISOBB32bit(extentpos)

   167     ISOBB32bit(datalen)

   168     ISO9660FileTimestamp recordtime;

   169     ISO9660FileFlags flags;

   170     PHYSFS_uint8 file_unit_size;

   171     PHYSFS_uint8 interleave_gap;

   172     ISOBB16bit(volseqno)

   173     PHYSFS_uint8 filenamelen;

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

   175 } ISO9660FileDescriptor;

   176 

   177 typedef struct

   178 {

   179     ISOBB16bit(owner)

   180     ISOBB16bit(group)

   181     PHYSFS_uint16 flags; /* not implemented*/

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

   183     ISO9660VolumeTimestamp mod_time;

   184     ISO9660VolumeTimestamp expire_time;

   185     ISO9660VolumeTimestamp effective_time;

   186     PHYSFS_uint8 record_format;

   187     PHYSFS_uint8 record_attributes;

   188     ISOBB16bit(record_len)

   189     char system_identifier[32];

   190     char system_use[64];

   191     PHYSFS_uint8 version;

   192     ISOBB16bit(escape_len)

   193     char reserved[64];

   194     /** further fields not implemented */

   195 } ISO9660ExtAttributeRec;

   196 

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

   198 

   199 typedef struct

   200 {

   201     PHYSFS_Io *io;

   202     PHYSFS_uint32 rootdirstart;

   203     PHYSFS_uint32 rootdirsize;

   204     PHYSFS_uint64 currpos;

   205     int isjoliet;

   206     char *path;

   207     void *mutex;

   208 } ISO9660Handle;

   209 

   210 

   211 typedef struct __ISO9660FileHandle

   212 {

   213     PHYSFS_sint64 filesize;

   214     PHYSFS_uint64 currpos;

   215     PHYSFS_uint64 startblock;

   216     ISO9660Handle *isohandle;

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

   218             PHYSFS_uint64 len);

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

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

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

   222     union

   223     {

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

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

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

   227     };

   228 } ISO9660FileHandle;

   229 

   230 /*******************************************************************************

   231  * Time conversion functions

   232  ******************************************************************************/

   233 

   234 static PHYSFS_sint64 iso_mktime(ISO9660FileTimestamp *timestamp)

   235 {

   236     struct tm tm;

   237     tm.tm_year = timestamp->year;

   238     tm.tm_mon = timestamp->month - 1;

   239     tm.tm_mday = timestamp->day;

   240     tm.tm_hour = timestamp->hour;

   241     tm.tm_min = timestamp->minute;

   242     tm.tm_sec = timestamp->second;

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

   244     return mktime(&tm);

   245 } /* iso_mktime */

   246 

   247 static int iso_atoi2(char *text)

   248 {

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

   250 } /* iso_atoi2 */

   251 

   252 static int iso_atoi4(char *text)

   253 {

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

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

   256 } /* iso_atoi4 */

   257 

   258 static PHYSFS_sint64 iso_volume_mktime(ISO9660VolumeTimestamp *timestamp)

   259 {

   260     struct tm tm;

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

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

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

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

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

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

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

   268     PHYSFS_sint64 value = mktime(&tm);

   269     return value == -1 ? 0 : value;

   270 } /* iso_volume_mktime */

   271 

   272 /*******************************************************************************

   273  * Filename extraction

   274  ******************************************************************************/

   275 

   276 static int iso_extractfilenameISO(ISO9660FileDescriptor *descriptor,

   277         char *filename, int *version)

   278 {

   279     *filename = '\0';

   280     if (descriptor->flags.directory)

   281     {

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

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

   284         *version = 0;

   285     } /* if */

   286     else

   287     {

   288         /* find last SEPARATOR2 */

   289         int pos = 0;

   290         int lastfound = -1;

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

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

   293                 lastfound = pos;

   294         BAIL_IF_MACRO(lastfound < 1, PHYSFS_ERR_NO_SUCH_PATH /* !!! FIXME: PHYSFS_ERR_BAD_FILENAME */, -1);

   295         BAIL_IF_MACRO(lastfound == (descriptor->filenamelen -1), PHYSFS_ERR_NO_SUCH_PATH /* !!! PHYSFS_ERR_BAD_FILENAME */, -1);

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

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

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

   299         else

   300             filename[lastfound] = '\0';

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

   302     } /* else */

   303 

   304     return 0;

   305 } /* iso_extractfilenameISO */

   306 

   307 

   308 static int iso_extractfilenameUCS2(ISO9660FileDescriptor *descriptor,

   309         char *filename, int *version)

   310 {

   311     PHYSFS_uint16 tmp[128];

   312     PHYSFS_uint16 *src;

   313     int len;

   314 

   315     *filename = '\0';

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

   317 

   318     src = (PHYSFS_uint16*) descriptor->filename;

   319     len = descriptor->filenamelen / 2;

   320     tmp[len] = 0;

   321 

   322     while(len--)

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

   324 

   325     PHYSFS_utf8FromUcs2(tmp, filename, 255);

   326 

   327     return 0;

   328 } /* iso_extractfilenameUCS2 */

   329 

   330 

   331 static int iso_extractfilename(ISO9660Handle *handle,

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

   333 {

   334     if (handle->isjoliet)

   335         return iso_extractfilenameUCS2(descriptor, filename, version);

   336     else

   337         return iso_extractfilenameISO(descriptor, filename, version);

   338 } /* iso_extractfilename */

   339 

   340 /*******************************************************************************

   341  * Basic image read functions

   342  ******************************************************************************/

   343 

   344 static int iso_readimage(ISO9660Handle *handle, PHYSFS_uint64 where,

   345                          void *buffer, PHYSFS_uint64 len)

   346 {

   347     BAIL_IF_MACRO(!__PHYSFS_platformGrabMutex(handle->mutex), ERRPASS, -1);

   348     int rc = -1;

   349     if (where != handle->currpos)

   350         GOTO_IF_MACRO(!handle->io->seek(handle->io,where), ERRPASS, unlockme);

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

   352     if (rc == -1)

   353     {

   354         handle->currpos = (PHYSFS_uint64) -1;

   355         goto unlockme;

   356     } /* if */

   357     handle->currpos += rc;

   358 

   359     unlockme:

   360     __PHYSFS_platformReleaseMutex(handle->mutex);

   361     return rc;

   362 } /* iso_readimage */

   363 

   364 

   365 static PHYSFS_sint64 iso_readfiledescriptor(ISO9660Handle *handle,

   366                                             PHYSFS_uint64 where,

   367                                             ISO9660FileDescriptor *descriptor)

   368 {

   369     PHYSFS_sint64 rc = iso_readimage(handle, where, descriptor,

   370                                      sizeof (descriptor->recordlen));

   371     BAIL_IF_MACRO(rc == -1, ERRPASS, -1);

   372     BAIL_IF_MACRO(rc != 1, PHYSFS_ERR_CORRUPT, -1);

   373 

   374     if (descriptor->recordlen == 0)

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

   376 

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

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

   379     BAIL_IF_MACRO(rc == -1, ERRPASS, -1);

   380     BAIL_IF_MACRO(rc != 1, PHYSFS_ERR_CORRUPT, -1);

   381 

   382     return 0;

   383 } /* iso_readfiledescriptor */

   384 

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

   386 {

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

   388     if (*subpath != 0)

   389     {

   390         **subpath = 0;

   391         *subpath +=1;

   392     } /* if */

   393 } /* iso_extractsubpath */

   394 

   395 /*

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

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

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

   399  */

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

   401                               ISO9660FileDescriptor *descriptor, int *exists)

   402 {

   403     char *subpath = 0;

   404     PHYSFS_uint64 readpos, end_of_dir;

   405     char filename[255];

   406     char pathcopy[256];

   407     char *mypath;

   408     int version = 0;

   409 

   410     strcpy(pathcopy, path);

   411     mypath = pathcopy;

   412     *exists = 0;

   413 

   414     readpos = handle->rootdirstart;

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

   416     iso_extractsubpath(mypath, &subpath);

   417     while (1)

   418     {

   419         BAIL_IF_MACRO(iso_readfiledescriptor(handle, readpos, descriptor), ERRPASS, -1);

   420 

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

   422         if (!descriptor->recordlen)

   423         {

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

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

   426                 break; /* finished */

   427 

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

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

   430             continue;

   431         } /* if */

   432 

   433         readpos += descriptor->recordlen;

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

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

   436             continue; /* special ones, ignore */

   437 

   438         BAIL_IF_MACRO(

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

   440             ERRPASS, -1);

   441 

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

   443         {

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

   445             {

   446                 *exists = 1;

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

   448             } /* if */

   449 

   450             if (descriptor->flags.directory)

   451             {

   452                 /* shorten the path to the subpath */

   453                 mypath = subpath;

   454                 iso_extractsubpath(mypath, &subpath);

   455                 /* gosub to the new directory extent */

   456                 readpos = descriptor->extentpos * 2048;

   457                 end_of_dir = readpos + descriptor->datalen;

   458             } /* if */

   459             else

   460             {

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

   462                 return 0;

   463             } /* else */

   464         } /* if */

   465     } /* while */

   466 

   467     return 0;

   468 } /* iso_find_dir_entry */

   469 

   470 

   471 static int iso_read_ext_attributes(ISO9660Handle *handle, int block,

   472                                    ISO9660ExtAttributeRec *attributes)

   473 {

   474     return iso_readimage(handle, block * 2048, attributes,

   475                          sizeof(ISO9660ExtAttributeRec));

   476 } /* iso_read_ext_attributes */

   477 

   478 

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

   480 

   481 static PHYSFS_Io *ISO9660_duplicate(PHYSFS_Io *_io)

   482 {

   483     BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);  /* !!! FIXME: write me. */

   484 } /* ISO9660_duplicate */

   485 

   486 

   487 static void ISO9660_destroy(PHYSFS_Io *io)

   488 {

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

   490     fhandle->close(fhandle);

   491     allocator.Free(io);

   492 } /* ISO9660_destroy */

   493 

   494 

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

   496 {

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

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

   499 } /* ISO9660_read */

   500 

   501 

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

   503 {

   504     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);

   505 } /* ISO9660_write */

   506 

   507 

   508 static PHYSFS_sint64 ISO9660_tell(PHYSFS_Io *io)

   509 {

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

   511 } /* ISO9660_tell */

   512 

   513 

   514 static int ISO9660_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)

   515 {

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

   517     return fhandle->seek(fhandle, offset);

   518 } /* ISO9660_seek */

   519 

   520 

   521 static PHYSFS_sint64 ISO9660_length(PHYSFS_Io *io)

   522 {

   523     return ((ISO9660FileHandle*) io->opaque)->filesize;

   524 } /* ISO9660_length */

   525 

   526 

   527 static const PHYSFS_Io ISO9660_Io =

   528 {

   529     CURRENT_PHYSFS_IO_API_VERSION, NULL,

   530     ISO9660_read,

   531     ISO9660_write,

   532     ISO9660_seek,

   533     ISO9660_tell,

   534     ISO9660_length,

   535     ISO9660_duplicate,

   536     ISO9660_flush,

   537     ISO9660_destroy

   538 };

   539 

   540 

   541 /*******************************************************************************

   542  * Archive management functions

   543  ******************************************************************************/

   544 

   545 static void *ISO9660_openArchive(PHYSFS_Io *io, const char *filename, int forWriting)

   546 {

   547     char magicnumber[6];

   548     ISO9660Handle *handle;

   549     int founddescriptor = 0;

   550     int foundjoliet = 0;

   551 

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

   553 

   554     BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);

   555 

   556     /* Skip system area to magic number in Volume descriptor */

   557     BAIL_IF_MACRO(!io->seek(io, 32769), ERRPASS, NULL);

   558     BAIL_IF_MACRO(!io->read(io, magicnumber, 5) != 5, ERRPASS, NULL);

   559     if (memcmp(magicnumber, "CD001", 6) != 0)

   560         BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);

   561 

   562     handle = allocator.Malloc(sizeof(ISO9660Handle));

   563     GOTO_IF_MACRO(!handle, PHYSFS_ERR_OUT_OF_MEMORY, errorcleanup);

   564     handle->path = 0;

   565     handle->mutex= 0;

   566     handle->io = NULL;

   567 

   568     handle->path = allocator.Malloc(strlen(filename) + 1);

   569     GOTO_IF_MACRO(!handle->path, PHYSFS_ERR_OUT_OF_MEMORY, errorcleanup);

   570     strcpy(handle->path, filename);

   571 

   572     handle->mutex = __PHYSFS_platformCreateMutex();

   573     GOTO_IF_MACRO(!handle->mutex, ERRPASS, errorcleanup);

   574 

   575     handle->io = io;

   576 

   577     /* seek Primary Volume Descriptor */

   578     GOTO_IF_MACRO(!io->seek(io, 32768), PHYSFS_ERR_IO, errorcleanup);

   579 

   580     while (1)

   581     {

   582         ISO9660VolumeDescriptor descriptor;

   583         GOTO_IF_MACRO(io->read(io, &descriptor, sizeof(ISO9660VolumeDescriptor)) != sizeof(ISO9660VolumeDescriptor), PHYSFS_ERR_IO, errorcleanup);

   584         GOTO_IF_MACRO(strncmp(descriptor.identifier, "CD001", 5) != 0, PHYSFS_ERR_UNSUPPORTED, errorcleanup);

   585 

   586         if (descriptor.type == 255)

   587         {

   588             /* type 255 terminates the volume descriptor list */

   589             if (founddescriptor)

   590                 return handle; /* ok, we've found one volume descriptor */

   591             else

   592                 GOTO_MACRO(PHYSFS_ERR_CORRUPT, errorcleanup);

   593         } /* if */

   594         if (descriptor.type == 1 && !founddescriptor)

   595         {

   596             handle->currpos = io->tell(io);

   597             handle->rootdirstart =

   598                     descriptor.rootdirectory.extent_location * 2048;

   599             handle->rootdirsize =

   600                     descriptor.rootdirectory.data_length;

   601             handle->isjoliet = 0;

   602             founddescriptor = 1; /* continue search for joliet */

   603         } /* if */

   604         if (descriptor.type == 2 && !foundjoliet)

   605         {

   606             /* check if is joliet */

   607             PHYSFS_uint8 *s = descriptor.escape_sequences;

   608             int joliet = !(descriptor.flags & 1)

   609                     && (s[0] == 0x25)

   610                     && (s[1] == 0x2F)

   611                     && ((s[2] == 0x40) || (s[2] == 0x43) || (s[2] == 0x45));

   612             if (!joliet)

   613                 continue;

   614 

   615             handle->currpos = io->tell(io);

   616             handle->rootdirstart =

   617                     descriptor.rootdirectory.extent_location * 2048;

   618             handle->rootdirsize =

   619                     descriptor.rootdirectory.data_length;

   620             handle->isjoliet = 1;

   621             founddescriptor = 1;

   622             foundjoliet = 1;

   623         } /* if */

   624     } /* while */

   625 

   626     GOTO_MACRO(PHYSFS_ERR_CORRUPT, errorcleanup);  /* not found. */

   627 

   628 errorcleanup:

   629     if (handle)

   630     {

   631         if (handle->path)

   632             allocator.Free(handle->path);

   633         if (handle->mutex)

   634             __PHYSFS_platformDestroyMutex(handle->mutex);

   635         allocator.Free(handle);

   636     } /* if */

   637     return NULL;

   638 } /* ISO9660_openArchive */

   639 

   640 

   641 static void ISO9660_closeArchive(PHYSFS_Dir *opaque)

   642 {

   643     ISO9660Handle *handle = (ISO9660Handle*) opaque;

   644     handle->io->destroy(handle->io);

   645     __PHYSFS_platformDestroyMutex(handle->mutex);

   646     allocator.Free(handle->path);

   647     allocator.Free(handle);

   648 } /* ISO9660_closeArchive */

   649 

   650 

   651 /*******************************************************************************

   652  * Read functions

   653  ******************************************************************************/

   654 

   655 

   656 static PHYSFS_uint32 iso_file_read_mem(ISO9660FileHandle *filehandle,

   657                                        void *buffer, PHYSFS_uint64 len)

   658 {

   659     /* check remaining bytes & max obj which can be fetched */

   660     const PHYSFS_sint64 bytesleft = filehandle->filesize - filehandle->currpos;

   661     if (bytesleft < len)

   662         len = bytesleft;

   663 

   664     if (len == 0)

   665         return 0;

   666 

   667     memcpy(buffer, filehandle->cacheddata + filehandle->currpos, (size_t) len);

   668 

   669     filehandle->currpos += len;

   670     return (PHYSFS_uint32) len;

   671 } /* iso_file_read_mem */

   672 

   673 

   674 static int iso_file_seek_mem(ISO9660FileHandle *fhandle, PHYSFS_sint64 offset)

   675 {

   676     BAIL_IF_MACRO(offset < 0, PHYSFS_ERR_INVALID_ARGUMENT, 0);

   677     BAIL_IF_MACRO(offset >= fhandle->filesize, PHYSFS_ERR_PAST_EOF, 0);

   678 

   679     fhandle->currpos = offset;

   680     return 0;

   681 } /* iso_file_seek_mem */

   682 

   683 

   684 static void iso_file_close_mem(ISO9660FileHandle *fhandle)

   685 {

   686     allocator.Free(fhandle->cacheddata);

   687     allocator.Free(fhandle);

   688 } /* iso_file_close_mem */

   689 

   690 

   691 static PHYSFS_uint32 iso_file_read_foreign(ISO9660FileHandle *filehandle,

   692                                            void *buffer, PHYSFS_uint64 len)

   693 {

   694     /* check remaining bytes & max obj which can be fetched */

   695     const PHYSFS_sint64 bytesleft = filehandle->filesize - filehandle->currpos;

   696     if (bytesleft < len)

   697         len = bytesleft;

   698 

   699     const PHYSFS_sint64 rc = filehandle->io->read(filehandle->io, buffer, len);

   700     BAIL_IF_MACRO(rc == -1, ERRPASS, -1);

   701 

   702     filehandle->currpos += rc; /* i trust my internal book keeping */

   703     BAIL_IF_MACRO(rc < len, PHYSFS_ERR_CORRUPT, -1);

   704     return rc;

   705 } /* iso_file_read_foreign */

   706 

   707 

   708 static int iso_file_seek_foreign(ISO9660FileHandle *fhandle,

   709                                  PHYSFS_sint64 offset)

   710 {

   711     BAIL_IF_MACRO(offset < 0, PHYSFS_ERR_INVALID_ARGUMENT, 0);

   712     BAIL_IF_MACRO(offset >= fhandle->filesize, PHYSFS_ERR_PAST_EOF, 0);

   713 

   714     PHYSFS_sint64 pos = fhandle->startblock * 2048 + offset;

   715     BAIL_IF_MACRO(!fhandle->io->seek(fhandle->io, pos), ERRPASS, -1);

   716 

   717     fhandle->currpos = offset;

   718     return 0;

   719 } /* iso_file_seek_foreign */

   720 

   721 

   722 static void iso_file_close_foreign(ISO9660FileHandle *fhandle)

   723 {

   724     fhandle->io->destroy(fhandle->io);

   725     allocator.Free(fhandle);

   726 } /* iso_file_close_foreign */

   727 

   728 

   729 static int iso_file_open_mem(ISO9660Handle *handle, ISO9660FileHandle *fhandle)

   730 {

   731     fhandle->cacheddata = allocator.Malloc(fhandle->filesize);

   732     BAIL_IF_MACRO(!fhandle->cacheddata, PHYSFS_ERR_OUT_OF_MEMORY, -1);

   733     int rc = iso_readimage(handle, fhandle->startblock * 2048,

   734                            fhandle->cacheddata, fhandle->filesize);

   735     GOTO_IF_MACRO(rc < 0, ERRPASS, freemem);

   736     GOTO_IF_MACRO(rc == 0, PHYSFS_ERR_CORRUPT, freemem);

   737 

   738     fhandle->read = iso_file_read_mem;

   739     fhandle->seek = iso_file_seek_mem;

   740     fhandle->close = iso_file_close_mem;

   741     return 0;

   742 

   743 freemem:

   744     allocator.Free(fhandle->cacheddata);

   745     return -1;

   746 } /* iso_file_open_mem */

   747 

   748 

   749 static int iso_file_open_foreign(ISO9660Handle *handle,

   750                                  ISO9660FileHandle *fhandle)

   751 {

   752     int rc;

   753     fhandle->io = __PHYSFS_createNativeIo(handle->path, 'r');

   754     BAIL_IF_MACRO(!fhandle->io, ERRPASS, -1);

   755     rc = fhandle->io->seek(fhandle->io, fhandle->startblock * 2048);

   756     GOTO_IF_MACRO(!rc, ERRPASS, closefile);

   757 

   758     fhandle->read = iso_file_read_foreign;

   759     fhandle->seek = iso_file_seek_foreign;

   760     fhandle->close = iso_file_close_foreign;

   761     return 0;

   762 

   763 closefile:

   764     fhandle->io->destroy(fhandle->io);

   765     return -1;

   766 } /* iso_file_open_foreign */

   767 

   768 

   769 static PHYSFS_Io *ISO9660_openRead(PHYSFS_Dir *opaque, const char *filename,

   770                                    int *exists)

   771 {

   772     PHYSFS_Io *retval = NULL;

   773     ISO9660Handle *handle = (ISO9660Handle*) opaque;

   774     ISO9660FileHandle *fhandle;

   775     ISO9660FileDescriptor descriptor;

   776     int rc;

   777 

   778     fhandle = allocator.Malloc(sizeof(ISO9660FileHandle));

   779     BAIL_IF_MACRO(fhandle == 0, PHYSFS_ERR_OUT_OF_MEMORY, NULL);

   780     fhandle->cacheddata = 0;

   781 

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

   783     GOTO_IF_MACRO(retval == 0, PHYSFS_ERR_OUT_OF_MEMORY, errorhandling);

   784 

   785     /* find file descriptor */

   786     rc = iso_find_dir_entry(handle, filename, &descriptor, exists);

   787     GOTO_IF_MACRO(rc, ERRPASS, errorhandling);

   788     GOTO_IF_MACRO(!*exists, PHYSFS_ERR_NO_SUCH_PATH, errorhandling);

   789 

   790     fhandle->startblock = descriptor.extentpos + descriptor.extattributelen;

   791     fhandle->filesize = descriptor.datalen;

   792     fhandle->currpos = 0;

   793     fhandle->isohandle = handle;

   794     fhandle->cacheddata = NULL;

   795     fhandle->io = NULL;

   796 

   797     if (descriptor.datalen <= ISO9660_FULLCACHEMAXSIZE)

   798         rc = iso_file_open_mem(handle, fhandle);

   799     else

   800         rc = iso_file_open_foreign(handle, fhandle);

   801     GOTO_IF_MACRO(rc, ERRPASS, errorhandling);

   802 

   803     memcpy(retval, &ISO9660_Io, sizeof (PHYSFS_Io));

   804     retval->opaque = fhandle;

   805     return retval;

   806 

   807 errorhandling:

   808     if (retval) allocator.Free(retval);

   809     if (fhandle) allocator.Free(fhandle);

   810     return NULL;

   811 } /* ISO9660_openRead */

   812 

   813 

   814 

   815 /*******************************************************************************

   816  * Information gathering functions

   817  ******************************************************************************/

   818 

   819 static void ISO9660_enumerateFiles(PHYSFS_Dir *opaque, const char *dname,

   820                                    int omitSymLinks,

   821                                    PHYSFS_EnumFilesCallback cb,

   822                                    const char *origdir, void *callbackdata)

   823 {

   824     ISO9660Handle *handle = (ISO9660Handle*) opaque;

   825     ISO9660FileDescriptor descriptor;

   826     PHYSFS_uint64 readpos;

   827     PHYSFS_uint64 end_of_dir;

   828     char filename[130]; /* ISO allows 31, Joliet 128 -> 128 + 2 eol bytes */

   829     int version = 0;

   830 

   831     if (*dname == '\0')

   832     {

   833         readpos = handle->rootdirstart;

   834         end_of_dir = readpos + handle->rootdirsize;

   835     } /* if */

   836     else

   837     {

   838         printf("pfad %s\n",dname);

   839         int exists = 0;

   840         BAIL_IF_MACRO(iso_find_dir_entry(handle,dname, &descriptor, &exists), ERRPASS,);

   841         BAIL_IF_MACRO(!exists, ERRPASS, );

   842         BAIL_IF_MACRO(!descriptor.flags.directory, ERRPASS,);

   843 

   844         readpos = descriptor.extentpos * 2048;

   845         end_of_dir = readpos + descriptor.datalen;

   846     } /* else */

   847 

   848     while (1)

   849     {

   850         BAIL_IF_MACRO(iso_readfiledescriptor(handle, readpos, &descriptor), ERRPASS, );

   851 

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

   853         if (!descriptor.recordlen)

   854         {

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

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

   857                 break;  /* finished */

   858 

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

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

   861             continue;

   862         } /* if */

   863 

   864         readpos +=  descriptor.recordlen;

   865         if (descriptor.filenamelen == 1 && (descriptor.filename[0] == 0

   866                 || descriptor.filename[0] == 1))

   867             continue; /* special ones, ignore */

   868 

   869         strncpy(filename,descriptor.filename,descriptor.filenamelen);

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

   871         cb(callbackdata, origdir,filename);

   872     } /* while */

   873 } /* ISO9660_enumerateFiles */

   874 

   875 

   876 static int ISO9660_stat(PHYSFS_Dir *opaque, const char *name, int *exists,

   877                         PHYSFS_Stat *stat)

   878 {

   879     ISO9660Handle *handle = (ISO9660Handle*) opaque;

   880     ISO9660FileDescriptor descriptor;

   881     ISO9660ExtAttributeRec extattr;

   882     BAIL_IF_MACRO(iso_find_dir_entry(handle, name, &descriptor, exists), ERRPASS, -1);

   883     if (!*exists)

   884         return 0;

   885 

   886     stat->readonly = 1;

   887 

   888     /* try to get extended info */

   889     if (descriptor.extattributelen)

   890     {

   891         BAIL_IF_MACRO(iso_read_ext_attributes(handle,

   892                 descriptor.extentpos, &extattr), ERRPASS, -1);

   893         stat->createtime = iso_volume_mktime(&extattr.create_time);

   894         stat->modtime = iso_volume_mktime(&extattr.mod_time);

   895         stat->accesstime = iso_volume_mktime(&extattr.mod_time);

   896     } /* if */

   897     else

   898     {

   899         stat->createtime = iso_mktime(&descriptor.recordtime);

   900         stat->modtime = iso_mktime(&descriptor.recordtime);

   901         stat->accesstime = iso_mktime(&descriptor.recordtime);

   902     } /* else */

   903 

   904     if (descriptor.flags.directory)

   905     {

   906         stat->filesize = 0;

   907         stat->filetype = PHYSFS_FILETYPE_DIRECTORY;

   908     } /* if */

   909     else

   910     {

   911         stat->filesize = descriptor.datalen;

   912         stat->filetype = PHYSFS_FILETYPE_REGULAR;

   913     } /* else */

   914 

   915     return 1;

   916 } /* ISO9660_stat */

   917 

   918 

   919 /*******************************************************************************

   920  * Not supported functions

   921  ******************************************************************************/

   922 

   923 static PHYSFS_Io *ISO9660_openWrite(PHYSFS_Dir *opaque, const char *name)

   924 {

   925     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);

   926 } /* ISO9660_openWrite */

   927 

   928 

   929 static PHYSFS_Io *ISO9660_openAppend(PHYSFS_Dir *opaque, const char *name)

   930 {

   931     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);

   932 } /* ISO9660_openAppend */

   933 

   934 

   935 static int ISO9660_remove(PHYSFS_Dir *opaque, const char *name)

   936 {

   937     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);

   938 } /* ISO9660_remove */

   939 

   940 

   941 static int ISO9660_mkdir(PHYSFS_Dir *opaque, const char *name)

   942 {

   943     BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);

   944 } /* ISO9660_mkdir */

   945 

   946 

   947 const PHYSFS_Archiver __PHYSFS_Archiver_ISO9660 =

   948 {

   949     {

   950         "ISO",

   951         "ISO9660 image file",

   952         "Christoph Nelles <evilazrael@evilazrael.de>",

   953         "http://www.evilazrael.de/",

   954     },

   955     ISO9660_openArchive,        /* openArchive() method    */

   956     ISO9660_enumerateFiles,     /* enumerateFiles() method */

   957     ISO9660_openRead,           /* openRead() method       */

   958     ISO9660_openWrite,          /* openWrite() method      */

   959     ISO9660_openAppend,         /* openAppend() method     */

   960     ISO9660_remove,             /* remove() method         */

   961     ISO9660_mkdir,              /* mkdir() method          */

   962     ISO9660_closeArchive,       /* closeArchive() method   */

   963     ISO9660_stat                /* stat() method           */

   964 };

   965 

   966 #endif  /* defined PHYSFS_SUPPORTS_ISO9660 */

   967 

   968 /* end of archiver_iso9660.c ... */

   969