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