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