/******************************* LICENCE **************************************
* Any code in this file may be redistributed or modified under the terms of
* the GNU General Public Licence as published by the Free Software 
* Foundation; version 2 of the licence.
****************************** END LICENCE ***********************************/

/******************************************************************************
* Author:
* Andrew Smith, http://littlesvr.ca/misc/contactandrew.php
*
* Contributors:
* 
******************************************************************************/

/******************************************************************************
* Functions in this file write to volInfo.imageForWriting and are probably
* unsutable for anything else.
******************************************************************************/

#include <strings.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>

#include "bk.h"
#include "bkInternal.h"
#include "bkWrite7x.h"
#include "bkTime.h"
#include "bkWrite.h"
#include "bkMangle.h"
#include "bkError.h"
#include "bkSort.h"
#include "bkPath.h"
#include "bkCache.h"
#include "bkRead7x.h"
#include "bkLink.h"
#include "bkIoWrappers.h"

/******************************************************************************
* bk_write_image()
* Writes everything from first to last byte of the iso.
* Public function.
* */
int bk_write_image(const char* newImagePathAndName, VolInfo* volInfo, 
                   time_t creationTime, int filenameTypes, 
                   void(*progressFunction)(VolInfo*, double))
{
    int rc;
    DirToWrite newTree;
    bk_off_t svdOffset;
    bk_off_t pRealRootDrOffset;
    int pRootDirSize;
    bk_off_t sRealRootDrOffset;
    int sRootDirSize;
    bk_off_t lPathTable9660Loc;
    bk_off_t mPathTable9660Loc;
    int pathTable9660Size;
    bk_off_t lPathTableJolietLoc;
    bk_off_t mPathTableJolietLoc;
    int pathTableJolietSize;
    bk_off_t bootCatalogSectorNumberOffset;
    bk_off_t currPos;
    
    volInfo->writeProgressFunction = progressFunction;
    volInfo->stopOperation = false;
    
    volInfo->estimatedIsoSize = bk_estimate_iso_size(volInfo, filenameTypes);
    progressFunction(volInfo, 0);
    
    BkStatStruct statStruct;
    rc = bkStat(newImagePathAndName, &statStruct);
    if(rc == 0 && statStruct.st_ino == volInfo->imageForReadingInode)
        return BKERROR_SAVE_OVERWRITE;
    
    /* because mangleDir works on dir's children i need to 
    * copy the root manually */
    memset(&newTree, 0, sizeof(DirToWrite));
    newTree.base.posixFileMode = volInfo->dirTree.base.posixFileMode;
    
    printf("mangling\n");fflush(NULL);
    /* create tree to write */
    rc = mangleDir(&(volInfo->dirTree), &newTree, filenameTypes);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        return rc;
    }
    
    printf("opening '%s' for writing\n", newImagePathAndName);fflush(NULL);
    volInfo->imageForWriting = open(newImagePathAndName, 
                                    O_RDWR | O_CREAT | O_TRUNC, 
                                    S_IRUSR | S_IWUSR);
    if(volInfo->imageForWriting == -1)
    {
        freeDirToWriteContents(&newTree);
        return BKERROR_OPEN_WRITE_FAILED;
    }
    
    printf("writing blank at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
    /* system area, always zeroes */
    rc = writeByteBlock(volInfo, 0, NBYTES_LOGICAL_BLOCK * NLS_SYSTEM_AREA);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    
    /* skip pvd (1 block), write it after files */
    wcSeekForward(volInfo, NBYTES_LOGICAL_BLOCK);
    
    if(volInfo->bootMediaType != BOOT_MEDIA_NONE)
    {
        /* el torito volume descriptor */
        rc = writeElToritoVd(volInfo, &bootCatalogSectorNumberOffset);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
    }
    
    if(filenameTypes & FNTYPE_JOLIET)
    /* skip svd (1 block), write it after pvd */
    {
        svdOffset = wcSeekTell(volInfo);
        wcSeekForward(volInfo, NBYTES_LOGICAL_BLOCK);
    }
    
    printf("writing terminator at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
    /* volume descriptor set terminator */
    rc = writeVdsetTerminator(volInfo);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    
    if(volInfo->bootMediaType != BOOT_MEDIA_NONE)
    {
        /* write boot catalog sector number */
        currPos = wcSeekTell(volInfo);
        wcSeekSet(volInfo, bootCatalogSectorNumberOffset);
        rc = write731(volInfo, currPos / NBYTES_LOGICAL_BLOCK);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
        wcSeekSet(volInfo, currPos);
        
        /* write el torito booting catalog */
        rc = writeElToritoBootCatalog(volInfo, &(volInfo->bootRecordSectorNumberOffset));
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
    }
    
    /* MAYBE write boot record file now */
    if(volInfo->bootMediaType != BOOT_MEDIA_NONE && 
       !volInfo->bootRecordIsVisible)
    {
        int blankSize;
        int srcFile; /* either the old image or the boot record file on 
                     * the regular filesystem */
        bool srcFileOpened;
        
        /* set up source file pointer */
        if(volInfo->bootRecordIsOnImage)
        {
            srcFile = volInfo->imageForReading;
            bkSeekSet(volInfo->imageForReading, volInfo->bootRecordOffset, SEEK_SET);
            srcFileOpened = false;
        }
        else
        {
            srcFile = open(volInfo->bootRecordPathAndName, O_RDONLY, 0);
            if(srcFile == -1)
            {
                freeDirToWriteContents(&newTree);
                bkClose(volInfo->imageForWriting);
                unlink(newImagePathAndName);
                return BKERROR_OPEN_READ_FAILED;
            }
            srcFileOpened = true;
        }
        
        /* write boot record sector number */
        currPos = wcSeekTell(volInfo);
        wcSeekSet(volInfo, volInfo->bootRecordSectorNumberOffset);
        
        rc = write731(volInfo, currPos / NBYTES_LOGICAL_BLOCK);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            if(srcFileOpened)
                bkClose(srcFile);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
        wcSeekSet(volInfo, currPos);
        
        /* file contents */
        rc = writeByteBlockFromFile(srcFile, volInfo, volInfo->bootRecordSize);
        if(rc < 0)
        {
            freeDirToWriteContents(&newTree);
            if(srcFileOpened)
                bkClose(srcFile);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
        
        blankSize = NBYTES_LOGICAL_BLOCK - 
                    volInfo->bootRecordSize % NBYTES_LOGICAL_BLOCK;
        
        /* fill the last sector with 0s */
        rc = writeByteBlock(volInfo, 0x00, blankSize);
        if(rc < 0)
        {
            freeDirToWriteContents(&newTree);
            if(srcFileOpened)
                bkClose(srcFile);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
        
        if(srcFileOpened)
            bkClose(srcFile);
    }
    /* END MAYBE write boot record file now */
    
    printf("sorting 9660\n");
    sortDir(&newTree, FNTYPE_9660);
    
    pRealRootDrOffset = wcSeekTell(volInfo);
    
    printf("writing primary directory tree at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
    /* 9660 and maybe rockridge dir tree */
    rc = writeDir(volInfo, &newTree, 0, 0, 0, creationTime, 
                  filenameTypes & (FNTYPE_9660 | FNTYPE_ROCKRIDGE), true);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    
    pRootDirSize = rc;
    
    /* joliet dir tree */
    if(filenameTypes & FNTYPE_JOLIET)
    {
        printf("sorting joliet\n");
        sortDir(&newTree, FNTYPE_JOLIET);
        
        printf("writing supplementary directory tree at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
        sRealRootDrOffset = wcSeekTell(volInfo);
        
        rc = writeDir(volInfo, &newTree, 0, 0, 0, creationTime, 
                      FNTYPE_JOLIET, true);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
        
        sRootDirSize = rc;
    }
    
    printf("writing 9660 path tables at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
    
    lPathTable9660Loc = wcSeekTell(volInfo);
    rc = writePathTable(volInfo, &newTree, true, FNTYPE_9660);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    pathTable9660Size = rc;
    
    mPathTable9660Loc = wcSeekTell(volInfo);
    rc = writePathTable(volInfo, &newTree, false, FNTYPE_9660);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    
    if(filenameTypes & FNTYPE_JOLIET)
    {
        printf("writing joliet path tables at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
        lPathTableJolietLoc = wcSeekTell(volInfo);
        rc = writePathTable(volInfo, &newTree, true, FNTYPE_JOLIET);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
        pathTableJolietSize = rc;
        
        mPathTableJolietLoc = wcSeekTell(volInfo);
        rc = writePathTable(volInfo, &newTree, false, FNTYPE_JOLIET);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
    }
    
    printf("writing files at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
    resetWriteStatus(volInfo->fileLocations);
    /* all files and offsets/sizes */
    rc = writeFileContents(volInfo, &newTree, filenameTypes);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    
    if(filenameTypes & FNTYPE_ROCKRIDGE)
    {
        printf("writing long NMs at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
        rc = writeLongNMsInDir(volInfo, &newTree);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
    }
    
    wcSeekSet(volInfo, NBYTES_LOGICAL_BLOCK * NLS_SYSTEM_AREA);
    
    printf("writing pvd at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
    rc = writeVolDescriptor(volInfo, pRealRootDrOffset, 
                            pRootDirSize, lPathTable9660Loc, mPathTable9660Loc, 
                            pathTable9660Size, creationTime, true);
    if(rc <= 0)
    {
        freeDirToWriteContents(&newTree);
        bkClose(volInfo->imageForWriting);
        unlink(newImagePathAndName);
        return rc;
    }
    
    if(filenameTypes & FNTYPE_JOLIET)
    {
        wcSeekSet(volInfo, svdOffset);
        
        printf("writing svd at %X\n", (int)wcSeekTell(volInfo));fflush(NULL);
        rc = writeVolDescriptor(volInfo, sRealRootDrOffset, 
                                sRootDirSize, lPathTableJolietLoc, mPathTableJolietLoc, 
                                pathTableJolietSize, creationTime, false);
        if(rc <= 0)
        {
            freeDirToWriteContents(&newTree);
            bkClose(volInfo->imageForWriting);
            unlink(newImagePathAndName);
            return rc;
        }
    }
    
    printf("freeing memory\n");fflush(NULL);
    freeDirToWriteContents(&newTree);
    bkClose(volInfo->imageForWriting);
    
    return 1;
}

/******************************************************************************
* bootInfoTableChecksum()
* Calculate the checksum to be written into the boot info table.
* */
int bootInfoTableChecksum(int oldImage, FileToWrite* file, unsigned* checksum)
{
    int numTrailingBytes; /* to make sure the file size is divisible by 4 */
    ssize_t rc;
    int srcFile;
    unsigned char* contents;
    unsigned count;
    
    numTrailingBytes = file->size % 4;
    
    contents = malloc(file->size + numTrailingBytes);
    if(contents == NULL)
        return BKERROR_OUT_OF_MEMORY;
    
    /* make sure the extra bytes i added are 0s */
    memset(contents + file->size, 0, numTrailingBytes);
    
    if(file->onImage)
    /* read file from original image */
    {
        bkSeekSet(oldImage, file->offset, SEEK_SET);
        
        rc = bkRead(oldImage, contents, file->size);
        if(rc == -1 || rc != (int)(file->size))
        {
            free(contents);
            return BKERROR_READ_GENERIC;
        }
    }
    else
    /* read file from fs */
    {
        srcFile = open(file->pathAndName, O_RDONLY, 0);
        if(srcFile == -1)
        {
            free(contents);
            return BKERROR_OPEN_READ_FAILED;
        }
        
        rc = bkRead(srcFile, contents, file->size);
        
        bkClose(srcFile);
        
        if(rc == -1 || rc != (int)(file->size))
        {
            free(contents);
            return BKERROR_READ_GENERIC;
        }
    }
    
    *checksum = 0;
    /* do 32 bit checksum starting from byte 64
    * because i check above that the file is divisible by 4 i will not be 
    * reading wrong memory */
    for(count = 64; count < file->size; count += 4)
    {
        unsigned toAdd;
        
        toAdd = *(contents + count) | (*(contents + count + 1) << 8) | 
                (*(contents + count + 2) << 16) | (*(contents + count + 3) << 24);
        
        *checksum += toAdd;
    }
    
    free(contents);
    
    return 1;
}

/******************************************************************************
* countDirsOnLevel()
* a 'level' is described in ecma119 6.8.2
* it's needed for path tables, don't remember exactly what for
* */
int countDirsOnLevel(const DirToWrite* dir, int targetLevel, int thisLevel)
{
    BaseToWrite* child;
    int sum;
    
    if(targetLevel == thisLevel)
    {
        return 1;
    }
    else
    {
        sum = 0;
        
        child = dir->children;
        while(child != NULL)
        {
            if( IS_DIR(child->posixFileMode) )
                sum += countDirsOnLevel(DIRTW_PTR(child), targetLevel, thisLevel + 1);
            
            child = child->next;
        }
        
        return sum;
    }
}

/******************************************************************************
* countTreeHeight()
* caller should set heightSoFar to 1
* */
int countTreeHeight(const DirToWrite* dir, int heightSoFar)
{
    BaseToWrite* child;
    int maxHeight;
    int thisHeight;
    
    maxHeight = heightSoFar;
    child = dir->children;
    while(child != NULL)
    {
        if( IS_DIR(child->posixFileMode) )
        {
            thisHeight = countTreeHeight(DIRTW_PTR(child), heightSoFar + 1);
            
            if(thisHeight > maxHeight)
                maxHeight = thisHeight;
        }
        
        child = child->next;
    }
    
    return maxHeight;
}

/******************************************************************************
* elToritoChecksum()
* Algorithm: the sum of all words, including the checksum must trunkate to 
* a 16-bit 0x0000
* */
unsigned short elToritoChecksum(const unsigned char* record)
{
    short sum;
    int i;
    
    sum = 0;
    for(i = 0; i < 32; i += 2)
    {
        sum += *(record + i) | (*(record + i + 1) << 8);
    }
    
    return 0xFFFF - sum + 1;
}

/******************************************************************************
* writeByteBlock()
* Fills numBytes with byteToWrite.

* */
int writeByteBlock(VolInfo* volInfo, unsigned char byteToWrite, int numBytes)
{
    int rc;
    int count;
    int numBlocks;
    int sizeLastBlock;
    
    memset(volInfo->readWriteBuffer, byteToWrite, READ_WRITE_BUFFER_SIZE);
    
    numBlocks = numBytes / READ_WRITE_BUFFER_SIZE;
    sizeLastBlock = numBytes % READ_WRITE_BUFFER_SIZE;
    
    for(count = 0; count < numBlocks; count++)
    {
        rc = wcWrite(volInfo, volInfo->readWriteBuffer, READ_WRITE_BUFFER_SIZE);
        if(rc <= 0)
            return rc;
    }
    
    if(sizeLastBlock > 0)
    {
        rc = wcWrite(volInfo, volInfo->readWriteBuffer, sizeLastBlock);
        if(rc <= 0)
            return rc;
    }
    
    return 1;
}

/******************************************************************************
* writeByteBlockFromFile()
* copies numBytes from src into the image to write in blocks of 10K
* */
int writeByteBlockFromFile(int src, VolInfo* volInfo, unsigned numBytes)
{
    int rc;
    int count;
    int numBlocks;
    int sizeLastBlock;
    
    numBlocks = numBytes / READ_WRITE_BUFFER_SIZE;
    sizeLastBlock = numBytes % READ_WRITE_BUFFER_SIZE;
    
    for(count = 0; count < numBlocks; count++)
    {
        if(volInfo->stopOperation)
            return BKERROR_OPER_CANCELED_BY_USER;

        rc = bkRead(src, volInfo->readWriteBuffer, READ_WRITE_BUFFER_SIZE);
        if(rc != READ_WRITE_BUFFER_SIZE)
            return BKERROR_READ_GENERIC;
        rc = wcWrite(volInfo, volInfo->readWriteBuffer, READ_WRITE_BUFFER_SIZE);
        if(rc <= 0)
            return rc;
    }
    
    if(sizeLastBlock > 0)
    {
        rc = bkRead(src, volInfo->readWriteBuffer, sizeLastBlock);
        if(rc != sizeLastBlock)
                return BKERROR_READ_GENERIC;
        rc = wcWrite(volInfo, volInfo->readWriteBuffer, sizeLastBlock);
        if(rc <= 0)
                return rc;
    }
    
    return 1;
}

/******************************************************************************
* writeDir()
* Writes the contents of a directory. Also writes locations and sizes of
* directory records for directories but not for files.
* Returns data length of the dir written.
* */
int writeDir(VolInfo* volInfo, DirToWrite* dir, int parentLbNum, 
             int parentNumBytes, int parentPosix, time_t recordingTime, 
             int filenameTypes, bool isRoot)
{
    int rc;
    
    bk_off_t startPos;
    int numUnusedBytes;
    bk_off_t endPos;
    
    DirToWrite selfDir; /* will have a different filename */
    DirToWrite parentDir;
    
    BaseToWrite* child;
    
    if(wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK != 0)
        return BKERROR_SANITY;
    
    /* names other then 9660 are not used for self and parent */
    selfDir.base.name9660[0] = 0x00;
    selfDir.base.posixFileMode = dir->base.posixFileMode;
    
    parentDir.base.name9660[0] = 0x01;
    parentDir.base.name9660[1] = '\0';
    if(isRoot)
        parentDir.base.posixFileMode = selfDir.base.posixFileMode;
    else
        parentDir.base.posixFileMode = parentPosix;
    
    startPos = wcSeekTell(volInfo);
    
    if( startPos % NBYTES_LOGICAL_BLOCK != 0 )
    /* this should never happen */
        return BKERROR_SANITY;
    
    if(filenameTypes & FNTYPE_JOLIET)
        dir->extentNumber2 = startPos / NBYTES_LOGICAL_BLOCK;
    else
        dir->base.extentNumber = startPos / NBYTES_LOGICAL_BLOCK;
    
    /* write self */
    if(isRoot)
    {
        rc = writeDr(volInfo, BASETW_PTR(&selfDir), recordingTime, true, true, true, filenameTypes);
        if(rc < 0)
            return rc;
        
        if(filenameTypes & FNTYPE_JOLIET)
            dir->base.extentLocationOffset2 = selfDir.base.extentLocationOffset2;
        else
            dir->base.extentLocationOffset = selfDir.base.extentLocationOffset;
    }
    else
    {
        rc = writeDr(volInfo, BASETW_PTR(&selfDir), recordingTime, true, true, false, filenameTypes);
        if(rc < 0)
            return rc;
    }
    if(rc < 0)
        return rc;
    
    /* write parent */
    rc = writeDr(volInfo, BASETW_PTR(&parentDir), recordingTime, true, true, false, filenameTypes);
    if(rc < 0)
        return rc;
    
    child = dir->children;
    
    /* WRITE children drs */
    while(child != NULL)
    {
        if(IS_DIR(child->posixFileMode))
        {
            rc = writeDr(volInfo, child, recordingTime, 
                         true,  false, false, filenameTypes);
        }
        else
        {
            rc = writeDr(volInfo, child, recordingTime, 
                         false,  false, false, filenameTypes);
        }
        if(rc < 0)
            return rc;
        
        child = child->next;
    }
    /* END WRITE children drs */
    
    /* write blank to conclude extent */
    numUnusedBytes = NBYTES_LOGICAL_BLOCK - 
                     wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK;
    rc = writeByteBlock(volInfo, 0x00, numUnusedBytes);
    if(rc < 0)
        return rc;
    
    if(filenameTypes & FNTYPE_JOLIET)
        dir->dataLength2 = wcSeekTell(volInfo) - startPos;
    else
        dir->dataLength = wcSeekTell(volInfo) - startPos;
    
    /* write subdirectories */
    child = dir->children;
    while(child != NULL)
    {
        if(IS_DIR(child->posixFileMode))
        {
            if(filenameTypes & FNTYPE_JOLIET)
            {
                rc = writeDir(volInfo, DIRTW_PTR(child), dir->extentNumber2, 
                              dir->dataLength2, BASETW_PTR(dir)->posixFileMode, recordingTime,
                              filenameTypes, false);
            }
            else
            {
                rc = writeDir(volInfo, DIRTW_PTR(child), BASETW_PTR(dir)->extentNumber, 
                              dir->dataLength, BASETW_PTR(dir)->posixFileMode, recordingTime,
                              filenameTypes, false);
            }
            if(rc < 0)
                return rc;
        }
        
        child = child->next;
    }
    
    endPos = wcSeekTell(volInfo);
    
    /* SELF extent location and size */
    if(filenameTypes & FNTYPE_JOLIET)
        wcSeekSet(volInfo, selfDir.base.extentLocationOffset2);
    else
        wcSeekSet(volInfo, selfDir.base.extentLocationOffset);
    
    if(filenameTypes & FNTYPE_JOLIET)
    {
        rc = write733(volInfo, dir->extentNumber2);
        if(rc <= 0)
            return rc;
        
        rc = write733(volInfo, dir->dataLength2);
        if(rc <= 0)
            return rc;
    }
    else
    {
        rc = write733(volInfo, BASETW_PTR(dir)->extentNumber);
        if(rc <= 0)
            return rc;
        
        rc = write733(volInfo, dir->dataLength);
        if(rc <= 0)
            return rc;
    }
    /* END SELF extent location and size */
    
    /* PARENT extent location and size */
    if(filenameTypes & FNTYPE_JOLIET)
        wcSeekSet(volInfo, parentDir.base.extentLocationOffset2);
    else
        wcSeekSet(volInfo, parentDir.base.extentLocationOffset);
    
    if(parentLbNum == 0)
    /* root, parent is same as self */
    {
        if(filenameTypes & FNTYPE_JOLIET)
        {
            rc = write733(volInfo, dir->extentNumber2);
            if(rc <= 0)
                return rc;
            
            rc = write733(volInfo, dir->dataLength2);
            if(rc <= 0)
                return rc;
        }
        else
        {
            rc = write733(volInfo, BASETW_PTR(dir)->extentNumber);
            if(rc <= 0)
                return rc;
            
            rc = write733(volInfo, dir->dataLength);
            if(rc <= 0)
                return rc;
        }
    }
    else
    /* normal parent */
    {
        rc = write733(volInfo, parentLbNum);
        if(rc <= 0)
            return rc;
        
        rc = write733(volInfo, parentNumBytes);
        if(rc <= 0)
            return rc;
    }
    /* END PARENT extent location and size */
    
    /* ALL subdir extent locations and sizes */
    child = dir->children;
    while(child != NULL)
    {
        if(IS_DIR(child->posixFileMode))
        {
            if(filenameTypes & FNTYPE_JOLIET)
            {
                wcSeekSet(volInfo, child->extentLocationOffset2);
                
                rc = write733(volInfo, DIRTW_PTR(child)->extentNumber2);
                if(rc <= 0)
                    return rc;
                
                rc = write733(volInfo, DIRTW_PTR(child)->dataLength2);
                if(rc <= 0)
                    return rc;
            }
            else
            {
                wcSeekSet(volInfo, child->extentLocationOffset);
                
                rc = write733(volInfo, child->extentNumber);
                if(rc <= 0)
                    return rc;
                
                rc = write733(volInfo, DIRTW_PTR(child)->dataLength);
                if(rc <= 0)
                    return rc;
            }
        }
        
        child = child->next;
    }
    /* END ALL subdir extent locations and sizes */
    
    wcSeekSet(volInfo, endPos);
    
    if(filenameTypes & FNTYPE_JOLIET)
        return dir->dataLength2;
    else
        return dir->dataLength;
}

/******************************************************************************
* writeDr()
* Writes a directory record.
* Note that it uses only the members of DirToWrite and FileToWrite that are
* the same.
* */
int writeDr(VolInfo* volInfo, BaseToWrite* node, time_t recordingTime, bool isADir, 
            bool isSelfOrParent, bool isFirstRecord, int filenameTypes)
{
    int rc;
    unsigned char byte;
    char aString[256];
    unsigned short aShort;
    bk_off_t startPos;
    bk_off_t endPos;
    unsigned char lenFileId;
    unsigned char recordLen;
    
    /* look at the end of the function for an explanation */
    writeDrStartLabel:
    
    startPos = wcSeekTell(volInfo);
    
    /* record length is recorded in the end */
    wcSeekForward(volInfo, 1);
    
    /* extended attribute record length */
    byte = 0;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    if(filenameTypes & FNTYPE_JOLIET)
        node->extentLocationOffset2 = wcSeekTell(volInfo);
    else
        node->extentLocationOffset = wcSeekTell(volInfo);
    
    /* location of extent not recorded in this function */
    wcSeekForward(volInfo, 8);
    
    /* data length not recorded in this function */
    wcSeekForward(volInfo, 8);
    
    /* RECORDING time and date */
    epochToShortString(recordingTime, aString);
    
    rc = write711(volInfo, aString[0]);
    if(rc <= 0)
        return rc;
    rc = write711(volInfo, aString[1]);
    if(rc <= 0)
        return rc;
    rc = write711(volInfo, aString[2]);
    if(rc <= 0)
        return rc;
    rc = write711(volInfo, aString[3]);
    if(rc <= 0)
        return rc;
    rc = write711(volInfo, aString[4]);
    if(rc <= 0)
        return rc;
    rc = write711(volInfo, aString[5]);
    if(rc <= 0)
        return rc;
    rc = write711(volInfo, aString[6]);
    if(rc <= 0)
        return rc;
    /* END RECORDING time and date */
    
    /* FILE flags  */
    if(isADir)
    /* (only directory bit on) */
        byte = 0x02;
    else
    /* nothing on */
        byte = 0x00;
    
    rc = wcWrite(volInfo, (char*)&byte, 1);
    if(rc <= 0)
        return rc;
    /* END FILE flags  */
    
    /* file unit size (always 0, non-interleaved mode) */
    byte = 0;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* interleave gap size (also always 0, non-interleaved mode) */
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* volume sequence number (always 1) */
    aShort = 1;
    rc = write723(volInfo, aShort);
    if(rc <= 0)
        return rc;
    
    /* LENGTH of file identifier */
    if(isSelfOrParent)
        lenFileId = 1;
    else
    {
        if(filenameTypes & FNTYPE_JOLIET)
            lenFileId = 2 * strlen(node->nameJoliet);
        else
            /*if(isADir) see microsoft comment below */
                lenFileId = strlen(node->name9660);
            /*else
                lenFileId = strlen(node->name9660) + 2; */
    }
    
    rc = write711(volInfo, lenFileId);
    if(rc <= 0)
        return rc;
    /* END LENGTH of file identifier */
    
    /* FILE identifier */
    if(isSelfOrParent)
    {
        /* that byte has 0x00 or 0x01 */
        rc = write711(volInfo, node->name9660[0]);
        if(rc <= 0)
            return rc;
    }
    else
    {
        if(filenameTypes & FNTYPE_JOLIET)
        {
            rc = writeJolietStringField(volInfo, node->nameJoliet, 
                                        2 * strlen(node->nameJoliet));
            if(rc < 0)
                return rc;
        }
        else
        {
            /* ISO9660 requires ";1" after the filename (not directory name) 
            * but the windows NT/2K boot loaders cannot find NTLDR inside
            * the I386 directory because they are looking for "NTLDR" not 
            * "NTLDR;1". i guess if microsoft can do it, i can do it. filenames
            * on images written by me do not end with ";1"
            if(isADir)
            {*/
                /* the name */
                rc = wcWrite(volInfo, node->name9660, lenFileId);
                if(rc <= 0)
                    return rc;
            /*}
            else
            {
                rc = writeWrapper(image, node->name9660, lenFileId - 2);
                if(rc <= 0)
                    return rc;
                
                rc = writeWrapper(image, ";1", 2);
                if(rc <= 0)
                    return rc;
            }*/
        }
    }
    /* END FILE identifier */
    
    /* padding field */
    if(lenFileId % 2 == 0)
    {
        byte = 0;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
    }
    
    if(filenameTypes & FNTYPE_ROCKRIDGE)
    {
        if(isFirstRecord)
        {
            rc = writeRockSP(volInfo);
            if(rc < 0)
                return rc;
            
            rc = writeRockER(volInfo);
            if(rc < 0)
                return rc;
        }
        
        rc = writeRockPX(volInfo, node->posixFileMode, isADir);
        if(rc < 0)
            return rc;
        
        if(!isSelfOrParent)
        {
            if(wcSeekTell(volInfo) - startPos < (int)strlen(node->nameRock) + 5)
            /* have no room for the NM entry in this directory record */
            {
                node->offsetForCE = wcSeekTell(volInfo);
                /* leave room for CE entry */
                wcSeekForward(volInfo, 28);
            }
            else
            {
                rc = writeRockNM(volInfo, node->nameRock, strlen(node->nameRock), false);
                if(rc < 0)
                    return rc;
            }
            
            if(IS_SYMLINK(node->posixFileMode))
            {
                rc = writeRockSL(volInfo, SYMLINKTW_PTR(node), true);
                if(rc < 0)
                    return rc;
            }
        }
    }
    
    /* RECORD length */
    endPos = wcSeekTell(volInfo);
    
    wcSeekSet(volInfo, startPos);
    
    recordLen = endPos - startPos;
    rc = write711(volInfo, recordLen);
    if(rc <= 0)
        return rc;
    
    wcSeekSet(volInfo, endPos);
    /* END RECORD length */
    
    /* the goto is good! really!
    * if, after writing the record we see that the record is in two logical
    * sectors (that's not allowed by iso9660) we erase the record just
    * written, write zeroes to the end of the first logical sector
    * (as required by iso9660) and restart the function, which will write
    * the same record again but at the beginning of the next logical sector
    * yeah, so don't complain :) */
    
    if(endPos / NBYTES_LOGICAL_BLOCK > startPos / NBYTES_LOGICAL_BLOCK)
    /* crossed a logical sector boundary while writing the record */
    {
        wcSeekSet(volInfo, startPos);
        
        /* overwrite a piece of the record written in this function
        * (the piece that's in the first sector) with zeroes */
        rc = writeByteBlock(volInfo, 0x00, recordLen - endPos % NBYTES_LOGICAL_BLOCK);
        if(rc < 0)
            return rc;
        
        goto writeDrStartLabel;
    }
    
    return 1;
}

/******************************************************************************
* writeElToritoBootCatalog()
* Write the el torito boot catalog (validation entry and inital/default entry).
* Returns the offset where the boot record sector number should
* be written (7.3.1).
* */
int writeElToritoBootCatalog(VolInfo* volInfo, 
                             bk_off_t* bootRecordSectorNumberOffset)
{
    unsigned char buffer[NBYTES_LOGICAL_BLOCK];
    int rc;
    
    memset(buffer, 0, NBYTES_LOGICAL_BLOCK);
    
    if(wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK != 0)
    /* file pointer not at sector boundary */
        return BKERROR_SANITY;
    
    /* SETUP VALIDATION entry (first 20 bytes of boot catalog) */
    /* header, must be 1 */
    buffer[0] = 1;
    /* platform id, 0 for x86 (bzero at start took care of this) */
    /* 2 bytes reserved, must be 0 (bzero at start took care of this) */
    /* 24 bytes id string for manufacturer/developer of cdrom */
    strncpy((char*)&(buffer[4]), "Edited with ISO Master", 22);
    /* key byte 0x55 */
    buffer[30] = 0x55;
    /* key byte 0xAA */
    buffer[31] = 0xAA;
    
    /* checksum */
    write721ToByteArray(&(buffer[28]), elToritoChecksum(buffer));
    /* END SETUP VALIDATION validation entry (first 20 bytes of boot catalog) */
    
    /* SETUP INITIAL entry (next 20 bytes of boot catalog) */
    /* boot indicator. 0x88 = bootable */
    buffer[32] = 0x88;
    
    /* BEGIN fix from Javier Navarro */
    /* The "sector count" value to load the bootstrap into memory is 
    * too large. Your code puts more than 2880 sectors, overflowing the
    * initial memory. Actually the normal values are 1 or 4.
    * Loading up to 60 works fine in real-hardware and emulated-hardware
    * (bochs), but there is no sense in loading more than 4 sectors. */
    
    /* sector count default */
	buffer[38] = 4; /* buffer[38][39] little endian word = 0x0004 default */
	buffer[39] = 0;
    /* boot media type & sector count */
    if(volInfo->bootMediaType == BOOT_MEDIA_NO_EMULATION)
    {   buffer[33] = 0; /* boot media type */
	buffer[38] = 4; /* sector count */
    }
    else if(volInfo->bootMediaType == BOOT_MEDIA_1_2_FLOPPY)
    {   buffer[33] = 1; /* boot media type */
	buffer[38] = 1; /* sector count */
    }
    else if(volInfo->bootMediaType == BOOT_MEDIA_1_44_FLOPPY)
    {   buffer[33] = 2; /* boot media type */
	buffer[38] = 1; /* sector count */
    }
    else if(volInfo->bootMediaType == BOOT_MEDIA_2_88_FLOPPY)
    {   buffer[33] = 3; /* boot media type */
	buffer[38] = 1; /* sector count */
    }
    else if(volInfo->bootMediaType == BOOT_MEDIA_HARD_DISK)
    {   buffer[33] = 4; /* boot media type */
	buffer[38] = 1; /* sector count */
    }
    /* load segment leave it at 0 */
    /* system type, leave it at 0 */
    /* 1 byte unused, leave it at 0 */
    
    //~ /* boot media type */
    //~ if(volInfo->bootMediaType == BOOT_MEDIA_NO_EMULATION)
        //~ buffer[33] = 0;
    //~ else if(volInfo->bootMediaType == BOOT_MEDIA_1_2_FLOPPY)
        //~ buffer[33] = 1;
    //~ else if(volInfo->bootMediaType == BOOT_MEDIA_1_44_FLOPPY)
        //~ buffer[33] = 2;
    //~ else if(volInfo->bootMediaType == BOOT_MEDIA_2_88_FLOPPY)
        //~ buffer[33] = 3;
    //~ else if(volInfo->bootMediaType == BOOT_MEDIA_HARD_DISK)
        //~ buffer[33] = 4;
    //~ /* load segment leave it at 0 */
    //~ /* system type, leave it at 0 */
    //~ /* 1 byte unused, leave it at 0 */
    //~ /* sector count */
    //~ write721ToByteArray(&(buffer[38]), volInfo->bootRecordSize / NBYTES_VIRTUAL_SECTOR);
    
    /* END fix from Javier Navarro */
    
    /* logical block number of boot record file. this is not known until 
    * after that file is written */
    *bootRecordSectorNumberOffset = wcSeekTell(volInfo) + 40;
    /* the rest is unused, leave it at 0 */
    /* END SETUP INITIAL entry (next 20 bytes of boot catalog) */
    
    rc = wcWrite(volInfo, (char*)buffer, NBYTES_LOGICAL_BLOCK);
    if(rc <= 0)
        return rc;
    
    return 1;
}

/******************************************************************************
* writeElToritoVd()
* Write the el torito volume descriptor.
* Returns the offset where the boot catalog sector number should 
* be written (7.3.1).
* */
int writeElToritoVd(VolInfo* volInfo, bk_off_t* bootCatalogSectorNumberOffset)
{
    char buffer[NBYTES_LOGICAL_BLOCK];
    int rc;
    
    memset(buffer, 0, NBYTES_LOGICAL_BLOCK);
    
    if(wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK != 0)
    /* file pointer not at sector boundary */
        return BKERROR_SANITY;
    
    /* SETUP BOOT record volume descriptor sector */
    /* boot record indicator, must be 0 (bzero at start took care of this) */
    /* iso9660 identifier, must be "CD001" */
    memcpy(buffer + 1, "CD001", 5);
    /* version, must be 1 */
    buffer[6] = 1;
    /* boot system identifier, must be 32 bytes "EL TORITO SPECIFICATION" 
    * padded with 0x00 (bzero at start took care of this) */
    memcpy(&(buffer[7]), "EL TORITO SPECIFICATION", 23);
    /* unused 32 bytes, must be 0 (bzero at start took care of this) */
    /* boot catalog location, 4 byte intel format. written later. */
    *bootCatalogSectorNumberOffset = wcSeekTell(volInfo) + 71;
    /*write731ToByteArray(&(buffer[71]), bootCatalogSectorNumber);*/
    /* the rest of this sector is unused, must be set to 0 */
    /* END SETUP BOOT record volume descriptor sector */
    
    rc = wcWrite(volInfo, buffer, NBYTES_LOGICAL_BLOCK);
    if(rc <= 0)
        return rc;
    
    return 1;
}

/******************************************************************************
* writeFileContents()
* Write file contents into an extent and also write the file's location and 
* size into the directory records back in the tree.
* Also write location and size for symbolic links.
* */
int writeFileContents(VolInfo* volInfo, DirToWrite* dir, int filenameTypes)
{
    int rc;
    
    BaseToWrite* child;
    int numUnusedBytes;
    int srcFile;
    bk_off_t endPos;
    
    child = dir->children;
    while(child != NULL)
    /* each file in current directory */
    {
        if(volInfo->stopOperation)
            return BKERROR_OPER_CANCELED_BY_USER;
        
        if(wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK != 0)
            return BKERROR_SANITY;
        
        if( IS_REG_FILE(child->posixFileMode) )
        {
            bool needToCopy = true;
            
            child->extentNumber = wcSeekTell(volInfo) / NBYTES_LOGICAL_BLOCK;
            if(volInfo->scanForDuplicateFiles)
            {
                if(FILETW_PTR(child)->location->extentNumberWrittenTo == 0)
                /* file not yet written */
                {
                    FILETW_PTR(child)->location->extentNumberWrittenTo = child->extentNumber;
                }
                else
                {
                    child->extentNumber = FILETW_PTR(child)->location->extentNumberWrittenTo;
                    needToCopy = false;
                }
            }
            
            if(volInfo->bootMediaType != BOOT_MEDIA_NONE && 
               volInfo->bootRecordIsVisible &&
               FILETW_PTR(child)->origFile == volInfo->bootRecordOnImage)
            /* this file is the boot record. write its sector number in 
            * the boot catalog */
            {
                bk_off_t currPos;
                
                currPos = wcSeekTell(volInfo);
                
                wcSeekSet(volInfo, volInfo->bootRecordSectorNumberOffset);
                rc = write731(volInfo, child->extentNumber);
                if(rc <= 0)
                    return rc;
                
                wcSeekSet(volInfo, currPos);
            }
            
            if(needToCopy)
            {
                if(FILETW_PTR(child)->onImage)
                /* copy file from original image to new one */
                {
                    readSeekSet(volInfo, FILETW_PTR(child)->offset, 
                                SEEK_SET);
                    
                    rc = writeByteBlockFromFile(volInfo->imageForReading, 
                                                volInfo, FILETW_PTR(child)->size);
                    if(rc < 0)
                        return rc;
                }
                else
                /* copy file from fs to new image */
                {
                    /* UPDATE the file's size, in case it's changed since we added it */
                    BkStatStruct statStruct;
                    
                    rc = bkStat(FILETW_PTR(child)->pathAndName, &statStruct);
                    if(rc != 0)
                        return BKERROR_STAT_FAILED;
                    
                    if(statStruct.st_size > 0xFFFFFFFF)
                    /* size won't fit in a 32bit variable on the iso */
                        return BKERROR_EDITED_WRITE_TOO_BIG;
                    
                    FILETW_PTR(child)->size = statStruct.st_size;
                    /* UPDATE the file's size, in case it's changed since we added it */
                    
                    srcFile = open(FILETW_PTR(child)->pathAndName, O_RDONLY, 0);
                    if(srcFile == -1)
                        return BKERROR_OPEN_READ_FAILED;
                    
                    rc = writeByteBlockFromFile(srcFile, 
                                                volInfo, FILETW_PTR(child)->size);
                    
                    bkClose(srcFile);
                    
                    if(rc < 0)
                        return rc;
                }
                
                /* fill extent with zeroes */
                numUnusedBytes = NBYTES_LOGICAL_BLOCK - 
                                 wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK;
                rc = writeByteBlock(volInfo, 0x00, numUnusedBytes);
                if(rc < 0)
                    return rc;
            }
            
            endPos = wcSeekTell(volInfo);
            
            bool isIsolinux;
            rc = wroteIsolinuxBootRecord(volInfo, FILETW_PTR(child), &isIsolinux);
            if(rc < 0)
                return rc;
            
            if(isIsolinux)
            /* write the boot info table for the isolinux boot record */
            {
                unsigned char bootInfoTable[56];
                unsigned checksum;
                
                memset(bootInfoTable, 0, 56);
                
                /* go to the offset in the file where the boot info table is */
                wcSeekSet(volInfo, child->extentNumber * 
                          NBYTES_LOGICAL_BLOCK + 8);
                
                /* sector number of pvd */
                write731ToByteArray(bootInfoTable, 16);
                /* sector number of boot file (this one) */
                write731ToByteArray(bootInfoTable + 4, child->extentNumber);
                /* boot file length in bytes */
                write731ToByteArray(bootInfoTable + 8, FILETW_PTR(child)->size);
                /* 32 bit checksum (the sum of all the 32-bit words in the boot
                * file starting at byte offset 64 */
                rc = bootInfoTableChecksum(volInfo->imageForReading, FILETW_PTR(child), &checksum);
                if(rc <= 0)
                    return rc;
                write731ToByteArray(bootInfoTable + 12, checksum);
                /* the rest is reserved, leave at zero */
                
                rc = wcWrite(volInfo, (char*)bootInfoTable, 56);
                if(rc <= 0)
                    return rc;
            }
            
            /* WRITE file location and size */
            wcSeekSet(volInfo, child->extentLocationOffset);
            
            rc = write733(volInfo, child->extentNumber);
            if(rc <= 0)
                return rc;
            
            rc = write733(volInfo, FILETW_PTR(child)->size);
            if(rc <= 0)
                return rc;
            
            if(filenameTypes & FNTYPE_JOLIET)
            /* also update location and size on joliet tree */
            {
                wcSeekSet(volInfo, child->extentLocationOffset2);
                
                rc = write733(volInfo, child->extentNumber);
                if(rc <= 0)
                    return rc;
                
                rc = write733(volInfo, FILETW_PTR(child)->size);
                if(rc <= 0)
                    return rc;
            }
            
            wcSeekSet(volInfo, endPos);
            /* END WRITE file location and size */
        }
        else if( IS_DIR(child->posixFileMode) )
        {
            rc = writeFileContents(volInfo, DIRTW_PTR(child), filenameTypes);
            if(rc < 0)
                return rc;
        }
        else if( IS_SYMLINK(child->posixFileMode) )
        {
            /* WRITE symlink location and size (0) */
            endPos = wcSeekTell(volInfo);
            
            wcSeekSet(volInfo, child->extentLocationOffset);
            
            rc = write733(volInfo, 0);
            if(rc <= 0)
                return rc;
            
            rc = write733(volInfo, 0);
            if(rc <= 0)
                return rc;
            
            if(filenameTypes & FNTYPE_JOLIET)
            /* also update location and size on joliet tree */
            {
                wcSeekSet(volInfo, child->extentLocationOffset2);
                
                rc = write733(volInfo, 0);
                if(rc <= 0)
                    return rc;
                
                rc = write733(volInfo, 0);
                if(rc <= 0)
                    return rc;
            }
            
            wcSeekSet(volInfo, endPos);
            /* END WRITE symlink location and size (0)  */
        }
        
        child = child->next;
        
    } /* while(nextFile != NULL) */
    
    return 1;
}

/* field size must be even. !!check all calls to make sure */
int writeJolietStringField(VolInfo* volInfo, const char* name, size_t fieldSize)
{
    char jolietName[512]; /* don't see why would ever want 
                          * to write a longer one */
    int srcCount;
    size_t destCount;
    int rc;
    
    srcCount = 0;
    destCount = 0;
    while(name[srcCount] != '\0' && destCount < fieldSize)
    {
        /* first byte zero */
        jolietName[destCount] = 0x00;
        /* second byte character */
        jolietName[destCount + 1] = name[srcCount];
        
        srcCount += 1;
        destCount += 2;
    }
    
    while(destCount < fieldSize)
    /* pad with ucs2 spaces */
    {
        jolietName[destCount] = 0x00;
        jolietName[destCount + 1] = ' ';
        
        destCount += 2;
    }
    
    rc = wcWrite(volInfo, jolietName, destCount);
    if(rc <= 0)
        return rc;
    
    return 1;
}

/* write NM that won't fit in a directory record */
int writeLongNM(VolInfo* volInfo, BaseToWrite* node)
{
    bk_off_t startPos;
    size_t fullNameLen;
    unsigned char CErecord[28];
    bool fitsInOneNM;
    size_t firstNMlen;
    bk_off_t endPos;
    int rc;
    int lenOfCE;
    
    startPos = wcSeekTell(volInfo);
    
    fullNameLen = strlen(node->nameRock);
    
    /* should have checked for this before getting into this function */
    if(fullNameLen > 255)
        return BKERROR_SANITY;
    
    if(fullNameLen > 250)
    {
        fitsInOneNM = false;
        firstNMlen = 250;
    }
    else
    {
        fitsInOneNM = true;
        firstNMlen = fullNameLen;
    }
    
    /* NM record(s) */
    if(fitsInOneNM)
    {
        rc = writeRockNM(volInfo, node->nameRock, firstNMlen, false);
        if(rc <= 0)
            return rc;
    }
    else
    {
        rc = writeRockNM(volInfo, node->nameRock, firstNMlen, true);
        if(rc <= 0)
            return rc;
        rc = writeRockNM(volInfo, node->nameRock + firstNMlen, fullNameLen - firstNMlen, false);
        if(rc <= 0)
            return rc;
    }
    
    lenOfCE = wcSeekTell(volInfo) - startPos;
    
    /* write blank to conclude extent */
    rc = writeByteBlock(volInfo, 0x00, NBYTES_LOGICAL_BLOCK - 
                        wcSeekTell(volInfo) % NBYTES_LOGICAL_BLOCK);
    if(rc < 0)
        return rc;
    
    endPos = wcSeekTell(volInfo);
    
    /* CE record back in the directory record */
    wcSeekSet(volInfo, node->offsetForCE);
    
    CErecord[0] = 'C';
    CErecord[1] = 'E';
    CErecord[2] = 28; /* length */
    CErecord[3] = 1; /* version */
    write733ToByteArray(CErecord + 4, startPos / NBYTES_LOGICAL_BLOCK); /* block location */
    /* i'm always using 1 logical block per name */
    write733ToByteArray(CErecord + 12, 0); /* offset to start */
    write733ToByteArray(CErecord + 20, lenOfCE); /* length */
    
    rc = wcWrite(volInfo, (char*)CErecord, CErecord[2]);
    if(rc <= 0)
        return rc;
    /* END CE record back in the directory record */
    
    wcSeekSet(volInfo, endPos);
    
    return 1;
}

/* write all NMs in the tree that won't fit in directory records */
int writeLongNMsInDir(VolInfo* volInfo, DirToWrite* dir)
{
    BaseToWrite* child;
    int rc;
    
    child = dir->children;
    while(child != NULL)
    {
        if(child->offsetForCE != 0)
        {
            rc = writeLongNM(volInfo, child);
            if(rc <= 0)
                return rc;
        }
        
        if( IS_DIR(child->posixFileMode) )
        {
            rc = writeLongNMsInDir(volInfo, DIRTW_PTR(child));
            if(rc <= 0)
                return rc;
        }
        
        child = child->next;
    }
    
    return 1;
}

/* returns path table size (number of bytes not counting the blank) */
int writePathTable(VolInfo* volInfo, const DirToWrite* tree, bool isTypeL, 
                   int filenameType)
{
    int treeHeight;
    int count;
    int level;
    int* dirsPerLevel; /* a dynamic array of the number of dirs per level */
    int numDirsSoFar;
    bk_off_t origPos;
    int numBytesWritten;
    int rc;
    
    origPos = wcSeekTell(volInfo);
    
    if(origPos % NBYTES_LOGICAL_BLOCK != 0)
        return BKERROR_SANITY;
    
    treeHeight = countTreeHeight(tree, 1);
    
    dirsPerLevel = malloc(sizeof(int) * treeHeight);
    if(dirsPerLevel == NULL)
        return BKERROR_OUT_OF_MEMORY;
    
    for(count = 0; count < treeHeight; count++)
    {
        dirsPerLevel[count] = countDirsOnLevel(tree, count + 1, 1);
    }
    
    for(level = 1; level <= treeHeight; level++)
    {
        if(level == 1)
        /* numDirsSoFar = parent dir num */
            numDirsSoFar = 1;
        else if(level == 2)
            numDirsSoFar = 1;
        else
        {
            /* ex. when i am on level 4 i want number of dirs on levels 1 + 2 */
            numDirsSoFar = 0;
            for(count = 0; count < level - 2; count++)
            {
                numDirsSoFar += dirsPerLevel[count];
            }
        }
        
        rc = writePathTableRecordsOnLevel(volInfo, tree, isTypeL, filenameType, 
                                          level, 1, &numDirsSoFar);
        if(rc < 0)
        {
            free(dirsPerLevel);
            return rc;
        }
    }
    
    numBytesWritten = wcSeekTell(volInfo) - origPos;
    
    /* blank to conclude extent */
    rc = writeByteBlock(volInfo, 0x00, NBYTES_LOGICAL_BLOCK - 
                        numBytesWritten % NBYTES_LOGICAL_BLOCK);
    if(rc < 0)
    {
        free(dirsPerLevel);
        return rc;
    }
    
    free(dirsPerLevel);
    
    return numBytesWritten;
}

int writePathTableRecordsOnLevel(VolInfo* volInfo, const DirToWrite* dir, 
                                 bool isTypeL, int filenameType, 
                                 int targetLevel, int thisLevel,
                                 int* parentDirNum)
{
    int rc;
    BaseToWrite* child;
    
    unsigned char fileIdLen;
    unsigned char byte;
    unsigned exentLocation;
    unsigned short parentDirId; /* copy of *parentDirNum */
    static const char rootId = 0x00;
    
    if(thisLevel == targetLevel)
    /* write path table record */
    {
        /* LENGTH  of directory identifier */
        if(targetLevel == 1)
        /* root */
            fileIdLen = 1;
        else
        {
            if(filenameType & FNTYPE_JOLIET)
            {
                fileIdLen = 2 * strlen(BASETW_PTR(dir)->nameJoliet);
            }
            else
            {
                fileIdLen = strlen(BASETW_PTR(dir)->name9660);
            }
        }
        
        rc = write711(volInfo, fileIdLen);
        if(rc <= 0)
            return rc;
        /* END LENGTH  of directory identifier */
        
        /* extended attribute record length */
        byte = 0;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
        
        /* LOCATION of extent */
        if(filenameType & FNTYPE_JOLIET)
            exentLocation = dir->extentNumber2;
        else
            exentLocation = BASETW_PTR(dir)->extentNumber;
        
        if(isTypeL)
            rc = write731(volInfo, exentLocation);
        else
            rc = write732(volInfo, exentLocation);
        if(rc <= 0)
            return rc;
        /* END LOCATION of extent */
        
        /* PARENT directory number */
        parentDirId = *parentDirNum;
        
        if(isTypeL)
            rc = write721(volInfo, parentDirId);
        else
            rc = write722(volInfo, parentDirId);
        
        if(rc <= 0)
            return rc;
        /* END PARENT directory number */
        
        /* DIRECTORY identifier */
        if(targetLevel == 1)
        /* root */
        {
            rc = wcWrite(volInfo, &rootId, 1);
            if(rc <= 0)
                return rc;
        }
        else
        {
            if(filenameType & FNTYPE_JOLIET)
            {
                rc = writeJolietStringField(volInfo, BASETW_PTR(dir)->nameJoliet, fileIdLen);
                if(rc < 0)
                    return rc;
            }
            else
            {
                rc = wcWrite(volInfo, BASETW_PTR(dir)->name9660, fileIdLen);
                if(rc <= 0)
                    return rc;
            }
        }
        /* END DIRECTORY identifier */
        
        /* padding field */
        if(fileIdLen % 2 != 0)
        {
            byte = 0;
            rc = write711(volInfo, byte);
            if(rc <= 0)
                return rc;
        }
        
    }
    else /* if(thisLevel < targetLevel) */
    {
        child = dir->children;
        while(child != NULL)
        {
            if( IS_DIR(child->posixFileMode) )
            {
                if(thisLevel == targetLevel - 2)
                /* am now going throught the list of dirs where the parent is */
                {
                    if(targetLevel != 2)
                    /* first and second level have the same parent: 1 */
                    {
                        (*parentDirNum)++;
                    }
                }
                
                rc = writePathTableRecordsOnLevel(volInfo, DIRTW_PTR(child), isTypeL,
                                                  filenameType, targetLevel, 
                                                  thisLevel + 1, parentDirNum);
                if(rc < 0)
                    return rc;
            }
            
            child = child->next;
        }
    }
    
    return 1;
}

/* This doesn't need support for CE because it's only written in one place,
* the root 'self' directory record. */
int writeRockER(VolInfo* volInfo)
{
    int rc;
    char record[46];
    
    /* identification */
    record[0] = 'E';
    record[1] = 'R';
    
    /* record length */
    record[2] = 46;
    
    /* entry version */
    record[3] = 1;
    
    /* extension identifier length */
    record[4] = 10;
    
    /* extension descriptor length */
    record[5] = 10;
    
    /* extension source length */
    record[6] = 18;
    
    /* extension version */
    record[7] = 1;
    
    /* extension identifier */
    memcpy(&(record[8]), "IEEE_P1282", 10);
    
    /* extension descriptor */
    memcpy(&(record[18]), "DRAFT_1_12", 10);
    
    /* extension source */
    memcpy(&(record[28]), "ADOPTED_1994_07_08", 18);
    
    rc = wcWrite(volInfo, record, 46);
    if(rc <= 0)
        return rc;
    
    return 1;
}

int writeRockNM(VolInfo* volInfo, char* name, size_t nameLen, bool doesContinue)
{
    int rc;
    char recordStart[5];
    
    /* identification */
    recordStart[0] = 'N';
    recordStart[1] = 'M';
    
    /* record length */
    recordStart[2] = 5 + nameLen;
    
    /* entry version */
    recordStart[3] = 1;
    
    /* flags */
    if(doesContinue)
        recordStart[4] = 0x01;
    else
        recordStart[4] = 0;
    
    rc = wcWrite(volInfo, recordStart, 5);
    if(rc <= 0)
        return rc;
    
    rc = wcWrite(volInfo, name, nameLen);
    if(rc <= 0)
        return rc;
    
    return 1;
}

/* the slackware cd has 36 byte PX entries, missing the file serial number
* so i will do the same */
int writeRockPX(VolInfo* volInfo, unsigned posixFileMode, bool isADir)
{
    int rc;
    unsigned char record[36];
    unsigned posixFileLinks;
    
    /* identification */
    record[0] = 'P';
    record[1] = 'X';
    
    /* record length */
    record[2] = 36;
    
    /* entry version */
    record[3] = 1;
    
    /* posix file mode */
    write733ToByteArray(&(record[4]), posixFileMode);
    
    /* POSIX file links */
    /*
    * this i think is number of subdirectories + 2 (self and parent)
    * and 1 for a file
    * it's probably not used on read-only filesystems
    * to add it, i would need to pass the number of links in a parent dir
    * recursively in writeDir(). brrrrr.
    */
    if(isADir)
        posixFileLinks = 2;
    else
        posixFileLinks = 1;
    
    write733ToByteArray(&(record[12]), posixFileLinks);
    /* END POSIX file links */
    
    /* posix file user id, posix file group id */
    memset(&(record[20]), 0, 16);
    
    rc = wcWrite(volInfo, (char*)record, 36);
    if(rc <= 0)
        return rc;
    
    return 1;
}

int writeRockSL(VolInfo* volInfo, SymLinkToWrite* symlink, bool doWrite)
{
    size_t stringCount;
    size_t targetLen;
    size_t numBytesNeeded;
    size_t numBytesToSkip;
    unsigned char* record;
    size_t recordCount;
    int rc;
    
    targetLen = strlen(symlink->target);
    
    /* figure out how much room i need */
    numBytesNeeded = 0;
    numBytesToSkip = 0;
    stringCount = 0;
    while(stringCount < targetLen)
    {
        char* nextSlash;
        
        if(symlink->target[stringCount] == '/')
        /* root (/) */
        {
            numBytesNeeded += 2;
            numBytesToSkip = 1;
        }
        else if( symlink->target[stringCount] == '.' && 
                 (stringCount + 1 == targetLen || symlink->target[stringCount + 1] == '/') )
        /* current (.) */
        {
            numBytesNeeded += 2;
            numBytesToSkip = 2;
        }
        else if( symlink->target[stringCount] == '.' && 
                 stringCount + 1 < targetLen && symlink->target[stringCount + 1] == '.' )
        /* parent (..) */
        {
            numBytesNeeded += 2;
            numBytesToSkip = 3;
        }
        else
        /* regular filename */
        {
            nextSlash = strchr(symlink->target + stringCount, '/');
            if(nextSlash != NULL)
                numBytesToSkip = nextSlash - (symlink->target + stringCount);
            else
                numBytesToSkip = targetLen - stringCount;
            
            numBytesNeeded += 2 + numBytesToSkip;
            
            numBytesToSkip += 1;
        }
        
        stringCount += numBytesToSkip;
    }
    
    if(!doWrite)
        return (int)(5 + numBytesNeeded);
    
    if(numBytesNeeded > NCHARS_SYMLINK_TARGET_MAX - 1)
        return BKERROR_SYMLINK_TARGET_TOO_LONG;
    
    record = malloc(5 + numBytesNeeded);
    if(record == NULL)
        return BKERROR_OUT_OF_MEMORY;
    
    record[0] = 'S';
    record[1] = 'L';
    record[2] = 5 + numBytesNeeded; /* length */
    record[3] = 1; /* version */
    record[4] = 0x00; /* flags */
    
    /* write SL */
    numBytesToSkip = 0;
    stringCount = 0;
    recordCount = 5;
    while(stringCount < targetLen)
    {
        char* nextSlash;
        
        if(symlink->target[stringCount] == '/')
        /* root (/) */
        {
            numBytesToSkip = 1;
            record[recordCount] = 0x08;
            record[recordCount + 1] = 0;
            recordCount += 2;
        }
        else if( symlink->target[stringCount] == '.' && 
                 (stringCount + 1 == targetLen || symlink->target[stringCount + 1] == '/') )
        /* current (.) */
        {
            numBytesToSkip = 2;
            record[recordCount] = 0x02;
            record[recordCount + 1] = 0;
            recordCount += 2;
        }
        else if( symlink->target[stringCount] == '.' && 
                 stringCount + 1 < targetLen && symlink->target[stringCount + 1] == '.' )
        /* parent (..) */
        {
            numBytesToSkip = 3;
            record[recordCount] = 0x04;
            record[recordCount + 1] = 0;
            recordCount += 2;
        }
        else
        /* regular filename */
        {
            nextSlash = strchr(symlink->target + stringCount, '/');
            if(nextSlash != NULL)
                numBytesToSkip = nextSlash - (symlink->target + stringCount);
            else
                numBytesToSkip = targetLen - stringCount;
            
            record[recordCount] = 0x00;
            record[recordCount + 1] = numBytesToSkip;
            strncpy((char*)record + recordCount + 2, symlink->target + stringCount, numBytesToSkip);
            recordCount += 2 + numBytesToSkip;
            
            numBytesToSkip += 1;
        }
        
        /* + separator */
        stringCount += numBytesToSkip;
    }
    
    if(recordCount != numBytesNeeded + 5)
    {
        free(record);
        return BKERROR_SANITY;
    }
    
    rc = wcWrite(volInfo, (char*)record, recordCount);
    if(rc <= 0)
    {
        free(record);
        return rc;
    }
    
    free(record);

    return (int)(5 + numBytesNeeded);
}

/* This doesn't need support for CE because it's only written in one place,
* the root 'self' directory record. */
int writeRockSP(VolInfo* volInfo)
{
    int rc;
    unsigned char record[7];
    
    /* identification */
    record[0] = 'S';
    record[1] = 'P';
    
    /* record length */
    record[2] = 7;
    
    /* entry version */
    record[3] = 1;
    
    /* check bytes */
    record[4] = 0xBE;
    record[5] = 0xEF;
    
    /* bytes skipped */
    record[6] = 0;
    
    rc = wcWrite(volInfo, (char*)record, 7);
    if(rc <= 0)
        return rc;
    
    return 1;
}

int writeVdsetTerminator(VolInfo* volInfo)
{
    int rc;
    unsigned char byte;
    unsigned char aString[6];
    
    /* volume descriptor type */
    byte = 255;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* standard identifier */
    strcpy((char*)aString, "CD001");
    rc = wcWrite(volInfo, (char*)aString, 5);
    if(rc <= 0)
        return rc;
    
    /* volume descriptor version */
    byte = 1;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    rc = writeByteBlock(volInfo, 0, 2041);
    if(rc < 0)
        return rc;
    
    return 1;
}

/*
* -has to be called after the files were written so that the 
*  volume size is recorded properly
* -rootdr location, size are in bytes
* -note strings are not terminated on image
*/
int writeVolDescriptor(VolInfo* volInfo, bk_off_t rootDrLocation,
                       unsigned rootDrSize, bk_off_t lPathTableLoc, 
                       bk_off_t mPathTableLoc, unsigned pathTableSize, 
                       time_t creationTime, bool isPrimary)
{
    int rc;
    size_t count;
    
    unsigned char byte;
    unsigned char aString[129];
    unsigned anUnsigned;
    unsigned short anUnsignedShort;
    bk_off_t currPos;
    
    /* VOLUME descriptor type */
    if(isPrimary)
        byte = 1;
    else
        byte = 2;
    /* END VOLUME descriptor type */

    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* standard identifier */
    strcpy((char*)aString, "CD001");
    rc = wcWrite(volInfo, (char*)aString, 5);
    if(rc <= 0)
        return rc;
    
    /* volume descriptor version (always 1) */
    byte = 1;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* primary: unused field
    *  supplementary: volume flags, 0x00 */
    byte = 0;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* system identifier (32 spaces) */
    if(isPrimary)
    {
        strcpy((char*)aString, "                                ");
        rc = wcWrite(volInfo, (char*)aString, 32);
        if(rc <= 0)
            return rc;
    }
    else
    {
        rc = writeJolietStringField(volInfo, "", 32);
        if(rc < 0)
            return rc;
    }
    
    /* VOLUME identifier */
    if(isPrimary)
    {
        strcpy((char*)aString, volInfo->volId);
        
        for(count = strlen((char*)aString); count < 32; count++)
            aString[count] = ' ';
        
        rc = wcWrite(volInfo, (char*)aString, 32);
        if(rc <= 0)
            return rc;
    }
    else
    {
        rc = writeJolietStringField(volInfo, volInfo->volId, 32);
        if(rc < 0)
            return rc;
    }
    /* END VOLUME identifier */
    
    /* unused field */
    rc = writeByteBlock(volInfo, 0, 8);
    if(rc < 0)
        return rc;
    
    /* VOLUME space size (number of logical blocks, absolutely everything) */
    /* it's safe to not use wcSeek() here since everything is left as it is */
    currPos = bkSeekTell(volInfo->imageForWriting);
    
    bkSeekSet(volInfo->imageForWriting, 0, SEEK_END);
    anUnsigned = bkSeekTell(volInfo->imageForWriting) / 
                 NBYTES_LOGICAL_BLOCK;
    
    bkSeekSet(volInfo->imageForWriting, currPos, SEEK_SET);
    
    rc = write733(volInfo, anUnsigned);
    if(rc <= 0)
        return rc;
    /* END VOLUME space size (number of logical blocks, absolutely everything) */
    
    /* primary: unused field
    *  joliet: escape sequences */
    if(isPrimary)
    {
        rc = writeByteBlock(volInfo, 0, 32);
        if(rc < 0)
            return rc;
    }
    else
    {
        /* this is the only joliet field that's padded with 0x00 instead of ' ' */
        aString[0] = 0x25;
        aString[1] = 0x2F;
        aString[2] = 0x45;
        
        rc = wcWrite(volInfo, (char*)aString, 3);
        if(rc <= 0)
            return rc;
        
        rc = writeByteBlock(volInfo, 0, 29);
        if(rc < 0)
            return rc;
    }
    
    /* volume set size (always 1) */
    anUnsignedShort = 1;
    rc = write723(volInfo, anUnsignedShort);
    if(rc <= 0)
        return rc;
    
    /* volume sequence number (also always 1) */
    rc = write723(volInfo, anUnsignedShort);
    if(rc <= 0)
        return rc;
    
    /* logical block size (always 2048) */
    anUnsignedShort = NBYTES_LOGICAL_BLOCK;
    rc = write723(volInfo, anUnsignedShort);
    if(rc <= 0)
        return rc;
    
    /* path table size */
    anUnsigned = pathTableSize;
    rc = write733(volInfo, anUnsigned);
    if(rc <= 0)
        return rc;
    
    /* location of occurence of type l path table */
    anUnsigned = lPathTableLoc / NBYTES_LOGICAL_BLOCK;
    rc = write731(volInfo, anUnsigned);
    if(rc <= 0)
        return rc;
    
    /* location of optional occurence of type l path table */
    anUnsigned = 0;
    rc = write731(volInfo, anUnsigned);
    if(rc <= 0)
        return rc;
    
    /* location of occurence of type m path table */
    anUnsigned = mPathTableLoc / NBYTES_LOGICAL_BLOCK;
    rc = write732(volInfo, anUnsigned);
    if(rc <= 0)
        return rc;
    
    /* location of optional occurence of type m path table */
    anUnsigned = 0;
    rc = write732(volInfo, anUnsigned);
    if(rc <= 0)
        return rc;
    
    /* ROOT dr */
        /* record length (always 34 here) */
        byte = 34;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
        
        /* extended attribute record length (always none) */
        byte = 0;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
        
        /* location of extent */
        anUnsigned = rootDrLocation / NBYTES_LOGICAL_BLOCK;
        rc = write733(volInfo, anUnsigned);
        if(rc <= 0)
            return rc;
        
        /* data length */
        rc = write733(volInfo, rootDrSize);
        if(rc <= 0)
            return rc;
        
        /* recording time */
        epochToShortString(creationTime, (char*)aString);
        rc = wcWrite(volInfo, (char*)aString, 7);
        if(rc <= 0)
            return rc;
        
        /* file flags (always binary 00000010 here) */
        byte = 0x02;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
        
        /* file unit size (not in interleaved mode -> 0) */
        byte = 0;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
        
        /* interleave gap size (not in interleaved mode -> 0) */
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
         
        /* volume sequence number */
        anUnsignedShort = 1;
        rc = write723(volInfo, anUnsignedShort);
        if(rc <= 0)
            return rc;
        
        /* length of file identifier */
        byte = 1;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
        
        /* file identifier */
        byte = 0;
        rc = write711(volInfo, byte);
        if(rc <= 0)
            return rc;
    /* END ROOT dr */
    
    /* volume set identidier */
    if(isPrimary)
    {
        rc = writeByteBlock(volInfo, ' ', 128);
        if(rc < 0)
            return rc;
    }
    else
    {
        rc = writeJolietStringField(volInfo, "", 128);
        if(rc < 0)
            return rc;
    }
    
    /* PUBLISHER identifier */
    strcpy((char*)aString, volInfo->publisher);
    
    if(isPrimary)
    {
        for(count = strlen((char*)aString); count < 128; count++)
            aString[count] = ' ';
        
        rc = wcWrite(volInfo, (char*)aString, 128);
        if(rc <= 0)
            return rc;
    }
    else
    {
        rc = writeJolietStringField(volInfo, (char*)aString, 128);
        if(rc < 0)
            return rc;
    }
    /* PUBLISHER identifier */
    
    /* DATA preparer identifier */
    if(isPrimary)
    {
        rc = wcWrite(volInfo, "ISO Master", 10);
        if(rc <= 0)
            return rc;
        
        rc = writeByteBlock(volInfo, ' ', 118);
        if(rc < 0)
            return rc;
    }
    else
    {
        rc = writeJolietStringField(volInfo, "ISO Master", 128);
        if(rc < 0)
            return rc;
    }
    /* END DATA preparer identifier */
    
    /* application identifier, copyright file identifier, abstract file 
    * identifier, bibliographic file identifier (128 + 3*37) */
    if(isPrimary)
    {
        rc = writeByteBlock(volInfo, ' ', 239);
        if(rc < 0)
            return rc;
    }
    else
    {
        /* application id */
        rc = writeJolietStringField(volInfo, "", 128);
        if(rc < 0)
            return rc;
        
        /* 18 ucs2 spaces + 0x00 */
        for(count = 0; count < 3; count++)
        {
            rc = writeJolietStringField(volInfo, "", 36);
            if(rc < 0)
                return rc;
            
            byte = 0x00;
            rc = wcWrite(volInfo, (char*)&byte, 1);
            if(rc <= 0)
                return rc;
        }
    }
    
    /* VOLUME creation date */
    epochToLongString(creationTime, (char*)aString);
    
    rc = wcWrite(volInfo, (char*)aString, 17);
    if(rc <= 0)
        return rc;
    /* END VOLUME creation date */
    
    /* volume modification date (same as creation) */
    rc = wcWrite(volInfo, (char*)aString, 17);
    if(rc <= 0)
        return rc;
    
    /* VOLUME expiration date (none) */
    rc = writeByteBlock(volInfo, '0', 16);
    if(rc < 0)
        return rc;
    
    byte = 0;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    /* END VOLUME expiration date (none) */
    
    /* volume effective date (same as creation) */
    rc = wcWrite(volInfo, (char*)aString, 17);
    if(rc <= 0)
        return rc;
    
    /* file structure version */
    byte = 1;
    rc = write711(volInfo, byte);
    if(rc <= 0)
        return rc;
    
    /* reserved, applications use, reserved */
    rc = writeByteBlock(volInfo, 0, 1166);
    if(rc < 0)
        return rc;
    
    return 1;
}

/******************************************************************************
* wroteIsolinuxBootRecord()
* Check whether the file already written to the new iso was a boot record.
* */
int wroteIsolinuxBootRecord(VolInfo* volInfo, FileToWrite* file, 
                            bool* isIsolinux)
{
    *isIsolinux = false;
    
    if(volInfo->bootMediaType == BOOT_MEDIA_NO_EMULATION && 
       volInfo->bootRecordIsVisible &&
       file->origFile == volInfo->bootRecordOnImage)
    /* Likely true, do one more check to make sure. The extra check
    * is needed for Windows XP isos with SP2 added by c't slipstreamer */
    {
        bk_off_t origPos;
        int rc;
        char fourBytes[4];
        
        origPos = wcSeekTell(volInfo);
        
        wcSeekSet(volInfo, BASETW_PTR(file)->extentNumber * 
                  NBYTES_LOGICAL_BLOCK + 8);
        
        rc = bkRead(volInfo->imageForWriting, fourBytes, 4);
        if(rc != 4)
            return BKERROR_READ_GENERIC;
        
        if(fourBytes[0] == 16 && fourBytes[1] == 0 && 
           fourBytes[2] == 0 && fourBytes[3] == 0)
            *isIsolinux = true;
        
        wcSeekSet(volInfo, origPos);
    }
    
    return 1;
}
