iso9660.h

Go to the documentation of this file.

/*
    Copyright (C) 2003-2008, 2012-2013, 2017, 2023-2024
                  Rocky Bernstein <rocky@gnu.org>
    Copyright (C) 2000 Herbert Valerio Riedel <hvr@gnu.org>
 
    See also iso9660.h by Eric Youngdale (1993).
 
    Copyright 1993 Yggdrasil Computing, Incorporated
 
    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/>.
*/
␌
#ifndef CDIO_ISO9660_H_
#define CDIO_ISO9660_H_
 
#include <time.h>
 
#include <cdio/cdio.h>
#include <cdio/ds.h>
#include <cdio/posix.h>
 
typedef uint8_t  iso711_t; 
typedef int8_t   iso712_t; 
typedef uint16_t iso721_t; 
typedef uint16_t iso722_t; 
typedef uint32_t iso723_t; 
typedef uint32_t iso731_t; 
typedef uint32_t iso732_t; 
typedef uint64_t iso733_t; 
typedef char     achar_t;  
typedef char     dchar_t;  
#ifndef EMPTY_ARRAY_SIZE
#define EMPTY_ARRAY_SIZE 0
#endif
 
#include <cdio/types.h>
#include <cdio/xa.h>
 
#ifdef ISODCL
#undef ISODCL
#endif
/* This part borrowed from the bsd386 isofs */
#define ISODCL(from, to)        ((to) - (from) + 1)
 
#define MIN_TRACK_SIZE 4*75
#define MIN_ISO_SIZE MIN_TRACK_SIZE
 
extern enum iso_enum1_s {
  ISO_PVD_SECTOR      =   16, 
  ISO_EVD_SECTOR      =   17, 
  LEN_ISONAME         =   31, 
  ISO_MAX_SYSTEM_ID   =   32, 
  MAX_ISONAME         =   37, 
  ISO_MAX_PREPARER_ID =  128, 
  MAX_ISOPATHNAME     =  255, 
  ISO_BLOCKSIZE       = 2048  
} iso_enums1;
 
extern enum iso_flag_enum_s {
  ISO_FILE            =   0,   
  ISO_EXISTENCE       =   1,   
  ISO_DIRECTORY       =   2,   
  ISO_ASSOCIATED      =   4,   
  ISO_RECORD          =   8,   
  ISO_PROTECTION      =  16,   
  ISO_DRESERVED1      =  32,   
  ISO_DRESERVED2      =  64,   
  ISO_MULTIEXTENT     = 128,   
} iso_flag_enums;
 
extern enum iso_vd_enum_s {
  ISO_VD_BOOT_RECORD   =  0,  
  ISO_VD_PRIMARY       =  1,  
  ISO_VD_SUPPLEMENTARY =  2,  
  ISO_VD_PARITION      =  3,  
  ISO_VD_END           = 255
} iso_vd_enums;
 
 
#define ISO_MAX_PUBLISHER_ID 128
 
#define ISO_MAX_APPLICATION_ID 128
 
#define ISO_MAX_VOLUME_ID 32
 
#define ISO_MAX_VOLUMESET_ID 128
 
extern const char ISO_STANDARD_ID[sizeof("CD001")-1];
 
#define ISO_STANDARD_ID      "CD001"
 
#define CDIO_EXTENT_BLOCKS(size) ((size + (ISO_BLOCKSIZE - 1)) / ISO_BLOCKSIZE)
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
typedef enum strncpy_pad_check {
  ISO9660_NOCHECK = 0,
  ISO9660_7BIT,
  ISO9660_ACHARS,
  ISO9660_DCHARS
} strncpy_pad_check_t;
 
PRAGMA_BEGIN_PACKED
 
struct  iso9660_dtime_s {
  iso711_t      dt_year;   
  iso711_t      dt_month;  
  iso711_t      dt_day;    
  iso711_t      dt_hour;   
  iso711_t      dt_minute; 
  iso711_t      dt_second; 
  iso712_t      dt_gmtoff; 
} GNUC_PACKED;
 
typedef struct iso9660_dtime_s  iso9660_dtime_t;
 
struct  iso9660_ltime_s {
  char   lt_year        [ISODCL(   1,   4)];   
  char   lt_month       [ISODCL(   5,   6)];   
  char   lt_day         [ISODCL(   7,   8)];   
  char   lt_hour        [ISODCL(   9,   10)];  
  char   lt_minute      [ISODCL(  11,   12)];  
  char   lt_second      [ISODCL(  13,   14)];  
  char   lt_hsecond     [ISODCL(  15,   16)];  
  iso712_t lt_gmtoff;  
} GNUC_PACKED;
 
typedef struct iso9660_ltime_s  iso9660_ltime_t;
typedef struct iso9660_dir_s    iso9660_dir_t;
typedef struct iso9660_stat_s   iso9660_stat_t;
 
#include <cdio/rock.h>
 
struct iso9660_dir_s {
  iso711_t         length;            
  iso711_t         xa_length;         
  iso733_t         extent;            
  iso733_t         size;              
  iso9660_dtime_t  recording_time;    
  uint8_t          file_flags;        
  iso711_t         file_unit_size;    
  iso711_t         interleave_gap;    
  iso723_t volume_sequence_number;    
  union {
    iso711_t        len;
    char            str[1];
  } filename;
} GNUC_PACKED;
 
struct iso9660_pvd_s {
  iso711_t         type;                         
  char             id[5];                        
  iso711_t         version;                      
  char             unused1[1];                   
  achar_t          system_id[ISO_MAX_SYSTEM_ID]; 
  dchar_t          volume_id[ISO_MAX_VOLUME_ID]; 
  uint8_t          unused2[8];                   
  iso733_t         volume_space_size;            
  uint8_t          unused3[32];                  
  iso723_t         volume_set_size;              
  iso723_t         volume_sequence_number;       
  iso723_t         logical_block_size;           
  iso733_t         path_table_size;              
  iso731_t         type_l_path_table;            
  iso731_t         opt_type_l_path_table;        
  iso732_t         type_m_path_table;            
  iso732_t         opt_type_m_path_table;        
  iso9660_dir_t    root_directory_record;        
  char             root_directory_filename;      
  dchar_t          volume_set_id[ISO_MAX_VOLUMESET_ID]; 
  achar_t          publisher_id[ISO_MAX_PUBLISHER_ID];  
  achar_t          preparer_id[ISO_MAX_PREPARER_ID]; 
  achar_t          application_id[ISO_MAX_APPLICATION_ID]; 
  dchar_t          copyright_file_id[37];     
  dchar_t          abstract_file_id[37];      
  dchar_t          bibliographic_file_id[37]; 
  iso9660_ltime_t  creation_date;             
  iso9660_ltime_t  modification_date;         
  iso9660_ltime_t  expiration_date;           
  iso9660_ltime_t  effective_date;            
  iso711_t         file_structure_version;    
  uint8_t           unused4[1];                
  char             application_data[512];     
  uint8_t          unused5[653];              
} GNUC_PACKED;
 
typedef struct iso9660_pvd_s  iso9660_pvd_t;
 
struct iso9660_svd_s {
  iso711_t         type;                         
  char             id[5];                        
  iso711_t         version;                      
  char             flags;                        
  achar_t          system_id[ISO_MAX_SYSTEM_ID]; 
  dchar_t          volume_id[ISO_MAX_VOLUME_ID]; 
  char             unused2[8];
  iso733_t         volume_space_size;            
  char             escape_sequences[32];         
  iso723_t         volume_set_size;              
  iso723_t         volume_sequence_number;       
  iso723_t         logical_block_size;           
  iso733_t         path_table_size;              
  iso731_t         type_l_path_table;            
  iso731_t         opt_type_l_path_table;        
  iso732_t         type_m_path_table;            
  iso732_t         opt_type_m_path_table;        
  iso9660_dir_t    root_directory_record;        
  char             root_directory_filename;      
  dchar_t          volume_set_id[ISO_MAX_VOLUMESET_ID];    
  achar_t          publisher_id[ISO_MAX_PUBLISHER_ID]; 
  achar_t          preparer_id[ISO_MAX_PREPARER_ID]; 
  achar_t          application_id[ISO_MAX_APPLICATION_ID]; 
  dchar_t          copyright_file_id[37];     
  dchar_t          abstract_file_id[37];      
  dchar_t          bibliographic_file_id[37]; 
  iso9660_ltime_t  creation_date;             
  iso9660_ltime_t  modification_date;         
  iso9660_ltime_t  expiration_date;           
  iso9660_ltime_t  effective_date;            
  iso711_t         file_structure_version;    
  uint8_t           unused4[1];                
  char             application_data[512];     
  uint8_t          unused5[653];              
} GNUC_PACKED;
 
typedef struct iso9660_svd_s  iso9660_svd_t;
 
PRAGMA_END_PACKED
 
typedef CdioList_t CdioISO9660FileList_t;
 
typedef CdioList_t CdioISO9660DirList_t;
 
struct iso9660_stat_s { /* big endian!! */
 
  iso_rock_statbuf_t rr;              
  struct tm          tm;              
  lsn_t              lsn;             
#ifndef DO_NOT_WANT_COMPATIBILITY
 
  /* *** Deprecated Legacy API ***
     Use .total_size and CDIO_EXTENT_BLOCKS.
   */
  uint32_t           size;         
  uint32_t           secsize;      
#endif /* DO_NOT_WANT_COMPATIBILITY */
 
  /* Multi-extent aware size, in bytes.
 
     It is guaranteed that the bytes are stored as gapless string in a
     contiguous sequence of blocks. I.e. they can be read sequentially
     starting at iso9660_stat_s.lsn.
     Data files which do not fulfil this promise cause a warning message
     and are not represented by this type of struct.
     (Directories are not allowed to have more than one extent and thus cannot
      legally break the promise.)
   */
  uint64_t           total_size;
 
  /* NB: If you need to access the 'secsize' equivalent for an extent,
   * you should use CDIO_EXTENT_BLOCKS(iso9660_stat_s.total_size) */
 
  iso9660_xa_t       xa;              
  enum { _STAT_FILE = 1, _STAT_DIR = 2 } type;
  bool               b_xa;
  char               filename[EMPTY_ARRAY_SIZE];    
};
 
typedef uint8_t iso_extension_mask_t;
 
extern enum iso_extension_enum_s {
  ISO_EXTENSION_JOLIET_LEVEL1 = 0x01,
  ISO_EXTENSION_JOLIET_LEVEL2 = 0x02,
  ISO_EXTENSION_JOLIET_LEVEL3 = 0x04,
  ISO_EXTENSION_ROCK_RIDGE    = 0x08,
  ISO_EXTENSION_HIGH_SIERRA   = 0x10
} iso_extension_enums;
 
 
#define ISO_EXTENSION_ALL           0xFF
#define ISO_EXTENSION_NONE          0x00
#define ISO_EXTENSION_JOLIET     \
  (ISO_EXTENSION_JOLIET_LEVEL1 | \
   ISO_EXTENSION_JOLIET_LEVEL2 | \
   ISO_EXTENSION_JOLIET_LEVEL3 )
 
 
typedef struct _iso9660_s iso9660_t;
 
  bool iso9660_close (iso9660_t * p_iso);
 
 
  iso9660_t *iso9660_open (const char *psz_path /*flags, mode */);
 
  iso9660_t *iso9660_open_ext (const char *psz_path,
                               iso_extension_mask_t iso_extension_mask);
 
  iso9660_t *iso9660_open_fuzzy (const char *psz_path /*flags, mode */,
                                 uint16_t i_fuzz);
 
  iso9660_t *iso9660_open_fuzzy_ext (const char *psz_path,
                                     iso_extension_mask_t iso_extension_mask,
                                     uint16_t i_fuzz
                                     /*flags, mode */);
 
  bool iso9660_ifs_fuzzy_read_superblock (iso9660_t *p_iso,
                                          iso_extension_mask_t iso_extension_mask,
                                          uint16_t i_fuzz);
 
  long int iso9660_iso_seek_read (const iso9660_t *p_iso, /*out*/ void *ptr,
                                  lsn_t start, long int i_size);
 
  bool iso9660_fs_read_pvd ( const CdIo_t *p_cdio,
                             /*out*/ iso9660_pvd_t *p_pvd );
 
  bool iso9660_ifs_read_pvd (const iso9660_t *p_iso,
                             /*out*/ iso9660_pvd_t *p_pvd);
 
  bool iso9660_fs_read_superblock (CdIo_t *p_cdio,
                                   iso_extension_mask_t iso_extension_mask);
 
  bool iso9660_ifs_read_superblock (iso9660_t *p_iso,
                                    iso_extension_mask_t iso_extension_mask);
 
 
/*====================================================
  Time conversion
 ====================================================*/
 
  void iso9660_set_dtime (const struct tm *tm,
                          /*out*/ iso9660_dtime_t *idr_date);
 
 
  void iso9660_set_dtime_with_timezone (const struct tm *p_tm,
                                        int timezone,
                                        /*out*/ iso9660_dtime_t *p_idr_date);
 
  void iso9660_set_ltime (const struct tm *_tm,
                          /*out*/ iso9660_ltime_t *p_pvd_date);
 
  void iso9660_set_ltime_with_timezone (const struct tm *_tm,
                                        int timezone,
                                        /*out*/ iso9660_ltime_t *p_pvd_date);
 
  bool iso9660_get_dtime (const iso9660_dtime_t *idr_date, bool b_localtime,
                          /*out*/ struct tm *p_tm);
 
 
  bool iso9660_get_ltime (const iso9660_ltime_t *p_ldate,
                          /*out*/ struct tm *p_tm);
 
  /*====================================================
    Character Classification and String Manipulation
    ====================================================*/
  bool iso9660_is_dchar (int c);
 
  bool iso9660_is_achar (int c);
 
  int iso9660_name_translate(const char *psz_oldname,
                             /*out*/ char *psz_newname);
 
  int iso9660_name_translate_ext(const char *psz_oldname, char *psz_newname,
                                 uint8_t i_joliet_level);
 
  char *iso9660_strncpy_pad(char dst[], const char src[], size_t len,
                            enum strncpy_pad_check _check);
 
  /*=====================================================================
    File and Directory Names
    ======================================================================*/
 
  bool iso9660_dirname_valid_p (const char psz_path[]);
 
  char *iso9660_pathname_isofy (const char psz_path[], uint16_t i_version);
 
  bool iso9660_pathname_valid_p (const char psz_path[]);
 
/*=====================================================================
  directory tree
======================================================================*/
 
void
iso9660_dir_init_new (void *dir, uint32_t self, uint32_t ssize,
                      uint32_t parent, uint32_t psize,
                      const time_t *dir_time);
 
void
iso9660_dir_init_new_su (void *dir, uint32_t self, uint32_t ssize,
                         const void *ssu_data, unsigned int ssu_size,
                         uint32_t parent, uint32_t psize,
                         const void *psu_data, unsigned int psu_size,
                         const time_t *dir_time);
 
void
iso9660_dir_add_entry_su (void *dir, const char filename[], uint32_t extent,
                          uint32_t size, uint8_t file_flags,
                          const void *su_data,
                          unsigned int su_size, const time_t *entry_time);
 
unsigned int
iso9660_dir_calc_record_size (unsigned int namelen, unsigned int su_len);
 
iso9660_stat_t *iso9660_fs_find_lsn(CdIo_t *p_cdio, lsn_t i_lsn);
iso9660_stat_t *iso9660_find_fs_lsn(CdIo_t *p_cdio, lsn_t i_lsn);
 
 
iso9660_stat_t *iso9660_fs_find_lsn_with_path(CdIo_t *p_cdio, lsn_t i_lsn,
                                              /*out*/ char **ppsz_full_filename);
 
iso9660_stat_t *iso9660_ifs_find_lsn(iso9660_t *p_iso, lsn_t i_lsn);
 
 
iso9660_stat_t *iso9660_ifs_find_lsn_with_path(iso9660_t *p_iso,
                                               lsn_t i_lsn,
                                               /*out*/ char **ppsz_path);
 
void iso9660_stat_free(iso9660_stat_t *p_stat);
 
iso9660_stat_t *iso9660_fs_stat (CdIo_t *p_cdio, const char psz_path[]);
 
 
iso9660_stat_t *iso9660_fs_stat_translate (CdIo_t *p_cdio,
                                           const char psz_path[]);
iso9660_stat_t *iso9660_ifs_stat (iso9660_t *p_iso, const char psz_path[]);
 
 
iso9660_stat_t *iso9660_ifs_stat_translate (iso9660_t *p_iso,
                                            const char psz_path[]);
 
 
CdioISO9660FileList_t * iso9660_filelist_new(void);
 
 
CdioISO9660DirList_t * iso9660_dirlist_new(void);
 
 
 
void iso9660_filelist_free(CdioISO9660FileList_t *p_filelist);
 
 
void iso9660_dirlist_free(CdioISO9660DirList_t *p_filelist);
 
 
CdioList_t * iso9660_fs_readdir (CdIo_t *p_cdio, const char psz_path[]);
 
CdioList_t * iso9660_ifs_readdir (iso9660_t *p_iso, const char psz_path[]);
 
char * iso9660_get_application_id(iso9660_pvd_t *p_pvd);
 
bool iso9660_ifs_get_application_id(iso9660_t *p_iso,
                                    /*out*/ cdio_utf8_t **p_psz_app_id);
 
uint8_t iso9660_ifs_get_joliet_level(iso9660_t *p_iso);
 
uint8_t iso9660_get_dir_len(const iso9660_dir_t *p_idr);
 
#ifdef FIXME
uint8_t iso9660_get_dir_size(const iso9660_dir_t *p_idr);
 
lsn_t iso9660_get_dir_extent(const iso9660_dir_t *p_idr);
#endif
 
  char * iso9660_dir_to_name (const iso9660_dir_t *p_iso9660_dir);
 
  mode_t iso9660_get_posix_filemode(const iso9660_stat_t *p_iso_dirent);
 
  char *iso9660_get_preparer_id(const iso9660_pvd_t *p_pvd);
 
  bool iso9660_ifs_get_preparer_id(iso9660_t *p_iso,
                                   /*out*/ cdio_utf8_t **p_psz_preparer_id);
 
  char *iso9660_get_publisher_id(const iso9660_pvd_t *p_pvd);
 
  bool iso9660_ifs_get_publisher_id(iso9660_t *p_iso,
                                    /*out*/ cdio_utf8_t **p_psz_publisher_id);
 
  uint8_t iso9660_get_pvd_type(const iso9660_pvd_t *p_pvd);
 
  const char * iso9660_get_pvd_id(const iso9660_pvd_t *p_pvd);
 
  int iso9660_get_pvd_space_size(const iso9660_pvd_t *p_pvd);
 
  int iso9660_get_pvd_block_size(const iso9660_pvd_t *p_pvd) ;
 
  int iso9660_get_pvd_version(const iso9660_pvd_t *pvd) ;
 
  char *iso9660_get_system_id(const iso9660_pvd_t *p_pvd);
 
  bool_3way_t iso9660_have_rr(iso9660_t *p_iso, uint64_t u_file_limit);
 
  bool iso9660_ifs_get_system_id(iso9660_t *p_iso,
                                 /*out*/ cdio_utf8_t **p_psz_system_id);
 
 
  lsn_t iso9660_get_root_lsn(const iso9660_pvd_t *p_pvd);
 
  char *iso9660_get_volume_id(const iso9660_pvd_t *p_pvd);
 
  bool iso9660_ifs_get_volume_id(iso9660_t *p_iso,
                                 /*out*/ cdio_utf8_t **p_psz_volume_id);
 
  char *iso9660_get_volumeset_id(const iso9660_pvd_t *p_pvd);
 
  bool iso9660_ifs_get_volumeset_id(iso9660_t *p_iso,
                                    /*out*/ cdio_utf8_t **p_psz_volumeset_id);
 
  /* pathtable */
 
  void iso9660_pathtable_init (void *pt);
 
  unsigned int iso9660_pathtable_get_size (const void *pt);
 
  uint16_t iso9660_pathtable_l_add_entry (void *pt, const char name[],
                                          uint32_t extent, uint16_t parent);
 
  uint16_t iso9660_pathtable_m_add_entry (void *pt, const char name[],
                                          uint32_t extent, uint16_t parent);
 
  void iso9660_set_pvd (void *pd, const char volume_id[],
                        const char application_id[],
                        const char publisher_id[], const char preparer_id[],
                        uint32_t iso_size, const void *root_dir,
                        uint32_t path_table_l_extent,
                        uint32_t path_table_m_extent,
                        uint32_t path_table_size, const time_t *pvd_time);
 
  void iso9660_set_evd (void *pd);
 
  bool iso9660_ifs_is_xa (const iso9660_t * p_iso);
 
 
#ifndef DO_NOT_WANT_COMPATIBILITY
#define iso9660_isdchar       iso9660_is_dchar
#define iso9660_isachar       iso9660_is_achar
#endif /*DO_NOT_WANT_COMPATIBILITY*/
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#undef ISODCL
#endif /* CDIO_ISO9660_H_ */
␌
/*
 * Local variables:
 *  c-file-style: "gnu"
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */