1 /* $NetBSD: cd9660_write.c,v 1.14 2011/01/04 09:48:21 wiz Exp $ */
4 * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
5 * Perez-Rathke and Ram Vedam. All rights reserved.
7 * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
8 * Alan Perez-Rathke and Ram Vedam.
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
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.
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
36 #include "iso9660_rrip.h"
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
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);
47 static int cd9660_write_buffered(FILE *, off_t, int, const unsigned char *);
49 static void cd9660_write_rr(FILE *, cd9660node *, off_t, off_t);
53 * Writes the entire image
54 * @param const char* The filename for the image
55 * @returns int 1 on success, 0 on failure
58 cd9660_write_image(const char* image)
62 char buf[CD9660_SECTOR_SIZE];
64 if ((fd = fopen(image, "w+")) == NULL) {
65 err(EXIT_FAILURE, "%s: Can't open `%s' for writing", __func__,
69 if (diskStructure.verbose_level > 0)
70 printf("Writing image\n");
72 if (diskStructure.has_generic_bootimage) {
73 status = cd9660_copy_file(fd, 0,
74 diskStructure.generic_bootimage);
76 warnx("%s: Error writing generic boot image",
78 goto cleanup_bad_image;
82 /* Write the volume descriptors */
83 status = cd9660_write_volume_descriptors(fd);
85 warnx("%s: Error writing volume descriptors to image",
87 goto cleanup_bad_image;
90 if (diskStructure.verbose_level > 0)
91 printf("Volume descriptors written\n");
94 * Write the path tables: there are actually four, but right
95 * now we are only concearned with two.
97 status = cd9660_write_path_tables(fd);
99 warnx("%s: Error writing path tables to image", __func__);
100 goto cleanup_bad_image;
103 if (diskStructure.verbose_level > 0)
104 printf("Path tables written\n");
106 /* Write the directories and files */
107 status = cd9660_write_file(fd, diskStructure.rootNode);
109 warnx("%s: Error writing files to image", __func__);
110 goto cleanup_bad_image;
113 if (diskStructure.is_bootable) {
114 cd9660_write_boot(fd);
117 /* Write padding bits. This is temporary */
118 memset(buf, 0, CD9660_SECTOR_SIZE);
119 cd9660_write_filedata(fd, diskStructure.totalSectors - 1, buf, 1);
121 if (diskStructure.verbose_level > 0)
122 printf("Files written\n");
125 if (diskStructure.verbose_level > 0)
126 printf("Image closed\n");
131 if (!diskStructure.keep_bad_images)
133 if (diskStructure.verbose_level > 0)
134 printf("Bad image cleaned up\n");
139 cd9660_write_volume_descriptors(FILE *fd)
141 volume_descriptor *vd_temp = diskStructure.firstVolumeDescriptor;
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;
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
162 cd9660_write_path_table(FILE *fd, off_t sector, int mode)
164 int path_table_sectors = CD9660_BLOCKS(diskStructure.sectorSize,
165 diskStructure.pathTableLength);
166 unsigned char *buffer;
167 unsigned char *buffer_head;
169 path_table_entry temp_entry;
172 buffer = malloc(diskStructure.sectorSize * path_table_sectors);
173 if (buffer == NULL) {
174 warnx("%s: Memory allocation error allocating buffer",
178 buffer_head = buffer;
179 memset(buffer, 0, diskStructure.sectorSize * path_table_sectors);
181 ptcur = diskStructure.rootNode;
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);
192 len = temp_entry.length[0] + 8 + (temp_entry.length[0] & 0x01);
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);
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);
210 memcpy(buffer, &temp_entry, len);
213 ptcur = ptcur->ptnext;
216 ret = cd9660_write_filedata(fd, sector, buffer_head,
224 * Write out the path tables to disk
225 * Each file descriptor should be pointed to by the PVD, so we know which
226 * sector to copy them to. One thing to watch out for: the only path tables
227 * stored are in the endian mode that the application is compiled for. So,
228 * the first thing to do is write out that path table, then to write the one
229 * in the other endian mode requires to convert the endianness of each entry
230 * in the table. The best way to do this would be to create a temporary
231 * path_table_entry structure, then for each path table entry, copy it to
232 * the temporary entry, translate, then copy that to disk.
234 * @param FILE* Valid file descriptor
235 * @returns int 0 on failure, 1 on success
238 cd9660_write_path_tables(FILE *fd)
240 if (cd9660_write_path_table(fd,
241 diskStructure.primaryLittleEndianTableSector, LITTLE_ENDIAN) == 0)
244 if (cd9660_write_path_table(fd,
245 diskStructure.primaryBigEndianTableSector, BIG_ENDIAN) == 0)
248 /* @TODO: handle remaining two path tables */
253 * Write a file to disk
254 * Writes a file, its directory record, and its data to disk
255 * This file is designed to be called RECURSIVELY, so initially call it
256 * with the root node. All of the records should store what sector the
257 * file goes in, so no computation should be necessary.
259 * @param int fd Valid file descriptor
260 * @param struct cd9660node* writenode Pointer to the file to be written
261 * @returns int 0 on failure, 1 on success
264 cd9660_write_file(FILE *fd, cd9660node *writenode)
267 char *temp_file_name;
269 off_t working_sector;
270 int cur_sector_offset;
272 iso_directory_record_cd9660 temp_record;
276 /* Todo : clean up variables */
278 temp_file_name = malloc(CD9660MAXPATH + 1);
279 if (temp_file_name == NULL)
280 err(EXIT_FAILURE, "%s: malloc", __func__);
282 memset(temp_file_name, 0, CD9660MAXPATH + 1);
284 buf = malloc(diskStructure.sectorSize);
286 err(EXIT_FAILURE, "%s: malloc", __func__);
288 if ((writenode->level != 0) &&
289 !(writenode->node->type & S_IFDIR)) {
290 fsinode *inode = writenode->node->inode;
291 /* Only attempt to write unwritten files that have length. */
292 if ((inode->flags & FI_WRITTEN) != 0) {
293 INODE_WARNX(("%s: skipping written inode %d", __func__,
294 (int)inode->st.st_ino));
295 } else if (writenode->fileDataLength > 0) {
296 INODE_WARNX(("%s: writing inode %d blocks at %" PRIu32,
297 __func__, (int)inode->st.st_ino, inode->ino));
298 inode->flags |= FI_WRITTEN;
299 if (writenode->node->contents == NULL)
300 cd9660_compute_full_filename(writenode,
302 ret = cd9660_copy_file(fd, writenode->fileDataSector,
303 (writenode->node->contents != NULL) ?
304 writenode->node->contents : temp_file_name);
310 * Here is a new revelation that ECMA didn't explain
311 * (at least not well).
312 * ALL . and .. records store the name "\0" and "\1"
313 * respectively. So, for each directory, we have to
316 * This is where it gets kinda messy, since we have to
317 * be careful of sector boundaries
319 cur_sector_offset = 0;
320 working_sector = writenode->fileDataSector;
321 if (fseeko(fd, working_sector * diskStructure.sectorSize,
326 * Now loop over children, writing out their directory
327 * records - beware of sector boundaries
329 TAILQ_FOREACH(temp, &writenode->cn_children, cn_next_child) {
331 * Copy the temporary record and adjust its size
334 memcpy(&temp_record, temp->isoDirRecord,
335 sizeof(iso_directory_record_cd9660));
337 temp_record.length[0] =
338 cd9660_compute_record_size(temp);
340 if (temp_record.length[0] + cur_sector_offset >=
341 diskStructure.sectorSize) {
342 cur_sector_offset = 0;
345 /* Seek to the next sector. */
346 if (fseeko(fd, working_sector *
347 diskStructure.sectorSize, SEEK_SET) == -1)
350 /* Write out the basic ISO directory record */
351 written = fwrite(&temp_record, 1,
352 temp->isoDirRecord->length[0], fd);
353 if (diskStructure.rock_ridge_enabled) {
354 cd9660_write_rr(fd, temp,
355 cur_sector_offset, working_sector);
357 if (fseeko(fd, working_sector *
358 diskStructure.sectorSize + cur_sector_offset +
359 temp_record.length[0] - temp->su_tail_size,
362 if (temp->su_tail_size > 0)
363 fwrite(temp->su_tail_data, 1,
364 temp->su_tail_size, fd);
366 warnx("%s: write error", __func__);
369 cur_sector_offset += temp_record.length[0];
374 * Recurse on children.
376 TAILQ_FOREACH(temp, &writenode->cn_children, cn_next_child) {
377 if ((ret = cd9660_write_file(fd, temp)) == 0)
383 free(temp_file_name);
389 * Wrapper function to write a buffer (one sector) to disk.
390 * Seeks and writes the buffer.
391 * NOTE: You dont NEED to use this function, but it might make your
392 * life easier if you have to write things that align to a sector
393 * (such as volume descriptors).
395 * @param int fd Valid file descriptor
396 * @param int sector Sector number to write to
397 * @param const unsigned char* Buffer to write. This should be the
398 * size of a sector, and if only a portion
399 * is written, the rest should be set to 0.
402 cd9660_write_filedata(FILE *fd, off_t sector, const unsigned char *buf,
410 if (fseeko(fd, sector * diskStructure.sectorSize, SEEK_SET) == -1)
413 success = fwrite(buf, diskStructure.sectorSize * numsecs, 1, fd);
415 if (fseeko(fd, curpos, SEEK_SET) == -1)
419 success = diskStructure.sectorSize * numsecs;
425 cd9660_write_buffered(FILE *fd, off_t offset, int buff_len,
426 const unsigned char* buffer)
428 static int working_sector = -1;
429 static char buf[CD9660_SECTOR_SIZE];
436 cd9660_copy_file(FILE *fd, off_t start_sector, const char *filename)
440 off_t sector = start_sector;
441 int buf_size = diskStructure.sectorSize;
444 buf = malloc(buf_size);
446 err(EXIT_FAILURE, "%s: malloc", __func__);
448 if ((rf = fopen(filename, "rb")) == NULL) {
449 warn("%s: cannot open %s", __func__, filename);
454 if (diskStructure.verbose_level > 1)
455 printf("Writing file: %s\n",filename);
457 if (fseeko(fd, start_sector * diskStructure.sectorSize, SEEK_SET) == -1)
461 bytes_read = fread(buf,1,buf_size,rf);
463 warn("%s: fread", __func__);
469 fwrite(buf,1,bytes_read,fd);
471 warn("%s: fwrite", __func__);
485 cd9660_write_rr(FILE *fd, cd9660node *writenode, off_t offset, off_t sector)
488 struct ISO_SUSP_ATTRIBUTES *myattr;
490 offset += writenode->isoDirRecord->length[0];
491 if (fseeko(fd, sector * diskStructure.sectorSize + offset, SEEK_SET) ==
494 /* Offset now points at the end of the record */
495 TAILQ_FOREACH(myattr, &writenode->head, rr_ll) {
496 fwrite(&(myattr->attr), CD9660_SUSP_ENTRY_SIZE(myattr), 1, fd);
499 offset += CD9660_SUSP_ENTRY_SIZE(myattr);
500 if (myattr->last_in_suf) {
502 * Point the offset to the start of this
505 if (fseeko(fd, ((off_t)diskStructure.
506 susp_continuation_area_start_sector *
507 diskStructure.sectorSize)
508 + writenode->susp_entry_ce_start,
517 * If we had to go to the continuation area, head back to
518 * where we should be.
521 if (fseeko(fd, sector * diskStructure.sectorSize + offset,