Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/makefs/cd9660/cd9660_write.c	Lines:	0	170	0.0 %
Date:	2017-11-07	Branches:	0	106	0.0 %


/*	$OpenBSD: cd9660_write.c,v 1.8 2017/04/06 19:09:45 natano Exp $	*/
/*	$NetBSD: cd9660_write.c,v 1.17 2013/10/19 17:16:37 christos Exp $	*/

/*
 * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
 * Perez-Rathke and Ram Vedam.  All rights reserved.
 *
 * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
 * Alan Perez-Rathke and Ram Vedam.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN
 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL DANIEL WATT, WALTER DEIGNAN, RYAN
 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE,DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 */

#include "cd9660.h"
#include "iso9660_rrip.h"

static int cd9660_write_volume_descriptors(iso9660_disk *, FILE *);
static int cd9660_write_path_table(iso9660_disk *, FILE *, off_t, int);
static int cd9660_write_path_tables(iso9660_disk *, FILE *);
static int cd9660_write_file(iso9660_disk *, FILE *, cd9660node *);
static int cd9660_write_filedata(iso9660_disk *, FILE *, off_t,
    const unsigned char *, int);
#if 0
static int cd9660_write_buffered(FILE *, off_t, int, const unsigned char *);
#endif
static void cd9660_write_rr(iso9660_disk *, FILE *, cd9660node *, off_t, off_t);

/*
 * Write the image
 * Writes the entire image
 * @param const char* The filename for the image
 * @returns int 1 on success, 0 on failure
 */
int
cd9660_write_image(iso9660_disk *diskStructure, const char* image)
{
	FILE *fd;
	int status;
	char buf[CD9660_SECTOR_SIZE];

	if ((fd = fopen(image, "w+")) == NULL)
		err(1, "%s: Can't open `%s' for writing", __func__, image);

	if (diskStructure->has_generic_bootimage) {
		status = cd9660_copy_file(diskStructure, fd, 0,
		    diskStructure->generic_bootimage);
		if (status == 0) {
			warnx("%s: Error writing generic boot image",
			    __func__);
			goto cleanup_bad_image;
		}
	}

	/* Write the volume descriptors */
	status = cd9660_write_volume_descriptors(diskStructure, fd);
	if (status == 0) {
		warnx("%s: Error writing volume descriptors to image",
		    __func__);
		goto cleanup_bad_image;
	}

	/*
	 * Write the path tables: there are actually four, but right
	 * now we are only concearned with two.
	 */
	status = cd9660_write_path_tables(diskStructure, fd);
	if (status == 0) {
		warnx("%s: Error writing path tables to image", __func__);
		goto cleanup_bad_image;
	}

	/* Write the directories and files */
	status = cd9660_write_file(diskStructure, fd, diskStructure->rootNode);
	if (status == 0) {
		warnx("%s: Error writing files to image", __func__);
		goto cleanup_bad_image;
	}

	if (diskStructure->is_bootable) {
		cd9660_write_boot(diskStructure, fd);
	}

	/* Write padding bits. This is temporary */
	memset(buf, 0, CD9660_SECTOR_SIZE);
	cd9660_write_filedata(diskStructure, fd,
	    diskStructure->totalSectors - 1, buf, 1);

	fclose(fd);
	return 1;

cleanup_bad_image:
	fclose(fd);
	unlink(image);
	return 0;
}

static int
cd9660_write_volume_descriptors(iso9660_disk *diskStructure, FILE *fd)
{
	volume_descriptor *vd_temp = diskStructure->firstVolumeDescriptor;
	while (vd_temp != NULL) {
		cd9660_write_filedata(diskStructure, fd, vd_temp->sector,
		    vd_temp->volumeDescriptorData, 1);
		vd_temp = vd_temp->next;
	}
	return 1;
}

/*
 * Write out an individual path table
 * Used just to keep redundant code to a minimum
 * @param FILE *fd Valid file pointer
 * @param int Sector to start writing path table to
 * @param int Endian mode : BIG_ENDIAN or LITTLE_ENDIAN
 * @returns int 1 on success, 0 on failure
 */
static int
cd9660_write_path_table(iso9660_disk *diskStructure, FILE *fd, off_t sector,
    int mode)
{
	int path_table_sectors = CD9660_BLOCKS(diskStructure->sectorSize,
	    diskStructure->pathTableLength);
	unsigned char *buffer;
	unsigned char *buffer_head;
	int len;
	path_table_entry temp_entry;
	cd9660node *ptcur;

	buffer = ecalloc(path_table_sectors, diskStructure->sectorSize);
	buffer_head = buffer;

	ptcur = diskStructure->rootNode;

	while (ptcur != NULL) {
		memset(&temp_entry, 0, sizeof(path_table_entry));
		temp_entry.length[0] = ptcur->isoDirRecord->name_len[0];
		temp_entry.extended_attribute_length[0] =
		    ptcur->isoDirRecord->ext_attr_length[0];
		memcpy(temp_entry.name, ptcur->isoDirRecord->name,
		    temp_entry.length[0] + 1);

		/* round up */
		len = temp_entry.length[0] + 8 + (temp_entry.length[0] & 0x01);

                /* todo: function pointers instead */
		if (mode == LITTLE_ENDIAN) {
			cd9660_731(ptcur->fileDataSector,
			    temp_entry.first_sector);
			cd9660_721((ptcur->parent == NULL ?
				1 : ptcur->parent->ptnumber),
			    temp_entry.parent_number);
		} else {
			cd9660_732(ptcur->fileDataSector,
			    temp_entry.first_sector);
			cd9660_722((ptcur->parent == NULL ?
				1 : ptcur->parent->ptnumber),
			    temp_entry.parent_number);
		}


		memcpy(buffer, &temp_entry, len);
		buffer += len;

		ptcur = ptcur->ptnext;
	}

	return cd9660_write_filedata(diskStructure, fd, sector, buffer_head,
	    path_table_sectors);
}


/*
 * Write out the path tables to disk
 * Each file descriptor should be pointed to by the PVD, so we know which
 * sector to copy them to. One thing to watch out for: the only path tables
 * stored are in the endian mode that the application is compiled for. So,
 * the first thing to do is write out that path table, then to write the one
 * in the other endian mode requires to convert the endianness of each entry
 * in the table. The best way to do this would be to create a temporary
 * path_table_entry structure, then for each path table entry, copy it to
 * the temporary entry, translate, then copy that to disk.
 *
 * @param FILE* Valid file descriptor
 * @returns int 0 on failure, 1 on success
 */
static int
cd9660_write_path_tables(iso9660_disk *diskStructure, FILE *fd)
{
	if (cd9660_write_path_table(diskStructure, fd,
	    diskStructure->primaryLittleEndianTableSector, LITTLE_ENDIAN) == 0)
		return 0;

	if (cd9660_write_path_table(diskStructure, fd,
	    diskStructure->primaryBigEndianTableSector, BIG_ENDIAN) == 0)
		return 0;

	/* @TODO: handle remaining two path tables */
	return 1;
}

/*
 * Write a file to disk
 * Writes a file, its directory record, and its data to disk
 * This file is designed to be called RECURSIVELY, so initially call it
 * with the root node. All of the records should store what sector the
 * file goes in, so no computation should be  necessary.
 *
 * @param int fd Valid file descriptor
 * @param struct cd9660node* writenode Pointer to the file to be written
 * @returns int 0 on failure, 1 on success
 */
static int
cd9660_write_file(iso9660_disk *diskStructure, FILE *fd, cd9660node *writenode)
{
	char *temp_file_name;
	off_t working_sector;
	int cur_sector_offset;
	iso_directory_record_cd9660 temp_record;
	cd9660node *temp;

	/* Todo : clean up variables */

	if ((writenode->level != 0) &&
	    !(writenode->node->type & S_IFDIR)) {
		fsinode *inode = writenode->node->inode;
		/* Only attempt to write unwritten files that have length. */
		if ((inode->flags & FI_WRITTEN) != 0) {
			INODE_WARNX(("%s: skipping written inode %d", __func__,
			    (int)inode->st.st_ino));
		} else if (writenode->fileDataLength > 0) {
			INODE_WARNX(("%s: writing inode %d blocks at %" PRIu32,
			    __func__, (int)inode->st.st_ino, inode->ino));
			inode->flags |= FI_WRITTEN;
			temp_file_name = cd9660_compute_full_filename(writenode);
			if (temp_file_name == NULL)
				return 0;
			if (cd9660_copy_file(diskStructure, fd,
			    writenode->fileDataSector, temp_file_name) == 0)
				return 0;
		}
	} else {
		/*
		 * Here is a new revelation that ECMA didnt explain
		 * (at least not well).
		 * ALL . and .. records store the name "\0" and "\1"
		 * resepctively. So, for each directory, we have to
		 * make a new node.
		 *
		 * This is where it gets kinda messy, since we have to
		 * be careful of sector boundaries
		 */
		cur_sector_offset = 0;
		working_sector = writenode->fileDataSector;
		if (fseeko(fd, working_sector * diskStructure->sectorSize,
		    SEEK_SET) == -1)
			err(1, "fseeko");

		/*
		 * Now loop over children, writing out their directory
		 * records - beware of sector boundaries
		 */
		TAILQ_FOREACH(temp, &writenode->cn_children, cn_next_child) {
			/*
			 * Copy the temporary record and adjust its size
			 * if necessary
			 */
			memcpy(&temp_record, temp->isoDirRecord,
			    sizeof(iso_directory_record_cd9660));

			temp_record.length[0] =
			    cd9660_compute_record_size(diskStructure, temp);

			if (temp_record.length[0] + cur_sector_offset >=
			    diskStructure->sectorSize) {
				cur_sector_offset = 0;
				working_sector++;

				/* Seek to the next sector. */
				if (fseeko(fd, working_sector *
				    diskStructure->sectorSize, SEEK_SET) == -1)
					err(1, "fseeko");
			}
			/* Write out the basic ISO directory record */
			(void)fwrite(&temp_record, 1,
			    temp->isoDirRecord->length[0], fd);
			if (diskStructure->rock_ridge_enabled) {
				cd9660_write_rr(diskStructure, fd, temp,
				    cur_sector_offset, working_sector);
			}
			if (fseeko(fd, working_sector *
			    diskStructure->sectorSize + cur_sector_offset +
			    temp_record.length[0] - temp->su_tail_size,
			    SEEK_SET) == -1)
				err(1, "fseeko");
			if (temp->su_tail_size > 0)
				fwrite(temp->su_tail_data, 1,
				    temp->su_tail_size, fd);
			if (ferror(fd)) {
				warnx("%s: write error", __func__);
				return 0;
			}
			cur_sector_offset += temp_record.length[0];

		}

		/*
		 * Recurse on children.
		 */
		TAILQ_FOREACH(temp, &writenode->cn_children, cn_next_child) {
			if (cd9660_write_file(diskStructure, fd, temp) == 0)
				return 0;
		}
	}
	return 1;
}

/*
 * Wrapper function to write a buffer (one sector) to disk.
 * Seeks and writes the buffer.
 * NOTE: You dont NEED to use this function, but it might make your
 * life easier if you have to write things that align to a sector
 * (such as volume descriptors).
 *
 * @param int fd Valid file descriptor
 * @param int sector Sector number to write to
 * @param const unsigned char* Buffer to write. This should be the
 *                             size of a sector, and if only a portion
 *                             is written, the rest should be set to 0.
 */
static int
cd9660_write_filedata(iso9660_disk *diskStructure, FILE *fd, off_t sector,
    const unsigned char *buf, int numsecs)
{
	off_t curpos;
	size_t success;

	curpos = ftello(fd);

	if (fseeko(fd, sector * diskStructure->sectorSize, SEEK_SET) == -1)
		err(1, "fseeko");

	success = fwrite(buf, diskStructure->sectorSize * numsecs, 1, fd);

	if (fseeko(fd, curpos, SEEK_SET) == -1)
		err(1, "fseeko");

	if (success == 1)
		success = diskStructure->sectorSize * numsecs;
	return success;
}

#if 0
static int
cd9660_write_buffered(FILE *fd, off_t offset, int buff_len,
		      const unsigned char* buffer)
{
	static int working_sector = -1;
	static char buf[CD9660_SECTOR_SIZE];

	return 0;
}
#endif

int
cd9660_copy_file(iso9660_disk *diskStructure, FILE *fd, off_t start_sector,
    const char *filename)
{
	FILE *rf;
	int bytes_read;
	off_t sector = start_sector;
	int buf_size = diskStructure->sectorSize;
	char *buf;

	buf = emalloc(buf_size);
	if ((rf = fopen(filename, "rb")) == NULL) {
		warn("%s: cannot open %s", __func__, filename);
		free(buf);
		return 0;
	}

	if (fseeko(fd, start_sector * diskStructure->sectorSize, SEEK_SET) == -1)
		err(1, "fseeko");

	while (!feof(rf)) {
		bytes_read = fread(buf,1,buf_size,rf);
		if (ferror(rf)) {
			warn("%s: fread", __func__);
			free(buf);
			(void)fclose(rf);
			return 0;
		}

		fwrite(buf,1,bytes_read,fd);
		if (ferror(fd)) {
			warn("%s: fwrite", __func__);
			free(buf);
			(void)fclose(rf);
			return 0;
		}
		sector++;
	}

	fclose(rf);
	free(buf);
	return 1;
}

static void
cd9660_write_rr(iso9660_disk *diskStructure, FILE *fd, cd9660node *writenode,
    off_t offset, off_t sector)
{
	int in_ca = 0;
	struct ISO_SUSP_ATTRIBUTES *myattr;

	offset += writenode->isoDirRecord->length[0];
	if (fseeko(fd, sector * diskStructure->sectorSize + offset, SEEK_SET) ==
	    -1)
		err(1, "fseeko");
	/* Offset now points at the end of the record */
	TAILQ_FOREACH(myattr, &writenode->head, rr_ll) {
		fwrite(&(myattr->attr), CD9660_SUSP_ENTRY_SIZE(myattr), 1, fd);

		if (!in_ca) {
			offset += CD9660_SUSP_ENTRY_SIZE(myattr);
			if (myattr->last_in_suf) {
				/*
				 * Point the offset to the start of this
				 * record's CE area
				 */
				if (fseeko(fd, ((off_t)diskStructure->
				    susp_continuation_area_start_sector *
				    diskStructure->sectorSize)
				    + writenode->susp_entry_ce_start,
				    SEEK_SET) == -1)
					err(1, "fseeko");
				in_ca = 1;
			}
		}
	}

	/*
	 * If we had to go to the continuation area, head back to
	 * where we should be.
	 */
	if (in_ca)
		if (fseeko(fd, sector * diskStructure->sectorSize + offset,
		    SEEK_SET) == -1)
			err(1, "fseeko");
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: cd9660_write.c,v 1.8 2017/04/06 19:09:45 natano Exp $ */
2			/* $NetBSD: cd9660_write.c,v 1.17 2013/10/19 17:16:37 christos Exp $ */
3
4			/*
5			* Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
6			* Perez-Rathke and Ram Vedam. All rights reserved.
7			*
8			* This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
9			* Alan Perez-Rathke and Ram Vedam.
10			*
11			* Redistribution and use in source and binary forms, with or
12			* without modification, are permitted provided that the following
13			* conditions are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above
17			* copyright notice, this list of conditions and the following
18			* disclaimer in the documentation and/or other materials provided
19			* with the distribution.
20			*
21			* THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN
22			* GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``AS IS'' AND ANY EXPRESS OR
23			* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25			* DISCLAIMED. IN NO EVENT SHALL DANIEL WATT, WALTER DEIGNAN, RYAN
26			* GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM BE LIABLE FOR ANY DIRECT, INDIRECT,
27			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28			* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
29			* USE,DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
30			* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31			* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
33			* OF SUCH DAMAGE.
34			*/
35
36			#include "cd9660.h"
37			#include "iso9660_rrip.h"
38
39			static int cd9660_write_volume_descriptors(iso9660_disk , FILE );
40			static int cd9660_write_path_table(iso9660_disk , FILE , off_t, int);
41			static int cd9660_write_path_tables(iso9660_disk , FILE );
42			static int cd9660_write_file(iso9660_disk , FILE , cd9660node *);
43			static int cd9660_write_filedata(iso9660_disk , FILE , off_t,
44			const unsigned char *, int);
45			#if 0
46			static int cd9660_write_buffered(FILE , off_t, int, const unsigned char );
47			#endif
48			static void cd9660_write_rr(iso9660_disk , FILE , cd9660node *, off_t, off_t);
49
50			/*
51			* Write the image
52			* Writes the entire image
53			* @param const char* The filename for the image
54			* @returns int 1 on success, 0 on failure
55			*/
56			int
57			cd9660_write_image(iso9660_disk diskStructure, const char image)
58			{
59			FILE *fd;
60			int status;
61			char buf[CD9660_SECTOR_SIZE];
62
63			if ((fd = fopen(image, "w+")) == NULL)
64			err(1, "%s: Can't open `%s' for writing", __func__, image);
65
66			if (diskStructure->has_generic_bootimage) {
67			status = cd9660_copy_file(diskStructure, fd, 0,
68			diskStructure->generic_bootimage);
69			if (status == 0) {
70			warnx("%s: Error writing generic boot image",
71			__func__);
72			goto cleanup_bad_image;
73			}
74			}
75
76			/* Write the volume descriptors */
77			status = cd9660_write_volume_descriptors(diskStructure, fd);
78			if (status == 0) {
79			warnx("%s: Error writing volume descriptors to image",
80			__func__);
81			goto cleanup_bad_image;
82			}
83
84			/*
85			* Write the path tables: there are actually four, but right
86			* now we are only concearned with two.
87			*/
88			status = cd9660_write_path_tables(diskStructure, fd);
89			if (status == 0) {
90			warnx("%s: Error writing path tables to image", __func__);
91			goto cleanup_bad_image;
92			}
93
94			/* Write the directories and files */
95			status = cd9660_write_file(diskStructure, fd, diskStructure->rootNode);
96			if (status == 0) {
97			warnx("%s: Error writing files to image", __func__);
98			goto cleanup_bad_image;
99			}
100
101			if (diskStructure->is_bootable) {
102			cd9660_write_boot(diskStructure, fd);
103			}
104
105			/* Write padding bits. This is temporary */
106			memset(buf, 0, CD9660_SECTOR_SIZE);
107			cd9660_write_filedata(diskStructure, fd,
108			diskStructure->totalSectors - 1, buf, 1);
109
110			fclose(fd);
111			return 1;
112
113			cleanup_bad_image:
114			fclose(fd);
115			unlink(image);
116			return 0;
117			}
118
119			static int
120			cd9660_write_volume_descriptors(iso9660_disk diskStructure, FILE fd)
121			{
122			volume_descriptor *vd_temp = diskStructure->firstVolumeDescriptor;
123			while (vd_temp != NULL) {
124			cd9660_write_filedata(diskStructure, fd, vd_temp->sector,
125			vd_temp->volumeDescriptorData, 1);
126			vd_temp = vd_temp->next;
127			}
128			return 1;
129			}
130
131			/*
132			* Write out an individual path table
133			* Used just to keep redundant code to a minimum
134			* @param FILE *fd Valid file pointer
135			* @param int Sector to start writing path table to
136			* @param int Endian mode : BIG_ENDIAN or LITTLE_ENDIAN
137			* @returns int 1 on success, 0 on failure
138			*/
139			static int
140			cd9660_write_path_table(iso9660_disk diskStructure, FILE fd, off_t sector,
141			int mode)
142			{
143			int path_table_sectors = CD9660_BLOCKS(diskStructure->sectorSize,
144			diskStructure->pathTableLength);
145			unsigned char *buffer;
146			unsigned char *buffer_head;
147			int len;
148			path_table_entry temp_entry;
149			cd9660node *ptcur;
150
151			buffer = ecalloc(path_table_sectors, diskStructure->sectorSize);
152			buffer_head = buffer;
153
154			ptcur = diskStructure->rootNode;
155
156			while (ptcur != NULL) {
157			memset(&temp_entry, 0, sizeof(path_table_entry));
158			temp_entry.length[0] = ptcur->isoDirRecord->name_len[0];
159			temp_entry.extended_attribute_length[0] =
160			ptcur->isoDirRecord->ext_attr_length[0];
161			memcpy(temp_entry.name, ptcur->isoDirRecord->name,
162			temp_entry.length[0] + 1);
163
164			/* round up */
165			len = temp_entry.length[0] + 8 + (temp_entry.length[0] & 0x01);
166
167			/* todo: function pointers instead */
168			if (mode == LITTLE_ENDIAN) {
169			cd9660_731(ptcur->fileDataSector,
170			temp_entry.first_sector);
171			cd9660_721((ptcur->parent == NULL ?
172			1 : ptcur->parent->ptnumber),
173			temp_entry.parent_number);
174			} else {
175			cd9660_732(ptcur->fileDataSector,
176			temp_entry.first_sector);
177			cd9660_722((ptcur->parent == NULL ?
178			1 : ptcur->parent->ptnumber),
179			temp_entry.parent_number);
180			}
181
182
183			memcpy(buffer, &temp_entry, len);
184			buffer += len;
185
186			ptcur = ptcur->ptnext;
187			}
188
189			return cd9660_write_filedata(diskStructure, fd, sector, buffer_head,
190			path_table_sectors);
191			}
192
193
194			/*
195			* Write out the path tables to disk
196			* Each file descriptor should be pointed to by the PVD, so we know which
197			* sector to copy them to. One thing to watch out for: the only path tables
198			* stored are in the endian mode that the application is compiled for. So,
199			* the first thing to do is write out that path table, then to write the one
200			* in the other endian mode requires to convert the endianness of each entry
201			* in the table. The best way to do this would be to create a temporary
202			* path_table_entry structure, then for each path table entry, copy it to
203			* the temporary entry, translate, then copy that to disk.
204			*
205			* @param FILE* Valid file descriptor
206			* @returns int 0 on failure, 1 on success
207			*/
208			static int
209			cd9660_write_path_tables(iso9660_disk diskStructure, FILE fd)
210			{
211			if (cd9660_write_path_table(diskStructure, fd,
212			diskStructure->primaryLittleEndianTableSector, LITTLE_ENDIAN) == 0)
213			return 0;
214
215			if (cd9660_write_path_table(diskStructure, fd,
216			diskStructure->primaryBigEndianTableSector, BIG_ENDIAN) == 0)
217			return 0;
218
219			/* @TODO: handle remaining two path tables */
220			return 1;
221			}
222
223			/*
224			* Write a file to disk
225			* Writes a file, its directory record, and its data to disk
226			* This file is designed to be called RECURSIVELY, so initially call it
227			* with the root node. All of the records should store what sector the
228			* file goes in, so no computation should be necessary.
229			*
230			* @param int fd Valid file descriptor
231			* @param struct cd9660node* writenode Pointer to the file to be written
232			* @returns int 0 on failure, 1 on success
233			*/
234			static int
235			cd9660_write_file(iso9660_disk diskStructure, FILE fd, cd9660node *writenode)
236			{
237			char *temp_file_name;
238			off_t working_sector;
239			int cur_sector_offset;
240			iso_directory_record_cd9660 temp_record;
241			cd9660node *temp;
242
243			/* Todo : clean up variables */
244
245			if ((writenode->level != 0) &&
246			!(writenode->node->type & S_IFDIR)) {
247			fsinode *inode = writenode->node->inode;
248			/* Only attempt to write unwritten files that have length. */
249			if ((inode->flags & FI_WRITTEN) != 0) {
250			INODE_WARNX(("%s: skipping written inode %d", __func__,
251			(int)inode->st.st_ino));
252			} else if (writenode->fileDataLength > 0) {
253			INODE_WARNX(("%s: writing inode %d blocks at %" PRIu32,
254			__func__, (int)inode->st.st_ino, inode->ino));
255			inode->flags \|= FI_WRITTEN;
256			temp_file_name = cd9660_compute_full_filename(writenode);
257			if (temp_file_name == NULL)
258			return 0;
259			if (cd9660_copy_file(diskStructure, fd,
260			writenode->fileDataSector, temp_file_name) == 0)
261			return 0;
262			}
263			} else {
264			/*
265			* Here is a new revelation that ECMA didnt explain
266			* (at least not well).
267			* ALL . and .. records store the name "\0" and "\1"
268			* resepctively. So, for each directory, we have to
269			* make a new node.
270			*
271			* This is where it gets kinda messy, since we have to
272			* be careful of sector boundaries
273			*/
274			cur_sector_offset = 0;
275			working_sector = writenode->fileDataSector;
276			if (fseeko(fd, working_sector * diskStructure->sectorSize,
277			SEEK_SET) == -1)
278			err(1, "fseeko");
279
280			/*
281			* Now loop over children, writing out their directory
282			* records - beware of sector boundaries
283			*/
284			TAILQ_FOREACH(temp, &writenode->cn_children, cn_next_child) {
285			/*
286			* Copy the temporary record and adjust its size
287			* if necessary
288			*/
289			memcpy(&temp_record, temp->isoDirRecord,
290			sizeof(iso_directory_record_cd9660));
291
292			temp_record.length[0] =
293			cd9660_compute_record_size(diskStructure, temp);
294
295			if (temp_record.length[0] + cur_sector_offset >=
296			diskStructure->sectorSize) {
297			cur_sector_offset = 0;
298			working_sector++;
299
300			/* Seek to the next sector. */
301			if (fseeko(fd, working_sector *
302			diskStructure->sectorSize, SEEK_SET) == -1)
303			err(1, "fseeko");
304			}
305			/* Write out the basic ISO directory record */
306			(void)fwrite(&temp_record, 1,
307			temp->isoDirRecord->length[0], fd);
308			if (diskStructure->rock_ridge_enabled) {
309			cd9660_write_rr(diskStructure, fd, temp,
310			cur_sector_offset, working_sector);
311			}
312			if (fseeko(fd, working_sector *
313			diskStructure->sectorSize + cur_sector_offset +
314			temp_record.length[0] - temp->su_tail_size,
315			SEEK_SET) == -1)
316			err(1, "fseeko");
317			if (temp->su_tail_size > 0)
318			fwrite(temp->su_tail_data, 1,
319			temp->su_tail_size, fd);
320			if (ferror(fd)) {
321			warnx("%s: write error", __func__);
322			return 0;
323			}
324			cur_sector_offset += temp_record.length[0];
325
326			}
327
328			/*
329			* Recurse on children.
330			*/
331			TAILQ_FOREACH(temp, &writenode->cn_children, cn_next_child) {
332			if (cd9660_write_file(diskStructure, fd, temp) == 0)
333			return 0;
334			}
335			}
336			return 1;
337			}
338
339			/*
340			* Wrapper function to write a buffer (one sector) to disk.
341			* Seeks and writes the buffer.
342			* NOTE: You dont NEED to use this function, but it might make your
343			* life easier if you have to write things that align to a sector
344			* (such as volume descriptors).
345			*
346			* @param int fd Valid file descriptor
347			* @param int sector Sector number to write to
348			* @param const unsigned char* Buffer to write. This should be the
349			* size of a sector, and if only a portion
350			* is written, the rest should be set to 0.
351			*/
352			static int
353			cd9660_write_filedata(iso9660_disk diskStructure, FILE fd, off_t sector,
354			const unsigned char *buf, int numsecs)
355			{
356			off_t curpos;
357			size_t success;
358
359			curpos = ftello(fd);
360
361			if (fseeko(fd, sector * diskStructure->sectorSize, SEEK_SET) == -1)
362			err(1, "fseeko");
363
364			success = fwrite(buf, diskStructure->sectorSize * numsecs, 1, fd);
365
366			if (fseeko(fd, curpos, SEEK_SET) == -1)
367			err(1, "fseeko");
368
369			if (success == 1)
370			success = diskStructure->sectorSize * numsecs;
371			return success;
372			}
373
374			#if 0
375			static int
376			cd9660_write_buffered(FILE *fd, off_t offset, int buff_len,
377			const unsigned char* buffer)
378			{
379			static int working_sector = -1;
380			static char buf[CD9660_SECTOR_SIZE];
381
382			return 0;
383			}
384			#endif
385
386			int
387			cd9660_copy_file(iso9660_disk diskStructure, FILE fd, off_t start_sector,
388			const char *filename)
389			{
390			FILE *rf;
391			int bytes_read;
392			off_t sector = start_sector;
393			int buf_size = diskStructure->sectorSize;
394			char *buf;
395
396			buf = emalloc(buf_size);
397			if ((rf = fopen(filename, "rb")) == NULL) {
398			warn("%s: cannot open %s", __func__, filename);
399			free(buf);
400			return 0;
401			}
402
403			if (fseeko(fd, start_sector * diskStructure->sectorSize, SEEK_SET) == -1)
404			err(1, "fseeko");
405
406			while (!feof(rf)) {
407			bytes_read = fread(buf,1,buf_size,rf);
408			if (ferror(rf)) {
409			warn("%s: fread", __func__);
410			free(buf);
411			(void)fclose(rf);
412			return 0;
413			}
414
415			fwrite(buf,1,bytes_read,fd);
416			if (ferror(fd)) {
417			warn("%s: fwrite", __func__);
418			free(buf);
419			(void)fclose(rf);
420			return 0;
421			}
422			sector++;
423			}
424
425			fclose(rf);
426			free(buf);
427			return 1;
428			}
429
430			static void
431			cd9660_write_rr(iso9660_disk diskStructure, FILE fd, cd9660node *writenode,
432			off_t offset, off_t sector)
433			{
434			int in_ca = 0;
435			struct ISO_SUSP_ATTRIBUTES *myattr;
436
437			offset += writenode->isoDirRecord->length[0];
438			if (fseeko(fd, sector * diskStructure->sectorSize + offset, SEEK_SET) ==
439			-1)
440			err(1, "fseeko");
441			/* Offset now points at the end of the record */
442			TAILQ_FOREACH(myattr, &writenode->head, rr_ll) {
443			fwrite(&(myattr->attr), CD9660_SUSP_ENTRY_SIZE(myattr), 1, fd);
444
445			if (!in_ca) {
446			offset += CD9660_SUSP_ENTRY_SIZE(myattr);
447			if (myattr->last_in_suf) {
448			/*
449			* Point the offset to the start of this
450			* record's CE area
451			*/
452			if (fseeko(fd, ((off_t)diskStructure->
453			susp_continuation_area_start_sector *
454			diskStructure->sectorSize)
455			+ writenode->susp_entry_ce_start,
456			SEEK_SET) == -1)
457			err(1, "fseeko");
458			in_ca = 1;
459			}
460			}
461			}
462
463			/*
464			* If we had to go to the continuation area, head back to
465			* where we should be.
466			*/
467			if (in_ca)
468			if (fseeko(fd, sector * diskStructure->sectorSize + offset,
469			SEEK_SET) == -1)
470			err(1, "fseeko");
471			}