cbmimage.h

Go to the documentation of this file.

#ifndef CBMIMAGE_H
#define CBMIMAGE_H 1
 
#include <stddef.h>
#include <stdint.h>
 
/* BAM handling */

typedef
enum cbmimage_BAM_state_e {
  BAM_UNKNOWN,          
  BAM_REALLY_FREE,      
  BAM_FREE,             
  BAM_USED,             
  BAM_DOES_NOT_EXIST    
} cbmimage_BAM_state;
 

typedef
struct cbmimage_track_sector_s {
  uint8_t track;        
  uint8_t sector;       
} cbmimage_track_sector;

#define CBMIMAGE_TS_INIT(_track, _sector) \
  { .track = (_track), .sector = (_sector) }

#define CBMIMAGE_TS_SET(_ts, _track, _sector) \
  do { (_ts).track = (_track); (_ts).sector = (_sector); } while (0)

#define CBMIMAGE_TS_CLEAR(_ts) \
  CBMIMAGE_TS_SET((_ts), 0, 0)

typedef uint16_t cbmimage_lba;

typedef
struct cbmimage_blockaddress_s {
  cbmimage_track_sector ts;    
  cbmimage_lba          lba;   
} cbmimage_blockaddress;
 
extern const cbmimage_blockaddress cbmimage_block_unused;

#define CBMIMAGE_BLOCK_INIT(_track, _sector, _lba) \
 { .lba = (_lba), .ts = CBMIMAGE_TS_INIT((_track), (_sector)) }

#define CBMIMAGE_BLOCK_INIT_FROM_TS(_track, _sector) \
  CBMIMAGE_BLOCK_INIT((_track), (_sector), 0)

#define CBMIMAGE_BLOCK_INIT_FROM_LBA(_lba) \
  CBMIMAGE_INIT_BLOCK(0, 0, (_lba))

#define CBMIMAGE_BLOCK_SET_FROM_TS(_image, _block, _track, _sector) \
  do { \
    CBMIMAGE_TS_SET((_block).ts, (_track), (_sector)); \
    cbmimage_blockaddress_init_from_ts((_image), &(_block)); \
  } while (0)

#define CBMIMAGE_BLOCK_SET_FROM_LBA(_image, _block, _lba) \
  do { \
    (_block).lba = (_lba); \
    cbmimage_blockaddress_init_from_lba((_image), &(_block)); \
  } while (0)
 
/* directory handling */

typedef
enum cbmimage_dir_type_e {
  DIR_TYPE_DEL        = 0,     
  DIR_TYPE_SEQ        = 1,     
  DIR_TYPE_PRG        = 2,     
  DIR_TYPE_USR        = 3,     
  DIR_TYPE_REL        = 4,     
  DIR_TYPE_PART1581   = 5,     
  DIR_TYPE_CMD_NATIVE = 6,     
 
  DIR_TYPE_PART_OFFSET     = 0x100,
  DIR_TYPE_PART_NO         = DIR_TYPE_PART_OFFSET,
  DIR_TYPE_PART_CMD_NATIVE = DIR_TYPE_PART_OFFSET + 0x01,
  DIR_TYPE_PART_D64        = DIR_TYPE_PART_OFFSET + 0x02,
  DIR_TYPE_PART_D71        = DIR_TYPE_PART_OFFSET + 0x03,
  DIR_TYPE_PART_D81        = DIR_TYPE_PART_OFFSET + 0x04,
  DIR_TYPE_PART_SYSTEM     = DIR_TYPE_PART_OFFSET + 0xFF,
} cbmimage_dir_type;

typedef
enum cbmimage_geos_filetype_e {
  GEOS_FILETYPE_NON_GEOS          = 0x00, 
  GEOS_FILETYPE_BASIC             = 0x01, 
  GEOS_FILETYPE_ASSEMBLER         = 0x02, 
  GEOS_FILETYPE_DATA_FILE         = 0x03, 
  GEOS_FILETYPE_SYSTEM_FILE       = 0x04, 
  GEOS_FILETYPE_DESK_ACCESSORY    = 0x05, 
  GEOS_FILETYPE_APPLICATION       = 0x06, 
  GEOS_FILETYPE_APPLICATION_DATA  = 0x07, 
  GEOS_FILETYPE_FONT_FILE         = 0x08, 
  GEOS_FILETYPE_PRINTER_DRIVER    = 0x09, 
  GEOS_FILETYPE_INPUT_DRIVER      = 0x0A, 
  GEOS_FILETYPE_DISK_DRIVER       = 0x0B, 
  GEOS_FILETYPE_SYSTEM_BOOT_FILE  = 0x0C, 
  GEOS_FILETYPE_TEMPORARY         = 0x0D, 
  GEOS_FILETYPE_AUTO_EXECUTE_FILE = 0x0E, 
} cbmimage_geos_filetype;

typedef
struct cbmimage_dir_header_name_s {

  int end_index;

  int length;

  const char text[24];
 
} cbmimage_dir_header_name;

typedef
struct cbmimage_dir_header_s {

  cbmimage_dir_header_name name;

  uint16_t free_block_count;

  unsigned int is_geos : 1;
 
} cbmimage_dir_header;

typedef
struct cbmimage_dir_entry_s {

  cbmimage_dir_header_name name;

  cbmimage_dir_type type;

  unsigned int is_locked : 1;

  unsigned int is_closed : 1;

  unsigned int has_datetime : 1;

  unsigned int is_geos : 1;

  unsigned int geos_is_vlir : 1;

  unsigned int is_valid : 1;

  cbmimage_blockaddress start_block;

  cbmimage_blockaddress rel_sidesector_block;

  uint16_t rel_recordlength;

  uint16_t block_count;
 

  uint16_t year;

  uint8_t month;

  uint8_t day;

  uint8_t hour;

  uint8_t minute;
 

  cbmimage_blockaddress geos_infoblock;

  cbmimage_geos_filetype geos_filetype;
 
} cbmimage_dir_entry;
 
/* disk image handling */

typedef
enum cbmimage_imagetype_e {
  TYPE_UNKNOWN,               
  TYPE_D40,                   
  TYPE_D64,                   
  TYPE_D64_40TRACK,           
  TYPE_D64_40TRACK_SPEEDDOS,  
  TYPE_D64_40TRACK_DOLPHIN,   
  TYPE_D64_40TRACK_PROLOGIC,  
  TYPE_D64_42TRACK,           
  TYPE_D71,                   
  TYPE_D81,                   
  TYPE_D80,                   
  TYPE_D82,                   
//  TYPE_D60,                   ///< 9060 file format
//  TYPE_D90,                   ///< 9090 file format
//  TYPE_D16,                   ///< Ruud Baltissen's own D16 format (tracks 1-255, sectors 0-255 per track)
  TYPE_CMD_D1M,               
  TYPE_CMD_D2M,               
  TYPE_CMD_D4M,               
  TYPE_CMD_NATIVE,            
  TYPE_LAST                   
} cbmimage_imagetype;
 
/* disk image handling */
 
struct cbmimage_image_parameter_s;
struct cbmimage_image_settings_s;

typedef
struct cbmimage_fileimage_s {

  struct cbmimage_image_settings_s * settings;

  struct cbmimage_image_settings_s * global_settings;

  struct cbmimage_image_parameter_s * parameter;

  uint8_t bufferarray[];
 
} cbmimage_fileimage;

typedef
struct cbmimage_loop_s {

  cbmimage_fileimage * image;

  void * map;

  size_t map_size;

  uint8_t bufferarray[];
 
} cbmimage_loop;
 

typedef
struct cbmimage_blockaccessor_s {

  cbmimage_fileimage * image;

  cbmimage_blockaddress  block;

  uint8_t * data;
 
} cbmimage_blockaccessor;
 
/* FAT handling */

typedef
struct cbmimage_fat_entry_s {
  uint16_t lba;
 
} cbmimage_fat_entry;

typedef
struct cbmimage_fat_s {

  cbmimage_fat_entry *entry;

  cbmimage_fileimage *image;

  size_t elements;

  uint8_t bufferarray[];
 
} cbmimage_fat;
 
/* file handling */

typedef
struct cbmimage_chain_s {
  cbmimage_fileimage *   image;

  cbmimage_blockaddress  block_start;

  unsigned int           is_done : 1;

  unsigned int           is_loop : 1;

  cbmimage_loop *        loop_detector;

  cbmimage_blockaccessor * block_accessor;
 
} cbmimage_chain;
 

typedef
struct cbmimage_file_s {

  cbmimage_fileimage * image;

  cbmimage_dir_entry * dir_entry;

  cbmimage_loop * loop_detector;

  cbmimage_chain * chain;

  uint16_t block_current_offset;

  uint16_t block_current_remain;

  uint16_t bytes_in_block;

  int error;

  uint8_t bufferarray[];
 
} cbmimage_file;
 
 
cbmimage_imagetype   cbmimage_image_guesstype                  (const uint8_t * buffer, size_t size, int * extra_errormap);
cbmimage_imagetype   cbmimage_image_file_guesstype             (const char * filename);
cbmimage_fileimage * cbmimage_image_open                       (const uint8_t * buffer, size_t size, cbmimage_imagetype);
cbmimage_fileimage * cbmimage_image_openfile                   (const char * filename, cbmimage_imagetype);
void                 cbmimage_image_readfile                   (cbmimage_fileimage *, const char * filename);
void                 cbmimage_image_writefile                  (cbmimage_fileimage *, const char * filename);
const void *         cbmimage_image_get_raw                    (cbmimage_fileimage *);
size_t               cbmimage_image_get_raw_size               (cbmimage_fileimage *);
void                 cbmimage_image_close                      (cbmimage_fileimage *);
void                 cbmimage_image_fat_dump                   (cbmimage_fileimage *, int linear);
 
const char *         cbmimage_get_imagetype_name               (cbmimage_fileimage *);
const char *         cbmimage_get_filename                     (cbmimage_fileimage *);
 
uint16_t             cbmimage_get_max_track                    (cbmimage_fileimage *);
uint16_t             cbmimage_get_max_sectors                  (cbmimage_fileimage *);
uint16_t             cbmimage_get_max_lba                      (cbmimage_fileimage *);
uint16_t             cbmimage_get_bytes_in_block               (cbmimage_fileimage *);
uint16_t             cbmimage_get_sectors_in_track             (cbmimage_fileimage *, uint16_t track);
 
int                  cbmimage_blockaddress_ts_exists           (cbmimage_fileimage *, uint8_t track, uint8_t sector);
int                  cbmimage_blockaddress_lba_exists          (cbmimage_fileimage *, uint16_t lba);
int                  cbmimage_blockaddress_init_from_ts        (cbmimage_fileimage *, cbmimage_blockaddress * block);
int                  cbmimage_blockaddress_init_from_lba       (cbmimage_fileimage *, cbmimage_blockaddress * block);
int                  cbmimage_blockaddress_init_from_ts_value  (cbmimage_fileimage *, cbmimage_blockaddress * block, uint8_t track, uint8_t sector);
int                  cbmimage_blockaddress_init_from_lba_value (cbmimage_fileimage *, cbmimage_blockaddress * block, uint16_t lba);
int                  cbmimage_blockaddress_advance             (cbmimage_fileimage *, cbmimage_blockaddress * block);
int                  cbmimage_blockaddress_advance_in_track    (cbmimage_fileimage *, cbmimage_blockaddress * block);
int                  cbmimage_blockaddress_add                 (cbmimage_fileimage *, cbmimage_blockaddress * blockresult, cbmimage_blockaddress block_adder);
 
int                  cbmimage_read_block                       (cbmimage_fileimage *, cbmimage_blockaddress block, void * buffer, size_t buffersize);
int                  cbmimage_write_block                      (cbmimage_fileimage *, cbmimage_blockaddress block, void * buffer, size_t buffersize);
 
int                  cbmimage_read_next_block                  (cbmimage_fileimage *, cbmimage_blockaddress * block, void * buffer, size_t buffersize);
 
cbmimage_blockaccessor * cbmimage_blockaccessor_create         (cbmimage_fileimage * image, cbmimage_blockaddress block);
cbmimage_blockaccessor * cbmimage_blockaccessor_create_from_ts (cbmimage_fileimage * image, uint8_t track, uint8_t sector);
cbmimage_blockaccessor * cbmimage_blockaccessor_create_from_lba(cbmimage_fileimage * image, uint16_t lba);
void                     cbmimage_blockaccessor_close          (cbmimage_blockaccessor * accessor);
int                      cbmimage_blockaccessor_set_to         (cbmimage_blockaccessor * accessor, cbmimage_blockaddress block);
int                      cbmimage_blockaccessor_set_to_ts      (cbmimage_blockaccessor * accessor, uint8_t track, uint8_t sector);
int                      cbmimage_blockaccessor_set_to_lba     (cbmimage_blockaccessor * accessor, uint16_t lba);
int                      cbmimage_blockaccessor_advance        (cbmimage_blockaccessor * accessor);
int                      cbmimage_blockaccessor_follow         (cbmimage_blockaccessor * accessor);
int                      cbmimage_blockaccessor_get_next_block (cbmimage_blockaccessor * accessor, cbmimage_blockaddress * block_next);
 
int                  cbmimage_bam_check_consistency            (cbmimage_fileimage *);
int                  cbmimage_get_blocks_free                  (cbmimage_fileimage *);
cbmimage_BAM_state   cbmimage_bam_get                          (cbmimage_fileimage *, cbmimage_blockaddress block);
int                  cbmimage_bam_get_free_on_track            (cbmimage_fileimage * image, uint8_t track);
 
cbmimage_dir_header *cbmimage_dir_get_header                   (cbmimage_fileimage *);
void                 cbmimage_dir_get_header_close             (cbmimage_dir_header *);
cbmimage_dir_entry * cbmimage_dir_get_first                    (cbmimage_fileimage *);
int                  cbmimage_dir_get_next                     (cbmimage_dir_entry *);
int                  cbmimage_dir_get_is_valid                 (cbmimage_dir_entry *);
char *               cbmimage_dir_extract_name                 (cbmimage_dir_header_name *, char * name, size_t len);
int                  cbmimage_dir_is_deleted                   (cbmimage_dir_entry *);
int                  cbmimage_dir_chdir                        (cbmimage_dir_entry *);
int                  cbmimage_dir_chdir_close                  (cbmimage_fileimage *);
void                 cbmimage_dir_get_close                    (cbmimage_dir_entry *);
 
cbmimage_loop *      cbmimage_loop_create                      (cbmimage_fileimage *);
void                 cbmimage_loop_close                       (cbmimage_loop *);
int                  cbmimage_loop_mark                        (cbmimage_loop *, cbmimage_blockaddress block);
int                  cbmimage_loop_check                       (cbmimage_loop *, cbmimage_blockaddress block);
 
int                  cbmimage_validate                         (cbmimage_fileimage *);
 
cbmimage_file * cbmimage_file_open_by_name(const char * filename);
cbmimage_file * cbmimage_file_open_by_dir_entry(cbmimage_dir_entry * dir_entry);
void            cbmimage_file_close(cbmimage_file * file);
int             cbmimage_file_read_next_block(cbmimage_file * file, uint8_t * buffer, size_t buffer_size);

typedef void cbmimage_print_function_type(const char * text);
int cbmimage_print_set_function(cbmimage_print_function_type print_function);
 
cbmimage_fat *         cbmimage_fat_create(cbmimage_fileimage * image);
int                    cbmimage_fat_set   (cbmimage_fat *, cbmimage_blockaddress block, cbmimage_blockaddress target);
int                    cbmimage_fat_clear (cbmimage_fat *, cbmimage_blockaddress block);
cbmimage_blockaddress  cbmimage_fat_get   (cbmimage_fat *, cbmimage_blockaddress block);
int                    cbmimage_fat_is_used(cbmimage_fat *, cbmimage_blockaddress block);
void                   cbmimage_fat_dump  (cbmimage_fat *, int linear);
void                   cbmimage_fat_close (cbmimage_fat *);
 
cbmimage_chain *       cbmimage_chain_start      (cbmimage_fileimage *, cbmimage_blockaddress);
void                   cbmimage_chain_close      (cbmimage_chain * chain);
int                    cbmimage_chain_advance    (cbmimage_chain * chain);
int                    cbmimage_chain_last_result(cbmimage_chain * chain);
int                    cbmimage_chain_is_done    (cbmimage_chain * chain);
int                    cbmimage_chain_is_loop    (cbmimage_chain * chain);
cbmimage_blockaddress  cbmimage_chain_get_current(cbmimage_chain * chain);
cbmimage_blockaddress  cbmimage_chain_get_next   (cbmimage_chain * chain);
uint8_t *              cbmimage_chain_get_data   (cbmimage_chain * chain);
 
#endif // #ifndef CBMIMAGE_H