/usr/src/usr.sbin/makefs/cd9660.c

Bug Summary

File:	src/usr.sbin/makefs/cd9660.c
Warning:	line 1423, column 13 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cd9660.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/makefs/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/usr.sbin/makefs -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/makefs/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.sbin/makefs/cd9660.c
1/*	$OpenBSD: cd9660.c,v 1.23 2022/01/11 05:34:32 jsg Exp $	*/
2/*	$NetBSD: cd9660.c,v 1.53 2016/11/25 23:02:44 christos Exp $	*/

4/*
* 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.
*/
35/*
* Copyright (c) 2001 Wasabi Systems, Inc.
* All rights reserved.
*
* Written by Luke Mewburn for Wasabi Systems, Inc.
*
* 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.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed for the NetBSD Project by
*      Wasabi Systems, Inc.
* 4. The name of Wasabi Systems, Inc. may not be used to endorse
*    or promote products derived from this software without specific prior
*    written permission.
*
* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
* 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.
*/
69/*
* Copyright (c) 1982, 1986, 1989, 1993
*	The Regents of the University of California.  All rights reserved.
*
* 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.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS 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.
*
*/

99#include <sys/queue.h>

101#include <string.h>
102#include <ctype.h>
103#include <inttypes.h>
104#include <limits.h>

106#include "makefs.h"
107#include "cd9660.h"
108#include "cd9660/iso9660_rrip.h"

110/*
* Global variables
*/

114static void cd9660_finalize_PVD(iso9660_disk *);
115static cd9660node *cd9660_allocate_cd9660node(void);
116static void cd9660_set_defaults(iso9660_disk *);
117static int cd9660_arguments_set_string(const char *, const char *, size_t,
  char, char *);
119static void cd9660_populate_iso_dir_record(
  struct _iso_directory_record_cd9660 *, u_char, u_char, u_char,
  const char *);
122static void cd9660_setup_root_node(iso9660_disk *);
123static int cd9660_setup_volume_descriptors(iso9660_disk *);
124#if 0
125static int cd9660_fill_extended_attribute_record(cd9660node *);
126#endif
127static void cd9660_sort_nodes(cd9660node *);
128static int cd9660_translate_node_common(iso9660_disk *, cd9660node *);
129static int cd9660_translate_node(iso9660_disk *, fsnode *, cd9660node *);
130static int cd9660_compare_filename(const char *, const char *);
131static void cd9660_sorted_child_insert(cd9660node *, cd9660node *);
132static int cd9660_handle_collisions(iso9660_disk *, cd9660node *, int);
133static cd9660node *cd9660_rename_filename(iso9660_disk *, cd9660node *, int,
  int);
135static void cd9660_copy_filenames(iso9660_disk *, cd9660node *);
136static void cd9660_sorting_nodes(cd9660node *);
137static int cd9660_count_collisions(cd9660node *);
138static cd9660node *cd9660_rrip_move_directory(iso9660_disk *, cd9660node *);
139static int cd9660_add_dot_records(iso9660_disk *, cd9660node *);

141static void cd9660_convert_structure(iso9660_disk *, fsnode *, cd9660node *, int,
  int *, int *);
143static void cd9660_free_structure(cd9660node *);
144static int cd9660_generate_path_table(iso9660_disk *);
145static int cd9660_level1_convert_filename(iso9660_disk *, const char *, char *,
  size_t, int);
147static int cd9660_level2_convert_filename(iso9660_disk *, const char *, char *,
  size_t, int);
149static int cd9660_convert_filename(iso9660_disk *, const char *, char *, size_t, int);
150static void cd9660_populate_dot_records(iso9660_disk *, cd9660node *);
151static int64_t cd9660_compute_offsets(iso9660_disk *, cd9660node *, int64_t);
152#if 0
153static int cd9660_copy_stat_info(cd9660node *, cd9660node *, int);
154#endif
155static cd9660node *cd9660_create_virtual_entry(iso9660_disk *, const char *,
  cd9660node *, int, int);
157static cd9660node *cd9660_create_file(iso9660_disk *, const char *,
  cd9660node *, cd9660node *);
159static cd9660node *cd9660_create_directory(iso9660_disk *, const char *,
  cd9660node *, cd9660node *);
161static cd9660node *cd9660_create_special_directory(iso9660_disk *, u_char,
  cd9660node *);
163static int  cd9660_add_generic_bootimage(iso9660_disk *, const char *);


166/*
* Allocate and initialize a cd9660node
* @returns struct cd9660node * Pointer to new node, or NULL on error
*/
170static cd9660node *
171cd9660_allocate_cd9660node(void)
172{
cd9660node *temp = ecalloc(1, sizeof(*temp));
TAILQ_INIT(&temp->cn_children)do { (&temp->cn_children)->tqh_first = ((void *)0);
 (&temp->cn_children)->tqh_last = &(&temp->
cn_children)->tqh_first; } while (0);
temp->parent = temp->dot_record = temp->dot_dot_record = NULL((void *)0);
temp->ptnext = temp->ptprev = temp->ptlast = NULL((void *)0);
temp->node = NULL((void *)0);
temp->isoDirRecord = NULL((void *)0);
temp->isoExtAttributes = NULL((void *)0);
temp->rr_real_parent = temp->rr_relocated = NULL((void *)0);
temp->su_tail_data = NULL((void *)0);
return temp;
183}

185int cd9660_defaults_set = 0;

187/**
188* Set default values for cd9660 extension to makefs
189*/
190static void
191cd9660_set_defaults(iso9660_disk *diskStructure)
192{
/*Fix the sector size for now, though the spec allows for other sizes*/
diskStructure->sectorSize = 2048;

/* Set up defaults in our own structure */
diskStructure->isoLevel = 2;

diskStructure->rock_ridge_enabled = 0;
diskStructure->rock_ridge_renamed_dir_name = 0;
diskStructure->rock_ridge_move_count = 0;
diskStructure->rr_moved_dir = 0;

diskStructure->include_padding_areas = 1;

/* Spec breaking functionality */
diskStructure->allow_deep_trees =
   diskStructure->allow_multidot =
   diskStructure->omit_trailing_period = 0;

/* Make sure the PVD is clear */
memset(&diskStructure->primaryDescriptor, 0, 2048);

memset(diskStructure->primaryDescriptor.publisher_id,	0x20,128);
memset(diskStructure->primaryDescriptor.preparer_id,	0x20,128);
memset(diskStructure->primaryDescriptor.application_id,	0x20,128);
memset(diskStructure->primaryDescriptor.copyright_file_id, 0x20,37);
memset(diskStructure->primaryDescriptor.abstract_file_id, 0x20,37);
memset(diskStructure->primaryDescriptor.bibliographic_file_id, 0x20,37);

strlcpy(diskStructure->primaryDescriptor.system_id,"NetBSD", sizeof(diskStructure->primaryDescriptor.system_id));

cd9660_defaults_set = 1;

/* Boot support: Initially disabled */
diskStructure->has_generic_bootimage = 0;
diskStructure->generic_bootimage = NULL((void *)0);

/*memset(diskStructure->boot_descriptor, 0, 2048);*/

diskStructure->is_bootable = 0;
TAILQ_INIT(&diskStructure->boot_images)do { (&diskStructure->boot_images)->tqh_first = ((void
 *)0); (&diskStructure->boot_images)->tqh_last = &
(&diskStructure->boot_images)->tqh_first; } while (
0);
LIST_INIT(&diskStructure->boot_entries)do { ((&diskStructure->boot_entries)->lh_first) = (
(void *)0); } while (0);
234}

236void
237cd9660_prep_opts(fsinfo_t *fsopts)
238{
iso9660_disk *diskStructure = ecalloc(1, sizeof(*diskStructure));

241#define OPT_STR(name){ name, ((void *)0), OPT_STRBUF, 0, 0 }  \
{ name, NULL((void *)0), OPT_STRBUF, 0, 0 }

244#define OPT_NUM(name, field, min, max){ name, &diskStructure->field, sizeof(diskStructure->
field) == 8 ? OPT_INT64 : (sizeof(diskStructure->field) ==
? OPT_INT32 : (sizeof(diskStructure->field) == 2 ? OPT_INT16
 : OPT_INT8)), min, max } \
{ name, &diskStructure->field, \
 sizeof(diskStructure->field) == 8 ? OPT_INT64 : \
 (sizeof(diskStructure->field) == 4 ? OPT_INT32 : \
 (sizeof(diskStructure->field) == 2 ? OPT_INT16 : OPT_INT8)), \
 min, max }

251#define OPT_BOOL(name, field){ name, &diskStructure->field, OPT_BOOL } \
{ name, &diskStructure->field, OPT_BOOL }

const option_t cd9660_options[] = {
       OPT_BOOL("allow-deep-trees", allow_deep_trees){ "allow-deep-trees", &diskStructure->allow_deep_trees
, OPT_BOOL },
       OPT_BOOL("allow-multidot", allow_multidot){ "allow-multidot", &diskStructure->allow_multidot, OPT_BOOL
 },
OPT_STR("applicationid"){ "applicationid", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("boot-load-segment"){ "boot-load-segment", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("bootimage"){ "bootimage", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("generic-bootimage"){ "generic-bootimage", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("hard-disk-boot"){ "hard-disk-boot", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_NUM("isolevel", isoLevel, 1, 3){ "isolevel", &diskStructure->isoLevel, sizeof(diskStructure
->isoLevel) == 8 ? OPT_INT64 : (sizeof(diskStructure->isoLevel
) == 4 ? OPT_INT32 : (sizeof(diskStructure->isoLevel) == 2
 ? OPT_INT16 : OPT_INT8)), 1, 3 },
OPT_STR("label"){ "label", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("no-boot"){ "no-boot", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("no-emul-boot"){ "no-emul-boot", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_BOOL("no-trailing-padding", include_padding_areas){ "no-trailing-padding", &diskStructure->include_padding_areas
, OPT_BOOL },
       OPT_BOOL("omit-trailing-period", omit_trailing_period){ "omit-trailing-period", &diskStructure->omit_trailing_period
, OPT_BOOL },
OPT_STR("preparer"){ "preparer", ((void *)0), OPT_STRBUF, 0, 0 },
OPT_STR("publisher"){ "publisher", ((void *)0), OPT_STRBUF, 0, 0 },
       OPT_BOOL("rockridge", rock_ridge_enabled){ "rockridge", &diskStructure->rock_ridge_enabled, OPT_BOOL
 },
OPT_STR("volumeid"){ "volumeid", ((void *)0), OPT_STRBUF, 0, 0 },
{ .name = NULL((void *)0) }
};

fsopts->fs_specific = diskStructure;
fsopts->fs_options = copy_opts(cd9660_options);

cd9660_set_defaults(diskStructure);
279}

281void
282cd9660_cleanup_opts(fsinfo_t *fsopts)
283{
free(fsopts->fs_specific);
free(fsopts->fs_options);
286}

288static int
289cd9660_arguments_set_string(const char *val, const char *fieldtitle,
  size_t length, char testmode, char * dest)
291{
size_t len;
int test;

if (val == NULL((void *)0))
warnx("error: '%s' requires a string argument", fieldtitle);
else if ((len = strlen(val)) <= length) {
if (testmode == 'd')
	test = cd9660_valid_d_chars(val);
else
	test = cd9660_valid_a_chars(val);
if (test) {
	memcpy(dest, val, len);
	if (test == 2)
		cd9660_uppercase_characters(dest, len);
	return 1;
} else
	warnx("error: '%s' must be composed of %c-characters",
	    fieldtitle, testmode);
} else
warnx("error: '%s' must be at most 32 characters long",
    fieldtitle);
return 0;
314}

316/*
* Command-line parsing function
*/

320int
321cd9660_parse_opts(const char *option, fsinfo_t *fsopts)
322{
int	rv, i;
iso9660_disk *diskStructure = fsopts->fs_specific;
option_t *cd9660_options = fsopts->fs_options;
char buf[1024];
const char *name;

assert(option != NULL)((option != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 329, __func__, "option != NULL"));

i = set_option(cd9660_options, option, buf, sizeof(buf));
if (i == -1)
return 0;

if (cd9660_options[i].name == NULL((void *)0))
abort();


name = cd9660_options[i].name;

if (strcmp(name, "applicationid") == 0) {
rv = cd9660_arguments_set_string(buf, name, 128, 'a',
    diskStructure->primaryDescriptor.application_id);
} else if (strcmp(name, "boot-load-segment") == 0) {
if (buf[0] == '\0') {
	warnx("Option `%s' doesn't contain a value",
	    name);
	rv = 0;
} else {
	cd9660_eltorito_add_boot_option(diskStructure,
	    name, buf);
	rv = 1;
}
} else if (strcmp(name, "bootimage") == 0) {
if (buf[0] == '\0') {
	warnx("The Boot Image parameter requires a valid boot"
	" information string");
	rv = 0;
} else
	rv = cd9660_add_boot_disk(diskStructure, buf);
} else if (strcmp(name, "generic-bootimage") == 0) {
if (buf[0] == '\0') {
	warnx("The Generic Boot Image parameter requires a"
	    " valid boot information string");
	rv = 0;
} else
	rv = cd9660_add_generic_bootimage(diskStructure, buf);
} else if (strcmp(name, "label") == 0) {
rv = cd9660_arguments_set_string(buf, name, 32, 'd',
    diskStructure->primaryDescriptor.volume_id);
} else if (strcmp(name, "preparer") == 0) {
rv = cd9660_arguments_set_string(buf, name, 128, 'a',
    diskStructure->primaryDescriptor.preparer_id);
} else if (strcmp(name, "publisher") == 0) {
rv = cd9660_arguments_set_string(buf, name, 128, 'a',
    diskStructure->primaryDescriptor.publisher_id);
} else if (strcmp(name, "volumeid") == 0) {
rv = cd9660_arguments_set_string(buf, name, 128, 'a',
    diskStructure->primaryDescriptor.volume_set_id);
} else if (strcmp(name, "hard-disk-boot") == 0 ||
   strcmp(name, "no-boot") == 0 ||
   strcmp(name, "no-emul-boot") == 0) {
/* RRIP */
cd9660_eltorito_add_boot_option(diskStructure, name, 0);
rv = 1;
} else
rv = 1;

return rv;
390}

392/*
* Main function for cd9660_makefs
* Builds the ISO image file
* @param const char *image The image filename to create
* @param const char *dir The directory that is being read
* @param struct fsnode *root The root node of the filesystem tree
* @param struct fsinfo_t *fsopts Any options
*/
400void
401cd9660_makefs(const char *image, const char *dir, fsnode *root,
  fsinfo_t *fsopts)
403{
int64_t startoffset;
int ret, numDirectories;
uint64_t pathTableSectors;
int64_t firstAvailableSector;
int64_t totalSpace;
int error;
cd9660node *real_root;
iso9660_disk *diskStructure = fsopts->fs_specific;

if (diskStructure->isoLevel < 2 &&
1
Assuming field 'isoLevel' is >= 2→
   diskStructure->allow_multidot)
errx(1, "allow-multidot requires iso level of 2");

assert(image != NULL)((image != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 417, __func__, "image != NULL"));
2
←
Assuming 'image' is not equal to null→
3
←
'?' condition is true→
assert(dir != NULL)((dir != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 418, __func__, "dir != NULL"));
4
←
Assuming 'dir' is not equal to null→
5
←
'?' condition is true→
assert(root != NULL)((root != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 419, __func__, "root != NULL"));
6
←
Assuming 'root' is not equal to null→
7
←
'?' condition is true→

/* Set up some constants. Later, these will be defined with options */

/* Counter needed for path tables */
numDirectories = 0;

/* Convert tree to our own format */
/* Actually, we now need to add the REAL root node, at level 0 */

real_root = cd9660_allocate_cd9660node();
real_root->isoDirRecord = emalloc(sizeof(*real_root->isoDirRecord));
/* Leave filename blank for root */
memset(real_root->isoDirRecord->name, 0,
   ISO_FILENAME_MAXLENGTH_WITH_PADDING37);

real_root->level = 0;
diskStructure->rootNode = real_root;
real_root->type = CD9660_TYPE_DIR0x02;
error = 0;
real_root->node = root;
cd9660_convert_structure(diskStructure, root, real_root, 1,
   &numDirectories, &error);

if (TAILQ_EMPTY(&real_root->cn_children)(((&real_root->cn_children)->tqh_first) == ((void *
)0))) {
8
←
Assuming field 'tqh_first' is not equal to null→
9
←
Taking false branch→
errx(1, "%s: converted directory is empty. "
    "Tree conversion failed", __func__);
} else if (error9.1
'error' is equal to 0
 != 0) {
10
←
Taking false branch→
errx(1, "%s: tree conversion failed", __func__);
}

/* Add the dot and dot dot records */
cd9660_add_dot_records(diskStructure, real_root);

cd9660_setup_root_node(diskStructure);

/* Rock ridge / SUSP init pass */
if (diskStructure->rock_ridge_enabled) {
11
←
Assuming field 'rock_ridge_enabled' is 0→
12
←
Taking false branch→
cd9660_susp_initialize(diskStructure, diskStructure->rootNode,
    diskStructure->rootNode, NULL((void *)0));
}

/* Build path table structure */
diskStructure->pathTableLength = cd9660_generate_path_table(
13
←
Calling 'cd9660_generate_path_table'→
   diskStructure);

pathTableSectors = CD9660_BLOCKS(diskStructure->sectorSize,((((diskStructure->pathTableLength)) + (((diskStructure->
sectorSize)) - 1)) / ((diskStructure->sectorSize)))
diskStructure->pathTableLength)((((diskStructure->pathTableLength)) + (((diskStructure->
sectorSize)) - 1)) / ((diskStructure->sectorSize)));

firstAvailableSector = cd9660_setup_volume_descriptors(diskStructure);
if (diskStructure->is_bootable) {
firstAvailableSector = cd9660_setup_boot(diskStructure,
    firstAvailableSector);
if (firstAvailableSector < 0)
	errx(1, "setup_boot failed");
}
/* LE first, then BE */
diskStructure->primaryLittleEndianTableSector = firstAvailableSector;
diskStructure->primaryBigEndianTableSector =
diskStructure->primaryLittleEndianTableSector + pathTableSectors;

/* Set the secondary ones to -1, not going to use them for now */
diskStructure->secondaryBigEndianTableSector = -1;
diskStructure->secondaryLittleEndianTableSector = -1;

diskStructure->dataFirstSector =
   diskStructure->primaryBigEndianTableSector + pathTableSectors;

startoffset = diskStructure->sectorSize*diskStructure->dataFirstSector;

totalSpace = cd9660_compute_offsets(diskStructure, real_root, startoffset);

diskStructure->totalSectors = diskStructure->dataFirstSector +
CD9660_BLOCKS(diskStructure->sectorSize, totalSpace)((((totalSpace)) + (((diskStructure->sectorSize)) - 1)) / (
(diskStructure->sectorSize)));

/* Disabled until pass 1 is done */
if (diskStructure->rock_ridge_enabled) {
diskStructure->susp_continuation_area_start_sector =
    diskStructure->totalSectors;
diskStructure->totalSectors +=
    CD9660_BLOCKS(diskStructure->sectorSize,((((diskStructure->susp_continuation_area_size)) + (((diskStructure
->sectorSize)) - 1)) / ((diskStructure->sectorSize)))
	diskStructure->susp_continuation_area_size)((((diskStructure->susp_continuation_area_size)) + (((diskStructure
->sectorSize)) - 1)) / ((diskStructure->sectorSize)));
cd9660_susp_finalize(diskStructure, diskStructure->rootNode);
}


cd9660_finalize_PVD(diskStructure);

/* Add padding sectors, just for testing purposes right now */
/* diskStructure->totalSectors+=150; */

/*
* Add padding sectors at the end
* TODO: Clean this up and separate padding
*/
if (diskStructure->include_padding_areas)
diskStructure->totalSectors += 150;

ret = cd9660_write_image(diskStructure, image);

/* Clean up data structures */
cd9660_free_structure(real_root);

if (ret == 0)	/* cd9660_write_image() failed */
exit(1);
524}

526/* Generic function pointer - implement later */
527typedef int (*cd9660node_func)(cd9660node *);

529static void
530cd9660_finalize_PVD(iso9660_disk *diskStructure)
531{
time_t tstamp = Tflag ? stampts : time(NULL((void *)0));

/* root should be a fixed size of 34 bytes since it has no name */
memcpy(diskStructure->primaryDescriptor.root_directory_record,
diskStructure->rootNode->dot_record->isoDirRecord, 34);

/* In RRIP, this might be longer than 34 */
diskStructure->primaryDescriptor.root_directory_record[0] = 34;

/* Set up all the important numbers in the PVD */
cd9660_bothendian_dword(diskStructure->totalSectors,
   (unsigned char *)diskStructure->primaryDescriptor.volume_space_size);
cd9660_bothendian_word(1,
   (unsigned char *)diskStructure->primaryDescriptor.volume_set_size);
cd9660_bothendian_word(1,
   (unsigned char *)
diskStructure->primaryDescriptor.volume_sequence_number);
cd9660_bothendian_word(diskStructure->sectorSize,
   (unsigned char *)
diskStructure->primaryDescriptor.logical_block_size);
cd9660_bothendian_dword(diskStructure->pathTableLength,
   (unsigned char *)diskStructure->primaryDescriptor.path_table_size);

cd9660_731(diskStructure->primaryLittleEndianTableSector,
(u_char *)diskStructure->primaryDescriptor.type_l_path_table);
cd9660_732(diskStructure->primaryBigEndianTableSector,
(u_char *)diskStructure->primaryDescriptor.type_m_path_table);

diskStructure->primaryDescriptor.file_structure_version[0] = 1;

/* Pad all strings with spaces instead of nulls */
cd9660_pad_string_spaces(diskStructure->primaryDescriptor.volume_id, 32);
cd9660_pad_string_spaces(diskStructure->primaryDescriptor.system_id, 32);
cd9660_pad_string_spaces(diskStructure->primaryDescriptor.volume_set_id,
   128);
cd9660_pad_string_spaces(diskStructure->primaryDescriptor.publisher_id,
   128);
cd9660_pad_string_spaces(diskStructure->primaryDescriptor.preparer_id,
   128);
cd9660_pad_string_spaces(diskStructure->primaryDescriptor.application_id,
   128);
cd9660_pad_string_spaces(
   diskStructure->primaryDescriptor.copyright_file_id, 37);
cd9660_pad_string_spaces(
diskStructure->primaryDescriptor.abstract_file_id, 37);
cd9660_pad_string_spaces(
diskStructure->primaryDescriptor.bibliographic_file_id, 37);

/* Setup dates */
cd9660_time_8426(
   (unsigned char *)diskStructure->primaryDescriptor.creation_date,
   tstamp);
cd9660_time_8426(
   (unsigned char *)diskStructure->primaryDescriptor.modification_date,
   tstamp);

588#if 0
cd9660_set_date(diskStructure->primaryDescriptor.expiration_date,
   tstamp);
591#endif
memset(diskStructure->primaryDescriptor.expiration_date, '0' ,16);
diskStructure->primaryDescriptor.expiration_date[16] = 0;

cd9660_time_8426(
   (unsigned char *)diskStructure->primaryDescriptor.effective_date,
   tstamp);
598}

600static void
601cd9660_populate_iso_dir_record(struct _iso_directory_record_cd9660 *record,
	       u_char ext_attr_length, u_char flags,
	       u_char name_len, const char * name)
604{
record->ext_attr_length[0] = ext_attr_length;
record->flags[0] = ISO_FLAG_CLEAR0x00 | flags;
record->file_unit_size[0] = 0;
record->interleave[0] = 0;
cd9660_bothendian_word(1, record->volume_sequence_number);
record->name_len[0] = name_len;
memset(record->name, '\0', sizeof (record->name));
memcpy(record->name, name, name_len);
record->length[0] = 33 + name_len;

/* Todo : better rounding */
record->length[0] += (record->length[0] & 1) ? 1 : 0;
617}

619static void
620cd9660_setup_root_node(iso9660_disk *diskStructure)
621{
cd9660_populate_iso_dir_record(diskStructure->rootNode->isoDirRecord,
   0, ISO_FLAG_DIRECTORY0x02, 1, "\0");

625}

627/*********** SUPPORT FUNCTIONS ***********/
628static int
629cd9660_setup_volume_descriptors(iso9660_disk *diskStructure)
630{
/* Boot volume descriptor should come second */
int sector = 16;
/* For now, a fixed 2 : PVD and terminator */
volume_descriptor *temp, *t;

/* Set up the PVD */
temp = emalloc(sizeof(*temp));
temp->volumeDescriptorData =
  (unsigned char *)&diskStructure->primaryDescriptor;
temp->volumeDescriptorData[0] = ISO_VOLUME_DESCRIPTOR_PVD1;
temp->volumeDescriptorData[6] = 1;
temp->sector = sector;
memcpy(temp->volumeDescriptorData + 1,
   ISO_VOLUME_DESCRIPTOR_STANDARD_ID"CD001", 5);
diskStructure->firstVolumeDescriptor = temp;

sector++;
/* Set up boot support if enabled. BVD must reside in sector 17 */
if (diskStructure->is_bootable) {
t = emalloc(sizeof(*t));
t->volumeDescriptorData = ecalloc(1, 2048);
temp->next = t;
temp = t;
t->sector = 17;
cd9660_setup_boot_volume_descriptor(diskStructure, t);
sector++;
}

/* Set up the terminator */
t = emalloc(sizeof(*t));
t->volumeDescriptorData = ecalloc(1, 2048);
temp->next = t;
t->volumeDescriptorData[0] = ISO_VOLUME_DESCRIPTOR_TERMINATOR255;
t->next = 0;
t->volumeDescriptorData[6] = 1;
t->sector = sector;
memcpy(t->volumeDescriptorData + 1,
   ISO_VOLUME_DESCRIPTOR_STANDARD_ID"CD001", 5);

sector++;
return sector;
672}

674#if 0
675/*
* Populate EAR at some point. Not required, but is used by NetBSD's
* cd9660 support
*/
679static int
680cd9660_fill_extended_attribute_record(cd9660node *node)
681{
node->isoExtAttributes = emalloc(sizeof(*node->isoExtAttributes));
return 1;
684}
685#endif

687static int
688cd9660_translate_node_common(iso9660_disk *diskStructure, cd9660node *newnode)
689{
time_t tstamp = Tflag ? stampts : time(NULL((void *)0));
u_char flag;
char temp[ISO_FILENAME_MAXLENGTH_WITH_PADDING37];

/* Now populate the isoDirRecord structure */
memset(temp, 0, ISO_FILENAME_MAXLENGTH_WITH_PADDING37);

(void)cd9660_convert_filename(diskStructure, newnode->node->name,
   temp, sizeof temp, !(S_ISDIR(newnode->node->type)((newnode->node->type & 0170000) == 0040000)));

flag = ISO_FLAG_CLEAR0x00;
if (S_ISDIR(newnode->node->type)((newnode->node->type & 0170000) == 0040000))
flag |= ISO_FLAG_DIRECTORY0x02;

cd9660_populate_iso_dir_record(newnode->isoDirRecord, 0,
   flag, strlen(temp), temp);

/* Set the various dates */

/* If we want to use the current date and time */

cd9660_time_915(newnode->isoDirRecord->date, tstamp);

cd9660_bothendian_dword(newnode->fileDataLength,
   newnode->isoDirRecord->size);
/* If the file is a link, we want to set the size to 0 */
if (S_ISLNK(newnode->node->type)((newnode->node->type & 0170000) == 0120000))
newnode->fileDataLength = 0;

return 1;
720}

722/*
* Translate fsnode to cd9660node
* Translate filenames and other metadata, including dates, sizes,
* permissions, etc
* @param struct fsnode * The node generated by makefs
* @param struct cd9660node * The intermediate node to be written to
* @returns int 0 on failure, 1 on success
*/
730static int
731cd9660_translate_node(iso9660_disk *diskStructure, fsnode *node,
  cd9660node *newnode)
733{
if (node == NULL((void *)0))
return 0;

newnode->isoDirRecord = emalloc(sizeof(*newnode->isoDirRecord));
/* Set the node pointer */
newnode->node = node;

/* Set the size */
if (!(S_ISDIR(node->type)((node->type & 0170000) == 0040000)))
newnode->fileDataLength = node->inode->st.st_size;

if (cd9660_translate_node_common(diskStructure, newnode) == 0)
return 0;

/* Finally, overwrite some of the values that are set by default */
cd9660_time_915(newnode->isoDirRecord->date,
   Tflag ? stampts : node->inode->st.st_mtimest_mtim.tv_sec);

return 1;
753}

755/*
* Compares two ISO filenames
* @param const char * The first file name
* @param const char * The second file name
* @returns : -1 if first is less than second, 0 if they are the same, 1 if
*	the second is greater than the first
*/
762static int
763cd9660_compare_filename(const char *first, const char *second)
764{
/*
* This can be made more optimal once it has been tested
* (the extra character, for example, is for testing)
*/

int p1 = 0;
int p2 = 0;
char c1, c2;
/* First, on the filename */

while (p1 < ISO_FILENAME_MAXLENGTH_BEFORE_VERSION30-1
&& p2 < ISO_FILENAME_MAXLENGTH_BEFORE_VERSION30-1) {
c1 = first[p1];
c2 = second[p2];
if (c1 == '.' && c2 =='.')
	break;
else if (c1 == '.') {
	p2++;
	c1 = ' ';
} else if (c2 == '.') {
	p1++;
	c2 = ' ';
} else {
	p1++;
	p2++;
}

if (c1 < c2)
	return -1;
else if (c1 > c2) {
	return 1;
}
}

if (first[p1] == '.' && second[p2] == '.') {
p1++;
p2++;
while (p1 < ISO_FILENAME_MAXLENGTH_BEFORE_VERSION30 - 1
	&& p2 < ISO_FILENAME_MAXLENGTH_BEFORE_VERSION30 - 1) {
	c1 = first[p1];
	c2 = second[p2];
	if (c1 == ';' && c2 == ';')
		break;
	else if (c1 == ';') {
		p2++;
		c1 = ' ';
	} else if (c2 == ';') {
		p1++;
		c2 = ' ';
	} else {
		p1++;
		p2++;
	}

	if (c1 < c2)
		return -1;
	else if (c1 > c2)
		return 1;
}
}
return 0;
826}

828/*
* Insert a node into list with ISO sorting rules
* @param cd9660node * The head node of the list
* @param cd9660node * The node to be inserted
*/
833static void
834cd9660_sorted_child_insert(cd9660node *parent, cd9660node *cn_new)
835{
int compare;
cd9660node *cn;
struct cd9660_children_head *head = &parent->cn_children;

/* TODO: Optimize? */
cn_new->parent = parent;

/*
* first will either be 0, the . or the ..
* if . or .., this means no other entry may be written before first
* if 0, the new node may be inserted at the head
*/

TAILQ_FOREACH(cn, head, cn_next_child)for((cn) = ((head)->tqh_first); (cn) != ((void *)0); (cn) =
 ((cn)->cn_next_child.tqe_next)) {
/*
 * Dont insert a node twice -
 * that would cause an infinite loop
 */
if (cn_new == cn)
	return;

compare = cd9660_compare_filename(cn_new->isoDirRecord->name,
	cn->isoDirRecord->name);

if (compare == 0)
	compare = cd9660_compare_filename(cn_new->node->name,
		cn->node->name);

if (compare < 0)
	break;
}
if (cn == NULL((void *)0))
TAILQ_INSERT_TAIL(head, cn_new, cn_next_child)do { (cn_new)->cn_next_child.tqe_next = ((void *)0); (cn_new
)->cn_next_child.tqe_prev = (head)->tqh_last; *(head)->
tqh_last = (cn_new); (head)->tqh_last = &(cn_new)->
cn_next_child.tqe_next; } while (0);
else
TAILQ_INSERT_BEFORE(cn, cn_new, cn_next_child)do { (cn_new)->cn_next_child.tqe_prev = (cn)->cn_next_child
.tqe_prev; (cn_new)->cn_next_child.tqe_next = (cn); *(cn)->
cn_next_child.tqe_prev = (cn_new); (cn)->cn_next_child.tqe_prev
 = &(cn_new)->cn_next_child.tqe_next; } while (0);
871}

873/*
* Called After cd9660_sorted_child_insert
* handles file collisions by suffixing each filename with ~n
* where n represents the files respective place in the ordering
*/
878static int
879cd9660_handle_collisions(iso9660_disk *diskStructure, cd9660node *colliding,
  int past)
881{
cd9660node *iter, *next, *prev;
int skip;
int delete_chars = 0;
int temp_past = past;
int temp_skip;
int flag = 0;
cd9660node *end_of_range;

for (iter = TAILQ_FIRST(&colliding->cn_children)((&colliding->cn_children)->tqh_first);
    iter != NULL((void *)0) && (next = TAILQ_NEXT(iter, cn_next_child)((iter)->cn_next_child.tqe_next)) != NULL((void *)0);) {
if (strcmp(iter->isoDirRecord->name,
           next->isoDirRecord->name) != 0) {
	iter = TAILQ_NEXT(iter, cn_next_child)((iter)->cn_next_child.tqe_next);
	continue;
}
flag = 1;
temp_skip = skip = cd9660_count_collisions(iter);
end_of_range = iter;
while (temp_skip > 0) {
	temp_skip--;
	end_of_range = TAILQ_NEXT(end_of_range, cn_next_child)((end_of_range)->cn_next_child.tqe_next);
}
temp_past = past;
while (temp_past > 0) {
	if ((next = TAILQ_NEXT(end_of_range, cn_next_child)((end_of_range)->cn_next_child.tqe_next)) != NULL((void *)0))
		end_of_range = next;
	else if ((prev = TAILQ_PREV(iter, cd9660_children_head, cn_next_child)(*(((struct cd9660_children_head *)((iter)->cn_next_child.
tqe_prev))->tqh_last))) != NULL((void *)0))
		iter = prev;
	else
		delete_chars++;
	temp_past--;
}
skip += past;
iter = cd9660_rename_filename(diskStructure, iter, skip,
    delete_chars);
}
return flag;
919}


922static cd9660node *
923cd9660_rename_filename(iso9660_disk *diskStructure, cd9660node *iter, int num,
  int delete_chars)
925{
int i = 0;
int numbts, dot, semi, digit, digits, temp, powers, multiplier, count;
char *naming;
int maxlength;
      char *tmp;

/* TODO : A LOT of chanes regarding 8.3 filenames */
if (diskStructure->isoLevel == 1)
maxlength = 8;
else if (diskStructure->isoLevel == 2)
maxlength = 31;
else
maxlength = ISO_FILENAME_MAXLENGTH_BEFORE_VERSION30;

tmp = emalloc(ISO_FILENAME_MAXLENGTH_WITH_PADDING37);

while (i < num && iter) {
powers = 1;
count = 0;
digits = 1;
multiplier = 1;
while (((int)(i / powers) ) >= 10) {
	digits++;
	powers = powers * 10;
}

naming = iter->o_name;

/*
while ((*naming != '.') && (*naming != ';')) {
	naming++;
	count++;
}
*/

dot = -1;
semi = -1;
while (count < maxlength) {
	if (*naming == '.')
		dot = count;
	else if (*naming == ';') {
		semi = count;
		break;
	}
	naming++;
	count++;
}

if ((count + digits) < maxlength)
	numbts = count;
else
	numbts = maxlength - (digits);
numbts -= delete_chars;

/* 8.3 rules - keep the extension, add before the dot */

/*
 * This code makes a bunch of assumptions.
 * See if you can spot them all :)
 */

987#if 0
if (diskStructure->isoLevel == 1) {
	numbts = 8 - digits - delete_chars;
	if (dot < 0) {

	} else {
		if (dot < 8) {
			memmove(&tmp[numbts],&tmp[dot],4);
		}
	}
}
998#else
(void)dot;
(void)semi;
(void)multiplier;
1002#endif

/* (copying just the filename before the '.' */
memcpy(tmp, (iter->o_name), numbts);

/* adding the appropriate number following the name */
temp = i;
while (digits > 0) {
	digit = (int)(temp / powers);
	temp = temp - digit * powers;
	snprintf(&tmp[numbts] , ISO_FILENAME_MAXLENGTH_WITH_PADDING37 - numbts, "%d", digit);
	digits--;
	numbts++;
	powers = powers / 10;
}

while ((*naming != ';')  && (numbts < maxlength)) {
	tmp[numbts] = (*naming);
	naming++;
	numbts++;
}

tmp[numbts] = ';';
tmp[numbts+1] = '1';
tmp[numbts+2] = '\0';

/*
 * now tmp has exactly the identifier
 * we want so we'll copy it back to record
 */
memcpy((iter->isoDirRecord->name), tmp, numbts + 3);

iter = TAILQ_NEXT(iter, cn_next_child)((iter)->cn_next_child.tqe_next);
i++;
}

free(tmp);
return iter;
1040}

1042/* Todo: Figure out why these functions are nec. */
1043static void
1044cd9660_copy_filenames(iso9660_disk *diskStructure, cd9660node *node)
1045{
cd9660node *cn;

if (TAILQ_EMPTY(&node->cn_children)(((&node->cn_children)->tqh_first) == ((void *)0)))
return;

if (TAILQ_FIRST(&node->cn_children)((&node->cn_children)->tqh_first)->isoDirRecord == NULL((void *)0)) {
debug_print_tree(diskStructure, diskStructure->rootNode, 0);
exit(1);
}

TAILQ_FOREACH(cn, &node->cn_children, cn_next_child)for((cn) = ((&node->cn_children)->tqh_first); (cn) !=
 ((void *)0); (cn) = ((cn)->cn_next_child.tqe_next)) {
cd9660_copy_filenames(diskStructure, cn);
memcpy(cn->o_name, cn->isoDirRecord->name,
    ISO_FILENAME_MAXLENGTH_WITH_PADDING37);
}
1061}

1063static void
1064cd9660_sorting_nodes(cd9660node *node)
1065{
cd9660node *cn;

TAILQ_FOREACH(cn, &node->cn_children, cn_next_child)for((cn) = ((&node->cn_children)->tqh_first); (cn) !=
 ((void *)0); (cn) = ((cn)->cn_next_child.tqe_next))
cd9660_sorting_nodes(cn);
cd9660_sort_nodes(node);
1071}

1073/* XXX Bubble sort. */
1074static void
1075cd9660_sort_nodes(cd9660node *node)
1076{
cd9660node *cn, *next;

do {
TAILQ_FOREACH(cn, &node->cn_children, cn_next_child)for((cn) = ((&node->cn_children)->tqh_first); (cn) !=
 ((void *)0); (cn) = ((cn)->cn_next_child.tqe_next)) {
	if ((next = TAILQ_NEXT(cn, cn_next_child)((cn)->cn_next_child.tqe_next)) == NULL((void *)0))
		return;
	else if (strcmp(next->isoDirRecord->name,
		        cn->isoDirRecord->name) >= 0)
		continue;
	TAILQ_REMOVE(&node->cn_children, next, cn_next_child)do { if (((next)->cn_next_child.tqe_next) != ((void *)0)) (
next)->cn_next_child.tqe_next->cn_next_child.tqe_prev =
 (next)->cn_next_child.tqe_prev; else (&node->cn_children
)->tqh_last = (next)->cn_next_child.tqe_prev; *(next)->
cn_next_child.tqe_prev = (next)->cn_next_child.tqe_next; ;
 ; } while (0);
	TAILQ_INSERT_BEFORE(cn, next, cn_next_child)do { (next)->cn_next_child.tqe_prev = (cn)->cn_next_child
.tqe_prev; (next)->cn_next_child.tqe_next = (cn); *(cn)->
cn_next_child.tqe_prev = (next); (cn)->cn_next_child.tqe_prev
 = &(next)->cn_next_child.tqe_next; } while (0);
	break;
}
} while (cn != NULL((void *)0));
1091}

1093static int
1094cd9660_count_collisions(cd9660node *copy)
1095{
int count = 0;
cd9660node *iter, *next;

for (iter = copy;
    (next = TAILQ_NEXT(iter, cn_next_child)((iter)->cn_next_child.tqe_next)) != NULL((void *)0);
    iter = next) {
if (cd9660_compare_filename(iter->isoDirRecord->name,
	next->isoDirRecord->name) == 0)
	count++;
else
	return count;
}
1108#if 0
if ((next = TAILQ_NEXT(iter, cn_next_child)((iter)->cn_next_child.tqe_next)) != NULL((void *)0)) {
printf("%s: count is %i \n", __func__, count);
compare = cd9660_compare_filename(iter->isoDirRecord->name,
	next->isoDirRecord->name);
if (compare == 0) {
	count++;
	return cd9660_recurse_on_collision(next, count);
} else
	return count;
}
1119#endif
return count;
1121}

1123static cd9660node *
1124cd9660_rrip_move_directory(iso9660_disk *diskStructure, cd9660node *dir)
1125{
char newname[9];
cd9660node *tfile;

/*
* This function needs to:
* 1) Create an empty virtual file in place of the old directory
* 2) Point the virtual file to the new directory
* 3) Point the relocated directory to its old parent
* 4) Move the directory specified by dir into rr_moved_dir,
* and rename it to "diskStructure->rock_ridge_move_count" (as a string)
*/

/* First see if the moved directory even exists */
if (diskStructure->rr_moved_dir == NULL((void *)0)) {
diskStructure->rr_moved_dir = cd9660_create_directory(
    diskStructure, ISO_RRIP_DEFAULT_MOVE_DIR_NAME"RR_MOVED",
    diskStructure->rootNode, dir);
if (diskStructure->rr_moved_dir == NULL((void *)0))
	return 0;
cd9660_time_915(diskStructure->rr_moved_dir->isoDirRecord->date,
    Tflag ? stampts : start_time.tv_sec);
}

/* Create a file with the same ORIGINAL name */
tfile = cd9660_create_file(diskStructure, dir->node->name, dir->parent,
   dir);
if (tfile == NULL((void *)0))
return NULL((void *)0);

diskStructure->rock_ridge_move_count++;
snprintf(newname, sizeof(newname), "%08i",
   diskStructure->rock_ridge_move_count);

/* Point to old parent */
dir->rr_real_parent = dir->parent;

/* Place the placeholder file */
if (TAILQ_EMPTY(&dir->rr_real_parent->cn_children)(((&dir->rr_real_parent->cn_children)->tqh_first
) == ((void *)0))) {
TAILQ_INSERT_HEAD(&dir->rr_real_parent->cn_children, tfile,do { if (((tfile)->cn_next_child.tqe_next = (&dir->
rr_real_parent->cn_children)->tqh_first) != ((void *)0)
) (&dir->rr_real_parent->cn_children)->tqh_first
->cn_next_child.tqe_prev = &(tfile)->cn_next_child.
tqe_next; else (&dir->rr_real_parent->cn_children)->
tqh_last = &(tfile)->cn_next_child.tqe_next; (&dir
->rr_real_parent->cn_children)->tqh_first = (tfile);
 (tfile)->cn_next_child.tqe_prev = &(&dir->rr_real_parent
->cn_children)->tqh_first; } while (0)
    cn_next_child)do { if (((tfile)->cn_next_child.tqe_next = (&dir->
rr_real_parent->cn_children)->tqh_first) != ((void *)0)
) (&dir->rr_real_parent->cn_children)->tqh_first
->cn_next_child.tqe_prev = &(tfile)->cn_next_child.
tqe_next; else (&dir->rr_real_parent->cn_children)->
tqh_last = &(tfile)->cn_next_child.tqe_next; (&dir
->rr_real_parent->cn_children)->tqh_first = (tfile);
 (tfile)->cn_next_child.tqe_prev = &(&dir->rr_real_parent
->cn_children)->tqh_first; } while (0);
} else {
cd9660_sorted_child_insert(dir->rr_real_parent, tfile);
}

/* Point to new parent */
dir->parent = diskStructure->rr_moved_dir;

/* Point the file to the moved directory */
tfile->rr_relocated = dir;

/* Actually move the directory */
cd9660_sorted_child_insert(diskStructure->rr_moved_dir, dir);

/* TODO: Inherit permissions / ownership (basically the entire inode) */

/* Set the new name */
memset(dir->isoDirRecord->name, 0, ISO_FILENAME_MAXLENGTH_WITH_PADDING37);
strncpy(dir->isoDirRecord->name, newname, 8);
dir->isoDirRecord->length[0] = 34 + 8;
dir->isoDirRecord->name_len[0] = 8;

return dir;
1188}

1190static int
1191cd9660_add_dot_records(iso9660_disk *diskStructure, cd9660node *root)
1192{
struct cd9660_children_head *head = &root->cn_children;
cd9660node *cn;

TAILQ_FOREACH(cn, head, cn_next_child)for((cn) = ((head)->tqh_first); (cn) != ((void *)0); (cn) =
 ((cn)->cn_next_child.tqe_next)) {
if ((cn->type & CD9660_TYPE_DIR0x02) == 0)
	continue;
/* Recursion first */
cd9660_add_dot_records(diskStructure, cn);
}
cd9660_create_special_directory(diskStructure, CD9660_TYPE_DOT0x04, root);
cd9660_create_special_directory(diskStructure, CD9660_TYPE_DOTDOT0x08,
   root);
return 1;
1206}

1208/*
* Convert node to cd9660 structure
* This function is designed to be called recursively on the root node of
* the filesystem
* Lots of recursion going on here, want to make sure it is efficient
* @param struct fsnode * The root node to be converted
* @param struct cd9660* The parent node (should not be NULL)
* @param int Current directory depth
* @param int* Running count of the number of directories that are being created
*/
1218static void
1219cd9660_convert_structure(iso9660_disk *diskStructure, fsnode *root,
  cd9660node *parent_node, int level, int *numDirectories, int *error)
1221{
fsnode *iterator = root;
cd9660node *this_node;
int working_level;
int add;
int flag = 0;
int counter = 0;

/*
* Newer, more efficient method, reduces recursion depth
*/
if (root == NULL((void *)0)) {
warnx("%s: root is null", __func__);
return;
}

/* Test for an empty directory - makefs still gives us the . record */
if ((S_ISDIR(root->type)((root->type & 0170000) == 0040000)) && (root->name[0] == '.')
&& (root->name[1] == '\0')) {
root = root->next;
if (root == NULL((void *)0))
	return;
}
if ((this_node = cd9660_allocate_cd9660node()) == NULL((void *)0)) {
CD9660_MEM_ALLOC_ERROR(__func__)err(1, "%s, %s l. %d", __func__, "/usr/src/usr.sbin/makefs/cd9660.c"
, 1245);
}

/*
* To reduce the number of recursive calls, we will iterate over
* the next pointers to the right.
*/
while (iterator != NULL((void *)0)) {
add = 1;
/*
 * Increment the directory count if this is a directory
 * Ignore "." entries. We will generate them later
 */
if (!S_ISDIR(iterator->type)((iterator->type & 0170000) == 0040000) ||
    strcmp(iterator->name, ".") != 0) {

	/* Translate the node, including its filename */
	this_node->parent = parent_node;
	cd9660_translate_node(diskStructure, iterator,
	    this_node);
	this_node->level = level;

	if (S_ISDIR(iterator->type)((iterator->type & 0170000) == 0040000)) {
		(*numDirectories)++;
		this_node->type = CD9660_TYPE_DIR0x02;
		working_level = level + 1;

		/*
		 * If at level 8, directory would be at 8
		 * and have children at 9 which is not
		 * allowed as per ISO spec
		 */
		if (level == 8) {
			if ((!diskStructure->allow_deep_trees) &&
			  (!diskStructure->rock_ridge_enabled)) {
				warnx("error: found entry "
				     "with depth greater "
				     "than 8.");
				(*error) = 1;
				return;
			} else if (diskStructure->
				   rock_ridge_enabled) {
				working_level = 3;
				/*
				 * Moved directory is actually
				 * at level 2.
				 */
				this_node->level =
				    working_level - 1;
				if (cd9660_rrip_move_directory(
					diskStructure,
					this_node) == 0) {
					warnx("Failure in "
					      "cd9660_rrip_"
					      "move_directory"
					);
					(*error) = 1;
					return;
				}
				add = 0;
			}
		}

		/* Do the recursive call on the children */
		if (iterator->child != 0) {
			cd9660_convert_structure(diskStructure,
				iterator->child, this_node,
				working_level,
				numDirectories, error);

			if ((*error) == 1) {
				warnx("%s: Error on recursive "
				    "call", __func__);
				return;
			}
		}

	} else {
		/* Only directories should have children */
		assert(iterator->child == NULL)((iterator->child == ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 1324, __func__, "iterator->child == NULL"));

		this_node->type = CD9660_TYPE_FILE0x01;
	}

	/*
	 * Finally, do a sorted insert
	 */
	if (add) {
		cd9660_sorted_child_insert(
		    parent_node, this_node);
	}

	/*Allocate new temp_node */
	if (iterator->next != 0) {
		this_node = cd9660_allocate_cd9660node();
		if (this_node == NULL((void *)0))
			CD9660_MEM_ALLOC_ERROR(__func__)err(1, "%s, %s l. %d", __func__, "/usr/src/usr.sbin/makefs/cd9660.c"
, 1341);
	}
}
iterator = iterator->next;
}

/* cd9660_handle_collisions(first_node); */

/* TODO: need cleanup */
cd9660_copy_filenames(diskStructure, parent_node);

do {
flag = cd9660_handle_collisions(diskStructure, parent_node,
    counter);
counter++;
cd9660_sorting_nodes(parent_node);
} while ((flag == 1) && (counter < 100));
1358}

1360/*
* Clean up the cd9660node tree
* This is designed to be called recursively on the root node
* @param struct cd9660node *root The node to free
* @returns void
*/
1366static void
1367cd9660_free_structure(cd9660node *root)
1368{
cd9660node *cn;

while ((cn = TAILQ_FIRST(&root->cn_children)((&root->cn_children)->tqh_first)) != NULL((void *)0)) {
TAILQ_REMOVE(&root->cn_children, cn, cn_next_child)do { if (((cn)->cn_next_child.tqe_next) != ((void *)0)) (cn
)->cn_next_child.tqe_next->cn_next_child.tqe_prev = (cn
)->cn_next_child.tqe_prev; else (&root->cn_children
)->tqh_last = (cn)->cn_next_child.tqe_prev; *(cn)->cn_next_child
.tqe_prev = (cn)->cn_next_child.tqe_next; ; ; } while (0);
cd9660_free_structure(cn);
}
free(root);
1376}

1378/*
* Be a little more memory conservative:
* instead of having the TAILQ_ENTRY as part of the cd9660node,
* just create a temporary structure
*/
1383struct ptq_entry
1384{
TAILQ_ENTRY(ptq_entry)struct { struct ptq_entry *tqe_next; struct ptq_entry **tqe_prev
; } ptq;
cd9660node *node;
1387} *n;

1389#define PTQUEUE_NEW(n,s,r,t){ n = emalloc(sizeof(struct s)); if (n == ((void *)0)) return
 r; n->node = t;}{\
n = emalloc(sizeof(struct s));	\
if (n == NULL((void *)0))	\
return r; \
n->node = t;\
1394}

1396/*
* Generate the path tables
* The specific implementation of this function is left as an exercise to the
* programmer. It could be done recursively. Make sure you read how the path
* table has to be laid out, it has levels.
* @param struct iso9660_disk *disk The disk image
* @returns int The number of built path tables (between 1 and 4), 0 on failure
*/
1404static int
1405cd9660_generate_path_table(iso9660_disk *diskStructure)
1406{
cd9660node *cn, *dirNode = diskStructure->rootNode;
cd9660node *last = dirNode;
int pathTableSize = 0;	/* computed as we go */
int counter = 1;	/* root gets a count of 0 */

TAILQ_HEAD(cd9660_pt_head, ptq_entry)struct cd9660_pt_head { struct ptq_entry *tqh_first; struct ptq_entry
 **tqh_last; } pt_head;
TAILQ_INIT(&pt_head)do { (&pt_head)->tqh_first = ((void *)0); (&pt_head
)->tqh_last = &(&pt_head)->tqh_first; } while (
0);
14
←
Loop condition is false.  Exiting loop→

PTQUEUE_NEW(n, ptq_entry, -1, diskStructure->rootNode){ n = emalloc(sizeof(struct ptq_entry)); if (n == ((void *)0)
) return -1; n->node = diskStructure->rootNode;};
15
←
Assuming 'n' is not equal to null→
16
←
Taking false branch→

/* Push the root node */
TAILQ_INSERT_HEAD(&pt_head, n, ptq)do { if (((n)->ptq.tqe_next = (&pt_head)->tqh_first
) != ((void *)0)) (&pt_head)->tqh_first->ptq.tqe_prev
 = &(n)->ptq.tqe_next; else (&pt_head)->tqh_last
 = &(n)->ptq.tqe_next; (&pt_head)->tqh_first = (
n); (n)->ptq.tqe_prev = &(&pt_head)->tqh_first;
 } while (0);
17
←
Taking false branch→
18
←
Loop condition is false.  Exiting loop→

/* Breadth-first traversal of file structure */
while (pt_head.tqh_first18.1
Field 'tqh_first' is not equal to null
1
Field 'tqh_first' is not equal to null
 != 0) {
19
←
Loop condition is true.  Entering loop body→
27
←
Assuming field 'tqh_first' is not equal to null→
28
←
Loop condition is true.  Entering loop body→
39
←
Loop condition is true.  Entering loop body→
n = pt_head.tqh_first;
dirNode = n->node;
40
←
Use of memory after it is freed
TAILQ_REMOVE(&pt_head, pt_head.tqh_first, ptq)do { if (((pt_head.tqh_first)->ptq.tqe_next) != ((void *)0
)) (pt_head.tqh_first)->ptq.tqe_next->ptq.tqe_prev = (pt_head
.tqh_first)->ptq.tqe_prev; else (&pt_head)->tqh_last
 = (pt_head.tqh_first)->ptq.tqe_prev; *(pt_head.tqh_first)
->ptq.tqe_prev = (pt_head.tqh_first)->ptq.tqe_next; ; ;
 } while (0);
20
←
Taking false branch→
21
←
Loop condition is false.  Exiting loop→
29
←
Assuming field 'tqe_next' is equal to null→
30
←
Taking false branch→
31
←
Loop condition is false.  Exiting loop→
free(n);
32
←
Memory is released→

/* Update the size */
pathTableSize += ISO_PATHTABLE_ENTRY_BASESIZE8
    + dirNode->isoDirRecord->name_len[0]+
	(dirNode->isoDirRecord->name_len[0] % 2 == 0 ? 0 : 1);
22
←
Assuming the condition is false→
23
←
'?' condition is false→
33
←
Assuming the condition is true→
34
←
'?' condition is true→
	/* includes the padding bit */

dirNode->ptnumber=counter;
if (dirNode23.1
'dirNode' is equal to 'last'
 != last) {
24
←
Taking false branch→
35
←
Assuming 'dirNode' is equal to 'last'→
36
←
Taking false branch→
	last->ptnext = dirNode;
	dirNode->ptprev = last;
}
last = dirNode;

/* Push children onto queue */
TAILQ_FOREACH(cn, &dirNode->cn_children, cn_next_child)for((cn) = ((&dirNode->cn_children)->tqh_first); (cn
) != ((void *)0); (cn) = ((cn)->cn_next_child.tqe_next)) {
25
←
Assuming 'cn' is equal to null→
26
←
Loop condition is false. Execution continues on line 1455→
37
←
Assuming 'cn' is equal to null→
38
←
Loop condition is false. Execution continues on line 1455→
	/*
	 * Dont add the DOT and DOTDOT types to the path
	 * table.
	 */
	if ((cn->type != CD9660_TYPE_DOT0x04)
		&& (cn->type != CD9660_TYPE_DOTDOT0x08)) {

		if (S_ISDIR(cn->node->type)((cn->node->type & 0170000) == 0040000)) {
			PTQUEUE_NEW(n, ptq_entry, -1, cn){ n = emalloc(sizeof(struct ptq_entry)); if (n == ((void *)0)
) return -1; n->node = cn;};
			TAILQ_INSERT_TAIL(&pt_head, n, ptq)do { (n)->ptq.tqe_next = ((void *)0); (n)->ptq.tqe_prev
 = (&pt_head)->tqh_last; *(&pt_head)->tqh_last =
 (n); (&pt_head)->tqh_last = &(n)->ptq.tqe_next
; } while (0);
		}
	}
}
counter++;
}
return pathTableSize;
1458}

1460char *
1461cd9660_compute_full_filename(cd9660node *node)
1462{
static char buf[PATH_MAX1024];
int len;

len = snprintf(buf, PATH_MAX1024, "%s/%s/%s", node->node->root,
   node->node->path, node->node->name);
if (len < 0) {
warn(NULL((void *)0));
return NULL((void *)0);
} else if (len >= PATH_MAX1024) {
warnc(ENAMETOOLONG63, NULL((void *)0));
return NULL((void *)0);
}
return buf;
1476}

1478/*
* TODO: These two functions are almost identical.
* Some code cleanup is possible here
*
* XXX bounds checking!
*/
1484static int
1485cd9660_level1_convert_filename(iso9660_disk *diskStructure, const char *oldname,
  char *newname, size_t newnamelen, int is_file)
1487{
/*
* ISO 9660 : 10.1
* File Name shall not contain more than 8 d or d1 characters
* File Name Extension shall not contain more than 3 d or d1 characters
* Directory Identifier shall not contain more than 8 d or d1 characters
*/
int namelen = 0;
int extlen = 0;
int found_ext = 0;
char *orignewname = newname;

while (*oldname != '\0' && extlen < 3) {
/* Handle period first, as it is special */
if (*oldname == '.') {
	if (found_ext) {
		*newname++ = '_';
		extlen ++;
	}
	else {
		*newname++ = '.';
		found_ext = 1;
	}
} else {
	/* Enforce 12.3 / 8 */
	if (namelen == 8 && !found_ext)
		break;

	if (islower((unsigned char)*oldname))
		*newname++ = toupper((unsigned char)*oldname);
	else if (isupper((unsigned char)*oldname)
	    || isdigit((unsigned char)*oldname))
		*newname++ = *oldname;
	else
		*newname++ = '_';

	if (found_ext)
		extlen++;
	else
		namelen++;
}
oldname++;
}
if (is_file) {
if (!found_ext && !diskStructure->omit_trailing_period)
	*newname++ = '.';
/* Add version */
snprintf(newname, newnamelen - (newname - orignewname), ";%i", 1);
}
return namelen + extlen + found_ext;
1537}

1539/* XXX bounds checking! */
1540static int
1541cd9660_level2_convert_filename(iso9660_disk *diskStructure, const char *oldname,
  char *newname, size_t newnamelen, int is_file)
1543{
/*
* ISO 9660 : 7.5.1
* File name : 0+ d or d1 characters
* separator 1 (.)
* File name extension : 0+ d or d1 characters
* separator 2 (;)
* File version number (5 characters, 1-32767)
* 1 <= Sum of File name and File name extension <= 30
*/
int namelen = 0;
int extlen = 0;
int found_ext = 0;
char *orignewname = newname;

while (*oldname != '\0' && namelen + extlen < 30) {
/* Handle period first, as it is special */
if (*oldname == '.') {
	if (found_ext) {
		if (diskStructure->allow_multidot) {
			*newname++ = '.';
		} else {
			*newname++ = '_';
		}
		extlen ++;
	}
	else {
		*newname++ = '.';
		found_ext = 1;
	}
} else {
	if (islower((unsigned char)*oldname))
		*newname++ = toupper((unsigned char)*oldname);
	else if (isupper((unsigned char)*oldname) ||
	    isdigit((unsigned char)*oldname))
		*newname++ = *oldname;
	else if (diskStructure->allow_multidot &&
	    *oldname == '.') {
		*newname++ = '.';
	} else {
		*newname++ = '_';
	}

	if (found_ext)
		extlen++;
	else
		namelen++;
}
oldname ++;
}
if (is_file) {
if (!found_ext && !diskStructure->omit_trailing_period)
	*newname++ = '.';
/* Add version */
snprintf(newname, newnamelen - (newname - orignewname), ";%i", 1);
}
return namelen + extlen + found_ext;
1600}

1602/*
* Convert a file name to ISO compliant file name
* @param char * oldname The original filename
* @param char ** newname The new file name, in the appropriate character
*                        set and of appropriate length
* @param int 1 if file, 0 if directory
* @returns int The length of the new string
*/
1610static int
1611cd9660_convert_filename(iso9660_disk *diskStructure, const char *oldname,
  char *newname, size_t newnamelen, int is_file)
1613{
if (diskStructure->isoLevel == 1)
return cd9660_level1_convert_filename(diskStructure,
    oldname, newname, newnamelen, is_file);
else if (diskStructure->isoLevel == 2)
return cd9660_level2_convert_filename(diskStructure,
    oldname, newname, newnamelen, is_file);
abort();
1621}

1623int
1624cd9660_compute_record_size(iso9660_disk *diskStructure, cd9660node *node)
1625{
int size = node->isoDirRecord->length[0];

if (diskStructure->rock_ridge_enabled)
size += node->susp_entry_size;
size += node->su_tail_size;
size += size & 1; /* Ensure length of record is even. */
assert(size <= 254)((size <= 254) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 1632, __func__, "size <= 254"));
return size;
1634}

1636static void
1637cd9660_populate_dot_records(iso9660_disk *diskStructure, cd9660node *node)
1638{
node->dot_record->fileDataSector = node->fileDataSector;
memcpy(node->dot_record->isoDirRecord,node->isoDirRecord, 34);
node->dot_record->isoDirRecord->name_len[0] = 1;
node->dot_record->isoDirRecord->name[0] = 0;
node->dot_record->isoDirRecord->name[1] = 0;
node->dot_record->isoDirRecord->length[0] = 34;
node->dot_record->fileRecordSize =
   cd9660_compute_record_size(diskStructure, node->dot_record);

if (node == diskStructure->rootNode) {
node->dot_dot_record->fileDataSector = node->fileDataSector;
memcpy(node->dot_dot_record->isoDirRecord,node->isoDirRecord,
    34);
} else {
node->dot_dot_record->fileDataSector =
    node->parent->fileDataSector;
memcpy(node->dot_dot_record->isoDirRecord,
    node->parent->isoDirRecord,34);
}
node->dot_dot_record->isoDirRecord->name_len[0] = 1;
node->dot_dot_record->isoDirRecord->name[0] = 1;
node->dot_dot_record->isoDirRecord->name[1] = 0;
node->dot_dot_record->isoDirRecord->length[0] = 34;
node->dot_dot_record->fileRecordSize =
   cd9660_compute_record_size(diskStructure, node->dot_dot_record);
1664}

1666/*
* @param struct cd9660node *node The node
* @param int The offset (in bytes) - SHOULD align to the beginning of a sector
* @returns int The total size of files and directory entries (should be
*              a multiple of sector size)
1671*/
1672static int64_t
1673cd9660_compute_offsets(iso9660_disk *diskStructure, cd9660node *node,
  int64_t startOffset)
1675{
/*
* This function needs to compute the size of directory records and
* runs, file lengths, and set the appropriate variables both in
* cd9660node and isoDirEntry
*/
int64_t used_bytes = 0;
int64_t current_sector_usage = 0;
cd9660node *child;
fsinode *inode;
int64_t r;

assert(node != NULL)((node != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 1687, __func__, "node != NULL"));


/*
* NOTE : There needs to be some special case detection for
* the "real root" node, since for it, node->node is undefined
*/

node->fileDataSector = -1;

if (node->type & CD9660_TYPE_DIR0x02) {
node->fileRecordSize = cd9660_compute_record_size(
    diskStructure, node);
/*Set what sector this directory starts in*/
node->fileDataSector =
    CD9660_BLOCKS(diskStructure->sectorSize,startOffset)((((startOffset)) + (((diskStructure->sectorSize)) - 1)) /
 ((diskStructure->sectorSize)));

cd9660_bothendian_dword(node->fileDataSector,
    node->isoDirRecord->extent);

/*
 * First loop over children, need to know the size of
 * their directory records
 */
node->fileSectorsUsed = 1;
TAILQ_FOREACH(child, &node->cn_children, cn_next_child)for((child) = ((&node->cn_children)->tqh_first); (child
) != ((void *)0); (child) = ((child)->cn_next_child.tqe_next
)) {
	node->fileDataLength +=
	    cd9660_compute_record_size(diskStructure, child);
	if ((cd9660_compute_record_size(diskStructure, child) +
	    current_sector_usage) >=
	    diskStructure->sectorSize) {
		current_sector_usage = 0;
		node->fileSectorsUsed++;
	}

	current_sector_usage +=
	    cd9660_compute_record_size(diskStructure, child);
}

cd9660_bothendian_dword(node->fileSectorsUsed *
	diskStructure->sectorSize,node->isoDirRecord->size);

/*
 * This should point to the sector after the directory
 * record (or, the first byte in that sector)
 */
used_bytes += node->fileSectorsUsed * diskStructure->sectorSize;

for (child = TAILQ_NEXT(node->dot_dot_record, cn_next_child)((node->dot_dot_record)->cn_next_child.tqe_next);
     child != NULL((void *)0); child = TAILQ_NEXT(child, cn_next_child)((child)->cn_next_child.tqe_next)) {
	/* Directories need recursive call */
	if (S_ISDIR(child->node->type)((child->node->type & 0170000) == 0040000)) {
		r = cd9660_compute_offsets(diskStructure, child,
		    used_bytes + startOffset);

		if (r != -1)
			used_bytes += r;
		else
			return -1;
	}
}

/* Explicitly set the . and .. records */
cd9660_populate_dot_records(diskStructure, node);

/* Finally, do another iteration to write the file data*/
for (child = TAILQ_NEXT(node->dot_dot_record, cn_next_child)((node->dot_dot_record)->cn_next_child.tqe_next);
     child != NULL((void *)0);
     child = TAILQ_NEXT(child, cn_next_child)((child)->cn_next_child.tqe_next)) {
	/* Files need extent set */
	if (S_ISDIR(child->node->type)((child->node->type & 0170000) == 0040000))
		continue;
	child->fileRecordSize =
	    cd9660_compute_record_size(diskStructure, child);

	child->fileSectorsUsed =
	    CD9660_BLOCKS(diskStructure->sectorSize,((((child->fileDataLength)) + (((diskStructure->sectorSize
)) - 1)) / ((diskStructure->sectorSize)))
		child->fileDataLength)((((child->fileDataLength)) + (((diskStructure->sectorSize
)) - 1)) / ((diskStructure->sectorSize)));

	inode = child->node->inode;
	if ((inode->flags & FI_ALLOCATED) == 0) {
		inode->ino =
		    CD9660_BLOCKS(diskStructure->sectorSize,((((used_bytes + startOffset)) + (((diskStructure->sectorSize
)) - 1)) / ((diskStructure->sectorSize)))
		        used_bytes + startOffset)((((used_bytes + startOffset)) + (((diskStructure->sectorSize
)) - 1)) / ((diskStructure->sectorSize)));
		inode->flags |= FI_ALLOCATED;
		used_bytes += child->fileSectorsUsed *
		    diskStructure->sectorSize;
	} else {
		INODE_WARNX(("%s: already allocated inode %d "
		      "data sectors at %" PRIu32, __func__,
		      (int)inode->st.st_ino, inode->ino));
	}
	child->fileDataSector = inode->ino;
	cd9660_bothendian_dword(child->fileDataSector,
		child->isoDirRecord->extent);
}
}

return used_bytes;
1786}

1788#if 0
1789/* Might get rid of this func */
1790static int
1791cd9660_copy_stat_info(cd9660node *from, cd9660node *to, int file)
1792{
to->node->inode->st.st_dev = 0;
to->node->inode->st.st_ino = 0;
to->node->inode->st.st_size = 0;
to->node->inode->st.st_blksize = from->node->inode->st.st_blksize;
to->node->inode->st.st_atimest_atim.tv_sec = from->node->inode->st.st_atimest_atim.tv_sec;
to->node->inode->st.st_mtimest_mtim.tv_sec = from->node->inode->st.st_mtimest_mtim.tv_sec;
to->node->inode->st.st_ctimest_ctim.tv_sec = from->node->inode->st.st_ctimest_ctim.tv_sec;
to->node->inode->st.st_uid = from->node->inode->st.st_uid;
to->node->inode->st.st_gid = from->node->inode->st.st_gid;
to->node->inode->st.st_mode = from->node->inode->st.st_mode;
/* Clear out type */
to->node->inode->st.st_mode = to->node->inode->st.st_mode & ~(S_IFMT0170000);
if (file)
to->node->inode->st.st_mode |= S_IFREG0100000;
else
to->node->inode->st.st_mode |= S_IFDIR0040000;
return 1;
1810}
1811#endif

1813static cd9660node *
1814cd9660_create_virtual_entry(iso9660_disk *diskStructure, const char *name,
  cd9660node *parent, int file, int insert)
1816{
cd9660node *temp;
fsnode * tfsnode;

assert(parent != NULL)((parent != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 1820, __func__, "parent != NULL"));

temp = cd9660_allocate_cd9660node();
if (temp == NULL((void *)0))
return NULL((void *)0);

tfsnode = emalloc(sizeof(*tfsnode));
tfsnode->name = estrdup(name);
temp->isoDirRecord = emalloc(sizeof(*temp->isoDirRecord));

cd9660_convert_filename(diskStructure, tfsnode->name,
   temp->isoDirRecord->name, sizeof temp->isoDirRecord->name, file);

temp->node = tfsnode;
temp->parent = parent;

if (insert) {
if (temp->parent != NULL((void *)0)) {
	temp->level = temp->parent->level + 1;
	if (!TAILQ_EMPTY(&temp->parent->cn_children)(((&temp->parent->cn_children)->tqh_first) == ((
void *)0)))
		cd9660_sorted_child_insert(temp->parent, temp);
	else
		TAILQ_INSERT_HEAD(&temp->parent->cn_children,do { if (((temp)->cn_next_child.tqe_next = (&temp->
parent->cn_children)->tqh_first) != ((void *)0)) (&
temp->parent->cn_children)->tqh_first->cn_next_child
.tqe_prev = &(temp)->cn_next_child.tqe_next; else (&
temp->parent->cn_children)->tqh_last = &(temp)->
cn_next_child.tqe_next; (&temp->parent->cn_children
)->tqh_first = (temp); (temp)->cn_next_child.tqe_prev =
 &(&temp->parent->cn_children)->tqh_first; }
 while (0)
		    temp, cn_next_child)do { if (((temp)->cn_next_child.tqe_next = (&temp->
parent->cn_children)->tqh_first) != ((void *)0)) (&
temp->parent->cn_children)->tqh_first->cn_next_child
.tqe_prev = &(temp)->cn_next_child.tqe_next; else (&
temp->parent->cn_children)->tqh_last = &(temp)->
cn_next_child.tqe_next; (&temp->parent->cn_children
)->tqh_first = (temp); (temp)->cn_next_child.tqe_prev =
 &(&temp->parent->cn_children)->tqh_first; }
 while (0);
}
}

if (parent->node != NULL((void *)0)) {
tfsnode->type = parent->node->type;
}

/* Clear out file type bits */
tfsnode->type &= ~(S_IFMT0170000);
if (file)
tfsnode->type |= S_IFREG0100000;
else
tfsnode->type |= S_IFDIR0040000;

/* Indicate that there is no spec entry (inode) */
tfsnode->flags &= ~(FSNODE_F_HASSPEC0x01);
1860#if 0
cd9660_copy_stat_info(parent, temp, file);
1862#endif
return temp;
1864}

1866static cd9660node *
1867cd9660_create_file(iso9660_disk *diskStructure, const char *name,
  cd9660node *parent, cd9660node *me)
1869{
cd9660node *temp;

temp = cd9660_create_virtual_entry(diskStructure, name, parent, 1, 1);
if (temp == NULL((void *)0))
return NULL((void *)0);

temp->fileDataLength = 0;

temp->type = CD9660_TYPE_FILE0x01 | CD9660_TYPE_VIRTUAL0x80;

temp->node->inode = ecalloc(1, sizeof(*temp->node->inode));
*temp->node->inode = *me->node->inode;

if (cd9660_translate_node_common(diskStructure, temp) == 0)
return NULL((void *)0);
return temp;
1886}

1888/*
* Create a new directory which does not exist on disk
* @param const char * name The name to assign to the directory
* @param const char * parent Pointer to the parent directory
* @returns cd9660node * Pointer to the new directory
*/
1894static cd9660node *
1895cd9660_create_directory(iso9660_disk *diskStructure, const char *name,
  cd9660node *parent, cd9660node *me)
1897{
cd9660node *temp;

temp = cd9660_create_virtual_entry(diskStructure, name, parent, 0, 1);
if (temp == NULL((void *)0))
return NULL((void *)0);
temp->node->type |= S_IFDIR0040000;

temp->type = CD9660_TYPE_DIR0x02 | CD9660_TYPE_VIRTUAL0x80;

temp->node->inode = ecalloc(1, sizeof(*temp->node->inode));
*temp->node->inode = *me->node->inode;

if (cd9660_translate_node_common(diskStructure, temp) == 0)
return NULL((void *)0);
return temp;
1913}

1915static cd9660node *
1916cd9660_create_special_directory(iso9660_disk *diskStructure, u_char type,
  cd9660node *parent)
1918{
cd9660node *temp, *first;
char na[2];

assert(parent != NULL)((parent != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 1922, __func__, "parent != NULL"));

if (type == CD9660_TYPE_DOT0x04)
na[0] = 0;
else if (type == CD9660_TYPE_DOTDOT0x08)
na[0] = 1;
else
return 0;

na[1] = 0;
if ((temp = cd9660_create_virtual_entry(diskStructure, na, parent,
   0, 0)) == NULL((void *)0))
return NULL((void *)0);

temp->parent = parent;
temp->type = type;
temp->isoDirRecord->length[0] = 34;
/* Dot record is always first */
if (type == CD9660_TYPE_DOT0x04) {
parent->dot_record = temp;
TAILQ_INSERT_HEAD(&parent->cn_children, temp, cn_next_child)do { if (((temp)->cn_next_child.tqe_next = (&parent->
cn_children)->tqh_first) != ((void *)0)) (&parent->
cn_children)->tqh_first->cn_next_child.tqe_prev = &
(temp)->cn_next_child.tqe_next; else (&parent->cn_children
)->tqh_last = &(temp)->cn_next_child.tqe_next; (&
parent->cn_children)->tqh_first = (temp); (temp)->cn_next_child
.tqe_prev = &(&parent->cn_children)->tqh_first;
 } while (0);
/* DotDot should be second */
} else if (type == CD9660_TYPE_DOTDOT0x08) {
parent->dot_dot_record = temp;
/*
               * If the first child is the dot record, insert
               * this second.  Otherwise, insert it at the head.
 */
if ((first = TAILQ_FIRST(&parent->cn_children)((&parent->cn_children)->tqh_first)) == NULL((void *)0) ||
    (first->type & CD9660_TYPE_DOT0x04) == 0) {
	TAILQ_INSERT_HEAD(&parent->cn_children, temp,do { if (((temp)->cn_next_child.tqe_next = (&parent->
cn_children)->tqh_first) != ((void *)0)) (&parent->
cn_children)->tqh_first->cn_next_child.tqe_prev = &
(temp)->cn_next_child.tqe_next; else (&parent->cn_children
)->tqh_last = &(temp)->cn_next_child.tqe_next; (&
parent->cn_children)->tqh_first = (temp); (temp)->cn_next_child
.tqe_prev = &(&parent->cn_children)->tqh_first;
 } while (0)
	    cn_next_child)do { if (((temp)->cn_next_child.tqe_next = (&parent->
cn_children)->tqh_first) != ((void *)0)) (&parent->
cn_children)->tqh_first->cn_next_child.tqe_prev = &
(temp)->cn_next_child.tqe_next; else (&parent->cn_children
)->tqh_last = &(temp)->cn_next_child.tqe_next; (&
parent->cn_children)->tqh_first = (temp); (temp)->cn_next_child
.tqe_prev = &(&parent->cn_children)->tqh_first;
 } while (0);
} else {
	TAILQ_INSERT_AFTER(&parent->cn_children, first, temp,do { if (((temp)->cn_next_child.tqe_next = (first)->cn_next_child
.tqe_next) != ((void *)0)) (temp)->cn_next_child.tqe_next->
cn_next_child.tqe_prev = &(temp)->cn_next_child.tqe_next
; else (&parent->cn_children)->tqh_last = &(temp
)->cn_next_child.tqe_next; (first)->cn_next_child.tqe_next
 = (temp); (temp)->cn_next_child.tqe_prev = &(first)->
cn_next_child.tqe_next; } while (0)
	    cn_next_child)do { if (((temp)->cn_next_child.tqe_next = (first)->cn_next_child
.tqe_next) != ((void *)0)) (temp)->cn_next_child.tqe_next->
cn_next_child.tqe_prev = &(temp)->cn_next_child.tqe_next
; else (&parent->cn_children)->tqh_last = &(temp
)->cn_next_child.tqe_next; (first)->cn_next_child.tqe_next
 = (temp); (temp)->cn_next_child.tqe_prev = &(first)->
cn_next_child.tqe_next; } while (0);
}
}

return temp;
1961}

1963static int
1964cd9660_add_generic_bootimage(iso9660_disk *diskStructure, const char *bootimage)
1965{
struct stat stbuf;

assert(bootimage != NULL)((bootimage != ((void *)0)) ? (void)0 : __assert2("/usr/src/usr.sbin/makefs/cd9660.c"
, 1968, __func__, "bootimage != NULL"));

if (*bootimage == '\0') {
warnx("Error: Boot image must be a filename");
return 0;
}

diskStructure->generic_bootimage = estrdup(bootimage);

if (unveil(diskStructure->generic_bootimage, "r") == -1)
err(1, "unveil %s", diskStructure->generic_bootimage);
/* Get information about the file */
if (lstat(diskStructure->generic_bootimage, &stbuf) == -1)
err(1, "%s: lstat(\"%s\")", __func__,
    diskStructure->generic_bootimage);

if (stbuf.st_size > 32768) {
warnx("Error: Boot image must be no greater than 32768 bytes");
return 0;
}

diskStructure->has_generic_bootimage = 1;
return 1;
1991}