cdmake.c

Go to the documentation of this file.

/*
 * CD-ROM Maker
 * by Philip J. Erdelsky
 * pje@acm.org
 * http://alumnus.caltech.edu/~pje/
 *
 * http://alumnus.caltech.edu/~pje/cdmake.txt
 *
 * According to his website, this file was released into the public domain
 * by Philip J. Erdelsky.
 */
/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS CD-ROM Maker
 * FILE:            tools/cdmake/cdmake.c
 * PURPOSE:         CD-ROM Premastering Utility
 * PROGRAMMERS:     Eric Kohl
 *                  Casper S. Hornstrup
 *                  Filip Navara
 *                  Magnus Olsen
 *                  Hermes Belusca-Maito
 *
 * HISTORY:
 *
 * ElTorito-Support
 * by Eric Kohl
 *
 * Linux port
 * by Casper S. Hornstrup
 * chorns@users.sourceforge.net
 *
 * Joliet support
 * by Filip Navara
 * xnavara@volny.cz
 * Limitations:
 * - No Joliet file name validations
 * - Very bad ISO file name generation
 *
 * Convert long filename to ISO9660 file name by Magnus Olsen
 * magnus@greatlord.com
 */

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <io.h>
# include <dos.h>
# ifdef _MSC_VER
#  define R_OK 4
# endif
#else
# if defined(__FreeBSD__) || defined(__APPLE__)
#  include <sys/uio.h>
# else
#  include <sys/io.h>
# endif // __FreeBSD__
# include <errno.h>
# include <sys/types.h>
# include <dirent.h>
# include <unistd.h>
# define TRUE 1
# define FALSE 0
#endif // _WIN32
#include <ctype.h>
#include <time.h>
#include "config.h"
#include "dirhash.h"

// FIXME! FIXME! Do it in a portable way!!
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned long DWORD;
typedef int BOOL;

// file system parameters

#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


struct cd_image
{
    FILE *file;
    DWORD sector;         // sector to receive next byte
    int offset;           // offset of next byte in sector
    int count;            // number of bytes in buffer
    char filespecs[128];
    BYTE *buffer;
};

typedef struct _boot_validation_header
{
    BYTE  header_id;
    BYTE  platform_id;
} BOOT_VALIDATION_HEADER, *PBOOT_VALIDATION_HEADER;

typedef struct boot_entry
{
    struct boot_entry *next_entry;
    BYTE  boot_id;
    BYTE  boot_emu_type;
    WORD  load_segment;
    BYTE  system_type;
    WORD  sector_count; // boot_image_size
    DWORD load_rba;     // boot_image_sector
    // BYTE  unused[20];
    char bootimage[512];
} BOOT_ENTRY, *PBOOT_ENTRY;

typedef struct boot_header
{
    struct boot_header *next_header;
    BYTE  header_id;
    BYTE  platform_id;
    WORD  num_entries;
    // char  id_string[28];
    PBOOT_ENTRY entry_list;
} BOOT_HEADER, *PBOOT_HEADER;

typedef struct date_and_time
{
    BYTE second;
    BYTE minute;
    BYTE hour;
    BYTE day;
    BYTE month;
    WORD year;
} DATE_AND_TIME, *PDATE_AND_TIME;

typedef struct directory_record
{
    struct directory_record *next_in_directory;
    struct directory_record *next_in_path_table; /* directory record only */
    struct directory_record *next_in_memory;
    struct directory_record *first_record;       /* directory record only */
    struct directory_record *parent;
    BYTE flags;
    char name[MAX_NAME_LENGTH+1];
    char name_on_cd[MAX_CDNAME_LENGTH+1];
    char extension[MAX_EXTENSION_LENGTH+1];
    char extension_on_cd[MAX_CDEXTENSION_LENGTH+1];
    char *joliet_name;
    const char *orig_name;
    DATE_AND_TIME date_and_time;
    DWORD sector;
    DWORD size;
    DWORD joliet_sector;
    DWORD joliet_size;
    unsigned level;                             /* directory record only */
    WORD path_table_index;                      /* directory record only */
} DIR_RECORD, *PDIR_RECORD;

typedef enum directory_record_type
{
    DOT_RECORD,
    DOT_DOT_RECORD,
    SUBDIRECTORY_RECORD,
    FILE_RECORD
} DIR_RECORD_TYPE, *PDIR_RECORD_TYPE;


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


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 {QUIET, NORMAL, VERBOSE} verbosity;
BOOL show_progress;

BOOL scan_files_only = FALSE;
// BOOL compute_crc = FALSE;

/*
 * ISO 9660 information
 */
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;


/*
 * Stats
 */
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;


/*
 * El-Torito boot information
 */
BOOL eltorito;   // TRUE/FALSE: bootable/non-bootable CD-ROM
BOOL multi_boot; // TRUE/FALSE: multi/single-boot CD-ROM
DWORD boot_catalog_sector;
BOOT_VALIDATION_HEADER boot_validation_header;
BOOT_ENTRY default_boot_entry;
PBOOT_HEADER boot_header_list;

/*
 * Joliet information
 */
BOOL joliet;
DWORD joliet_path_table_size;
DWORD joliet_little_endian_path_table_sector;
DWORD joliet_big_endian_path_table_sector;

/*
 * UDF information
 */
BOOL make_bridged_udf = TRUE;  // TRUE for "UDF-Bridge" (aka. UDF/ISO); FALSE for pure UDF.


/*-----------------------------------------------------------------------------
This function edits a 32-bit unsigned number into a comma-delimited form, such
as 4,294,967,295 for the largest possible number, and returns a pointer to a
static buffer containing the result. It suppresses leading zeros and commas,
but optionally pads the result with blanks at the left so the result is always
exactly 13 characters long (excluding the terminating zero).

CAUTION: A statement containing more than one call on this function, such as
printf("%s, %s", edit_with_commas(a), edit_with_commas(b)), will produce
incorrect results because all calls use the same static bufffer.
-----------------------------------------------------------------------------*/

static char *edit_with_commas(DWORD x, BOOL pad)
{
    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;
}

/*-----------------------------------------------------------------------------
This function releases all allocated memory blocks.
-----------------------------------------------------------------------------*/

static void release_memory(void)
{
    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;
    }
}

/*-----------------------------------------------------------------------------
This function edits and displays an error message and then jumps back to the
error exit point in main().
-----------------------------------------------------------------------------*/

static void error_exit(const char* fmt, ...)
{
    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);
}

/*-----------------------------------------------------------------------------
This function, which is called only on the second pass, and only when the
buffer is not empty, flushes the buffer to the CD-ROM image.
-----------------------------------------------------------------------------*/

static void flush_buffer(void)
{
    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));
    }
}

/*-----------------------------------------------------------------------------
This function writes a single byte to the CD-ROM image. On the first pass (in
which cd.handle < 0), it does not actually write anything but merely updates
the file pointer as though the byte had been written.
-----------------------------------------------------------------------------*/

static void write_byte(BYTE x)
{
    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;
    }
}

/*-----------------------------------------------------------------------------
These functions write a word or double word to the CD-ROM image with the
specified endianity.
-----------------------------------------------------------------------------*/

static void write_little_endian_word(WORD x)
{
    write_byte((BYTE)x);
    write_byte((BYTE)(x >> 8));
}

static void write_big_endian_word(WORD x)
{
    write_byte((BYTE)(x >> 8));
    write_byte((BYTE)x);
}

static void write_both_endian_word(WORD x)
{
    write_little_endian_word(x);
    write_big_endian_word(x);
}

static void write_little_endian_dword(DWORD x)
{
    write_byte((BYTE)x);
    write_byte((BYTE)(x >> 8));
    write_byte((BYTE)(x >> 16));
    write_byte((BYTE)(x >> 24));
}

static void write_big_endian_dword(DWORD x)
{
    write_byte((BYTE)(x >> 24));
    write_byte((BYTE)(x >> 16));
    write_byte((BYTE)(x >> 8));
    write_byte((BYTE)x);
}

static void write_both_endian_dword(DWORD x)
{
    write_little_endian_dword(x);
    write_big_endian_dword(x);
}

/*-----------------------------------------------------------------------------
This function writes enough zeros to fill out the end of a sector, and leaves
the file pointer at the beginning of the next sector. If the file pointer is
already at the beginning of a sector, it writes nothing.
-----------------------------------------------------------------------------*/

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

/*-----------------------------------------------------------------------------
This function writes a string to the CD-ROM image. The terminating \0 is not
written.
-----------------------------------------------------------------------------*/

static void write_string(char *s)
{
    while (*s != 0)
        write_byte(*s++);
}

static void write_bytecounted_string(unsigned bytecount, char *s, char padding)
{
    while (*s != 0 && bytecount != 0)
    {
        write_byte(*s++);
        bytecount--;
    }
    while (bytecount != 0)
    {
        write_byte(padding);
        bytecount--;
    }
}

/*-----------------------------------------------------------------------------
This function writes a ansi string as a big endian unicode string to the CD-ROM
image. The terminating \0 is not written.
-----------------------------------------------------------------------------*/

static void write_string_as_big_endian_unicode(char *s)
{
    while (*s != 0)
    {
        write_big_endian_word(*s++);
    }
}

static void write_bytecounted_string_as_big_endian_unicode(unsigned bytecount, char *s, char padding)
{
    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);
}

/*-----------------------------------------------------------------------------
This function writes a block of identical bytes to the CD-ROM image.
-----------------------------------------------------------------------------*/

static void write_block(unsigned count, BYTE value)
{
    while (count != 0)
    {
        write_byte(value);
        count--;
    }
}

/*-----------------------------------------------------------------------------
This function writes a block of identical big endian words to the CD-ROM image.
-----------------------------------------------------------------------------*/

static void write_word_block(unsigned count, WORD value)
{
    while (count != 0)
    {
        write_big_endian_word(value);
        count--;
    }
}

/*-----------------------------------------------------------------------------
This function writes a directory record to the CD_ROM image.
-----------------------------------------------------------------------------*/

static void
write_directory_record(PDIR_RECORD d,
                       DIR_RECORD_TYPE DirType,
                       BOOL joliet)
{
    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);
}

/*-----------------------------------------------------------------------------
This function converts the date and time words from an ffblk structure and
puts them into a date_and_time structure.
-----------------------------------------------------------------------------*/

static void convert_date_and_time(PDATE_AND_TIME dt, time_t *time)
{
    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;
}

/*-----------------------------------------------------------------------------
This function checks the specified character, if necessary, and
generates an error if it is a punctuation mark other than an underscore.
It also converts small letters to capital letters and returns the
result.
-----------------------------------------------------------------------------*/

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

/*-----------------------------------------------------------------------------
This function checks to see if there's a cdname conflict.
-----------------------------------------------------------------------------*/

#if defined(_WIN32) && !defined(strcasecmp)
#define strcasecmp stricmp
#endif // _WIN32

static BOOL cdname_exists(PDIR_RECORD d)
{
    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;
}

static void parse_filename_into_dirrecord(const char* filename, PDIR_RECORD d, BOOL dir)
{
    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);
    }
}

/*-----------------------------------------------------------------------------
This function creates a new directory record with the information from the
specified ffblk. It links it into the beginning of the directory list
for the specified parent and returns a pointer to the new record.
-----------------------------------------------------------------------------*/

#ifdef _WIN32

/* Win32 version */
PDIR_RECORD
new_directory_record(struct _finddata_t *f,
                     PDIR_RECORD parent)
{
    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;
    parse_filename_into_dirrecord(f->name, d, f->attrib & _A_SUBDIR);

    convert_date_and_time(&d->date_and_time, &f->time_write);
    d->flags |= f->attrib & _A_HIDDEN ? HIDDEN_FLAG : 0;
    d->size = d->joliet_size = f->size;
    d->next_in_directory = parent->first_record;
    parent->first_record = d;
    return d;
}

#else

/* Linux version */
PDIR_RECORD
new_directory_record(struct dirent *entry,
                     struct stat *stbuf,
                     PDIR_RECORD parent)
{
    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;
}

#endif

/*-----------------------------------------------------------------------------
This function compares two directory records according to the ISO9660 rules
for directory sorting and returns a negative value if p is before q, or a
positive value if p is after q.
-----------------------------------------------------------------------------*/

static int compare_directory_order(PDIR_RECORD p, PDIR_RECORD q)
{
    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;
}

/*-----------------------------------------------------------------------------
This function compares two directory records (which must represent
directories) according to the ISO9660 rules for path table sorting and returns
a negative value if p is before q, or a positive vlaue if p is after q.
-----------------------------------------------------------------------------*/

static int compare_path_table_order(PDIR_RECORD p, PDIR_RECORD q)
{
    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;
}

/*-----------------------------------------------------------------------------
This function appends the specified string to the buffer source[].
-----------------------------------------------------------------------------*/

static void append_string_to_source(char *s)
{
    while (*s != 0)
        *end_source++ = *s++;
}

/*-----------------------------------------------------------------------------
This function scans all files from the current source[] (which must end in \,
and represents a directory already in the database as d),
and puts the appropriate directory records into the database in memory, with
the specified root. It calls itself recursively to scan all subdirectories.
-----------------------------------------------------------------------------*/

#ifdef _WIN32

static void
make_directory_records(PDIR_RECORD d)
{
    PDIR_RECORD new_d;
    struct _finddata_t f;
    char *old_end_source;
    int findhandle;

    d->first_record = NULL;
    strcpy(end_source, "*.*");

    findhandle = _findfirst(source, &f);
    if (findhandle != 0)
    {
        do
        {
            if ((f.attrib & (_A_HIDDEN | _A_SUBDIR)) == 0 && f.name[0] != '.')
            {
                if (strcmp(f.name, DIRECTORY_TIMESTAMP) == 0)
                {
                    convert_date_and_time(&d->date_and_time, &f.time_write);
                }
                else
                {
                    if (verbosity == VERBOSE)
                    {
                        old_end_source = end_source;
                        strcpy(end_source, f.name);
                        printf("%d: file %s\n", d->level, source);
                        end_source = old_end_source;
                    }
                    (void) new_directory_record(&f, d);
                }
            }
        }
        while (_findnext(findhandle, &f) == 0);

        _findclose(findhandle);
    }

    strcpy(end_source, "*.*");
    findhandle = _findfirst(source, &f);
    if (findhandle)
    {
        do
        {
            if (f.attrib & _A_SUBDIR && f.name[0] != '.')
            {
                old_end_source = end_source;
                append_string_to_source(f.name);
                *end_source++ = DIR_SEPARATOR_CHAR;
                if (verbosity == VERBOSE)
                {
                    *end_source = 0;
                    printf("%d: directory %s\n", d->level + 1, source);
                }
                if (d->level < MAX_LEVEL)
                {
                    new_d = new_directory_record(&f, 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;
            }
        }
        while (_findnext(findhandle, &f) == 0);

      _findclose(findhandle);
    }

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

#else

/* Linux version */
static void
make_directory_records(PDIR_RECORD d)
{
    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);
}

#endif

static PDIR_RECORD
new_empty_dirrecord(PDIR_RECORD d, BOOL directory)
{
    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;
}

#ifdef _WIN32
static BOOL
get_cd_file_time(HANDLE handle, PDATE_AND_TIME cd_time_info)
{
    FILETIME file_time;
    SYSTEMTIME sys_time;

    if (!GetFileTime(handle, NULL, NULL, &file_time))
        return FALSE;

    FileTimeToSystemTime(&file_time, &sys_time);
    memset(cd_time_info, 0, sizeof(*cd_time_info));

    cd_time_info->year = sys_time.wYear;
    cd_time_info->month = sys_time.wMonth;
    cd_time_info->day = sys_time.wDay;
    cd_time_info->hour = sys_time.wHour;
    cd_time_info->minute = sys_time.wMinute;
    cd_time_info->second = sys_time.wSecond;

    return TRUE;
}
#endif

static void
scan_specified_files(PDIR_RECORD d, struct target_dir_entry *dir)
{
    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;
}

/*-----------------------------------------------------------------------------
This function loads the file specifications for the file or directory
corresponding to the specified directory record into the source[] buffer. It
is recursive.
-----------------------------------------------------------------------------*/

static void get_file_specifications(PDIR_RECORD d)
{
    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;
    }
}

static void get_time_string(char *str)
{
    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);
}

static BOOL write_from_file(FILE *file, DWORD size)
{
    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;
}

static void pass(void)
{
    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;
}

static char HELP[] =
    "\n"
    "CDMAKE CD-ROM Premastering Utility\n"
    "Copyright (C) 1997 Philip J. Erdelsky\n"
    "Copyright (C) 2003-2016 ReactOS Team\n"
    "\n\n"
    "CDMAKE [-vN] [-p] [-s N] [-m] [-j] [-q] "
        // "[-x] "
        "[-pN] [-eN] [-b bootimage]\n"
    "       [-bootdata:N#<defaultBootEntry>#<bootEntry1>#...#<bootEntryN>]\n"
    "       source volume image\n"
    "\n"
    "Mandatory options:\n"
    "  source        Specifications of base directory containing all files to be\n"
    "                written to CD-ROM image. Can be a directory, or a path to a\n"
    "                file list (in which case the path must start with a '@').\n"
    "  volume        Volume label.\n"
    "  image         Image file or device.\n"
    "\n"
    "General options:\n"
    "  -vN           Verbosity level. Valid values for 'N' are:\n"
    "                    0: Quiet mode - display nothing but error messages.\n"
    "                    1: Normal mode (default).\n"
    "                    2: Verbose mode - display file information as files are\n"
    "                       scanned and written. Overrides the -p option.\n"
    "  -p            Show progress while writing.\n"
    "  -s N          Abort operation before beginning write if image will be larger\n"
    "                than N megabytes (i.e. 1024*1024*N bytes).\n"
    "  -q            Only scan the source files; do not create an image.\n"
    // "  -x            Compute and encode the AutoCRC value in the image.\n"
    "\n"
    "ISO 9660 and Joliet options:\n"
    "  -m            Accept punctuation marks other than underscores in names and\n"
    "                extensions.\n"
    "  -j            Generate Joliet filename records.\n"
    "\n"
    // "UDF options:\n"
    // "  Not implemented yet!\n"
    // "\n"
    "El-Torito boot options:\n"
    "  -pN           Boot platform ID in hex format (default: 00 for a BIOS system).\n"
    "  -eN           Boot media emulation. Valid values for 'N' are:\n"
    "                    0 (or nothing): No emulation.\n"
    "                    1: 1.2 MB diskette.\n"
    "                    2: 1.44MB diskette.\n"
    "                    3: 2.88MB diskette.\n"
    "                    4: Hard disk.\n"
    "  -b bootimage  Create a single-boot El-Torito image.\n"
    "  -bootdata:    Create a multi-boot El-Torito image. This option cannot be\n"
    "                combined with the -b option.\n"
    "       Syntax:\n"
    "       -bootdata:N#<defaultBootEntry>#<bootEntry2>#...#<bootEntryN>\n"
    "            'N': number of boot entries following.\n"
    "            defaultBootEntry: The default boot entry, needed in all cases.\n"
    "                Used by BIOSes which do not support additional boot entries.\n"
    "            bootEntryX: Additional boot entries.\n"
    "            - Do not use spaces.\n"
    "            - Each multi-boot entry must be delimited with a hash symbol (#).\n"
    "            - Each option for a boot entry must be delimited with a comma (,).\n"
    "            - Each boot entry must specify the platform ID.\n";

/*-----------------------------------------------------------------------------
Program execution starts here.
-----------------------------------------------------------------------------*/

#if (defined(__GNUC__) || (_MSC_VER < 1900))
char* strtok_s(char *str, const char *delim, char **ctx)
{
    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;
}
#endif

static void
init_boot_entry(PBOOT_ENTRY boot_entry,
                BYTE boot_emu_type, WORD load_segment,
                char* bootimage)
{
    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';
}

int main(int argc, char **argv)
{
    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;
}

/* EOF */