/*

  Copyright (C) 2003-2008, 2011-2015, 2017 Rocky Bernstein <rocky@gnu.org>

  Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>

  This program is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/* iso9660 filesystem-based routines */

/* FIXME: _cdio_list_free for iso9660 statbuf is insufficient because it doesn't

   free bits that are allocated inside the data. */

#if defined(HAVE_CONFIG_H) && !defined(__CDIO_CONFIG_H__)

#include "config.h"

#define __CDIO_CONFIG_H__ 1

#endif

#ifdef HAVE_STDBOOL_H

# include <stdbool.h>

#endif

#ifdef HAVE_STDIO_H

#include <stdio.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_LANGINFO_CODESET

#include <langinfo.h>

#endif

#include <cdio/cdio.h>

#include <cdio/bytesex.h>

#include <cdio/iso9660.h>

#include <cdio/util.h>

#include <cdio/utf8.h>

/* Private headers */

#include "cdio_assert.h"

#include "_cdio_stdio.h"

#include "cdio_private.h"

/** Implementation of iso9660_t type */

struct _iso9660_s {

  CdioDataSource_t *stream; /**< Stream pointer */

  bool_3way_t b_xa;         /**< true if has XA attributes. */

  bool_3way_t b_mode2;      /**< true if has mode 2, false for mode 1. */

  uint8_t  u_joliet_level;  /**< 0 = no Joliet extensions.

			         1-3: Joliet level. */

  iso9660_pvd_t pvd;

  iso9660_svd_t svd;

  iso_extension_mask_t iso_extension_mask; /**< What extensions we

					        tolerate. */

  uint32_t i_datastart;     /**< Usually 0 when i_framesize is ISO_BLOCKSIZE.

			         This is the normal condition. But in a fuzzy

			         read we may be reading a CD-image

			         and not a true ISO 9660 image this might be

			         CDIO_CD_SYNC_SIZE

                            */

  uint32_t i_framesize;     /**< Usually ISO_BLOCKSIZE (2048), but in a

			        fuzzy read, we may be reading a CD-image

			        and not a true ISO 9660 image this might

			        be CDIO_CD_FRAMESIZE_RAW (2352) or

			        M2RAW_SECTOR_SIZE (2336).

                            */

  int i_fuzzy_offset;       /**< Adjustment in bytes to make ISO_STANDARD_ID

			         ("CD001") come out as ISO_PVD_SECTOR

			         (frame 16).  Normally this should be 0

			         for an ISO 9660 image, but if one is

			         say reading a BIN/CUE or cdrdao BIN/TOC

			         without having the CUE or TOC and

			         trying to extract an ISO-9660

			         filesystem inside that it may be

			         different.

			     */

    bool b_have_superblock; /**< Superblock has been read in? */

};

static long int iso9660_seek_read_framesize (const iso9660_t *p_iso,

					     void *ptr, lsn_t start,

					     long int size,

					     uint16_t i_framesize);

/* Adjust the p_iso's i_datastart, i_byte_offset and i_framesize

   based on whether we find a frame header or not.

*/

static void

adjust_fuzzy_pvd( iso9660_t *p_iso )

{

  long int i_byte_offset;

  if (!p_iso) return;

  i_byte_offset = (ISO_PVD_SECTOR * p_iso->i_framesize)

    + p_iso->i_fuzzy_offset + p_iso->i_datastart;

  /* If we have a raw 2352-byte frame then we should expect to see a sync

     frame and a header.

   */

  if (CDIO_CD_FRAMESIZE_RAW == p_iso->i_framesize) {

    char buf[CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE];

    i_byte_offset -= CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE;

    if ( DRIVER_OP_SUCCESS != cdio_stream_seek (p_iso->stream, i_byte_offset,

						SEEK_SET) )

      return;

    if (sizeof(buf) == cdio_stream_read (p_iso->stream, buf, sizeof(buf), 1)) {

      /* Does the sector frame header suggest Mode 1 format? */

      if (!memcmp(CDIO_SECTOR_SYNC_HEADER, buf+CDIO_CD_SUBHEADER_SIZE,

		  CDIO_CD_SYNC_SIZE)) {

	if (buf[14+CDIO_CD_SUBHEADER_SIZE] != 0x16) {

	  cdio_warn ("Expecting the PVD sector header MSF to be 0x16, is: %x",

		     buf[14]);

	}

	if (buf[15+CDIO_CD_SUBHEADER_SIZE] != 0x1) {

	  cdio_warn ("Expecting the PVD sector mode to be Mode 1 is: %x",

		     buf[15]);

	}

	p_iso->b_mode2 = nope;

	p_iso->b_xa = nope;

      } else if (!memcmp(CDIO_SECTOR_SYNC_HEADER, buf, CDIO_CD_SYNC_SIZE)) {

	/* Frame header indicates Mode 2 Form 1*/

	if (buf[14] != 0x16) {

	  cdio_warn ("Expecting the PVD sector header MSF to be 0x16, is: %x",

		     buf[14]);

	}

	if (buf[15] != 0x2) {

	  cdio_warn ("Expecting the PVD sector mode to be Mode 2 is: %x",

		     buf[15]);

	}

	p_iso->b_mode2 = yep;

	/* Do do: check Mode 2 Form 2? */

      } else {

	  /* Has no frame header */

	  p_iso->i_framesize = M2RAW_SECTOR_SIZE;

	  p_iso->i_fuzzy_offset = (CDIO_CD_FRAMESIZE_RAW - M2RAW_SECTOR_SIZE)

	    * ISO_PVD_SECTOR + p_iso->i_fuzzy_offset + p_iso->i_datastart;

	  p_iso->i_datastart = 0;

	}

    }

  }

}

/*!

  Open an ISO 9660 image for reading in either fuzzy mode or not.

*/

static iso9660_t *

iso9660_open_ext_private (const char *psz_path,

			  iso_extension_mask_t iso_extension_mask,

			  uint16_t i_fuzz, bool b_fuzzy)

{

  iso9660_t *p_iso = (iso9660_t *) calloc(1, sizeof(iso9660_t)) ;

  if (!p_iso) return NULL;

  p_iso->stream = cdio_stdio_new( psz_path );

  if (NULL == p_iso->stream)

    goto error;

  p_iso->i_framesize = ISO_BLOCKSIZE;

  p_iso->b_have_superblock = (b_fuzzy)

    ? iso9660_ifs_fuzzy_read_superblock(p_iso, iso_extension_mask, i_fuzz)

    : iso9660_ifs_read_superblock(p_iso, iso_extension_mask) ;

  if ( ! p_iso->b_have_superblock ) goto error;

  /* Determine if image has XA attributes. */

  p_iso->b_xa = strncmp ((char *) &(p_iso->pvd) + ISO_XA_MARKER_OFFSET,

			 ISO_XA_MARKER_STRING,

			 sizeof (ISO_XA_MARKER_STRING))

    ? nope : yep;

  p_iso->iso_extension_mask = iso_extension_mask;

  return p_iso;

 error:

  if (p_iso && p_iso->stream) cdio_stdio_destroy(p_iso->stream);

  free(p_iso);

  return NULL;

}

/*!

  Open an ISO 9660 image for reading. Maybe in the future we will have

  a mode. NULL is returned on error.

  @param psz_path full path of ISO9660 file.

  @return a IS9660 structure  is unconditionally returned. The caller

  should call iso9660_close() when done.

*/

iso9660_t *

iso9660_open (const char *psz_path /*, mode*/)

{

  return iso9660_open_ext(psz_path, ISO_EXTENSION_NONE);

}

/*!

  Open an ISO 9660 image for reading allowing various ISO 9660

  extensions.  Maybe in the future we will have a mode. NULL is

  returned on error.

  @see iso9660_open_fuzzy

*/

iso9660_t *

iso9660_open_ext (const char *psz_path,

		  iso_extension_mask_t iso_extension_mask)

{

  return iso9660_open_ext_private(psz_path, iso_extension_mask, 0, false);

}

/*! Open an ISO 9660 image for "fuzzy" reading. This means that we

  will try to guess various internal offset based on internal

  checks. This may be useful when trying to read an ISO 9660 image

  contained in a file format that libiso9660 doesn't know natively

  (or knows imperfectly.)

  Some tolerence allowed for positioning the ISO 9660 image. We scan

  for STANDARD_ID and use that to set the eventual offset to adjust

  by (as long as that is <= i_fuzz).

  Maybe in the future we will have a mode. NULL is returned on error.

  @see iso9660_open, @see iso9660_fuzzy_ext

*/

iso9660_t *

iso9660_open_fuzzy (const char *psz_path, uint16_t i_fuzz /*, mode*/)

{

  return iso9660_open_fuzzy_ext(psz_path, ISO_EXTENSION_NONE, i_fuzz);

}

/*!

  Open an ISO 9660 image for reading with some tolerence for positioning

  of the ISO9660 image. We scan for ISO_STANDARD_ID and use that to set

  the eventual offset to adjust by (as long as that is <= i_fuzz).

  Maybe in the future we will have a mode. NULL is returned on error.

  @see iso9660_open_ext @see iso9660_open_fuzzy

*/

iso9660_t *

iso9660_open_fuzzy_ext (const char *psz_path,

			iso_extension_mask_t iso_extension_mask,

			uint16_t i_fuzz)

{

  return iso9660_open_ext_private(psz_path, iso_extension_mask, i_fuzz,

				  true);

}

/*! Close previously opened ISO 9660 image and free resources

    associated with the image. Call this when done using using an ISO

    9660 image.

    @return true is unconditionally returned. If there was an error

    false would be returned.

*/

bool

iso9660_close (iso9660_t *p_iso)

{

  if (NULL != p_iso) {

    cdio_stdio_destroy(p_iso->stream);

    p_iso->stream = NULL;

    free(p_iso);

  }

  return true;

}

static bool

check_pvd (const iso9660_pvd_t *p_pvd, cdio_log_level_t log_level)

{

  if ( ISO_VD_PRIMARY != from_711(p_pvd->type) ) {

    cdio_log (log_level, "unexpected PVD type %d", p_pvd->type);

    return false;

  }

  if (strncmp (p_pvd->id, ISO_STANDARD_ID, strlen (ISO_STANDARD_ID)))

    {

      cdio_log (log_level, "unexpected ID encountered (expected `"

		ISO_STANDARD_ID "', got `%.5s')", p_pvd->id);

      return false;

    }

  return true;

}

/*!

  Core procedure for the iso9660_ifs_get_###_id() calls.

  pvd_member/svd_member is a pointer to an achar_t or dchar_t

  ID string which we can superset as char.

  If the Joliet converted string is the same as the achar_t/dchar_t

  one, we fall back to using the latter, as it may be longer.

*/

static inline bool

get_member_id(iso9660_t *p_iso, cdio_utf8_t **p_psz_member_id,

              char* pvd_member, char* svd_member, size_t max_size)

{

  int j;

  bool strip;

  if (!p_iso) {

    *p_psz_member_id = NULL;

    return false;

  }

#ifdef HAVE_JOLIET

  if (p_iso->u_joliet_level) {

    /* Translate USC-2 string from Secondary Volume Descriptor */

    if (cdio_charset_to_utf8(svd_member, max_size,

                            p_psz_member_id, "UCS-2BE")) {

      /* NB: *p_psz_member_id is never NULL on success. */

      if (strncmp(*p_psz_member_id, pvd_member,

                  strlen(*p_psz_member_id)) != 0) {

        /* Strip trailing spaces */

        for (j = strlen(*p_psz_member_id)-1; j >= 0; j--) {

          if ((*p_psz_member_id)[j] != ' ')

            break;

          (*p_psz_member_id)[j] = '\0';

        }

        if ((*p_psz_member_id)[0] != 0) {

          /* Joliet string is not empty and differs from

             non Joliet one => use it */

          return true;

        }

      }

      /* Joliet string was either empty or same */

      free(*p_psz_member_id);

    }

  }

#endif /*HAVE_JOLIET*/

  *p_psz_member_id = calloc(max_size+1, sizeof(cdio_utf8_t));

  if (!*p_psz_member_id) {

    cdio_warn("Memory allocation error");

    return false;

  }

  /* Copy string while removing trailing spaces */

  (*p_psz_member_id)[max_size] = 0;

  for (strip=true, j=max_size-1; j>=0; j--) {

    if (strip && (pvd_member[j] == ' '))

      continue;

    strip = false;

    (*p_psz_member_id)[j] = pvd_member[j];

  }

  if (strlen(*p_psz_member_id) == 0) {

    free(*p_psz_member_id);

    *p_psz_member_id = NULL;

    return false;

  }

  return true;

}

/*!

  Return the application ID.  NULL is returned in psz_app_id if there

  is some problem in getting this.

*/

bool

iso9660_ifs_get_application_id(iso9660_t *p_iso,

			       /*out*/ cdio_utf8_t **p_psz_app_id)

{

  return get_member_id(p_iso, p_psz_app_id,

                       (char*)p_iso->pvd.application_id,

                       (char*)p_iso->svd.application_id,

                       ISO_MAX_APPLICATION_ID);

}

/*!

  Return the Joliet level recognized for p_iso.

*/

uint8_t iso9660_ifs_get_joliet_level(iso9660_t *p_iso)

{

  if (!p_iso) return 0;

  return p_iso->u_joliet_level;

}

/*!

   Return a string containing the preparer id with trailing

   blanks removed.

*/

bool

iso9660_ifs_get_preparer_id(iso9660_t *p_iso,

			/*out*/ cdio_utf8_t **p_psz_preparer_id)

{

  return get_member_id(p_iso, p_psz_preparer_id,

                       (char*)p_iso->pvd.preparer_id,

                       (char*)p_iso->svd.preparer_id,

                       ISO_MAX_PREPARER_ID);

}

/*!

   Return a string containing the PVD's publisher id with trailing

   blanks removed.

*/

bool iso9660_ifs_get_publisher_id(iso9660_t *p_iso,

                                  /*out*/ cdio_utf8_t **p_psz_publisher_id)

{

  return get_member_id(p_iso, p_psz_publisher_id,

                       (char*)p_iso->pvd.publisher_id,

                       (char*)p_iso->svd.publisher_id,

                       ISO_MAX_PUBLISHER_ID);

}

/*!

   Return a string containing the PVD's publisher id with trailing

   blanks removed.

*/

bool iso9660_ifs_get_system_id(iso9660_t *p_iso,

			       /*out*/ cdio_utf8_t **p_psz_system_id)

{

  return get_member_id(p_iso, p_psz_system_id,

                       (char*)p_iso->pvd.system_id,

                       (char*)p_iso->svd.system_id,

                       ISO_MAX_SYSTEM_ID);

}

/*!

   Return a string containing the PVD's publisher id with trailing

   blanks removed.

*/

bool iso9660_ifs_get_volume_id(iso9660_t *p_iso,

			       /*out*/ cdio_utf8_t **p_psz_volume_id)

{

  return get_member_id(p_iso, p_psz_volume_id,

                       (char*)p_iso->pvd.volume_id,

                       (char*)p_iso->svd.volume_id,

                       ISO_MAX_VOLUME_ID);

}

/*!

   Return a string containing the PVD's publisher id with trailing

   blanks removed.

*/

bool iso9660_ifs_get_volumeset_id(iso9660_t *p_iso,

				  /*out*/ cdio_utf8_t **p_psz_volumeset_id)

{

  return get_member_id(p_iso, p_psz_volumeset_id,

                       (char*)p_iso->pvd.volume_set_id,

                       (char*)p_iso->svd.volume_set_id,

                       ISO_MAX_VOLUMESET_ID);

}

/*!

  Read the Primary Volume Descriptor for an ISO 9660 image.

  True is returned if read, and false if there was an error.

*/

static bool

iso9660_ifs_read_pvd_loglevel (const iso9660_t *p_iso,

			       /*out*/ iso9660_pvd_t *p_pvd,

			       cdio_log_level_t log_level)

{

  if (0 == iso9660_iso_seek_read (p_iso, p_pvd, ISO_PVD_SECTOR, 1)) {

    cdio_log ( log_level, "error reading PVD sector (%d)", ISO_PVD_SECTOR );

    return false;

  }

  return check_pvd(p_pvd, log_level);

}

/*!

  Read the Primary Volume Descriptor for an ISO 9660 image.

  True is returned if read, and false if there was an error.

*/

bool

iso9660_ifs_read_pvd (const iso9660_t *p_iso, /*out*/ iso9660_pvd_t *p_pvd)

{

  return iso9660_ifs_read_pvd_loglevel(p_iso, p_pvd, CDIO_LOG_WARN);

}

/*!

  Read the Super block of an ISO 9660 image. This is the

  Primary Volume Descriptor (PVD) and perhaps a Supplemental Volume

  Descriptor if (Joliet) extensions are acceptable.

*/

bool

iso9660_ifs_read_superblock (iso9660_t *p_iso,

			     iso_extension_mask_t iso_extension_mask)

{

  iso9660_svd_t p_svd;  /* Secondary volume descriptor. */

  int i;

  if (!p_iso || !iso9660_ifs_read_pvd(p_iso, &(p_iso->pvd)))

    return false;

  p_iso->u_joliet_level = 0;

  /* There may be multiple Secondary Volume Descriptors (eg. El Torito + Joliet) */

  for (i=1; (0 != iso9660_iso_seek_read (p_iso, &p_svd, ISO_PVD_SECTOR+i, 1)); i++) {

    if (ISO_VD_END == from_711(p_svd.type) ) /* Last SVD */

      break;

    if ( ISO_VD_SUPPLEMENTARY == from_711(p_svd.type) ) {

      /* We're only interested in Joliet => make sure the SVD isn't overwritten */

      if (p_iso->u_joliet_level == 0)

        memcpy(&(p_iso->svd), &p_svd, sizeof(iso9660_svd_t));

      if (p_svd.escape_sequences[0] == 0x25

	  && p_svd.escape_sequences[1] == 0x2f) {

	switch (p_svd.escape_sequences[2]) {

	case 0x40:

	  if (iso_extension_mask & ISO_EXTENSION_JOLIET_LEVEL1)

	    p_iso->u_joliet_level = 1;

	  break;

	case 0x43:

	  if (iso_extension_mask & ISO_EXTENSION_JOLIET_LEVEL2)

	    p_iso->u_joliet_level = 2;

	  break;

	case 0x45:

	  if (iso_extension_mask & ISO_EXTENSION_JOLIET_LEVEL3)

	    p_iso->u_joliet_level = 3;

	  break;

	default:

	  cdio_info("Supplementary Volume Descriptor found, but not Joliet");

	}

	if (p_iso->u_joliet_level > 0) {

	  cdio_info("Found Extension: Joliet Level %d", p_iso->u_joliet_level);

	}

      }

    }

  }

  return true;

}

/*!

  Read the Super block of an ISO 9660 image but determine framesize

  and datastart and a possible additional offset. Generally here we are

  not reading an ISO 9660 image but a CD-Image which contains an ISO 9660

  filesystem.

*/

bool

iso9660_ifs_fuzzy_read_superblock (iso9660_t *p_iso,

				   iso_extension_mask_t iso_extension_mask,

				   uint16_t i_fuzz)

{

  /* Got some work to do to find ISO_STANDARD_ID ("CD001") */

  unsigned int i;

  for (i=0; i

    unsigned int j;

    char *pvd = NULL;

    for (j = 0; j <= 1; j++ ) {

      lsn_t lsn;

      uint16_t k;

      const uint16_t framesizes[] = { ISO_BLOCKSIZE, CDIO_CD_FRAMESIZE_RAW,

				      M2RAW_SECTOR_SIZE } ;

      /* We don't need to loop over a zero offset twice*/

      if (0==i && j)

	continue;

      lsn = (j) ? ISO_PVD_SECTOR - i : ISO_PVD_SECTOR + i;

      for (k=0; k < 3; k++) {

	char *p, *q;

	char frame[CDIO_CD_FRAMESIZE_RAW] = {'\0',};

	p_iso->i_framesize = framesizes[k];

	p_iso->i_datastart = (ISO_BLOCKSIZE == framesizes[k]) ?

			      0 : CDIO_CD_SYNC_SIZE;

	p_iso->i_fuzzy_offset = 0;

	if (0 == iso9660_seek_read_framesize (p_iso, frame, lsn, 1,

					      p_iso->i_framesize)) {

	  return false;

	}

	q = memchr(frame, 'C', p_iso->i_framesize);

	for ( p=q; p && p < frame + p_iso->i_framesize ; p=q+1 ) {

	  q = memchr(p, 'C', p_iso->i_framesize - (p - frame));

	  if ( !q || (pvd = strstr(q, ISO_STANDARD_ID)) )

	    break;

	}

	if (pvd) {

	  /* Yay! Found something */

	  p_iso->i_fuzzy_offset = (pvd - frame - 1) -

	    ((ISO_PVD_SECTOR-lsn)*p_iso->i_framesize) ;

	  /* But is it *really* a PVD? */

	  if ( iso9660_ifs_read_pvd_loglevel(p_iso, &(p_iso->pvd),

					     CDIO_LOG_DEBUG) ) {

	    adjust_fuzzy_pvd(p_iso);

	    return true;

	  }

	}

      }

    }

  }

  return false;

}

/*!

  Read the Primary Volume Descriptor for of CD.

*/

bool

iso9660_fs_read_pvd(const CdIo_t *p_cdio, /*out*/ iso9660_pvd_t *p_pvd)

{

  /* A bit of a hack, we'll assume track 1 contains ISO_PVD_SECTOR.*/

  char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };

  driver_return_code_t driver_return =

    cdio_read_data_sectors (p_cdio, buf, ISO_PVD_SECTOR, ISO_BLOCKSIZE, 1);

  if (DRIVER_OP_SUCCESS != driver_return) {

    cdio_warn ("error reading PVD sector (%d) error %d", ISO_PVD_SECTOR,

	       driver_return);

    return false;

  }

  /* The size of a PVD or SVD is smaller than a sector. So we

     allocated a bigger block above (buf) and now we'll copy just

     the part we need to save.

   */

  cdio_assert (sizeof(buf) >= sizeof (iso9660_pvd_t));

  memcpy(p_pvd, buf, sizeof(iso9660_pvd_t));

  return check_pvd(p_pvd, CDIO_LOG_WARN);

}

/*!

  Read the Super block of an ISO 9660 image. This is the

  Primary Volume Descriptor (PVD) and perhaps a Supplemental Volume

  Descriptor if (Joliet) extensions are acceptable.

*/

bool

iso9660_fs_read_superblock (CdIo_t *p_cdio,

			    iso_extension_mask_t iso_extension_mask)

{

  if (!p_cdio) return false;

  {

    generic_img_private_t *p_env = (generic_img_private_t *) p_cdio->env;

    iso9660_pvd_t         *p_pvd = &(p_env->pvd);

    iso9660_svd_t         *p_svd = &(p_env->svd);

    char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };

    driver_return_code_t driver_return;

    if ( !iso9660_fs_read_pvd(p_cdio, p_pvd) )

      return false;

    p_env->u_joliet_level = 0;

    driver_return =

      cdio_read_data_sectors ( p_cdio, buf, ISO_PVD_SECTOR+1, ISO_BLOCKSIZE,

			       1 );

    if (DRIVER_OP_SUCCESS == driver_return) {

      /* The size of a PVD or SVD is smaller than a sector. So we

	 allocated a bigger block above (buf) and now we'll copy just

	 the part we need to save.

      */

      cdio_assert (sizeof(buf) >= sizeof (iso9660_svd_t));

      memcpy(p_svd, buf, sizeof(iso9660_svd_t));

      if ( ISO_VD_SUPPLEMENTARY == from_711(p_svd->type) ) {

	if (p_svd->escape_sequences[0] == 0x25

	    && p_svd->escape_sequences[1] == 0x2f) {

	  switch (p_svd->escape_sequences[2]) {

	  case 0x40:

	    if (iso_extension_mask & ISO_EXTENSION_JOLIET_LEVEL1)

	      p_env->u_joliet_level = 1;

	    break;

	  case 0x43:

	    if (iso_extension_mask & ISO_EXTENSION_JOLIET_LEVEL2)

	      p_env->u_joliet_level = 2;

	    break;

	  case 0x45:

	    if (iso_extension_mask & ISO_EXTENSION_JOLIET_LEVEL3)

	      p_env->u_joliet_level = 3;

	    break;

	  default:

	    cdio_info("Supplementary Volume Descriptor found, but not Joliet");

	  }

	  if (p_env->u_joliet_level > 0) {

	    cdio_info("Found Extension: Joliet Level %d",

		      p_env->u_joliet_level);

	  }

	}

      }

    }

  }

  return true;

}

/*!

  Seek to a position and then read n blocks. Size read is returned.

*/

static long int

iso9660_seek_read_framesize (const iso9660_t *p_iso, void *ptr,

			     lsn_t start, long int size,

			     uint16_t i_framesize)

{

  long int ret;

  int64_t i_byte_offset;

  if (!p_iso) return 0;

  i_byte_offset = (start * (int64_t)(p_iso->i_framesize))

    + p_iso->i_fuzzy_offset + p_iso->i_datastart;

  ret = cdio_stream_seek (p_iso->stream, i_byte_offset, SEEK_SET);

  if (ret!=0) return 0;

  return cdio_stream_read (p_iso->stream, ptr, i_framesize, size);

}

/*!

  Seek to a position and then read n blocks. Size read is returned.

*/

long int

iso9660_iso_seek_read (const iso9660_t *p_iso, void *ptr, lsn_t start,

		       long int size)

{

  return iso9660_seek_read_framesize(p_iso, ptr, start, size, ISO_BLOCKSIZE);

}

/*!

  Check for the end of a directory record list in a single directory

  block.  If at the end, set the offset to start of the next block and

  return "true". The caller often skips actions only when at the end

  of a record list.

*/

static bool

iso9660_check_dir_block_end(iso9660_dir_t *p_iso9660_dir, unsigned *offset)

{

  if (!iso9660_get_dir_len(p_iso9660_dir))

    {

      /*

	 Length 0 indicates that no more directory records are in this

	 block. This matches how Linux and libburn's libisofs work.

	 Note that assignment below does not exactly round up.

	 If (offset % ISO_BLOCKSIZE) == 0  then offset is incremented

	 by ISO_BLOCKSIZE, i.e. the block is skipped.

      */

      *offset += ISO_BLOCKSIZE - (*offset % ISO_BLOCKSIZE);

      return true;

    }

  if ((*offset + iso9660_get_dir_len(p_iso9660_dir) - 1) / ISO_BLOCKSIZE

      != *offset / ISO_BLOCKSIZE)

    {

      /*

	 Directory record spans over block limit.

	 Hop to next block where a new record is supposed to begin,

	 if it is not after the end of the directory data.

       */

      *offset += ISO_BLOCKSIZE - (*offset % ISO_BLOCKSIZE);

      return true;

    }

  return false;

}

static iso9660_stat_t *

_iso9660_dir_to_statbuf (iso9660_dir_t *p_iso9660_dir, bool_3way_t b_xa,

			 uint8_t u_joliet_level)

{

  uint8_t dir_len= iso9660_get_dir_len(p_iso9660_dir);

  iso711_t i_fname;

  unsigned int stat_len;

  iso9660_stat_t *p_stat = NULL;

  bool err;

  if (!dir_len) return NULL;

  i_fname  = from_711(p_iso9660_dir->filename.len);

  /* .. string in statbuf is one longer than in p_iso9660_dir's listing '\1' */

  stat_len      = sizeof(iso9660_stat_t)+i_fname+2;

  p_stat          = calloc(1, stat_len);

  if (!p_stat)

    {

    cdio_warn("Couldn't calloc(1, %d)", stat_len);

    return NULL;

    }

  p_stat->type    = (p_iso9660_dir->file_flags & ISO_DIRECTORY)

    ? _STAT_DIR : _STAT_FILE;

  p_stat->lsn     = from_733_with_err (p_iso9660_dir->extent, &err;;

  if (err) {

    free(p_stat);

    return NULL;

  }

  p_stat->size    = from_733_with_err (p_iso9660_dir->size, &err;;

  if (err) {

    free(p_stat);

    return NULL;

  }

  p_stat->secsize = _cdio_len2blocks (p_stat->size, ISO_BLOCKSIZE);

  p_stat->rr.b3_rock = dunno; /*FIXME should do based on mask */

  p_stat->b_xa    = false;

  {

    char rr_fname[256] = "";

    int  i_rr_fname =

#ifdef HAVE_ROCK

      get_rock_ridge_filename(p_iso9660_dir, rr_fname, p_stat);

#else

      0;

#endif

    if (i_rr_fname > 0) {

      if (i_rr_fname > i_fname) {

	/* realloc gives valgrind errors */

	iso9660_stat_t *p_stat_new =

	  calloc(1, sizeof(iso9660_stat_t)+i_rr_fname+2);

        if (!p_stat_new)

          {

          cdio_warn("Couldn't calloc(1, %d)", (int)(sizeof(iso9660_stat_t)+i_rr_fname+2));

	  free(p_stat);

          return NULL;

          }

	memcpy(p_stat_new, p_stat, stat_len);

	free(p_stat);

	p_stat = p_stat_new;

      }

      strncpy(p_stat->filename, rr_fname, i_rr_fname+1);

    } else {

      if ('\0' == p_iso9660_dir->filename.str[1] && 1 == i_fname)

	strncpy (p_stat->filename, ".", sizeof("."));

      else if ('\1' == p_iso9660_dir->filename.str[1] && 1 == i_fname)

	strncpy (p_stat->filename, "..", sizeof(".."));

#ifdef HAVE_JOLIET

      else if (u_joliet_level) {

	int i_inlen = i_fname;

	cdio_utf8_t *p_psz_out = NULL;

	if (cdio_charset_to_utf8(&p_iso9660_dir->filename.str[1], i_inlen,

                             &p_psz_out, "UCS-2BE")) {

          strncpy(p_stat->filename, p_psz_out, i_fname);

          free(p_psz_out);

        }

        else {

          free(p_stat);

          return NULL;

        }

      }

#endif /*HAVE_JOLIET*/

      else {

	strncpy (p_stat->filename, &p_iso9660_dir->filename.str[1], i_fname);

      }

    }

  }

  iso9660_get_dtime(&(p_iso9660_dir->recording_time), true, &(p_stat->tm));

  if (dir_len < sizeof (iso9660_dir_t)) {

    iso9660_stat_free(p_stat);

    return NULL;

  }

  {

    int su_length = iso9660_get_dir_len(p_iso9660_dir)