cdmake.c File Reference

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/io.h>
#include <errno.h>
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <ctype.h>
#include <time.h>
#include "config.h"
#include "dirhash.h"

Include dependency graph for cdmake.c:

Go to the source code of this file.

Classes
struct	cd_image
struct	_boot_validation_header
struct	boot_entry
struct	boot_header
struct	date_and_time
struct	directory_record

Macros
#define	TRUE   1
#define	FALSE   0
#define	MAX_LEVEL   8
#define	MAX_NAME_LENGTH   64
#define	MAX_CDNAME_LENGTH   8
#define	MAX_EXTENSION_LENGTH   10
#define	MAX_CDEXTENSION_LENGTH   3
#define	SECTOR_SIZE   2048
#define	BUFFER_SIZE   (8 * SECTOR_SIZE)
#define	HIDDEN_FLAG   1
#define	DIRECTORY_FLAG   2

Typedefs
typedef unsigned char	BYTE
typedef unsigned short	WORD
typedef unsigned long	DWORD
typedef int	BOOL
typedef struct _boot_validation_header	BOOT_VALIDATION_HEADER
typedef struct _boot_validation_header *	PBOOT_VALIDATION_HEADER
typedef struct boot_entry	BOOT_ENTRY
typedef struct boot_entry *	PBOOT_ENTRY
typedef struct boot_header	BOOT_HEADER
typedef struct boot_header *	PBOOT_HEADER
typedef struct date_and_time	DATE_AND_TIME
typedef struct date_and_time *	PDATE_AND_TIME
typedef struct directory_record	DIR_RECORD
typedef struct directory_record *	PDIR_RECORD
typedef enum directory_record_type	DIR_RECORD_TYPE
typedef enum directory_record_type *	PDIR_RECORD_TYPE

Enumerations
enum	directory_record_type { DOT_RECORD, DOT_DOT_RECORD, SUBDIRECTORY_RECORD, FILE_RECORD }
enum	{ QUIET, NORMAL, VERBOSE }

Functions
PDIR_RECORD	sort_linked_list (PDIR_RECORD, unsigned, int(*)(PDIR_RECORD, PDIR_RECORD))
static char *	edit_with_commas (DWORD x, BOOL pad)
static void	release_memory (void)
static void	error_exit (const char *fmt,...)
static void	flush_buffer (void)
static void	write_byte (BYTE x)
static void	write_little_endian_word (WORD x)
static void	write_big_endian_word (WORD x)
static void	write_both_endian_word (WORD x)
static void	write_little_endian_dword (DWORD x)
static void	write_big_endian_dword (DWORD x)
static void	write_both_endian_dword (DWORD x)
static void	fill_sector (void)
static void	write_string (char *s)
static void	write_bytecounted_string (unsigned bytecount, char *s, char padding)
static void	write_string_as_big_endian_unicode (char *s)
static void	write_bytecounted_string_as_big_endian_unicode (unsigned bytecount, char *s, char padding)
static void	write_block (unsigned count, BYTE value)
static void	write_word_block (unsigned count, WORD value)
static void	write_directory_record (PDIR_RECORD d, DIR_RECORD_TYPE DirType, BOOL joliet)
static void	convert_date_and_time (PDATE_AND_TIME dt, time_t *time)
static int	check_for_punctuation (int c, const char *name)
static BOOL	cdname_exists (PDIR_RECORD d)
static void	parse_filename_into_dirrecord (const char *filename, PDIR_RECORD d, BOOL dir)
PDIR_RECORD	new_directory_record (struct dirent *entry, struct stat *stbuf, PDIR_RECORD parent)
static int	compare_directory_order (PDIR_RECORD p, PDIR_RECORD q)
static int	compare_path_table_order (PDIR_RECORD p, PDIR_RECORD q)
static void	append_string_to_source (char *s)
static void	make_directory_records (PDIR_RECORD d)
static PDIR_RECORD	new_empty_dirrecord (PDIR_RECORD d, BOOL directory)
static void	scan_specified_files (PDIR_RECORD d, struct target_dir_entry *dir)
static void	get_file_specifications (PDIR_RECORD d)
static void	get_time_string (char *str)
static BOOL	write_from_file (FILE *file, DWORD size)
static void	pass (void)
char *	strtok_s (char *str, const char *delim, char **ctx)
static void	init_boot_entry (PBOOT_ENTRY boot_entry, BYTE boot_emu_type, WORD load_segment, char *bootimage)
int	main (int argc, char **argv)

Variables
static char	DIRECTORY_TIMESTAMP [] = "~Y$'KOR$.3K&"
static struct cd_image	cd
DIR_RECORD	root
char	volume_label [32]
char	source [512]
char *	end_source
enum { ... }	verbosity
BOOL	show_progress
BOOL	scan_files_only = FALSE
DWORD	size_limit
BOOL	accept_punctuation_marks
DWORD	total_sectors
DWORD	path_table_size
DWORD	little_endian_path_table_sector
DWORD	big_endian_path_table_sector
DWORD	number_of_files
DWORD	bytes_in_files
DWORD	unused_bytes_at_ends_of_files
DWORD	number_of_directories
DWORD	bytes_in_directories
struct target_dir_hash	specified_files
BOOL	eltorito
BOOL	multi_boot
DWORD	boot_catalog_sector
BOOT_VALIDATION_HEADER	boot_validation_header
BOOT_ENTRY	default_boot_entry
PBOOT_HEADER	boot_header_list
BOOL	joliet
DWORD	joliet_path_table_size
DWORD	joliet_little_endian_path_table_sector
DWORD	joliet_big_endian_path_table_sector
BOOL	make_bridged_udf = TRUE
static char	HELP []

Macro Definition Documentation

BUFFER_SIZE

#define BUFFER_SIZE   (8 * SECTOR_SIZE)

Definition at line 89 of file cdmake.c.

DIRECTORY_FLAG

#define DIRECTORY_FLAG   2

Definition at line 92 of file cdmake.c.

FALSE

#define FALSE   0

Definition at line 68 of file cdmake.c.

HIDDEN_FLAG

#define HIDDEN_FLAG   1

Definition at line 91 of file cdmake.c.

MAX_CDEXTENSION_LENGTH

#define MAX_CDEXTENSION_LENGTH   3

Definition at line 87 of file cdmake.c.

MAX_CDNAME_LENGTH

#define MAX_CDNAME_LENGTH   8

Definition at line 85 of file cdmake.c.

MAX_EXTENSION_LENGTH

#define MAX_EXTENSION_LENGTH   10

Definition at line 86 of file cdmake.c.

MAX_LEVEL

#define MAX_LEVEL   8

Definition at line 83 of file cdmake.c.

MAX_NAME_LENGTH

#define MAX_NAME_LENGTH   64

Definition at line 84 of file cdmake.c.

SECTOR_SIZE

#define SECTOR_SIZE   2048

Definition at line 88 of file cdmake.c.

TRUE

#define TRUE   1

Definition at line 67 of file cdmake.c.

Typedef Documentation

BOOL

typedef int BOOL

Definition at line 79 of file cdmake.c.

BOOT_ENTRY

typedef struct boot_entry BOOT_ENTRY

BOOT_HEADER

typedef struct boot_header BOOT_HEADER

BOOT_VALIDATION_HEADER

typedef struct _boot_validation_header BOOT_VALIDATION_HEADER

BYTE

typedef unsigned char BYTE

Definition at line 76 of file cdmake.c.

DATE_AND_TIME

typedef struct date_and_time DATE_AND_TIME

DIR_RECORD

typedef struct directory_record DIR_RECORD

DIR_RECORD_TYPE

typedef enum directory_record_type DIR_RECORD_TYPE

DWORD

typedef unsigned long DWORD

Definition at line 78 of file cdmake.c.

PBOOT_ENTRY

typedef struct boot_entry * PBOOT_ENTRY

PBOOT_HEADER

typedef struct boot_header * PBOOT_HEADER

PBOOT_VALIDATION_HEADER

typedef struct _boot_validation_header * PBOOT_VALIDATION_HEADER

PDATE_AND_TIME

typedef struct date_and_time * PDATE_AND_TIME

PDIR_RECORD

typedef struct directory_record * PDIR_RECORD

PDIR_RECORD_TYPE

typedef enum directory_record_type * PDIR_RECORD_TYPE

WORD

typedef unsigned short WORD

Definition at line 77 of file cdmake.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
QUIET
NORMAL
VERBOSE

Definition at line 189 of file cdmake.c.

{QUIET, NORMAL, VERBOSE} verbosity;

directory_record_type

enum directory_record_type

Enumerator
DOT_RECORD
DOT_DOT_RECORD
SUBDIRECTORY_RECORD
FILE_RECORD

Definition at line 167 of file cdmake.c.

{
    DOT_RECORD,
    DOT_DOT_RECORD,
    SUBDIRECTORY_RECORD,
    FILE_RECORD
} DIR_RECORD_TYPE, *PDIR_RECORD_TYPE;

Function Documentation

append_string_to_source()

static void append_string_to_source ( char *  s )

static

Definition at line 866 of file cdmake.c.

{
    while (*s != 0)
        *end_source++ = *s++;
}

Referenced by get_file_specifications(), and make_directory_records().

cdname_exists()

static BOOL cdname_exists ( PDIR_RECORD  d )

static

Definition at line 654 of file cdmake.c.

{
    PDIR_RECORD p = d->parent->first_record;
    while (p)
    {
        if ( p != d
            && !strcasecmp(p->name_on_cd, d->name_on_cd)
            && !strcasecmp(p->extension_on_cd, d->extension_on_cd) )
            return TRUE;
        p = p->next_in_directory;
    }
    return FALSE;
}

Referenced by parse_filename_into_dirrecord().

check_for_punctuation()

static int check_for_punctuation ( int  c, const char *  name  )

static

Definition at line 638 of file cdmake.c.

{
    c = toupper(c & 0xFF);
    if (!accept_punctuation_marks && !isalnum(c) && c != '_')
        error_exit("Punctuation mark in %s", name);
    return c;
}

Referenced by parse_filename_into_dirrecord().

compare_directory_order()

static int compare_directory_order ( PDIR_RECORD  p, PDIR_RECORD  q  )

static

Definition at line 834 of file cdmake.c.

{
    int n = strcmp(p->name_on_cd, q->name_on_cd);
    if (n == 0)
        n = strcmp(p->extension_on_cd, q->extension_on_cd);
    return n;
}

Referenced by compare_path_table_order(), make_directory_records(), and scan_specified_files().

compare_path_table_order()

static int compare_path_table_order ( PDIR_RECORD  p, PDIR_RECORD  q  )

static

Definition at line 848 of file cdmake.c.

{
    int n = p->level - q->level;
    if (p == q)
        return 0;
    if (n == 0)
    {
        n = compare_path_table_order(p->parent, q->parent);
        if (n == 0)
            n = compare_directory_order(p, q);
    }
    return n;
}

Referenced by main().

convert_date_and_time()

static void convert_date_and_time ( PDATE_AND_TIME  dt, time_t *  time  )

static

Definition at line 618 of file cdmake.c.

{
    struct tm *timedef;
    timedef = gmtime(time);

    dt->second = timedef->tm_sec;
    dt->minute = timedef->tm_min;
    dt->hour = timedef->tm_hour;
    dt->day = timedef->tm_mday;
    dt->month = timedef->tm_mon + 1;
    dt->year = timedef->tm_year + 1900;
}

Referenced by main(), make_directory_records(), new_directory_record(), and scan_specified_files().

edit_with_commas()

static char* edit_with_commas ( DWORD  x, BOOL  pad  )

static

Definition at line 255 of file cdmake.c.

{
    static char s[14];
    unsigned i = 13;
    do
    {
        if (i % 4 == 2) s[--i] = ',';
        s[--i] = (char)(x % 10 + '0');
    } while ((x/=10) != 0);
    if (pad)
    {
        while (i > 0) s[--i] = ' ';
    }
    return s + i;
}

Referenced by flush_buffer(), and main().

error_exit()

static void error_exit ( const char *  fmt,   ...  )

static

Definition at line 315 of file cdmake.c.

{
    va_list arg;

    va_start(arg, fmt);
    vprintf(fmt, arg);
    va_end(arg);
    printf("\n");
    if (cd.file != NULL)
        fclose(cd.file);
    release_memory();
    exit(1);
}

Referenced by check_for_punctuation(), flush_buffer(), main(), make_directory_records(), new_directory_record(), parse_filename_into_dirrecord(), pass(), and scan_specified_files().

fill_sector()

static void fill_sector ( void  )

static

Definition at line 418 of file cdmake.c.

{
    while (cd.offset != 0)
        write_byte(0);
}

Referenced by pass(), and write_directory_record().

flush_buffer()

static void flush_buffer ( void  )

static

Definition at line 334 of file cdmake.c.

{
    if (fwrite(cd.buffer, cd.count, 1, cd.file) < 1)
        error_exit("File write error");
    cd.count = 0;
    if (show_progress)
    {
        printf("\r%s ",
            edit_with_commas((total_sectors - cd.sector) * SECTOR_SIZE, TRUE));
    }
}

Referenced by main(), write_byte(), and write_from_file().

get_file_specifications()

static void get_file_specifications ( PDIR_RECORD  d )

static

Definition at line 1343 of file cdmake.c.

{
    if (d != &root)
    {
        get_file_specifications(d->parent);
        if (d->joliet_name == NULL)
            append_string_to_source(d->name);
        else
            append_string_to_source(d->joliet_name);

        if (((d->flags & DIRECTORY_FLAG) == 0 || joliet) && d->extension[0] != 0)
        {
            if (d->joliet_name == NULL)
            {
                *end_source++ = '.';
                append_string_to_source(d->extension);
            }
        }
        if (d->flags & DIRECTORY_FLAG)
            *end_source++ = DIR_SEPARATOR_CHAR;
    }
}

Referenced by pass().

get_time_string()

static void get_time_string ( char *  str )

static

Definition at line 1366 of file cdmake.c.

{
    sprintf(str, "%04d%02d%02d%02d%02d%02d00",
            root.date_and_time.year,
            root.date_and_time.month,
            root.date_and_time.day,
            root.date_and_time.hour,
            root.date_and_time.minute,
            root.date_and_time.second);
}

Referenced by pass().

init_boot_entry()

static void init_boot_entry ( PBOOT_ENTRY  boot_entry, BYTE  boot_emu_type, WORD  load_segment, char *  bootimage  )

static

Definition at line 1949 of file cdmake.c.

{
    boot_entry->boot_id       = 0x88;           // Bootable entry
    boot_entry->boot_emu_type = boot_emu_type;  // 0: No emulation, etc...
    boot_entry->load_segment  = load_segment;   // If 0 then use default 0x07C0

    boot_entry->bootimage[0]  = '\0';
    strncpy(boot_entry->bootimage, bootimage, sizeof(boot_entry->bootimage));
    boot_entry->bootimage[sizeof(boot_entry->bootimage)-1] = '\0';
}

Referenced by main().

main()

int main	(	int argc	,
		char **	argv
	)

Definition at line 1962 of file cdmake.c.

{
    time_t timestamp = time(NULL);
    int i;
    char *t;

    if (argc < 2)
    {
        puts(HELP);
        return 1;
    }

    // Initialize CD-ROM write buffer

    cd.file = NULL;
    cd.filespecs[0] = 0;

    cd.buffer = malloc(BUFFER_SIZE);
    if (cd.buffer == NULL)
        error_exit("Insufficient memory");

    // Initialize root directory

    memset(&root, 0, sizeof(root));
    root.level = 1;
    root.flags = DIRECTORY_FLAG;
    convert_date_and_time(&root.date_and_time, &timestamp);

    // Initialize parameters

    scan_files_only = FALSE;
    make_bridged_udf = TRUE;
    // compute_crc = FALSE;

    verbosity = NORMAL;
    show_progress = FALSE;
    size_limit = 0;
    accept_punctuation_marks = FALSE;
    source[0] = 0;
    volume_label[0] = 0;

    // Initialize boot information
    eltorito   = FALSE;
    multi_boot = FALSE;
    boot_validation_header.header_id   = 1;  // Validation header ID
    boot_validation_header.platform_id = 0;  // x86/64 BIOS system
    init_boot_entry(&default_boot_entry,
                    0,  // No emulation
                    0,  // Use default 0x07C0
                    "");
    default_boot_entry.sector_count  = 0;
    default_boot_entry.load_rba      = 0;
    boot_header_list = NULL;

    // Scan command line arguments

    for (i = 1; i < argc; i++)
    {
        if (strncmp(argv[i], "-v", 2) == 0)
        {
            t = argv[i] + 2;
            if (*t == 0) // Normal verbosity level.
                verbosity = NORMAL;
            else // Verbosity level in decimal
                verbosity = strtoul(t, NULL, 10);

            // Check for validity
            if (verbosity > VERBOSE)
                verbosity = NORMAL;

            // Disable by default, unless we are in normal verbosity level.
            // If progress is still wanted, use '-p'.
            if (verbosity == QUIET || verbosity == VERBOSE)
                show_progress = FALSE;
        }
        else if (strcmp(argv[i], "-p") == 0)
            show_progress = TRUE;
        else if (strncmp(argv[i], "-s", 2) == 0)
        {
            t = argv[i] + 2;
            if (*t == 0)
            {
                if (++i < argc)
                    t = argv[i];
                else
                    error_exit("Missing size limit parameter");
            }
            // size_limit = strtoul(t, NULL, 10);
            while (isdigit(*t))
                size_limit = size_limit * 10 + *t++ - '0';
            if (size_limit < 1 || size_limit > 800)
                error_exit("Invalid size limit");
            size_limit <<= 9;  // convert megabyte to sector count
        }
        else if (strcmp(argv[i], "-m") == 0)
            accept_punctuation_marks = TRUE;
        else if (strcmp(argv[i], "-j") == 0)
            joliet = TRUE;
        else if (strncmp(argv[i], "-e", 2) == 0)
        {
            // Check whether the multi-boot option '-bootdata:' was already set.
            // If so, print an error and bail out.
            if (eltorito && multi_boot)
                error_exit("Single-boot and multi-boot entries cannot be combined");

            eltorito   = TRUE;
            multi_boot = FALSE;

            t = argv[i] + 2;
            if (*t == 0) // No emulation
                default_boot_entry.boot_emu_type = 0;
            else // ID in decimal
                default_boot_entry.boot_emu_type = (BYTE)strtoul(t, NULL, 10);
        }
        else if (strncmp(argv[i], "-p", 2) == 0)
        {
            // Check whether the multi-boot option '-bootdata:' was already set.
            // If so, print an error and bail out.
            if (eltorito && multi_boot)
                error_exit("Single-boot and multi-boot entries cannot be combined");

            eltorito   = TRUE;
            multi_boot = FALSE;

            // Platform ID in hexadecimal
            boot_validation_header.platform_id = (BYTE)strtoul(argv[i] + 2, NULL, 16);
        }
        else if (strcmp(argv[i], "-b") == 0)
        {
            // Check whether the multi-boot option '-bootdata:' was already set.
            // If so, print an error and bail out.
            if (eltorito && multi_boot)
                error_exit("Single-boot and multi-boot entries cannot be combined");

            eltorito   = TRUE;
            multi_boot = FALSE;

            strncpy(default_boot_entry.bootimage, argv[++i], sizeof(default_boot_entry.bootimage));
            default_boot_entry.bootimage[sizeof(default_boot_entry.bootimage)-1] = '\0';
        }
        else if (strncmp(argv[i], "-bootdata:", sizeof("-bootdata:") - 1) == 0)
        {
            char *bootdata, *entry_ctx, *option_ctx;
            DWORD num_boot_entries = 0;

            BOOL default_entry = TRUE; // Start by setting the default boot entry
            PBOOT_HEADER boot_header = NULL; // Current boot header
            PBOOT_ENTRY  boot_entry  = NULL; // The last boot entry in the current boot header
            BYTE platform_id, old_platform_id = 0;
            BYTE boot_emu_type;
            WORD load_segment;
            char bootimage[512];

            // Check whether the single-boot option '-b' was already set.
            // If so, print an error and bail out.
            if (eltorito && !multi_boot)
                error_exit("Single-boot and multi-boot entries cannot be combined");

            t = argv[i] + (sizeof("-bootdata:") - 1);
            bootdata = strdup(t);
            if (bootdata == NULL)
                error_exit("Insufficient memory");

            eltorito   = TRUE;
            multi_boot = TRUE;

            // FIXME: Paths containing '#' or ',' or ' ' are not yet supported!!

            // Start parsing...
            t = strtok_s(bootdata, "#", &entry_ctx);
            if (t == NULL)
            {
                free(bootdata);
                error_exit("Malformed bootdata command");
            }

            num_boot_entries = strtoul(t, NULL, 10);

            while (num_boot_entries--)
            {
                // Reset to default values
                platform_id   = 0;  // x86/64 BIOS system
                boot_emu_type = 0;  // No emulation
                load_segment  = 0;  // Use default 0x07C0
                bootimage[0]  = '\0';

                t = strtok_s(NULL, "#", &entry_ctx);
                if (t == NULL)
                {
                    free(bootdata);
                    error_exit("Malformed bootdata command");
                }

                t = strtok_s(t, ",", &option_ctx);
                while (t != NULL)
                {
                    switch (*t++)
                    {
                        case 'b': // Boot sector file
                        {
                            char *q;

                            // Searches for any of the valid separators:
                            // '#' starts a new boot entry;
                            // ',' starts a new boot option;
                            // ' ' finishes the bootdata command.
                            q = strpbrk(t, "#, ");
                            if (!q) q = t + strlen(t);
                            strncpy(bootimage, t, q - t + 1);
                            break;
                        }

                        case 'p': // Platform ID
                        {
                            // Platform ID in hexadecimal
                            platform_id = (BYTE)strtoul(t, NULL, 16);
                            break;
                        }

                        case 'e': // No floppy-disk emulation
                        {
                            if (*t == 0) // No emulation
                                boot_emu_type = 0;
                            else // ID in decimal
                                boot_emu_type = (BYTE)strtoul(t, NULL, 10);

                            break;
                        }

                        case 't': // Loading segment
                        {
                            if (*t == 0) // Not specified: use default 0x07C0
                                load_segment = 0;
                            else // Segment in hexadecimal
                                load_segment = (BYTE)strtoul(t, NULL, 16);

                            break;
                        }

                        default:
                            free(bootdata);
                            error_exit("Malformed bootdata command");
                    }

                    t = strtok_s(NULL, ",", &option_ctx);
                }

                // Create a new entry and possibly a boot header
                if (default_entry)
                {
                    // Initialize the default boot entry and header

                    boot_validation_header.header_id   = 1;  // Validation header ID
                    boot_validation_header.platform_id = platform_id;

                    init_boot_entry(&default_boot_entry, boot_emu_type, load_segment, bootimage);

                    // Default entry is now initialized.
                    default_entry = FALSE;
                }
                else
                {
                    // Initialize a new boot entry
                    PBOOT_ENTRY old_boot_entry = boot_entry;

                    boot_entry = calloc(1, sizeof(*boot_entry));
                    if (boot_entry == NULL)
                        error_exit("Insufficient memory");
                    // boot_entry->next_entry = NULL;

                    init_boot_entry(boot_entry, boot_emu_type, load_segment, bootimage);

                    // Create a new boot header if we don't have one yet
                    if (boot_header == NULL)
                    {
                        boot_header = calloc(1, sizeof(*boot_header));
                        if (boot_header == NULL)
                            error_exit("Insufficient memory");

                        boot_header->header_id   = 0x91; // So far this is the last boot header
                        boot_header->platform_id = platform_id;
                        // boot_header->next_header = NULL;
                        // boot_header->num_entries = 0;
                        // boot_header->entry_list  = NULL;

                        old_boot_entry  = NULL;
                        old_platform_id = platform_id;

                        boot_header_list = boot_header;
                    }
                    else
                    {
                        // Create a new boot header if we change the platform ID
                        if (old_platform_id != platform_id)
                        {
                            PBOOT_HEADER prev_boot_header = boot_header;

                            boot_header = calloc(1, sizeof(*boot_header));
                            if (boot_header == NULL)
                                error_exit("Insufficient memory");

                            boot_header->header_id   = 0x91; // So far this is the last boot header
                            boot_header->platform_id = platform_id;
                            // boot_header->next_header = NULL;
                            // boot_header->num_entries = 0;
                            // boot_header->entry_list  = NULL;

                            old_boot_entry  = NULL;
                            old_platform_id = platform_id;

                            // Link into the header list
                            prev_boot_header->header_id = 0x90; // The previous boot header was not the last one
                            prev_boot_header->next_header = boot_header;
                        }
                    }

                    // Add the entry into the header
                    ++boot_header->num_entries;
                    if (old_boot_entry == NULL)
                        boot_header->entry_list = boot_entry;
                    else
                        old_boot_entry->next_entry = boot_entry;
                }
            }

            free(bootdata);
        }
        else if (strcmp(argv[i], "-q") == 0)
            scan_files_only = TRUE;
        // else if (strcmp(argv[i], "-x") == 0)
        //     compute_crc = TRUE;
        else if (i + 2 < argc)
        {
            strcpy(source, argv[i++]);
            strncpy(volume_label, argv[i++], sizeof(volume_label) - 1);
            strcpy(cd.filespecs, argv[i]);
        }
        else
            error_exit("Missing command line argument");
    }

    if (source[0] == 0)
        error_exit("Missing source directory");
    if (volume_label[0] == 0)
        error_exit("Missing volume label");
    if (cd.filespecs[0] == 0)
        error_exit("Missing image file specifications");

    if (source[0] != '@')
    {
        /* set source[] and end_source to source directory,
         * with a terminating directory separator */
        end_source = source + strlen(source);
        if (end_source[-1] == ':')
            *end_source++ = '.';
        if (end_source[-1] != DIR_SEPARATOR_CHAR)
            *end_source++ = DIR_SEPARATOR_CHAR;

        /* scan all files and create directory structure in memory */
        make_directory_records(&root);
    }
    else
    {
        char *trimmedline, *targetname, *normdir, *srcname, *eq;
        char lineread[1024];

        FILE *f = fopen(source+1, "r");
        if (!f)
        {
            error_exit("Cannot open CD-ROM file description '%s'\n", source+1);
        }
        while (fgets(lineread, sizeof(lineread), f))
        {
            /* We treat these characters as line endings */
            trimmedline = strtok(lineread, "\t\r\n;");
            eq = strchr(trimmedline, '=');
            if (!eq)
            {
                /* Treat this as a directory name */
                targetname = trimmedline;
                normdir = strdup(targetname);
                normalize_dirname(normdir);
                dir_hash_create_dir(&specified_files, targetname, normdir);
                free(normdir);
            }
            else
            {
                targetname = strtok(lineread, "=");
                srcname = strtok(NULL, "");

#ifdef _WIN32
                if (_access(srcname, R_OK) == 0)
#else
                if (access(srcname, R_OK) == 0)
#endif
                {
                    if (!dir_hash_add_file(&specified_files, srcname, targetname))
                        error_exit("Target '%s' (file '%s') is invalid\n", targetname, srcname);
                }
                else
                    error_exit("Cannot access file '%s' (target '%s')\n", srcname, targetname);
            }
        }
        fclose(f);

        /* scan all files and create directory structure in memory */
        scan_specified_files(&root, &specified_files.root);
    }

    /* sort path table entries */
    root.next_in_path_table = sort_linked_list(root.next_in_path_table,
                                               1,
                                               compare_path_table_order);

    // initialize CD-ROM write buffer

    cd.file = NULL;
    cd.sector = 0;
    cd.offset = 0;
    cd.count  = 0;

    // make non-writing pass over directory structure to obtain the proper
    // sector numbers and offsets and to determine the size of the image

    number_of_files = bytes_in_files = number_of_directories =
    bytes_in_directories = unused_bytes_at_ends_of_files = 0;
    pass();

    if (verbosity >= NORMAL)
    {
        printf("%s bytes ", edit_with_commas(bytes_in_files, TRUE));
        printf("in %s files\n", edit_with_commas(number_of_files, FALSE));
        printf("%s unused bytes at ends of files\n",
            edit_with_commas(unused_bytes_at_ends_of_files, TRUE));
        printf("%s bytes ", edit_with_commas(bytes_in_directories, TRUE));
        printf("in %s directories\n",
            edit_with_commas(number_of_directories, FALSE));
        printf("%s other bytes\n", edit_with_commas(root.sector * SECTOR_SIZE, TRUE));
        puts("-------------");
        printf("%s total bytes\n",
            edit_with_commas(total_sectors * SECTOR_SIZE, TRUE));
        puts("=============");
    }

    if (size_limit != 0 && total_sectors > size_limit)
        error_exit("Size limit exceeded");

    if (!scan_files_only)
    {
        // re-initialize CD-ROM write buffer

        cd.file = fopen(cd.filespecs, "w+b");
        if (cd.file == NULL)
            error_exit("Cannot open image file '%s'", cd.filespecs);
        cd.sector = 0;
        cd.offset = 0;
        cd.count  = 0;


        // make writing pass over directory structure

        pass();

        if (cd.count > 0)
            flush_buffer();
        if (show_progress)
            printf("\r             \n");
        if (fclose(cd.file) != 0)
        {
            cd.file = NULL;
            error_exit("File write error in image file '%s'", cd.filespecs);
        }

        if (verbosity >= NORMAL)
            puts("CD-ROM image made successfully");
    }

    dir_hash_destroy(&specified_files);
    release_memory();
    return 0;
}

make_directory_records()

static void make_directory_records ( PDIR_RECORD  d )

static

Definition at line 965 of file cdmake.c.

{
    PDIR_RECORD new_d;
    DIR *dirp;
    struct dirent *entry;
    char *old_end_source;
    struct stat stbuf;
    char buf[MAX_PATH];

    d->first_record = NULL;

#ifdef HAVE_D_TYPE
    dirp = opendir(source);
    if (dirp != NULL)
    {
        while ((entry = readdir(dirp)) != NULL)
        {
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
                continue; // skip self and parent

            if (entry->d_type == DT_REG) // normal file
            {
                // Check for an absolute path
                if (source[0] == DIR_SEPARATOR_CHAR)
                {
                    strcpy(buf, source);
                    strcat(buf, DIR_SEPARATOR_STRING);
                    strcat(buf, entry->d_name);
                }
                else
                {
                    if (!getcwd(buf, sizeof(buf)))
                        error_exit("Cannot get CWD: %s\n", strerror(errno));
                    strcat(buf, DIR_SEPARATOR_STRING);
                    strcat(buf, source);
                    strcat(buf, entry->d_name);
                }

                if (stat(buf, &stbuf) == -1)
                {
                    error_exit("Cannot access '%s' (%s)\n", buf, strerror(errno));
                    return;
                }

                if (strcmp(entry->d_name, DIRECTORY_TIMESTAMP) == 0)
                {
                    convert_date_and_time(&d->date_and_time, &stbuf.st_ctime);
                }
                else
                {
                    if (verbosity == VERBOSE)
                    {
                        printf("%d: file %s\n", d->level, buf);
                    }
                    (void) new_directory_record(entry, &stbuf, d);
                }
            }
        }
        closedir(dirp);
    }
    else
    {
        error_exit("Cannot open '%s'\n", source);
        return;
    }

    dirp = opendir(source);
    if (dirp != NULL)
    {
        while ((entry = readdir(dirp)) != NULL)
        {
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
                continue; // skip self and parent

            if (entry->d_type == DT_DIR) // directory
            {
                old_end_source = end_source;
                append_string_to_source(entry->d_name);
                *end_source++ = DIR_SEPARATOR_CHAR;
                *end_source = 0;
                if (verbosity == VERBOSE)
                {
                    printf("%d: directory %s\n", d->level + 1, source);
                }
                if (d->level < MAX_LEVEL)
                {
                    // Check for an absolute path
                    if (source[0] == DIR_SEPARATOR_CHAR)
                    {
                        strcpy(buf, source);
                    }
                    else
                    {
                        if (!getcwd(buf, sizeof(buf)))
                            error_exit("Cannot get CWD: %s\n", strerror(errno));
                        strcat(buf, DIR_SEPARATOR_STRING);
                        strcat(buf, source);
                    }

                    if (stat(buf, &stbuf) == -1)
                    {
                        error_exit("Cannot access '%s' (%s)\n", buf, strerror(errno));
                        return;
                    }
                    new_d = new_directory_record(entry, &stbuf, d);
                    new_d->next_in_path_table = root.next_in_path_table;
                    root.next_in_path_table = new_d;
                    new_d->level = d->level + 1;
                    make_directory_records(new_d);
                }
                else
                {
                    error_exit("Directory is nested too deep");
                }
                end_source = old_end_source;
                *end_source = 0;
            }
        }
        closedir(dirp);
    }
    else
    {
        error_exit("Cannot open '%s'\n", source);
        return;
    }

#else

    dirp = opendir(source);
    if (dirp != NULL)
    {
        while ((entry = readdir(dirp)) != NULL)
        {
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
                continue; // skip self and parent

            // Check for an absolute path
            if (source[0] == DIR_SEPARATOR_CHAR)
            {
                strcpy(buf, source);
                strcat(buf, DIR_SEPARATOR_STRING);
                strcat(buf, entry->d_name);
            }
            else
            {
                if (!getcwd(buf, sizeof(buf)))
                    error_exit("Cannot get CWD: %s\n", strerror(errno));
                strcat(buf, DIR_SEPARATOR_STRING);
                strcat(buf, source);
                strcat(buf, entry->d_name);
            }

            if (stat(buf, &stbuf) == -1)
            {
                error_exit("Cannot access '%s' (%s)\n", buf, strerror(errno));
                return;
            }

            if (S_ISDIR(stbuf.st_mode))
            {
                old_end_source = end_source;
                append_string_to_source(entry->d_name);
                *end_source++ = DIR_SEPARATOR_CHAR;
                *end_source = 0;
                if (verbosity == VERBOSE)
                {
                    printf("%d: directory %s\n", d->level + 1, source);
                }

                if (d->level < MAX_LEVEL)
                {
                    new_d = new_directory_record(entry, &stbuf, d);
                    new_d->next_in_path_table = root.next_in_path_table;
                    root.next_in_path_table = new_d;
                    new_d->level = d->level + 1;
                    make_directory_records(new_d);
                }
                else
                {
                    error_exit("Directory is nested too deep");
                }

                end_source = old_end_source;
                *end_source = 0;
            }
            else if (S_ISREG(stbuf.st_mode))
            {
                if (strcmp(entry->d_name, DIRECTORY_TIMESTAMP) == 0)
                {
                    convert_date_and_time(&d->date_and_time, &stbuf.st_ctime);
                }
                else
                {
                    if (verbosity == VERBOSE)
                    {
                        printf("%d: file %s\n", d->level, buf);
                    }
                    (void) new_directory_record(entry, &stbuf, d);
                }
            }
        }
        closedir(dirp);
    }
    else
    {
        error_exit("Cannot open '%s'\n", source);
        return;
    }

#endif

    // sort directory
    d->first_record = sort_linked_list(d->first_record, 0, compare_directory_order);
}

Referenced by main().

new_directory_record()

PDIR_RECORD new_directory_record	(	struct dirent *	entry,
		struct stat *	stbuf,
		PDIR_RECORD	parent
	)

Definition at line 797 of file cdmake.c.

{
    PDIR_RECORD d;

    d = calloc(1, sizeof(*d));
    if (d == NULL)
        error_exit("Insufficient memory");
    d->next_in_memory = root.next_in_memory;
    root.next_in_memory = d;

    /* I need the parent set before calling parse_filename_into_dirrecord(),
    because that functions checks for duplicate file names*/
    d->parent = parent;
#ifdef HAVE_D_TYPE
    parse_filename_into_dirrecord(entry->d_name, d, entry->d_type == DT_DIR);
#else
    parse_filename_into_dirrecord(entry->d_name, d, S_ISDIR(stbuf->st_mode));
#endif

    convert_date_and_time(&d->date_and_time, &stbuf->st_mtime);
    d->flags |= entry->d_name[0] == '.' ? HIDDEN_FLAG : 0;
    d->size = d->joliet_size = stbuf->st_size;
    d->next_in_directory = parent->first_record;
    parent->first_record = d;
    return d;
}

Referenced by make_directory_records().

new_empty_dirrecord()

static PDIR_RECORD new_empty_dirrecord ( PDIR_RECORD  d, BOOL  directory  )

static

Definition at line 1183 of file cdmake.c.

{
    PDIR_RECORD new_d;
    new_d = calloc(1, sizeof(*new_d));
    new_d->parent = d;
    new_d->level = d->level + 1;
    new_d->next_in_directory = d->first_record;
    d->first_record = new_d;
    new_d->next_in_memory = root.next_in_memory;
    root.next_in_memory = new_d;
    new_d->date_and_time = d->date_and_time;
    if (directory)
    {
        new_d->flags |= DIRECTORY_FLAG;
        new_d->next_in_path_table = root.next_in_path_table;
        root.next_in_path_table = new_d;
    }
    return new_d;
}

Referenced by scan_specified_files().

parse_filename_into_dirrecord()

static void parse_filename_into_dirrecord ( const char *  filename, PDIR_RECORD  d, BOOL  dir  )

static

Definition at line 668 of file cdmake.c.

{
    const char *s = filename;
    char *t = d->name_on_cd;
    char *n = d->name;
    int joliet_length;
    int filename_counter;
    filename_counter = 1;
    while (*s != 0)
    {
        if (*s == '.')
        {
            s++;
            break;
        }

        if ((size_t)(t-d->name_on_cd) < sizeof(d->name_on_cd)-1)
            *t++ = check_for_punctuation(*s, filename);
        else if (!joliet)
            error_exit("'%s' is not ISO-9660, aborting...", filename);

        if ((size_t)(n-d->name) < sizeof(d->name)-1)
            *n++ = *s;
        else if (!joliet)
            error_exit("'%s' is not ISO-9660, aborting...", filename);
        s++;
    }
    // Check for extension length
    if (!joliet && strlen(s) > MAX_EXTENSION_LENGTH)
    {
        error_exit("'%s' has too long extension, aborting...", filename);
    }
    *t = 0;
    strcpy(d->extension, s);
    t = d->extension_on_cd;
    while (*s != 0)
    {
        if ((size_t)(t-d->extension_on_cd) < sizeof(d->extension_on_cd)-1)
            *t++ = check_for_punctuation(*s, filename);
        else if (!joliet)
            error_exit("'%s' is not ISO-9660, aborting...", filename);
        s++;
    }
    *t = 0;
    *n = 0;

    if (dir)
    {
        if (d->extension[0] != 0)
        {
            if (!joliet)
                error_exit("Directory with extension '%s'", filename);
        }
        d->flags = DIRECTORY_FLAG;
    } else
    {
        d->flags = 0;
    }

    filename_counter = 1;
    while (cdname_exists(d))
    {
        // the file name must be at least 8 chars long
        if (strlen(d->name_on_cd)<8)
            error_exit("'%s' is a duplicate file name, aborting...", filename);

        if ((d->name_on_cd[8] == '.') && (strlen(d->name_on_cd) < 13))
            error_exit("'%s' is a duplicate file name, aborting...", filename);

        // max 255 times for equal short filename
        if (filename_counter>255)
            error_exit("'%s' is a duplicate file name, aborting...", filename);

        d->name_on_cd[8] = '~';
        memset(&d->name_on_cd[9],0,5);
        sprintf(&d->name_on_cd[9],"%d",filename_counter);
        filename_counter++;
    }

    if (joliet)
    {
        joliet_length = strlen(filename);
        if (joliet_length > 64)
            error_exit("'%s' is not Joliet, aborting...", filename);
        d->joliet_name = malloc(joliet_length + 1);
        if (d->joliet_name == NULL)
            error_exit("Insufficient memory");
        strcpy(d->joliet_name, filename);
    }
}

Referenced by new_directory_record(), and scan_specified_files().

pass()

static void pass ( void  )

static

Definition at line 1410 of file cdmake.c.

{
    PDIR_RECORD d, q;
    unsigned int index;
    unsigned int name_length;
    DWORD size;
    DWORD number_of_sectors;
    char *old_end_source;
    FILE *file;

    PBOOT_HEADER header;
    PBOOT_ENTRY  entry;

    char timestring[17];

    get_time_string(timestring);

    // first 16 sectors are zeros
    write_block(16 * SECTOR_SIZE, 0);


    // Primary Volume Descriptor
    if (make_bridged_udf)
    {
        write_string("\1CD001\1");
        write_byte(0);
        write_bytecounted_string(32, "", ' ');           // system identifier
        write_bytecounted_string(32, volume_label, ' '); // volume label

        write_block(8, 0);
        write_both_endian_dword(total_sectors);
        write_block(32, 0);
        write_both_endian_word(1); // volume set size
        write_both_endian_word(1); // volume sequence number
        write_both_endian_word(2048); // sector size
        write_both_endian_dword(path_table_size);
        write_little_endian_dword(little_endian_path_table_sector);
        write_little_endian_dword(0);  // second little endian path table
        write_big_endian_dword(big_endian_path_table_sector);
        write_big_endian_dword(0);  // second big endian path table
        write_directory_record(&root, DOT_RECORD, FALSE);

        write_bytecounted_string(128, volume_label, ' '); // volume set identifier
        write_bytecounted_string(128, PUBLISHER_ID, ' '); // publisher identifier
        write_bytecounted_string(128, DATA_PREP_ID, ' '); // data preparer identifier
        write_bytecounted_string(128, APP_ID, ' ');       // application identifier

        write_bytecounted_string(37, "", ' '); // copyright file identifier
        write_bytecounted_string(37, "", ' '); // abstract file identifier
        write_bytecounted_string(37, "", ' '); // bibliographic file identifier

        write_string(timestring);  // volume creation
        write_byte(0);
        write_string(timestring);  // most recent modification
        write_byte(0);
        write_string("0000000000000000");  // volume expires
        write_byte(0);
        write_string("0000000000000000");  // volume is effective
        write_byte(0);
        write_byte(1);
        write_byte(0);
        fill_sector();
    }

    // Boot Volume Descriptor
    if (eltorito)
    {
        write_byte(0);  // Boot record ID
        write_string("CD001\1");
        write_bytecounted_string(32, "EL TORITO SPECIFICATION", 0); // El-Torito identifier
        write_block(32, 0);  // unused
        write_little_endian_dword(boot_catalog_sector);  // pointer to boot catalog
        fill_sector();
    }

    // Supplementary Volume Descriptor
    if (joliet)
    {
        write_string("\2CD001\1");
        write_byte(0);
        write_bytecounted_string_as_big_endian_unicode(32, "", ' ');           // system identifier
        write_bytecounted_string_as_big_endian_unicode(32, volume_label, ' '); // volume label

        write_block(8, 0);
        write_both_endian_dword(total_sectors);
        write_string("%/E");
        write_block(29, 0);
        write_both_endian_word(1); // volume set size
        write_both_endian_word(1); // volume sequence number
        write_both_endian_word(2048); // sector size
        write_both_endian_dword(joliet_path_table_size);
        write_little_endian_dword(joliet_little_endian_path_table_sector);
        write_little_endian_dword(0);  // second little endian path table
        write_big_endian_dword(joliet_big_endian_path_table_sector);
        write_big_endian_dword(0);  // second big endian path table
        write_directory_record(&root, DOT_RECORD, TRUE);

        write_bytecounted_string_as_big_endian_unicode(128, volume_label, ' '); // volume set identifier
        write_bytecounted_string_as_big_endian_unicode(128, PUBLISHER_ID, ' '); // publisher identifier
        write_bytecounted_string_as_big_endian_unicode(128, DATA_PREP_ID, ' '); // data preparer identifier
        write_bytecounted_string_as_big_endian_unicode(128, APP_ID, ' ');       // application identifier

        write_bytecounted_string_as_big_endian_unicode(37, "", ' '); // copyright file identifier
        write_bytecounted_string_as_big_endian_unicode(37, "", ' '); // abstract file identifier
        write_bytecounted_string_as_big_endian_unicode(37, "", ' '); // bibliographic file identifier

        write_string(timestring);  // volume creation
        write_byte(0);
        write_string(timestring);  // most recent modification
        write_byte(0);
        write_string("0000000000000000");  // volume expires
        write_byte(0);
        write_string("0000000000000000");  // volume is effective
        write_byte(0);
        write_byte(1);
        write_byte(0);
        fill_sector();
    }

    // Volume Descriptor Set Terminator
    if (make_bridged_udf)
    {
        write_string("\377CD001\1");
        fill_sector();
    }

    // TODO: Add UDF support!

    // Boot Catalog
    if (eltorito)
    {
        boot_catalog_sector = cd.sector;

        // Validation entry header
        write_byte(boot_validation_header.header_id);
        write_byte(boot_validation_header.platform_id);
        write_little_endian_word(0);  // reserved
        write_bytecounted_string(24, MANUFACTURER_ID, 0); // Manufacturer identifier
        write_little_endian_word(0x62E);  // checksum // FIXME: This is hardcoded!!
        write_little_endian_word(0xAA55);  // signature

        // Default entry
        write_byte(default_boot_entry.boot_id);
        write_byte(default_boot_entry.boot_emu_type);
        write_little_endian_word(default_boot_entry.load_segment);
        write_byte(0);  // partition type
        write_byte(0);  // unused
        write_little_endian_word(default_boot_entry.sector_count);
        write_little_endian_dword(default_boot_entry.load_rba);
        write_block(20, 0); // unused

        // Loop through each boot header
        header = boot_header_list;
        while (header)
        {
            write_byte(header->header_id);
            write_byte(header->platform_id);
            write_little_endian_word(header->num_entries);
            write_block(28, 0); // Identifier string (unused)

            // Loop through each boot entry
            entry = header->entry_list;
            while (entry)
            {
                write_byte(entry->boot_id);
                write_byte(entry->boot_emu_type);
                write_little_endian_word(entry->load_segment);
                write_byte(0);  // partition type
                write_byte(0);  // unused
                write_little_endian_word(entry->sector_count);
                write_little_endian_dword(entry->load_rba);
                write_block(20, 0); // Selection criteria (unused)

                entry = entry->next_entry;
            }

            header = header->next_header;
        }

        fill_sector();
    }


    // Boot Images
    if (eltorito)
    {
        default_boot_entry.load_rba = cd.sector;

        file = fopen(default_boot_entry.bootimage, "rb");
        if (file == NULL)
            error_exit("Cannot open '%s'\n", default_boot_entry.bootimage);
        fseek(file, 0, SEEK_END);
        size = ftell(file);
        if (size == 0 || (size % 2048))
        {
            fclose(file);
            error_exit("Invalid boot image size (%lu bytes)\n", size);
        }
        // Sector count in 512 byte sectors and rounded up
        default_boot_entry.sector_count = (size + 511) / 512;
        if (!write_from_file(file, size))
        {
            fclose(file);
            error_exit("Read error in file '%s'\n", default_boot_entry.bootimage);
        }
        fclose(file);

        // Loop through each boot header
        header = boot_header_list;
        while (header)
        {
            // Loop through each boot entry
            entry = header->entry_list;
            while (entry)
            {
                entry->load_rba = cd.sector;

                file = fopen(entry->bootimage, "rb");
                if (file == NULL)
                    error_exit("Cannot open '%s'\n", entry->bootimage);
                fseek(file, 0, SEEK_END);
                size = ftell(file);
                if (size == 0 || (size % 2048))
                {
                    fclose(file);
                    error_exit("Invalid boot image size (%lu bytes)\n", size);
                }
                // Sector count in 512 byte sectors and rounded up
                entry->sector_count = (size + 511) / 512;
                if (!write_from_file(file, size))
                {
                    fclose(file);
                    error_exit("Read error in file '%s'\n", entry->bootimage);
                }
                fclose(file);

                entry = entry->next_entry;
            }

            header = header->next_header;
        }

//      fill_sector();
    }


    // Little Endian Path Table

    little_endian_path_table_sector = cd.sector;
    write_byte(1);
    write_byte(0);  // number of sectors in extended attribute record
    write_little_endian_dword(root.sector);
    write_little_endian_word(1);
    write_byte(0);
    write_byte(0);

    index = 1;
    root.path_table_index = 1;
    for (d = root.next_in_path_table; d != NULL; d = d->next_in_path_table)
    {
        name_length = strlen(d->name_on_cd);
        write_byte((BYTE)name_length);
        write_byte(0);  // number of sectors in extended attribute record
        write_little_endian_dword(d->sector);
        write_little_endian_word(d->parent->path_table_index);
        write_string(d->name_on_cd);
        if (name_length & 1)
            write_byte(0);
        d->path_table_index = ++index;
    }

    path_table_size = (cd.sector - little_endian_path_table_sector) *
                       SECTOR_SIZE + cd.offset;
    fill_sector();


    // Big Endian Path Table

    big_endian_path_table_sector = cd.sector;
    write_byte(1);
    write_byte(0);  // number of sectors in extended attribute record
    write_big_endian_dword(root.sector);
    write_big_endian_word(1);
    write_byte(0);
    write_byte(0);

    for (d = root.next_in_path_table; d != NULL; d = d->next_in_path_table)
    {
        name_length = strlen(d->name_on_cd);
        write_byte((BYTE)name_length);
        write_byte(0);  // number of sectors in extended attribute record
        write_big_endian_dword(d->sector);
        write_big_endian_word(d->parent->path_table_index);
        write_string(d->name_on_cd);
        if (name_length & 1)
            write_byte(0);
    }
    fill_sector();

    if (joliet)
    {
        // Little Endian Path Table

        joliet_little_endian_path_table_sector = cd.sector;
        write_byte(1);
        write_byte(0);  // number of sectors in extended attribute record
        write_little_endian_dword(root.joliet_sector);
        write_little_endian_word(1);
        write_byte(0);
        write_byte(0);

        for (d = root.next_in_path_table; d != NULL; d = d->next_in_path_table)
        {
            name_length = strlen(d->joliet_name) * 2;
            write_byte((BYTE)name_length);
            write_byte(0);  // number of sectors in extended attribute record
            write_little_endian_dword(d->joliet_sector);
            write_little_endian_word(d->parent->path_table_index);
            write_string_as_big_endian_unicode(d->joliet_name);
        }

        joliet_path_table_size = (cd.sector - joliet_little_endian_path_table_sector) *
                                  SECTOR_SIZE + cd.offset;
        fill_sector();

        // Big Endian Path Table

        joliet_big_endian_path_table_sector = cd.sector;
        write_byte(1);
        write_byte(0);  // number of sectors in extended attribute record
        write_big_endian_dword(root.joliet_sector);
        write_big_endian_word(1);
        write_byte(0);
        write_byte(0);

        for (d = root.next_in_path_table; d != NULL; d = d->next_in_path_table)
        {
            name_length = strlen(d->joliet_name) * 2;
            write_byte((BYTE)name_length);
            write_byte(0);  // number of sectors in extended attribute record
            write_big_endian_dword(d->joliet_sector);
            write_big_endian_word(d->parent->path_table_index);
            write_string_as_big_endian_unicode(d->joliet_name);
        }
        fill_sector();
    }

    // TODO: Add UDF support!

#if 0
    // Boot Images ??
#endif

    // TODO: Add CRC block for header!

    // Directories and files
    for (d = &root; d != NULL; d = d->next_in_path_table)
    {
        // write directory
        d->sector = cd.sector;
        write_directory_record(d, DOT_RECORD, FALSE);
        write_directory_record(d == &root ? d : d->parent, DOT_DOT_RECORD, FALSE);
        for (q = d->first_record; q != NULL; q = q->next_in_directory)
        {
            write_directory_record(q,
                                   q->flags & DIRECTORY_FLAG ? SUBDIRECTORY_RECORD : FILE_RECORD,
                                   FALSE);
        }
        fill_sector();
        d->size = (cd.sector - d->sector) * SECTOR_SIZE;

        // write directory for joliet
        if (joliet)
        {
            d->joliet_sector = cd.sector;
            write_directory_record(d, DOT_RECORD, TRUE);
            write_directory_record(d == &root ? d : d->parent, DOT_DOT_RECORD, TRUE);
            for (q = d->first_record; q != NULL; q = q->next_in_directory)
            {
                write_directory_record(q,
                                       q->flags & DIRECTORY_FLAG ? SUBDIRECTORY_RECORD : FILE_RECORD,
                                       TRUE);
            }
            fill_sector();
            d->joliet_size = (cd.sector - d->joliet_sector) * SECTOR_SIZE;
            bytes_in_directories += d->joliet_size;
        }

        number_of_directories++;
        bytes_in_directories += d->size;

        // write file data
        for (q = d->first_record; q != NULL; q = q->next_in_directory)
        {
            if ((q->flags & DIRECTORY_FLAG) == 0)
            {
                q->sector = q->joliet_sector = cd.sector;
                size = q->size;
                if (cd.file == NULL)
                {
                    number_of_sectors = (size + SECTOR_SIZE - 1) / SECTOR_SIZE;
                    cd.sector += number_of_sectors;
                    number_of_files++;
                    bytes_in_files += size;
                    unused_bytes_at_ends_of_files +=
                    number_of_sectors * SECTOR_SIZE - size;
                }
                else
                {
                    const char *file_source;
                    old_end_source = end_source;
                    if (!q->orig_name)
                    {
                        get_file_specifications(q);
                        *end_source = 0;
                        file_source = source;
                    }
                    else
                    {
                        file_source = q->orig_name;
                    }
                    if (verbosity == VERBOSE)
                        printf("Writing contents of %s\n", file_source);
                    file = fopen(file_source, "rb");
                    if (file == NULL)
                        error_exit("Cannot open '%s'\n", file_source);
                    if (!write_from_file(file, size))
                    {
                        fclose(file);
                        error_exit("Read error in file '%s'\n", file_source);
                    }
                    fclose(file);
                    end_source = old_end_source;
                    fill_sector();
                }
            }
        }
    }

    // TODO: Add final CRC block!

    total_sectors = (DWORD)cd.sector;
}

Referenced by main().

release_memory()

static void release_memory ( void  )

static

Definition at line 275 of file cdmake.c.

{
    while (boot_header_list)
    {
        PBOOT_HEADER next_header = boot_header_list->next_header;

        while (boot_header_list->entry_list)
        {
            PBOOT_ENTRY next_entry = boot_header_list->entry_list->next_entry;
            free(boot_header_list->entry_list);
            boot_header_list->entry_list = next_entry;
        }

        free(boot_header_list);
        boot_header_list = next_header;
    }

    while (root.next_in_memory != NULL)
    {
        PDIR_RECORD next = root.next_in_memory->next_in_memory;
        if (joliet)
            free(root.next_in_memory->joliet_name);
        free(root.next_in_memory);
        root.next_in_memory = next;
    }
    if (joliet)
        free(root.joliet_name);

    if (cd.buffer != NULL)
    {
        free(cd.buffer);
        cd.buffer = NULL;
    }
}

Referenced by error_exit(), and main().

scan_specified_files()

static void scan_specified_files ( PDIR_RECORD  d, struct target_dir_entry *  dir  )

static

Definition at line 1228 of file cdmake.c.

{
    PDIR_RECORD new_d;
#ifdef _WIN32
    HANDLE open_file;
    LARGE_INTEGER file_size;
#else
    struct stat stbuf;
#endif
    struct target_file *file;
    struct target_dir_entry *child;

    d->first_record = NULL;

    for (file = dir->head; file; file = file->next)
    {
        if (strcmp(file->target_name, DIRECTORY_TIMESTAMP) == 0)
        {
#ifdef _WIN32
            if ((open_file = CreateFileA(file->source_name,
                                         GENERIC_READ,
                                         FILE_SHARE_READ,
                                         NULL,
                                         OPEN_EXISTING,
                                         FILE_ATTRIBUTE_NORMAL,
                                         NULL)) == INVALID_HANDLE_VALUE)
            {
                error_exit("Cannot open timestamp file '%s'\n", file->source_name);
            }

            if (!get_cd_file_time(open_file, &d->date_and_time))
            {
                error_exit("Cannot stat timestamp file '%s'\n", file->source_name);
            }
            CloseHandle(open_file);
#else
            if (stat(file->target_name, &stbuf) == -1)
            {
                error_exit("Cannot stat timestamp file '%s'\n", file->source_name);
            }
            convert_date_and_time(&d->date_and_time, &stbuf.st_ctime);
#endif
        }
        else
        {
            if (verbosity == VERBOSE)
            {
                printf("%d: file %s (from %s)\n",
                       d->level,
                       file->target_name,
                       file->source_name);
            }
            new_d = new_empty_dirrecord(d, FALSE);
            parse_filename_into_dirrecord(file->target_name, new_d, FALSE);
#ifdef _WIN32
            if ((open_file = CreateFileA(file->source_name,
                                         GENERIC_READ,
                                         FILE_SHARE_READ,
                                         NULL,
                                         OPEN_EXISTING,
                                         FILE_ATTRIBUTE_NORMAL,
                                         NULL)) == INVALID_HANDLE_VALUE)
            {
                error_exit("Cannot open file '%s'\n", file->source_name);
            }
            if (!get_cd_file_time(open_file, &new_d->date_and_time))
            {
                error_exit("Cannot stat file '%s'\n", file->source_name);
            }
            if (!GetFileSizeEx(open_file, &file_size))
            {
                error_exit("Cannot get file size of '%s'\n", file->source_name);
            }
            new_d->size = new_d->joliet_size = file_size.QuadPart;
            new_d->orig_name = file->source_name;
            CloseHandle(open_file);
#else
            if (stat(file->source_name, &stbuf) == -1)
            {
                error_exit("Cannot find '%s' (target '%s')\n",
                           file->source_name,
                           file->target_name);
            }
            convert_date_and_time(&new_d->date_and_time, &stbuf.st_mtime);
            new_d->size = new_d->joliet_size = stbuf.st_size;
            new_d->orig_name = file->source_name;
#endif
        }
    }

    for (child = dir->child; child; child = child->next)
    {
        if (verbosity == VERBOSE)
        {
            printf("%d: directory %s\n", d->level, child->case_name);
        }
        new_d = new_empty_dirrecord(d, TRUE);
        parse_filename_into_dirrecord(child->case_name, new_d, TRUE);
        scan_specified_files(new_d, child);
    }

    /* sort directory */
    d->first_record = sort_linked_list(d->first_record,
                                       0,
                                       compare_directory_order);
    source[0] = 0;
    end_source = source;
}

Referenced by main().

sort_linked_list()

PDIR_RECORD sort_linked_list	(	PDIR_RECORD	,
		unsigned	,
		int(*)(PDIR_RECORD, PDIR_RECORD)
	)

Referenced by main(), make_directory_records(), and scan_specified_files().

strtok_s()

char* strtok_s	(	char *	str,
		const char *	delim,
		char **	ctx
	)

Definition at line 1920 of file cdmake.c.

{
    if (delim == NULL || ctx == NULL || (str == NULL && *ctx == NULL))
    {
        return NULL;
    }

    if (!str)
        str = *ctx;

    while (*str && strchr(delim, *str))
        str++;
    if (!*str)
    {
        *ctx = str;
        return NULL;
    }

    *ctx = str + 1;
    while (**ctx && !strchr(delim, **ctx))
        (*ctx)++;
    if (**ctx)
        *(*ctx)++ = '\0';

    return str;
}

Referenced by main().

write_big_endian_dword()

static void write_big_endian_dword ( DWORD  x )

static

Definition at line 398 of file cdmake.c.

{
    write_byte((BYTE)(x >> 24));
    write_byte((BYTE)(x >> 16));
    write_byte((BYTE)(x >> 8));
    write_byte((BYTE)x);
}

Referenced by pass(), and write_both_endian_dword().

write_big_endian_word()

static void write_big_endian_word ( WORD  x )

static

Definition at line 378 of file cdmake.c.

{
    write_byte((BYTE)(x >> 8));
    write_byte((BYTE)x);
}

Referenced by pass(), write_both_endian_word(), write_bytecounted_string_as_big_endian_unicode(), write_string_as_big_endian_unicode(), and write_word_block().

write_block()

static void write_block ( unsigned  count, BYTE  value  )

static

Definition at line 485 of file cdmake.c.

{
    while (count != 0)
    {
        write_byte(value);
        count--;
    }
}

Referenced by pass().

write_both_endian_dword()

static void write_both_endian_dword ( DWORD  x )

static

Definition at line 406 of file cdmake.c.

{
    write_little_endian_dword(x);
    write_big_endian_dword(x);
}

Referenced by pass(), and write_directory_record().

write_both_endian_word()

static void write_both_endian_word ( WORD  x )

static

Definition at line 384 of file cdmake.c.

{
    write_little_endian_word(x);
    write_big_endian_word(x);
}

Referenced by pass(), and write_directory_record().

write_byte()

static void write_byte ( BYTE  x )

static

Definition at line 352 of file cdmake.c.

{
    if (cd.file != NULL)
    {
        cd.buffer[cd.count] = x;
        if (++cd.count == BUFFER_SIZE)
            flush_buffer();
    }
    if (++cd.offset == SECTOR_SIZE)
    {
        cd.sector++;
        cd.offset = 0;
    }
}

Referenced by fill_sector(), pass(), write_big_endian_dword(), write_big_endian_word(), write_block(), write_bytecounted_string(), write_bytecounted_string_as_big_endian_unicode(), write_directory_record(), write_little_endian_dword(), write_little_endian_word(), and write_string().

write_bytecounted_string()

static void write_bytecounted_string ( unsigned  bytecount, char *  s, char  padding  )

static

Definition at line 435 of file cdmake.c.

{
    while (*s != 0 && bytecount != 0)
    {
        write_byte(*s++);
        bytecount--;
    }
    while (bytecount != 0)
    {
        write_byte(padding);
        bytecount--;
    }
}

Referenced by pass().

write_bytecounted_string_as_big_endian_unicode()

static void write_bytecounted_string_as_big_endian_unicode ( unsigned  bytecount, char *  s, char  padding  )

static

Definition at line 462 of file cdmake.c.

{
    unsigned wordcount = bytecount / 2;

    while (*s != 0 && wordcount != 0)
    {
        write_big_endian_word(*s++);
        wordcount--;
    }
    while (wordcount != 0)
    {
        write_big_endian_word(padding);
        wordcount--;
    }

    if (bytecount % 2 != 0)
        write_byte(padding);
}

Referenced by pass().

write_directory_record()

static void write_directory_record ( PDIR_RECORD  d, DIR_RECORD_TYPE  DirType, BOOL  joliet  )

static

Definition at line 512 of file cdmake.c.

{
    unsigned identifier_size;
    unsigned record_size;

    if (joliet)
    {
        if (DirType == DOT_RECORD || DirType == DOT_DOT_RECORD)
            identifier_size = 1;
        else
            identifier_size = strlen(d->joliet_name) * 2;
    }
    else
    {
        switch (DirType)
        {
            case DOT_RECORD:
            case DOT_DOT_RECORD:
                identifier_size = 1;
                break;
            case SUBDIRECTORY_RECORD:
                /*printf("Subdir: %s\n", d->name_on_cd);*/
                identifier_size = strlen(d->name_on_cd);
                break;
            case FILE_RECORD:
                /*printf("File: %s.%s -> %s.%s\n", d->name, d->extension, d->name_on_cd, d->extension_on_cd);*/
                identifier_size = strlen(d->name_on_cd) + 2;
                if (d->extension_on_cd[0] != 0)
                    identifier_size += 1 + strlen(d->extension_on_cd);
                break;
            default:
                identifier_size = 1;
                break;
        }
    }
    record_size = 33 + identifier_size;
    if ((identifier_size & 1) == 0)
        record_size++;
    if (cd.offset + record_size > SECTOR_SIZE)
        fill_sector();
    write_byte((BYTE)record_size);
    write_byte(0); // number of sectors in extended attribute record
    if (joliet)
    {
        write_both_endian_dword(d->joliet_sector);
        write_both_endian_dword(d->joliet_size);
    }
    else
    {
        write_both_endian_dword(d->sector);
        write_both_endian_dword(d->size);
    }
    write_byte((BYTE)(d->date_and_time.year - 1900));
    write_byte(d->date_and_time.month);
    write_byte(d->date_and_time.day);
    write_byte(d->date_and_time.hour);
    write_byte(d->date_and_time.minute);
    write_byte(d->date_and_time.second);
    write_byte(0);    // GMT offset
    write_byte(d->flags);
    write_byte(0);    // file unit size for an interleaved file
    write_byte(0);    // interleave gap size for an interleaved file
    write_both_endian_word(1); // volume sequence number
    write_byte((BYTE)identifier_size);
    switch (DirType)
    {
        case DOT_RECORD:
            write_byte(0);
            break;
        case DOT_DOT_RECORD:
            write_byte(1);
            break;
        case SUBDIRECTORY_RECORD:
            if (joliet)
                write_string_as_big_endian_unicode(d->joliet_name);
            else
                write_string(d->name_on_cd);
            break;
        case FILE_RECORD:
            if (joliet)
            {
                write_string_as_big_endian_unicode(d->joliet_name);
            }
            else
            {
                write_string(d->name_on_cd);
                if (d->extension_on_cd[0] != 0)
                {
                    write_byte('.');
                    write_string(d->extension_on_cd);
                }
                write_string(";1");
            }
            break;
    }
    if ((identifier_size & 1) == 0)
        write_byte(0);
}

Referenced by pass().

write_from_file()

static BOOL write_from_file ( FILE *  file, DWORD  size  )

static

Definition at line 1377 of file cdmake.c.

{
    if (cd.file != NULL)
    {
        int n;

        fseek(file, 0, SEEK_SET);
        while (size > 0)
        {
            n = BUFFER_SIZE - cd.count;
            if ((DWORD)n > size)
                n = size;

            if (fread(cd.buffer + cd.count, n, 1, file) < 1)
                return FALSE;

            cd.count += n;
            if (cd.count == BUFFER_SIZE)
                flush_buffer();
            cd.sector += n / SECTOR_SIZE;
            cd.offset += n % SECTOR_SIZE;
            size -= n;
        }
    }
    else
    {
        cd.sector += size / SECTOR_SIZE;
        cd.offset += size % SECTOR_SIZE;
    }

    return TRUE;
}

Referenced by pass().

write_little_endian_dword()

static void write_little_endian_dword ( DWORD  x )

static

Definition at line 390 of file cdmake.c.

{
    write_byte((BYTE)x);
    write_byte((BYTE)(x >> 8));
    write_byte((BYTE)(x >> 16));
    write_byte((BYTE)(x >> 24));
}

Referenced by pass(), and write_both_endian_dword().

write_little_endian_word()

static void write_little_endian_word ( WORD  x )

static

Definition at line 372 of file cdmake.c.

{
    write_byte((BYTE)x);
    write_byte((BYTE)(x >> 8));
}

Referenced by pass(), and write_both_endian_word().

write_string()

static void write_string ( char *  s )

static

Definition at line 429 of file cdmake.c.

{
    while (*s != 0)
        write_byte(*s++);
}

Referenced by pass(), and write_directory_record().

write_string_as_big_endian_unicode()

static void write_string_as_big_endian_unicode ( char *  s )

static

Definition at line 454 of file cdmake.c.

{
    while (*s != 0)
    {
        write_big_endian_word(*s++);
    }
}

Referenced by pass(), and write_directory_record().

write_word_block()

static void write_word_block ( unsigned  count, WORD  value  )

static

Definition at line 498 of file cdmake.c.

{
    while (count != 0)
    {
        write_big_endian_word(value);
        count--;
    }
}

Variable Documentation

accept_punctuation_marks

BOOL accept_punctuation_marks

Definition at line 199 of file cdmake.c.

Referenced by check_for_punctuation(), and main().

big_endian_path_table_sector

DWORD big_endian_path_table_sector

Definition at line 204 of file cdmake.c.

Referenced by pass().

boot_catalog_sector

DWORD boot_catalog_sector

Definition at line 224 of file cdmake.c.

Referenced by pass().

boot_header_list

PBOOT_HEADER boot_header_list

Definition at line 227 of file cdmake.c.

Referenced by main(), pass(), and release_memory().

boot_validation_header

BOOT_VALIDATION_HEADER boot_validation_header

Definition at line 225 of file cdmake.c.

Referenced by main(), and pass().

bytes_in_directories

DWORD bytes_in_directories

Definition at line 214 of file cdmake.c.

Referenced by main(), and pass().

bytes_in_files

DWORD bytes_in_files

Definition at line 211 of file cdmake.c.

Referenced by main(), and pass().

cd

struct cd_image cd

static

Definition at line 182 of file cdmake.c.

Referenced by __svc_clean_idle(), __svc_vc_dodestroy(), DequeTest::at(), check_enc(), compat_dirclose(), compat_diropen(), compat_nextdir(), compat_nextfile(), error_exit(), Ext2PreAcquireForCreateSection(), fill_sector(), flush_buffer(), iconv(), iconv_close(), iconv_open(), main(), makefd_xprt(), TypeTraitsTest::manips(), pass(), release_memory(), rendezvous_request(), svc_vc_recv(), svc_vc_reply(), svc_vc_stat(), test(), test_font_charset(), TIFFFindCODEC(), TIFFGetConfiguredCODECs(), TIFFRegisterCODEC(), TIFFUnRegisterCODEC(), TLB_FreeCustData(), ui_clip_handle_data(), win_iconv(), win_iconv_open(), WMSFT_compile_custdata(), write_byte(), write_directory_record(), write_from_file(), write_vc(), and xclip_send_data_with_convert().

default_boot_entry

BOOT_ENTRY default_boot_entry

Definition at line 226 of file cdmake.c.

Referenced by main(), and pass().

DIRECTORY_TIMESTAMP

char DIRECTORY_TIMESTAMP[] = "~Y$'KOR$.3K&"

static

Definition at line 180 of file cdmake.c.

Referenced by make_directory_records(), and scan_specified_files().

eltorito

BOOL eltorito

Definition at line 222 of file cdmake.c.

Referenced by main(), and pass().

end_source

char* end_source

Definition at line 187 of file cdmake.c.

Referenced by append_string_to_source(), get_file_specifications(), main(), make_directory_records(), pass(), and scan_specified_files().

HELP

char HELP[]

static

Definition at line 1854 of file cdmake.c.

Referenced by main().

joliet

BOOL joliet

Definition at line 232 of file cdmake.c.

Referenced by get_file_specifications(), main(), parse_filename_into_dirrecord(), pass(), release_memory(), and write_directory_record().

joliet_big_endian_path_table_sector

DWORD joliet_big_endian_path_table_sector

Definition at line 235 of file cdmake.c.

Referenced by pass().

joliet_little_endian_path_table_sector

DWORD joliet_little_endian_path_table_sector

Definition at line 234 of file cdmake.c.

Referenced by pass().

joliet_path_table_size

DWORD joliet_path_table_size

Definition at line 233 of file cdmake.c.

Referenced by pass().

little_endian_path_table_sector

DWORD little_endian_path_table_sector

Definition at line 203 of file cdmake.c.

Referenced by pass().

make_bridged_udf

BOOL make_bridged_udf = TRUE

Definition at line 240 of file cdmake.c.

Referenced by main(), and pass().

multi_boot

BOOL multi_boot

Definition at line 223 of file cdmake.c.

Referenced by main().

number_of_directories

DWORD number_of_directories

Definition at line 213 of file cdmake.c.

Referenced by main(), and pass().

number_of_files

DWORD number_of_files

Definition at line 210 of file cdmake.c.

Referenced by main(), and pass().

path_table_size

DWORD path_table_size

Definition at line 202 of file cdmake.c.

Referenced by file_write(), generate_path_tables(), pass(), pvd_write(), and sort_n_finish().

root

DIR_RECORD root

Definition at line 183 of file cdmake.c.

scan_files_only

BOOL scan_files_only = FALSE

Definition at line 192 of file cdmake.c.

Referenced by main().

show_progress

BOOL show_progress

Definition at line 190 of file cdmake.c.

Referenced by flush_buffer(), and main().

size_limit

DWORD size_limit

Definition at line 198 of file cdmake.c.

Referenced by decode_open_write_delegation4(), and main().

source

char source[512]

Definition at line 186 of file cdmake.c.

Referenced by pass(), and scan_specified_files().

specified_files

struct target_dir_hash specified_files

Definition at line 216 of file cdmake.c.

Referenced by main().

total_sectors

DWORD total_sectors

Definition at line 201 of file cdmake.c.

Referenced by flush_buffer(), main(), pass(), and read_boot().

unused_bytes_at_ends_of_files

DWORD unused_bytes_at_ends_of_files

Definition at line 212 of file cdmake.c.

Referenced by main(), and pass().

verbosity

enum { ... } verbosity

Referenced by BZ2_bzBuffToBuffCompress(), BZ2_bzBuffToBuffDecompress(), BZ2_bzCompressInit(), BZ2_bzDecompressInit(), BZ2_bzReadOpen(), BZ2_bzWriteOpen(), bzopen_or_bzdopen(), main(), make_directory_records(), pass(), and scan_specified_files().

volume_label

char volume_label[32]

Definition at line 185 of file cdmake.c.

Referenced by main(), msi_package_add_media_disk(), and pass().