Get Gentoo!
gentoo.org sites
gentoo.org Wiki Bugs Forums Packages
Planet Archives Sources
Infra Status
summaryrefslogtreecommitdiff
path: root/lib/bkisofs/bkWrite.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/bkisofs/bkWrite.c')
-rw-r--r--lib/bkisofs/bkWrite.c2547
1 files changed, 2547 insertions, 0 deletions
diff --git a/lib/bkisofs/bkWrite.c b/lib/bkisofs/bkWrite.c
new file mode 100644
index 0000000..031cb30
--- /dev/null
+++ b/lib/bkisofs/bkWrite.c
@@ -0,0 +1,2547 @@
+/******************************* 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;
+ /* 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. i have yet to see a boot record with a sector count
+ * that's not 4 */
+ write721ToByteArray(&(buffer[38]), 4);
+ /* 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" */
+ strncpy((char*)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) */
+ strncpy(&(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 */
+ strncpy(&(record[8]), "IEEE_P1282", 10);
+
+ /* extension descriptor */
+ strncpy(&(record[18]), "DRAFT_1_12", 10);
+
+ /* extension source */
+ strncpy(&(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;
+}