307 lines
8.5 KiB
C
Executable File
307 lines
8.5 KiB
C
Executable File
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
|
|
/* vim: set noet ts=8 sts=8 sw=8 : */
|
|
|
|
/**
|
|
* \file ecma119.h
|
|
*
|
|
* Structures and definitions used for writing an emca119 (ISO9660) compatible
|
|
* volume.
|
|
*/
|
|
|
|
#ifndef LIBISO_ECMA119_H
|
|
#define LIBISO_ECMA119_H
|
|
|
|
#include <sys/time.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h> /* for FILE */
|
|
#include <sys/types.h>
|
|
#include "susp.h"
|
|
|
|
struct ecma119_tree_node;
|
|
struct joliet_tree_node;
|
|
|
|
/**
|
|
* The possible states that the ecma119 writer can be in.
|
|
*/
|
|
enum ecma119_write_state
|
|
{
|
|
ECMA119_WRITE_BEFORE,
|
|
|
|
ECMA119_WRITE_SYSTEM_AREA,
|
|
ECMA119_WRITE_PRI_VOL_DESC,
|
|
ECMA119_WRITE_ELTORITO_BOOT_VOL_DESC,
|
|
ECMA119_WRITE_SUP_VOL_DESC_JOLIET,
|
|
ECMA119_WRITE_VOL_DESC_TERMINATOR,
|
|
ECMA119_WRITE_L_PATH_TABLE,
|
|
ECMA119_WRITE_M_PATH_TABLE,
|
|
ECMA119_WRITE_L_PATH_TABLE_JOLIET,
|
|
ECMA119_WRITE_M_PATH_TABLE_JOLIET,
|
|
ECMA119_WRITE_DIR_RECORDS,
|
|
ECMA119_WRITE_DIR_RECORDS_JOLIET,
|
|
ECMA119_WRITE_ELTORITO_CATALOG,
|
|
ECMA119_WRITE_FILES,
|
|
|
|
ECMA119_WRITE_DONE
|
|
};
|
|
|
|
/**
|
|
* Data describing the state of the ecma119 writer. Everything here should be
|
|
* considered private!
|
|
*/
|
|
struct ecma119_write_target
|
|
{
|
|
struct ecma119_tree_node *root;
|
|
struct joliet_tree_node *joliet_root;
|
|
struct iso_volset *volset;
|
|
int volnum;
|
|
|
|
time_t now; /**< Time at which writing began. */
|
|
off_t total_size; /**< Total size of the output. This only
|
|
* includes the current volume. */
|
|
uint32_t vol_space_size;
|
|
|
|
unsigned int rockridge:1;
|
|
unsigned int joliet:1;
|
|
unsigned int iso_level:2;
|
|
unsigned int eltorito:1;
|
|
|
|
int relaxed_constraints; /**< see ecma119_relaxed_constraints_flag */
|
|
|
|
struct el_torito_boot_catalog *catalog;
|
|
|
|
int replace_mode; /**< Replace ownership and modes of files
|
|
*
|
|
* 0. filesystem values
|
|
* 1. useful values
|
|
* bits 1-4 bitmask:
|
|
* 2 - replace dir
|
|
* 3 - replace file
|
|
* 4 - replace gid
|
|
* 5 - replace uid
|
|
*/
|
|
mode_t dir_mode;
|
|
mode_t file_mode;
|
|
gid_t gid;
|
|
uid_t uid;
|
|
|
|
char *input_charset;
|
|
char *ouput_charset;
|
|
|
|
int cache_inodes;
|
|
|
|
int sort_files; /**< if sort files or not. Sorting is based of
|
|
* the weight of each file */
|
|
|
|
/**
|
|
* In the CD, each file must have an unique inode number. So each
|
|
* time we add a new file, this is incremented.
|
|
*/
|
|
ino_t ino;
|
|
|
|
int curblock;
|
|
uint16_t block_size;
|
|
uint32_t path_table_size;
|
|
uint32_t path_table_size_joliet;
|
|
uint32_t l_path_table_pos;
|
|
uint32_t m_path_table_pos;
|
|
uint32_t l_path_table_pos_joliet;
|
|
uint32_t m_path_table_pos_joliet;
|
|
uint32_t total_dir_size;
|
|
uint32_t total_dir_size_joliet;
|
|
|
|
struct ecma119_tree_node **dirlist;
|
|
/**< A pre-order list of directories
|
|
* (this is the order in which we write
|
|
* out directory records).
|
|
*/
|
|
struct ecma119_tree_node **pathlist;
|
|
/**< A breadth-first list of
|
|
* directories. This is used for
|
|
* writing out the path tables.
|
|
*/
|
|
size_t dirlist_len; /**< The length of the previous 2 lists.
|
|
*/
|
|
|
|
|
|
struct iso_file_table *file_table;
|
|
/**<
|
|
* A hash table with info about all files
|
|
*/
|
|
|
|
struct iso_file **filelist; /**< A pre-order list of files.*/
|
|
size_t filelist_len; /* Length of the previous list. */
|
|
|
|
int curfile; /**< Used as a helper field for writing
|
|
out filelist and dirlist */
|
|
|
|
/* Joliet versions of the above lists. Since Joliet doesn't require
|
|
* directory relocation, the order of these lists might be different
|
|
* from the lists above (but they will be the same length).
|
|
*/
|
|
struct joliet_tree_node **dirlist_joliet;
|
|
struct joliet_tree_node **pathlist_joliet;
|
|
|
|
size_t dirlist_len_joliet;
|
|
|
|
enum ecma119_write_state state; /* The current state of the writer. */
|
|
|
|
/* Most writers work by
|
|
* 1) making sure state_data is big enough for their data
|
|
* 2) writing _all_ their data into state_data
|
|
* 3) relying on write_data_chunk to write the data block
|
|
* by block.
|
|
*/
|
|
uint8_t *state_data;
|
|
off_t state_data_size;
|
|
off_t state_data_off;
|
|
int state_data_valid;
|
|
|
|
/* for writing out files */
|
|
struct state_files {
|
|
off_t pos; /* The number of bytes we have written
|
|
* so far in the current file.
|
|
*/
|
|
off_t data_len;/* The number of bytes in the currently
|
|
* open file.
|
|
*/
|
|
FILE *fd; /* The currently open file. */
|
|
int file; /* The index in filelist that we are
|
|
* currently writing (or about to write). */
|
|
} state_files;
|
|
};
|
|
|
|
#define BP(a,b) [(b) - (a) + 1]
|
|
|
|
struct ecma119_pri_vol_desc
|
|
{
|
|
uint8_t vol_desc_type BP(1, 1);
|
|
uint8_t std_identifier BP(2, 6);
|
|
uint8_t vol_desc_version BP(7, 7);
|
|
uint8_t unused1 BP(8, 8);
|
|
uint8_t system_id BP(9, 40);
|
|
uint8_t volume_id BP(41, 72);
|
|
uint8_t unused2 BP(73, 80);
|
|
uint8_t vol_space_size BP(81, 88);
|
|
uint8_t unused3 BP(89, 120);
|
|
uint8_t vol_set_size BP(121, 124);
|
|
uint8_t vol_seq_number BP(125, 128);
|
|
uint8_t block_size BP(129, 132);
|
|
uint8_t path_table_size BP(133, 140);
|
|
uint8_t l_path_table_pos BP(141, 144);
|
|
uint8_t opt_l_path_table_pos BP(145, 148);
|
|
uint8_t m_path_table_pos BP(149, 152);
|
|
uint8_t opt_m_path_table_pos BP(153, 156);
|
|
uint8_t root_dir_record BP(157, 190);
|
|
uint8_t vol_set_id BP(191, 318);
|
|
uint8_t publisher_id BP(319, 446);
|
|
uint8_t data_prep_id BP(447, 574);
|
|
uint8_t application_id BP(575, 702);
|
|
uint8_t copyright_file_id BP(703, 739);
|
|
uint8_t abstract_file_id BP(740, 776);
|
|
uint8_t bibliographic_file_id BP(777, 813);
|
|
uint8_t vol_creation_time BP(814, 830);
|
|
uint8_t vol_modification_time BP(831, 847);
|
|
uint8_t vol_expiration_time BP(848, 864);
|
|
uint8_t vol_effective_time BP(865, 881);
|
|
uint8_t file_structure_version BP(882, 882);
|
|
uint8_t reserved1 BP(883, 883);
|
|
uint8_t app_use BP(884, 1395);
|
|
uint8_t reserved2 BP(1396, 2048);
|
|
};
|
|
|
|
struct ecma119_sup_vol_desc
|
|
{
|
|
uint8_t vol_desc_type BP(1, 1);
|
|
uint8_t std_identifier BP(2, 6);
|
|
uint8_t vol_desc_version BP(7, 7);
|
|
uint8_t vol_flags BP(8, 8);
|
|
uint8_t system_id BP(9, 40);
|
|
uint8_t volume_id BP(41, 72);
|
|
uint8_t unused2 BP(73, 80);
|
|
uint8_t vol_space_size BP(81, 88);
|
|
uint8_t esc_sequences BP(89, 120);
|
|
uint8_t vol_set_size BP(121, 124);
|
|
uint8_t vol_seq_number BP(125, 128);
|
|
uint8_t block_size BP(129, 132);
|
|
uint8_t path_table_size BP(133, 140);
|
|
uint8_t l_path_table_pos BP(141, 144);
|
|
uint8_t opt_l_path_table_pos BP(145, 148);
|
|
uint8_t m_path_table_pos BP(149, 152);
|
|
uint8_t opt_m_path_table_pos BP(153, 156);
|
|
uint8_t root_dir_record BP(157, 190);
|
|
uint8_t vol_set_id BP(191, 318);
|
|
uint8_t publisher_id BP(319, 446);
|
|
uint8_t data_prep_id BP(447, 574);
|
|
uint8_t application_id BP(575, 702);
|
|
uint8_t copyright_file_id BP(703, 739);
|
|
uint8_t abstract_file_id BP(740, 776);
|
|
uint8_t bibliographic_file_id BP(777, 813);
|
|
uint8_t vol_creation_time BP(814, 830);
|
|
uint8_t vol_modification_time BP(831, 847);
|
|
uint8_t vol_expiration_time BP(848, 864);
|
|
uint8_t vol_effective_time BP(865, 881);
|
|
uint8_t file_structure_version BP(882, 882);
|
|
uint8_t reserved1 BP(883, 883);
|
|
uint8_t app_use BP(884, 1395);
|
|
uint8_t reserved2 BP(1396, 2048);
|
|
};
|
|
|
|
struct ecma119_boot_rec_vol_desc
|
|
{
|
|
uint8_t vol_desc_type BP(1, 1);
|
|
uint8_t std_identifier BP(2, 6);
|
|
uint8_t vol_desc_version BP(7, 7);
|
|
uint8_t boot_sys_id BP(8, 39);
|
|
uint8_t boot_id BP(40, 71);
|
|
uint8_t boot_catalog BP(72, 75);
|
|
uint8_t unused BP(76, 2048);
|
|
};
|
|
|
|
struct ecma119_vol_desc_terminator
|
|
{
|
|
uint8_t vol_desc_type BP(1, 1);
|
|
uint8_t std_identifier BP(2, 6);
|
|
uint8_t vol_desc_version BP(7, 7);
|
|
uint8_t reserved BP(8, 2048);
|
|
};
|
|
|
|
struct ecma119_dir_record
|
|
{
|
|
uint8_t len_dr BP(1, 1);
|
|
uint8_t len_xa BP(2, 2);
|
|
uint8_t block BP(3, 10);
|
|
uint8_t length BP(11, 18);
|
|
uint8_t recording_time BP(19, 25);
|
|
uint8_t flags BP(26, 26);
|
|
uint8_t file_unit_size BP(27, 27);
|
|
uint8_t interleave_gap_size BP(28, 28);
|
|
uint8_t vol_seq_number BP(29, 32);
|
|
uint8_t len_fi BP(33, 33);
|
|
uint8_t file_id BP(34, 34); /* 34 to 33+len_fi */
|
|
/* padding field (if len_fi is even) */
|
|
/* system use (len_dr - len_su + 1 to len_dr) */
|
|
};
|
|
|
|
struct ecma119_path_table_record
|
|
{
|
|
uint8_t len_di BP(1, 1);
|
|
uint8_t len_xa BP(2, 2);
|
|
uint8_t block BP(3, 6);
|
|
uint8_t parent BP(7, 8);
|
|
uint8_t dir_id BP(9, 9); /* 9 to 8+len_di */
|
|
/* padding field (if len_di is odd) */
|
|
};
|
|
|
|
/**
|
|
* A utility function for writers that want to write their data all at once
|
|
* rather than block-by-block. This creates a buffer of size \p size, passes
|
|
* it to the given writer, then hands out block-sized chunks.
|
|
*/
|
|
void
|
|
ecma119_start_chunking(struct ecma119_write_target *t,
|
|
void (*)(struct ecma119_write_target*, uint8_t*),
|
|
off_t size,
|
|
uint8_t *buf);
|
|
|
|
#endif /* LIBISO_ECMA119_H */
|