/usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/tree.c

Bug Summary

File:	src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/tree.c
Warning:	line 743, column 11 Access to field 'rr_attributes' results in a dereference of a null pointer (loaded from variable 's_entry')
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 tree.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/gnu/usr.sbin/mkhybrid/mkhybrid/obj -resource-dir /usr/local/lib/clang/13.0.0 -D SYSTEM_ID_DEFAULT="OpenBSD" -D APPLE_HYB -D VANILLA_AUTOCONF -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/include -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libhfs_iso -I /usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/libfile -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.sbin/mkhybrid/mkhybrid/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/gnu/usr.sbin/mkhybrid/mkhybrid/../src/tree.c
1/*
* File tree.c - scan directory  tree and build memory structures for iso9660
* filesystem

 Written by Eric Youngdale (1993).

 Copyright 1993 Yggdrasil Computing, Incorporated

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

23/* ADD_FILES changes made by Ross Biro biro@yggdrasil.com 2/23/95 */

25/* APPLE_HYB James Pearson j.pearson@ge.ucl.ac.uk 16/3/1999 */

27#include <stdlib.h>
28#include <string.h>
29#include <time.h>
30#include <errno(*__errno()).h>

32#include "config.h"
33#include "apple_proto.h"

35#ifndef VMS
36#if defined(MAJOR_IN_SYSMACROS)
37#include <sys/sysmacros.h>
38#endif

40#ifdef HAVE_UNISTD_H1
41#include <unistd.h>
42#endif
43#include <fctldefs.h>

45#if defined(MAJOR_IN_MKDEV)
46#include <sys/types.h>
47#include <sys/mkdev.h>
48#endif
49#else
50#include <sys/file.h>
51#include <vms/fabdef.h>
52#include "vms.h"
53extern char * strdup(const char *);
54#endif

56/*
* Autoconf should be able to figure this one out for us and let us know
* whether the system has memmove or not.
*/
60# ifndef HAVE_MEMMOVE1
61#  define memmove(d, s, n) bcopy ((s), (d), (n))
62# endif

64#include "mkisofs.h"
65#include "iso9660.h"
66#include "match.h"

68#include <sys/stat.h>

70#ifdef	DOESNT_WORK

72#ifdef NON_UNIXFS
73#define S_ISLNK(m)((m & 0170000) == 0120000)	(0)
74#define S_ISSOCK(m)((m & 0170000) == 0140000)	(0)
75#define S_ISFIFO(m)((m & 0170000) == 0010000)	(0)
76#else
77#ifndef S_ISLNK
78#define S_ISLNK(m)((m & 0170000) == 0120000)	(((m) & S_IFMT0170000) == S_IFLNK0120000)
79#endif
80#ifndef S_ISSOCK
81# ifdef S_IFSOCK0140000
82#   define S_ISSOCK(m)((m & 0170000) == 0140000)	(((m) & S_IFMT0170000) == S_IFSOCK0140000)
83# else
84#   define S_ISSOCK(m)((m & 0170000) == 0140000)	(0)
85# endif
86#endif
87#endif

89#else
90#include <statdefs.h>
91#endif


94#ifdef __SVR4
95extern char * strdup(const char *);
96#endif

98static unsigned char symlink_buff[256];

100static void stat_fix	__PR((struct stat * st))(struct stat * st);
101static void generate_reloc_directory __PR((void))(void);

103static void DECL(attach_dot_entries, (struct directory * dirnode,attach_dot_entries (struct directory * dirnode, struct stat *
 parent_stat)
   struct stat * parent_stat))attach_dot_entries (struct directory * dirnode, struct stat *
 parent_stat);
105static void DECL(delete_directory, (struct directory * parent, struct directory * child))delete_directory (struct directory * parent, struct directory
 * child);

107extern int verbose;

109struct stat fstatbuf = {0,};  /* We use this for the artificial entries we create */

111struct stat root_statbuf = {0, };  /* Stat buffer for root directory */

113struct directory * reloc_dir = NULL((void *)0);

115static void
116FDECL1(stat_fix, struct stat *, st)stat_fix(struct stat * st)
117{
/* Remove the uid and gid, they will only be useful on the author's
   system.  */
st->st_uid = 0;
st->st_gid = 0;

/*
* Make sure the file modes make sense.  Turn on all read bits.  Turn
* on all exec/search bits if any exec/search bit is set.  Turn off
* all write bits, and all special mode bits (on a r/o fs lock bits
* are useless, and with uid+gid 0 don't want set-id bits, either).
*/
st->st_mode |= 0444;
130#ifndef _WIN32		/* make all file "executable" */
if (st->st_mode & 0111)
132#endif /* _WIN32 */
  st->st_mode |= 0111;
st->st_mode &= ~07222;
135}

137int
138FDECL2(stat_filter, char *, path, struct stat *, st)stat_filter(char * path, struct stat * st)
139{
int result = stat(path, st);
if (result >= 0 && rationalize)
  stat_fix(st);
return result;
144}

146int
147FDECL2(lstat_filter, char *, path, struct stat *, st)lstat_filter(char * path, struct stat * st)
148{
int result = lstat(path, st);
if (result >= 0 && rationalize)
  stat_fix(st);
return result;
153}

155static int FDECL1(sort_n_finish, struct directory *, this_dir)sort_n_finish(struct directory * this_dir)
156{
struct directory_entry  * s_entry;
struct directory_entry  * s_entry1;
struct directory_entry  * table;
int			    count;
int			    d1;
int			    d2;
int			    d3;
int			    new_reclen;
char			 *  c;
int			    status = 0;
int			    tablesize = 0;
char			    newname[34];
char			    rootname[34];

/* Here we can take the opportunity to toss duplicate entries from the
   directory.  */

/* ignore if it's hidden */
if(this_dir->dir_flags & INHIBIT_ISO9660_ENTRY0x40)
  {
    return 0;
  }

table = NULL((void *)0);

init_fstatbuf();

/*
 * If we had artificially created this directory, then we might be
 * missing the required '.' entries.  Create these now if we need
 * them.
 */
if( (this_dir->dir_flags & (DIR_HAS_DOT0x02 | DIR_HAS_DOTDOT0x04)) != 
    (DIR_HAS_DOT0x02 | DIR_HAS_DOTDOT0x04) )
  {
    attach_dot_entries(this_dir, &fstatbuf);
  }

flush_file_hash();
s_entry = this_dir->contents;
while(s_entry)
  {
  /* ignore if it's hidden */
  if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY0x40)
    {
s_entry = s_entry->next;
continue;
    }
 
    /*
     * First assume no conflict, and handle this case 
     */
    if(!(s_entry1 = find_file_hash(s_entry->isorec.name)))
{
 add_file_hash(s_entry);
 s_entry = s_entry->next;
 continue;
}
 
216#ifdef APPLE_HYB1
    /* if the pair are associated, then skip (as they have the same name!) */
    if(apple_both && s_entry1->assoc && s_entry1->assoc == s_entry)
{
 s_entry = s_entry->next;
 continue;
}
223#endif /* APPLE_HYB */

    if(s_entry1 == s_entry)
{
 fprintf(stderr(&__sF[2]),"Fatal goof\n");
 exit(1);
}
    
    /* 
     * OK, handle the conflicts.  Try substitute names until we come
     * up with a winner 
     */
    strcpy(rootname, s_entry->isorec.name);
    if(full_iso9660_filenames) 
{
 if(strlen(rootname) > 27) rootname[27] = 0;
}

    /*
     * Strip off the non-significant part of the name so that we are left
     * with a sensible root filename.  If we don't find a '.', then try
     * a ';'.
     */
    c  = strchr(rootname, '.');
    if (c) 
*c = 0;
    else
{
 c  = strchr(rootname, ';');
 if (c) *c = 0;
}
    for(d1 = 0; d1 < 36; d1++)
{
 for(d2 = 0; d2 < 36; d2++)
   {
     for(d3 = 0; d3 < 36; d3++)
{
  snprintf(newname, sizeof newname, "%s.%c%c%c%s", rootname,  
	  (d1 <= 9 ? '0' + d1 : 'A' + d1 - 10),
	  (d2 <= 9 ? '0' + d2 : 'A' + d2 - 10),
	  (d3 <= 9 ? '0' + d3 : 'A' + d3 - 10),
	  (s_entry->isorec.flags[0] == 2 || 
	   omit_version_number ? "" : ";1"));
  
267#ifdef VMS
  /* Sigh.  VAXCRTL seems to be broken here */
  {
    int ijk = 0;
    while(newname[ijk]) 
      {
	if(newname[ijk] == ' ') newname[ijk] = '0';
	ijk++;
      }
  }
277#endif
  
  if(!find_file_hash(newname)) goto got_valid_name;
}
   }
}

    /*
     * If we fell off the bottom here, we were in real trouble.
     */
    fprintf(stderr(&__sF[2]),"Unable to  generate unique  name for file %s\n", s_entry->name);
    exit(1);

290got_valid_name:      
    /* 
     * OK, now we have a good replacement name.  Now decide which one
     * of these two beasts should get the name changed 
     */
    if(s_entry->priority < s_entry1->priority) 
{
 if( verbose > 0 )
   {
     fprintf(stderr(&__sF[2]),"Using %s for  %s%s%s (%s)\n", newname,  
      this_dir->whole_name, SPATH_SEPARATOR"/", 
      s_entry->name, s_entry1->name);
   }
 s_entry->isorec.name_len[0] =  strlen(newname);
 new_reclen =  sizeof(struct iso_directory_record) -
   sizeof(s_entry->isorec.name) +
   strlen(newname);
 if(use_RockRidge) 
   {
     if (new_reclen & 1) new_reclen++;  /* Pad to an even byte */
     new_reclen += s_entry->rr_attr_size;
   }
 if (new_reclen & 1) new_reclen++;  /* Pad to an even byte */
 s_entry->isorec.length[0] = new_reclen;
 strcpy(s_entry->isorec.name, newname);
315#ifdef APPLE_HYB1
 /* has resource fork - needs new name */
 if (apple_both && s_entry->assoc) {
   struct directory_entry  *s_entry2 = s_entry->assoc;

   /* resource fork name *should* be the same as the data fork */
   s_entry2->isorec.name_len[0] = s_entry->isorec.name_len[0];
   strcpy(s_entry2->isorec.name, s_entry->isorec.name);
   s_entry2->isorec.length[0] = new_reclen;
 }
325#endif /* APPLE_HYB */
}
    else 
{
 delete_file_hash(s_entry1);
 if( verbose > 0 )
   {
     fprintf(stderr(&__sF[2]),"Using %s for  %s%s%s (%s)\n", newname,  
      this_dir->whole_name, SPATH_SEPARATOR"/", 
      s_entry1->name, s_entry->name);
   }
 s_entry1->isorec.name_len[0] =  strlen(newname);
 new_reclen =  sizeof(struct iso_directory_record) -
   sizeof(s_entry1->isorec.name) +
   strlen(newname);
 if(use_RockRidge) 
   {
     if (new_reclen & 1) new_reclen++;  /* Pad to an even byte */
     new_reclen += s_entry1->rr_attr_size;
   }
 if (new_reclen & 1) new_reclen++;  /* Pad to an even byte */
 s_entry1->isorec.length[0] = new_reclen;
 strcpy(s_entry1->isorec.name, newname);
 add_file_hash(s_entry1);
349#ifdef APPLE_HYB1
 /* has resource fork - needs new name */
 if (apple_both && s_entry1->assoc) {
   struct directory_entry  *s_entry2 = s_entry1->assoc;

   /* resource fork name *should* be the same as the data fork */
   s_entry2->isorec.name_len[0] = s_entry1->isorec.name_len[0];
   strcpy(s_entry2->isorec.name, s_entry1->isorec.name);
   s_entry2->isorec.length[0] = new_reclen;
 }
359#endif /* APPLE_HYB */
}
    add_file_hash(s_entry);
    s_entry = s_entry->next;
  }

if(generate_tables 
366#ifdef APPLE_HYB1
   && !find_file_hash(trans_tbl)
368#else
   && !find_file_hash("TRANS.TBL") 
370#endif /* APPLE_HYB */
   && (reloc_dir != this_dir)
   && (this_dir->extent == 0) )
  {
    /* 
     * First we need to figure out how big this table is 
     */
    for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next)
{
 if(strcmp(s_entry->name, ".") == 0  ||
    strcmp(s_entry->name, "..") == 0) continue; 
381#ifdef APPLE_HYB1
 /* skip table entry for the resource fork */
 if(apple_both && (s_entry->isorec.flags[0] & ASSOC_FLAG4))
    continue;
385#endif /* APPLE_HYB */
 if(s_entry->de_flags & INHIBIT_ISO9660_ENTRY0x40) continue;
 if(s_entry->table) tablesize += 35 + strlen(s_entry->table);
}
  }

if( tablesize > 0 )
  {
    table = (struct directory_entry *) 
e_malloc(sizeof (struct directory_entry));
    memset(table, 0, sizeof(struct directory_entry));
    table->table = NULL((void *)0);
    table->next = this_dir->contents;
    this_dir->contents = table;
    
    table->filedir = root;
    table->isorec.flags[0] = 0;
    table->priority  = 32768;
    iso9660_date(table->isorec.date, fstatbuf.st_mtimest_mtim.tv_sec);
    table->inode = TABLE_INODE(sizeof(ino_t) >= 8 ? 0x7ffffffffffffffeLL : 0x7ffffffe);
    table->dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
    set_723(table->isorec.volume_sequence_number, volume_sequence_number);
    set_733((char *) table->isorec.size, tablesize);
    table->size = tablesize;
    table->filedir = this_dir;
    table->de_flags    |= INHIBIT_JOLIET_ENTRY0x08;
    table->name = strdup("<translation table>");
    table->table = (char *) e_malloc(ROUND_UP(tablesize)((tablesize + ((2048) - 1)) & ~((2048) - 1)));
    memset(table->table, 0, ROUND_UP(tablesize)((tablesize + ((2048) - 1)) & ~((2048) - 1)));
414#ifdef APPLE_HYB1
    iso9660_file_length  (trans_tbl, table, 0);
416#else
    iso9660_file_length  ("TRANS.TBL", table, 0);
418#endif /* APPLE_HYB */
    
    if(use_RockRidge)
{
 fstatbuf.st_mode = 0444 | S_IFREG0100000;
 fstatbuf.st_nlink = 1;
 generate_rock_ridge_attributes("",
425#ifdef APPLE_HYB1
			 trans_tbl, table,
427#else
			 "TRANS.TBL", table,
429#endif /* APPLE_HYB */
			 &fstatbuf, &fstatbuf, 0);
}
  }

/*
 * We have now chosen the 8.3 names and we should now know the length
 * of every entry in the directory.
 */
for(s_entry = this_dir->contents; s_entry; s_entry = s_entry->next)
  {
    /* skip if it's hidden */
    if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY0x40)
{
 continue;
}

    new_reclen = strlen(s_entry->isorec.name);
 
    /*
     * First update the path table sizes for directories.
     */
    if(s_entry->isorec.flags[0] ==  2)
{
 if (strcmp(s_entry->name,".") && strcmp(s_entry->name,"..")) 
   {
     path_table_size += new_reclen + sizeof(struct iso_path_table) - 1;
     if (new_reclen & 1) path_table_size++;
   }
 else 
   {
     new_reclen = 1;
     if (this_dir == root && strlen(s_entry->name) == 1)
{
  path_table_size += sizeof(struct iso_path_table);
}
   }
}
    if(path_table_size & 1) path_table_size++;  /* For odd lengths we pad */
    s_entry->isorec.name_len[0] = new_reclen;
    
    new_reclen += 
sizeof(struct iso_directory_record) -
sizeof(s_entry->isorec.name);
    
    if (new_reclen & 1)	
new_reclen++;
    
    new_reclen += s_entry->rr_attr_size;
    
    if (new_reclen & 1) new_reclen++;
    
    if(new_reclen > 0xff) 
{
 fprintf(stderr(&__sF[2]),"Fatal error - RR overflow for file %s\n",
  s_entry->name);
 exit(1);
}
    s_entry->isorec.length[0] = new_reclen;
  }

status = sort_directory(&this_dir->contents);
if( status > 0 )
  {
    fprintf(stderr(&__sF[2]), "Unable to sort directory %s\n", 
     this_dir->whole_name);
  }

/*
 * If we are filling out a TRANS.TBL, generate the entries that will
 * go in the thing.
 */
if(table)
  {
    count = 0;
    for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next){
if(s_entry == table) continue;
if(!s_entry->table) continue;
if(strcmp(s_entry->name, ".") == 0  ||
  strcmp(s_entry->name, "..") == 0) continue;
509#ifdef APPLE_HYB1
/* skip table entry for the resource fork */
if(apple_both && (s_entry->isorec.flags[0] & ASSOC_FLAG4))
  continue;
513#endif /* APPLE_HYB */
if(s_entry->de_flags & INHIBIT_ISO9660_ENTRY0x40) continue;
/*
* Warning: we cannot use the return value of sprintf because
* old BSD based sprintf() implementations will return
* a pointer to the result instead of a count.
*/
sprintf(table->table + count, "%c %-34s%s",
s_entry->table[0],
s_entry->isorec.name, s_entry->table+1);
count += strlen(table->table + count);
free(s_entry->table);
s_entry->table = NULL((void *)0);
    }

    if(count !=  tablesize) 
{
 fprintf(stderr(&__sF[2]),"Translation table size mismatch %d %d\n",
  count, tablesize);
 exit(1);
}
  }

/* 
 * Now go through the directory and figure out how large this one will be.
 * Do not split a directory entry across a sector boundary 
 */
s_entry = this_dir->contents;
this_dir->ce_bytes = 0;
while(s_entry)
  {
    /* skip if it's hidden */
    if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY0x40) {
s_entry = s_entry->next;
continue;
    }

    new_reclen = s_entry->isorec.length[0];
    if ((this_dir->size & (SECTOR_SIZE(2048) - 1)) + new_reclen >= SECTOR_SIZE(2048))
this_dir->size = (this_dir->size + (SECTOR_SIZE(2048) - 1)) & 
~(SECTOR_SIZE(2048) - 1);
    this_dir->size += new_reclen;

    /* See if continuation entries were used on disc */
    if(use_RockRidge && 
s_entry->rr_attr_size != s_entry->total_rr_attr_size) 
{
 unsigned char * pnt;
 int len;
 int nbytes;
 
 pnt = s_entry->rr_attributes;
 len = s_entry->total_rr_attr_size;
 
 /*
  * We make sure that each continuation entry record is not
  * split across sectors, but each file could in theory have more
  * than one CE, so we scan through and figure out what we need. 
  */
 while(len > 3)
   {
     if(pnt[0] == 'C' && pnt[1] == 'E') 
{
  nbytes = get_733((char *) pnt+20);
  
  if((this_dir->ce_bytes & (SECTOR_SIZE(2048) - 1)) + nbytes >=
     SECTOR_SIZE(2048)) this_dir->ce_bytes = 
		    ROUND_UP(this_dir->ce_bytes)((this_dir->ce_bytes + ((2048) - 1)) & ~((2048) - 1));
  /* Now store the block in the ce buffer */
  this_dir->ce_bytes += nbytes;
  if(this_dir->ce_bytes & 1) this_dir->ce_bytes++;
}
     len -= pnt[2];
     pnt += pnt[2];
   }
}
    s_entry = s_entry->next;
  }
return status;
592}

594static void generate_reloc_directory()
595{
time_t current_time;
struct directory_entry  *s_entry;

/* Create an  entry for our internal tree */
time (&current_time);
reloc_dir = (struct directory *) 
e_malloc(sizeof(struct directory));
memset(reloc_dir, 0, sizeof(struct directory));
reloc_dir->parent = root;
reloc_dir->next = root->subdir;
root->subdir = reloc_dir;
reloc_dir->depth = 1;
reloc_dir->whole_name = strdup("./rr_moved");
reloc_dir->de_name =  strdup("rr_moved");
reloc_dir->extent = 0;


/* Now create an actual directory  entry */
s_entry = (struct directory_entry *) 
e_malloc(sizeof (struct directory_entry));
memset(s_entry, 0, sizeof(struct directory_entry));
s_entry->next = root->contents;
reloc_dir->self = s_entry;

/*
* The rr_moved entry will not appear in the Joliet tree.
*/
reloc_dir->dir_flags |= INHIBIT_JOLIET_ENTRY0x08;
s_entry->de_flags    |= INHIBIT_JOLIET_ENTRY0x08;

root->contents = s_entry;
root->contents->name = strdup(reloc_dir->de_name);
root->contents->filedir = root;
root->contents->isorec.flags[0] = 2;
root->contents->priority  = 32768;
iso9660_date(root->contents->isorec.date, current_time);
root->contents->inode = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
root->contents->dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
set_723(root->contents->isorec.volume_sequence_number, volume_sequence_number);
iso9660_file_length (reloc_dir->de_name, root->contents, 1);

if(use_RockRidge){
fstatbuf.st_mode = 0555 | S_IFDIR0040000;
fstatbuf.st_nlink = 2;
generate_rock_ridge_attributes("",
			       "rr_moved", s_entry,
			       &fstatbuf, &fstatbuf, 0);
};

/* Now create the . and .. entries in rr_moved */
/* Now create an actual directory  entry */
attach_dot_entries(reloc_dir, &root_statbuf);
648}

650/* 
* Function:		attach_dot_entries
*
* Purpose:		Create . and .. entries for a new directory.
*
* Notes:		Only used for artificial directories that
*			we are creating.
*/
658static void FDECL2(attach_dot_entries, struct directory *, dirnode,attach_dot_entries(struct directory * dirnode, struct stat * parent_stat
)
   struct stat *, parent_stat)attach_dot_entries(struct directory * dirnode, struct stat * parent_stat
)
660{
struct directory_entry  *s_entry;
struct directory_entry  *orig_contents;
int deep_flag = 0;

init_fstatbuf();

orig_contents = dirnode->contents;

if( (dirnode->dir_flags & DIR_HAS_DOTDOT0x04) == 0 )
 {
   s_entry = (struct directory_entry *) 
     e_malloc(sizeof (struct directory_entry));
   memcpy(s_entry, dirnode->self, 
   sizeof(struct directory_entry));
   s_entry->name = strdup("..");
   s_entry->whole_name = NULL((void *)0);
   s_entry->isorec.name_len[0] = 1;
   s_entry->isorec.flags[0] = 2; /* Mark as a directory */
   iso9660_file_length ("..", s_entry, 1);
   iso9660_date(s_entry->isorec.date, fstatbuf.st_mtimest_mtim.tv_sec);
   s_entry->filedir = dirnode->parent;

   dirnode->contents = s_entry;
   dirnode->contents->next = orig_contents;
   orig_contents = s_entry;

   if(use_RockRidge)
     {
if( parent_stat == NULL((void *)0) )
  {
    parent_stat = &fstatbuf;
  }
generate_rock_ridge_attributes("",
			       "..", s_entry,
			       parent_stat, 
			       parent_stat, 0);
     }
   dirnode->dir_flags |= DIR_HAS_DOTDOT0x04;
 }

if( (dirnode->dir_flags & DIR_HAS_DOT0x02) == 0 )
 {
   s_entry = (struct directory_entry *) 
     e_malloc(sizeof (struct directory_entry));
   memcpy(s_entry, dirnode->self, 
   sizeof(struct directory_entry));
   s_entry->name = strdup(".");
   s_entry->whole_name = NULL((void *)0);
   s_entry->isorec.name_len[0] = 1;
   s_entry->isorec.flags[0] = 2; /* Mark as a directory */
   iso9660_file_length (".", s_entry, 1);
   iso9660_date(s_entry->isorec.date, fstatbuf.st_mtimest_mtim.tv_sec);
   s_entry->filedir = dirnode;
   
   dirnode->contents = s_entry;
   dirnode->contents->next = orig_contents;

   if(use_RockRidge)
     {
fstatbuf.st_mode = 0555 | S_IFDIR0040000;
fstatbuf.st_nlink = 2;

if( dirnode == root )
  {
    deep_flag |= NEED_CE8 | NEED_SP16;  /* For extension record */
  }

generate_rock_ridge_attributes("",
			       ".", s_entry,
			       &fstatbuf, &fstatbuf, deep_flag);
     }
   
   dirnode->dir_flags |= DIR_HAS_DOT0x02;
 }

736}

738static void FDECL2(update_nlink, struct directory_entry *, s_entry, int, value)update_nlink(struct directory_entry * s_entry, int value)
739{
  unsigned char * pnt;
  int len;
  
  pnt = s_entry->rr_attributes;
9
←
Access to field 'rr_attributes' results in a dereference of a null pointer (loaded from variable 's_entry')
  len = s_entry->total_rr_attr_size;
  while(len)
  {
if(pnt[0] == 'P' && pnt[1] == 'X') 
{
   set_733((char *) pnt+12, value);
   break;
}
len -= pnt[2];
pnt += pnt[2];
  }
755}

757static void FDECL1(increment_nlink, struct directory_entry *, s_entry)increment_nlink(struct directory_entry * s_entry)
758{
  unsigned char * pnt;
  int len, nlink;
  
  pnt = s_entry->rr_attributes;
  len = s_entry->total_rr_attr_size;
  while(len)
  {
if(pnt[0] == 'P' && pnt[1] == 'X') 
{
   nlink =  get_733((char *) pnt+12);
   set_733((char *) pnt+12, nlink+1);
   break;
}
len -= pnt[2];
pnt += pnt[2];
  }
775}

777void finish_cl_pl_entries(){
struct directory_entry  *s_entry, *s_entry1;
struct directory *  d_entry;

/* if the reloc_dir is hidden (empty), then return */
if (reloc_dir->dir_flags & INHIBIT_ISO9660_ENTRY0x40)
  return;

s_entry = reloc_dir->contents;
 s_entry  = s_entry->next->next;  /* Skip past . and .. */
for(; s_entry; s_entry = s_entry->next){
 /* skip if it's hidden */
 if(s_entry->de_flags & INHIBIT_ISO9660_ENTRY0x40) {
   continue;
 }
 d_entry = reloc_dir->subdir;
 while(d_entry){
  if(d_entry->self == s_entry) break;
  d_entry = d_entry->next;
 };
 if(!d_entry){
  fprintf(stderr(&__sF[2]),"Unable to locate directory parent\n");
  exit(1);
 };

 /* First fix the PL pointer in the directory in the rr_reloc dir */
 s_entry1 = d_entry->contents->next;
 set_733((char *) s_entry1->rr_attributes +  s_entry1->total_rr_attr_size - 8,
  s_entry->filedir->extent);

 /* Now fix the CL pointer */
 s_entry1 = s_entry->parent_rec;

 set_733((char *) s_entry1->rr_attributes +  s_entry1->total_rr_attr_size - 8,
  d_entry->extent);

 s_entry->filedir = reloc_dir;  /* Now we can fix this */
}
/* Next we need to modify the NLINK terms in the assorted root directory records
   to account for the presence of the RR_MOVED directory */

increment_nlink(root->self);
increment_nlink(root->self->next);
d_entry = root->subdir;
while(d_entry){
  increment_nlink(d_entry->contents->next);
  d_entry = d_entry->next;
};
825}

827/* 
* Function:		scan_directory_tree
*
* Purpose:		Walk through a directory on the local machine
*			filter those things we don't want to include
*			and build our representation of a dir.
*
* Notes:
*/
836int
837FDECL3(scan_directory_tree,struct directory *, this_dir,scan_directory_tree(struct directory * this_dir, char * path,
 struct directory_entry * de)
     char *, path,scan_directory_tree(struct directory * this_dir, char * path,
 struct directory_entry * de) 
     struct directory_entry *, de)scan_directory_tree(struct directory * this_dir, char * path,
 struct directory_entry * de)
840{
DIR				* current_dir;
char				  whole_path[1024];
struct dirent			* d_entry;
struct directory		* parent;
int				  dflag;
char				* old_path;

  if (verbose > 1)
  {
    fprintf(stderr(&__sF[2]), "Scanning %s\n", path);
  }

current_dir = opendir(path);
d_entry = NULL((void *)0);

/* Apparently NFS sometimes allows you to open the directory, but
   then refuses to allow you to read the contents.  Allow for this */

old_path = path;

if(current_dir) d_entry = readdir(current_dir);

if(!current_dir || !d_entry) 
  {
    fprintf(stderr(&__sF[2]),"Unable to open directory %s\n", path);
    de->isorec.flags[0] &= ~2; /* Mark as not a directory */
    if(current_dir) closedir(current_dir);
    return 0;
  }

parent = de->filedir;
/* Set up the struct for the current directory, and insert it into the
   tree */

875#ifdef VMS
vms_path_fixup(path);
877#endif

/*
 * if entry for this sub-directory is hidden, then hide this directory
 */
if (de->de_flags & INHIBIT_ISO9660_ENTRY0x40)
  this_dir->dir_flags |= INHIBIT_ISO9660_ENTRY0x40;

if (de->de_flags & INHIBIT_JOLIET_ENTRY0x08)
  this_dir->dir_flags |= INHIBIT_JOLIET_ENTRY0x08;

/* 
 * Now we scan the directory itself, and look at what is inside of it. 
 */
dflag = 0;
while(1==1){

  /* The first time through, skip this, since we already asked for
     the first entry when we opened the directory. */
  if(dflag) d_entry = readdir(current_dir);
  dflag++;

  if(!d_entry) break;

  /* OK, got a valid entry */

  /* If we do not want all files, then pitch the backups. */
  if(!all_files){
   if(   strchr(d_entry->d_name,'~')
      || strchr(d_entry->d_name,'#'))
     {
if( verbose > 0 )
  {
    fprintf(stderr(&__sF[2]), "Ignoring file %s\n", d_entry->d_name);
  }
continue;
     }
  }

916#ifdef APPLE_HYB1
  if (apple_both) {
    /* exclude certain HFS type files/directories for the time being */
    if (hfs_exclude(d_entry->d_name))
continue;
  }
922#endif /* APPLE_HYB */

  if(strlen(path)+strlen(d_entry->d_name) + 2 > sizeof(whole_path)){
    fprintf(stderr(&__sF[2]), "Overflow of stat buffer\n");
    exit(1);
  };

  /* Generate the complete ASCII path for this file */
  strcpy(whole_path, path);
931#ifndef VMS
  if(whole_path[strlen(whole_path)-1] != '/')
    strcat(whole_path, "/");
934#endif
  strcat(whole_path, d_entry->d_name);

  /** Should we exclude this file ? */
  if (matches(d_entry->d_name) || matches(whole_path)) {
    if (verbose > 1) {
fprintf(stderr(&__sF[2]), "Excluded by match: %s\n", whole_path);
    }
    continue;
  }

  if(    generate_tables 
946#ifdef APPLE_HYB1
&& strcmp(d_entry->d_name, trans_tbl) == 0 )
948#else
&& strcmp(d_entry->d_name, "TRANS.TBL") == 0 )
950#endif /* APPLE_HYB */
    {
/*
* Ignore this entry.  We are going to be generating new
* versions of these files, and we need to ignore any
* originals that we might have found.
*/
if (verbose > 1) 
 {
   fprintf(stderr(&__sF[2]), "Excluded: %s\n",whole_path);
 }
continue;
    }

  /*
   * If we already have a '.' or a '..' entry, then don't
   * insert new ones.
   */
  if( strcmp(d_entry->d_name, ".") == 0 
&& this_dir->dir_flags & DIR_HAS_DOT0x02 )
    {
continue;
    }

  if( strcmp(d_entry->d_name, "..") == 0 
&& this_dir->dir_flags & DIR_HAS_DOTDOT0x04 )
    {
continue;
    }

980#if 0
  if (verbose > 1)  fprintf(stderr(&__sF[2]), "%s\n",whole_path);
982#endif
  /*
   * This actually adds the entry to the directory in question.
   */
986#ifdef APPLE_HYB1
  insert_file_entry(this_dir, whole_path, d_entry->d_name, 0);
988#else
  insert_file_entry(this_dir, whole_path, d_entry->d_name);
990#endif /* APPLE_HYB */
}
closedir(current_dir);

994#ifdef APPLE_HYB1
/* if we cached the HFS info stuff for this directory, then delete it */
if (this_dir->hfs_info) {
  del_hfs_info(this_dir->hfs_info);
  this_dir->hfs_info = 0;
}
1000#endif /* APPLE_HYB */

return 1;
1003}


1006/* 
* Function:		insert_file_entry
*
* Purpose:		Insert one entry into our directory node.
*
* Note:
* This function inserts a single entry into the directory.  It
* is assumed that all filtering and decision making regarding what
* we want to include has already been made, so the purpose of this
* is to insert one entry (file, link, dir, etc), into this directory.
* Note that if the entry is a dir (or if we are following links,
* and the thing it points to is a dir), then we will scan those
* trees before we return.
*/
1020#ifdef APPLE_HYB1
1021int
1022FDECL4(insert_file_entry,struct directory *, this_dir,insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name, int have_rsrc)
     char *, whole_path,insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name, int have_rsrc)
     char *, short_name,insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name, int have_rsrc)
     int, have_rsrc)insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name, int have_rsrc)
1026#else
1027int
1028FDECL3(insert_file_entry,struct directory *, this_dir,insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name)
     char *, whole_path,insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name)
     char *, short_name)insert_file_entry(struct directory * this_dir, char * whole_path
, char * short_name)
1031#endif /* APPLE_HYB */
1032{
struct stat			  statbuf, lstatbuf;
struct directory_entry	* s_entry, *s_entry1;
int				  lstatus;
int				  status;
int				  deep_flag;
1038#ifdef APPLE_HYB1
int				  x_hfs = 0;
int				  htype = 0;
1041#endif /* APPLE_HYB */

status = stat_filter(whole_path, &statbuf);

lstatus = lstat_filter(whole_path, &lstatbuf);

if( (status == -1) && (lstatus == -1) )
  {
    /*
     * This means that the file doesn't exist, or isn't accessible.
     * Sometimes this is because of NFS permissions problems.
     */
    fprintf(stderr(&__sF[2]), "Non-existant or inaccessible: %s\n",whole_path);
    return 0;
  }

if(this_dir == root && strcmp(short_name, ".") == 0)
  root_statbuf = statbuf;  /* Save this for later on */

/* We do this to make sure that the root entries are consistent */
if(this_dir == root && strcmp(short_name, "..") == 0) 
  {
    statbuf = root_statbuf;
    lstatbuf = root_statbuf;
  }

if(S_ISLNK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0120000))
  {
    
    /* Here we decide how to handle the symbolic links.  Here
we handle the general case - if we are not following
links or there is an error, then we must change
something.  If RR is in use, it is easy, we let RR
describe the file.  If not, then we punt the file. */
    
    if((status || !follow_links))
{
 if(use_RockRidge)
   {
     status = 0;
     statbuf.st_size = 0;
     STAT_INODE(statbuf)(statbuf.st_ino) = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
     statbuf.st_dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
     statbuf.st_mode = (statbuf.st_mode & ~S_IFMT0170000) | S_IFREG0100000;
   } else {
     if(follow_links) 
{
  fprintf(stderr(&__sF[2]),
	  "Unable to stat file %s - ignoring and continuing.\n",
	  whole_path);
}
     else
{
  fprintf(stderr(&__sF[2]),
	  "Symlink %s ignored - continuing.\n",
	  whole_path);
  return 0;  /* Non Rock Ridge discs - ignore all symlinks */
}
   }
}
    
    /* Here we handle a different kind of case.  Here we have
a symlink, but we want to follow symlinks.  If we run
across a directory loop, then we need to pretend that
we are not following symlinks for this file.  If this
is the first time we have seen this, then make this
seem as if there was no symlink there in the first
place */
    
    if( follow_links
 && S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000) ) 
{
 if(   strcmp(short_name, ".")
&& strcmp(short_name, "..") )
   {
     if(find_directory_hash(statbuf.st_dev, STAT_INODE(statbuf)(statbuf.st_ino)))
{
  if(!use_RockRidge) 
    {
      fprintf(stderr(&__sF[2]), "Already cached directory seen (%s)\n", 
	      whole_path);
      return 0;
    }
  statbuf.st_size = 0;
  STAT_INODE(statbuf)(statbuf.st_ino) = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
  statbuf.st_dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
  statbuf.st_mode = (statbuf.st_mode & ~S_IFMT0170000) | S_IFREG0100000;
}
     else 
{
  lstatbuf = statbuf;
  add_directory_hash(statbuf.st_dev, STAT_INODE(statbuf)(statbuf.st_ino));
}
   }
}
    
    /*
     * For non-directories, we just copy the stat information over
     * so we correctly include this file.
     */
    if( follow_links
 && !S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000) ) 
{
 lstatbuf = statbuf;
}
  }

/*
 * Add directories to the cache so that we don't waste space even
 * if we are supposed to be following symlinks.
 */
if( follow_links
    && strcmp(short_name, ".")
    && strcmp(short_name, "..")
    && S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000) ) 
  {
    add_directory_hash(statbuf.st_dev, STAT_INODE(statbuf)(statbuf.st_ino));
  }
1159#ifdef VMS
if(!S_ISDIR(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0040000) && (statbuf.st_fab_rfm != FAB$C_FIX && 
		    statbuf.st_fab_rfm != FAB$C_STMLF)) {
  fprintf(stderr(&__sF[2]),"Warning - file %s has an unsupported VMS record"
   " format (%d)\n",
   whole_path, statbuf.st_fab_rfm);
}
1166#endif

if(S_ISREG(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0100000) && (status = access(whole_path, R_OK0x04)))
  {
    fprintf(stderr(&__sF[2]), "File %s is not readable (errno = %d) - ignoring\n", 
     whole_path, errno(*__errno()));
    return 0;
  }

/* Add this so that we can detect directory loops with hard links.
   If we are set up to follow symlinks, then we skip this checking. */
if(   !follow_links 
&& S_ISDIR(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0040000) 
&& strcmp(short_name, ".") 
&& strcmp(short_name, "..") ) 
  {
    if(find_directory_hash(statbuf.st_dev, STAT_INODE(statbuf)(statbuf.st_ino))) {
1183#ifdef APPLE_HYB1
/* NON-HFS change - print just a warning *if* this ever happens */
fprintf(stderr(&__sF[2]),"Warning: Directory loop (%s)\n", whole_path);
1186#else
fprintf(stderr(&__sF[2]),"Directory loop - fatal goof (%s %lx %llu).\n",
whole_path, (unsigned long) statbuf.st_dev,
(unsigned long long) STAT_INODE(statbuf)(statbuf.st_ino));
exit(1);
1191#endif
    }
    add_directory_hash(statbuf.st_dev, STAT_INODE(statbuf)(statbuf.st_ino));
  }

if (!S_ISCHR(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0020000) && !S_ISBLK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0060000) &&
    !S_ISFIFO(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0010000) && !S_ISSOCK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0140000)
    && !S_ISLNK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0120000) && !S_ISREG(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0100000) &&
    !S_ISDIR(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0040000)) {
  fprintf(stderr(&__sF[2]),"Unknown file type %s - ignoring and continuing.\n",
   whole_path);
  return 0;
}

/* Who knows what trash this is - ignore and continue */

if(status) 
  {
    fprintf(stderr(&__sF[2]),
     "Unable to stat file %s - ignoring and continuing.\n",
     whole_path);
    return 0; 
  }

/*
 * Check to see if we have already seen this directory node.
 * If so, then we don't create a new entry for it, but we do want
 * to recurse beneath it and add any new files we do find.
 */
if (S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000)) 
  {
    int dflag;
    
    for( s_entry = this_dir->contents; s_entry; s_entry = s_entry->next)
{
 if( strcmp(s_entry->name, short_name) == 0 )
   {
     break;
   }
}
    if ( s_entry != NULL((void *)0) 
  && strcmp(short_name,".") 
  && strcmp(short_name,"..")) 
{
 struct directory * child;
 
 if ( (s_entry->de_flags & RELOCATED_DIRECTORY0x20) != 0)
   {
     for( s_entry = reloc_dir->contents; s_entry; s_entry = s_entry->next)
{
  if( strcmp(s_entry->name, short_name) == 0 )
    {
      break;
    }
}
     child = find_or_create_directory(reloc_dir, whole_path, 
			       s_entry, 1);
   }
 else
   {
     child = find_or_create_directory(this_dir, whole_path, 
			       s_entry, 1);
     /* If unable to scan directory, mark this as a non-directory */
   }
 dflag = scan_directory_tree(child, whole_path, s_entry);
 if(!dflag)
   {
     lstatbuf.st_mode = (lstatbuf.st_mode & ~S_IFMT0170000) | S_IFREG0100000;
   }
 return 0;
}
  }
1263#ifdef APPLE_HYB1 
  /* Should we exclude this HFS file ? - only works with -hfs */
  if (!have_rsrc && apple_hyb && strcmp(short_name,".") && strcmp(short_name,"..")) {
    x_hfs = hfs_matches(short_name) || hfs_matches(whole_path);
    if (x_hfs) {
if (verbose > 1) {
 fprintf(stderr(&__sF[2]), "Hidden from HFS tree: %s\n", whole_path);
}
    }
  }

  /* check we are a file, using Apple extensions and have a .resource part
and not excluded */
  if (S_ISREG(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0100000) && !have_rsrc && apple_both && !x_hfs) {
    char	rsrc_path[1024];	/* rsrc fork filename */

    /* construct the resource full path */
    htype = get_hfs_rname(whole_path, short_name, rsrc_path);
    /* check we can read the resouce fork */
    if (htype) {
struct stat	rstatbuf, rlstatbuf;

/* some further checks on the file */
status = stat_filter(rsrc_path, &rstatbuf);

lstatus = lstat_filter(rsrc_path, &rlstatbuf);

if(!status && !lstatus && S_ISREG(rstatbuf.st_mode)((rstatbuf.st_mode & 0170000) == 0100000) && rstatbuf.st_size > 0) {
 /* have a resource file - insert it into the current directory
    but flag that we have a resource fork */
 insert_file_entry(this_dir, rsrc_path, short_name, htype);
}
    }
  }
1297#endif /* APPLE_HYB */

s_entry = (struct directory_entry *) 
  e_malloc(sizeof (struct directory_entry));
/* memset the whole struct, not just the isorec.extent part JCP */
memset(s_entry, 0, sizeof (struct directory_entry));
s_entry->next = this_dir->contents;
1304/*memset(s_entry->isorec.extent, 0, 8); */
this_dir->contents = s_entry;
deep_flag = 0;
s_entry->table = NULL((void *)0);

s_entry->name = strdup(short_name);
s_entry->whole_name = strdup (whole_path);

s_entry->de_flags = 0;

/*
 * If the current directory is hidden, then hide all it's members
 * otherwise check if this entry needs to be hidden as well */
if (this_dir->dir_flags & INHIBIT_ISO9660_ENTRY0x40) {
  s_entry->de_flags |= INHIBIT_ISO9660_ENTRY0x40;
}
else if (strcmp(short_name,".") && strcmp(short_name,"..")) {
  if (i_matches(short_name) || i_matches(whole_path)) {
    if (verbose > 1) {
fprintf(stderr(&__sF[2]), "Hidden from ISO9660 tree: %s\n", whole_path);
    }
    s_entry->de_flags |= INHIBIT_ISO9660_ENTRY0x40;
  }
}

if (this_dir != reloc_dir && this_dir->dir_flags & INHIBIT_JOLIET_ENTRY0x08) {
  s_entry->de_flags |= INHIBIT_JOLIET_ENTRY0x08;
}
else if (strcmp(short_name,".") && strcmp(short_name,"..")) {
  if (j_matches(short_name) || j_matches(whole_path)) {
    if (verbose > 1) {
fprintf(stderr(&__sF[2]), "Hidden from Joliet tree: %s\n", whole_path);
    }
    s_entry->de_flags |= INHIBIT_JOLIET_ENTRY0x08;
  }
}

s_entry->filedir = this_dir;
s_entry->isorec.flags[0] = 0;
s_entry->isorec.ext_attr_length[0] = 0;
iso9660_date(s_entry->isorec.date, statbuf.st_mtimest_mtim.tv_sec);
s_entry->isorec.file_unit_size[0] = 0;
s_entry->isorec.interleave[0] = 0;

1348#ifdef APPLE_HYB1
if (apple_both && !x_hfs) {
  s_entry->hfs_ent = NULL((void *)0);
  s_entry->assoc = NULL((void *)0);
  s_entry->hfs_off = 0;
  s_entry->hfs_type = htype;
  if (have_rsrc) {
    s_entry->isorec.flags[0] = ASSOC_FLAG4;	/* associated (rsrc) file */
    /* set the type of HFS file */
    s_entry->hfs_type = have_rsrc;
    /* don't want the rsrc file to be included in any Joliet tree */
    s_entry->de_flags |= INHIBIT_JOLIET_ENTRY0x08;
  }
  else if (s_entry->next) {
    /* if previous entry is an associated file, then "link" it
to this file i.e. we have a data/resource pair */
    if (s_entry->next->isorec.flags[0] & ASSOC_FLAG4) {
s_entry->assoc = s_entry->next;
/* share the same HFS parameters */
s_entry->hfs_ent = s_entry->next->hfs_ent;
s_entry->hfs_type = s_entry->next->hfs_type;
    }
  }
  /* allocate HFS entry if required */
  if (apple_both && strcmp(short_name, ".") && strcmp(short_name, "..")) {
    if (!s_entry->hfs_ent) {
hfsdirent *hfs_ent;
hfs_ent = (hfsdirent *)e_malloc(sizeof(hfsdirent));

/* fill in the defaults */
hfs_ent->flags = hfs_ent->fdflags = 0;
hfs_ent->crdate = lstatbuf.st_ctimest_ctim.tv_sec;
hfs_ent->mddate = lstatbuf.st_mtimest_mtim.tv_sec;
hfs_ent->dsize = hfs_ent->rsize = 0;
s_entry->hfs_ent = hfs_ent;
    }
    if (have_rsrc)
/* set rsrc size */
s_entry->hfs_ent->rsize = lstatbuf.st_size;
    else
/* set data size */
s_entry->hfs_ent->dsize = lstatbuf.st_size;
  }
}
1392#endif /* APPLE_HYB */

if( strcmp(short_name,  ".") == 0)
  {
    this_dir->dir_flags |= DIR_HAS_DOT0x02;
  } 

if( strcmp(short_name,  "..") == 0)
  {
    this_dir->dir_flags |= DIR_HAS_DOTDOT0x04;
  } 

if(   this_dir->parent 
   && this_dir->parent == reloc_dir 
   && strcmp(short_name,  "..") == 0)
  {
    s_entry->inode = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
    s_entry->dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
    deep_flag  = NEED_PL2;
  } 
else
1413#ifdef APPLE_HYB1
  if (have_rsrc) {
    /* don't want rsrc files to be cached */
    s_entry->inode = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
    s_entry->dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
  }
else
1420#endif /* APPLE_HYB */
  {
    s_entry->inode = STAT_INODE(statbuf)(statbuf.st_ino);
    s_entry->dev = statbuf.st_dev;
  }
set_723(s_entry->isorec.volume_sequence_number, volume_sequence_number);
iso9660_file_length(short_name, s_entry, S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000));
s_entry->rr_attr_size = 0;
s_entry->total_rr_attr_size = 0;
s_entry->rr_attributes = NULL((void *)0);

/* Directories are assigned sizes later on */
if (!S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000)) 
  {
    if (S_ISCHR(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0020000) || S_ISBLK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0060000) || 
 S_ISFIFO(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0010000) || S_ISSOCK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0140000)
 || S_ISLNK(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0120000))
{
 s_entry->size = 0; 
 statbuf.st_size = 0; 
}
    else
{
 s_entry->size = statbuf.st_size; 
}

    set_733((char *) s_entry->isorec.size, statbuf.st_size); 
  } 
else
  {
    s_entry->isorec.flags[0] = 2;
  }
1452#ifdef APPLE_HYB1
/* if the directory is HFS excluded, then we don't have an hfs_ent */
if (apple_both && s_entry->hfs_ent && s_entry->isorec.flags[0] & 2) {
  /* get the Mac directory name */
  get_hfs_dir(whole_path, short_name, s_entry);

  /* if required, set ISO directory name from HFS name */
  if (mac_name)
    iso9660_file_length(s_entry->hfs_ent->name, s_entry, 1);
}
1462#endif /* APPLE_HYB */

if (strcmp(short_name,".") && strcmp(short_name,"..") && 
    S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000) && this_dir->depth >  RR_relocation_depth)
  {
    struct directory * child;

    if(!reloc_dir) generate_reloc_directory();
    
    /*
     * Replicate the entry for this directory.  The old one will stay where it
     * is, and it will be neutered so that it no longer looks like a directory.
     * The new one will look like a directory, and it will be put in the reloc_dir.
     */
    s_entry1 = (struct directory_entry *) 
e_malloc(sizeof (struct directory_entry));
    memcpy(s_entry1, s_entry,  sizeof(struct directory_entry));
    s_entry1->table = NULL((void *)0);
    s_entry1->name = strdup(this_dir->contents->name);
    s_entry1->whole_name = strdup(this_dir->contents->whole_name);
    s_entry1->next = reloc_dir->contents;
    reloc_dir->contents = s_entry1;
    s_entry1->priority  =  32768;
    s_entry1->parent_rec = this_dir->contents;
    
    deep_flag = NEED_RE1;
    
    if(use_RockRidge) 
{
 generate_rock_ridge_attributes(whole_path,
			 short_name, s_entry1,
			 &statbuf, &lstatbuf, deep_flag);
}
    
    deep_flag = 0;
    
    /* We need to set this temporarily so that the parent to this
is correctly determined. */
    s_entry1->filedir = reloc_dir;
    child = find_or_create_directory(reloc_dir, whole_path, 
		       s_entry1, 0);
    scan_directory_tree(child, whole_path, s_entry1);
    s_entry1->filedir = this_dir;
    
    statbuf.st_size = 0;
    statbuf.st_mode &= 0777;
    set_733((char *) s_entry->isorec.size, 0);
    s_entry->size = 0;
    s_entry->isorec.flags[0] = 0;
    s_entry->inode = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
    s_entry->de_flags |= RELOCATED_DIRECTORY0x20;
    deep_flag = NEED_CL4;
  }

if(generate_tables 
   && strcmp(s_entry->name, ".") 
   && strcmp(s_entry->name, "..")) 
  {
    char  buffer[2048];
    int nchar;
    switch(lstatbuf.st_mode & S_IFMT0170000)
{
case S_IFDIR0040000:
 snprintf(buffer, sizeof buffer, "D\t%s\n",
  s_entry->name);
 break;
1528#ifdef S_IFBLK0060000
1529/* extra for WIN32 - if it doesn't have the major/minor defined, then
 S_IFBLK and S_IFCHR type files are unlikely to exist anyway ...
 code similar to that in rock.c */

1533/* for some reason, MAJOR_IN_SYSMACROS isn't defined on a SunOS when
 it should be, so see if major() is defined instead  */
1535/*
1536#if !(defined(MAJOR_IN_SYSMACROS) || defined(MAJOR_IN_MKDEV))
1537*/
1538#ifndef major
1539#define major(dev)(((unsigned)(dev) >> 8) & 0xff) (sizeof(dev_t) <= 2 ? ((dev) >> 8) : \
(sizeof(dev_t) <= 4 ? (((dev) >> 8) >> 8) : \
(((dev) >> 16) >> 16)))
1542#define minor(dev)((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
 8)) (sizeof(dev_t) <= 2 ? (dev) & 0xff : \
(sizeof(dev_t) <= 4 ? (dev) & 0xffff : \
(dev) & 0xffffffff))
1545#endif
case S_IFBLK0060000:
 snprintf(buffer, sizeof buffer, "B\t%s\t%lu %lu\n",
  s_entry->name,
  (unsigned long) major(statbuf.st_rdev)(((unsigned)(statbuf.st_rdev) >> 8) & 0xff),
  (unsigned long) minor(statbuf.st_rdev)((unsigned)((statbuf.st_rdev) & 0xff) | (((statbuf.st_rdev
) & 0xffff0000) >> 8)));
 break;
1552#endif
1553#ifdef S_IFIFO0010000
case S_IFIFO0010000:
 snprintf(buffer, sizeof buffer, "P\t%s\n",
  s_entry->name);
 break;
1558#endif
1559#ifdef S_IFCHR0020000
case S_IFCHR0020000:
 snprintf(buffer, sizeof buffer, "C\t%s\t%lu %lu\n",
  s_entry->name,
  (unsigned long) major(statbuf.st_rdev)(((unsigned)(statbuf.st_rdev) >> 8) & 0xff),
  (unsigned long) minor(statbuf.st_rdev)((unsigned)((statbuf.st_rdev) & 0xff) | (((statbuf.st_rdev
) & 0xffff0000) >> 8)));
 break;
1566#endif
1567#ifdef S_IFLNK0120000
case S_IFLNK0120000:
 nchar = readlink(whole_path, 
	   (char *)symlink_buff, 
	   sizeof(symlink_buff)-1);
 symlink_buff[nchar < 0 ? 0 : nchar] = 0;
 snprintf(buffer, sizeof buffer, "L\t%s\t%s\n",
  s_entry->name, symlink_buff);
 break;
1576#endif
1577#ifdef S_IFSOCK0140000
case S_IFSOCK0140000:
 snprintf(buffer, sizeof buffer, "S\t%s\n",
  s_entry->name);
 break;
1582#endif
case S_IFREG0100000:
default:
 snprintf(buffer, sizeof buffer, "F\t%s\n",
  s_entry->name);
 break;
};
    s_entry->table = strdup(buffer);
  }

if(S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000))
  {
    int dflag;
    if (strcmp(short_name,".") && strcmp(short_name,"..")) 
{
 struct directory * child;
 
 child = find_or_create_directory(this_dir, whole_path, 
			   s_entry, 1);
 dflag = scan_directory_tree(child, whole_path, s_entry);
 
 if(!dflag)
   {
     lstatbuf.st_mode = (lstatbuf.st_mode & ~S_IFMT0170000) | S_IFREG0100000;
     if( child->contents == NULL((void *)0) )
{
  delete_directory(this_dir, child);
}
   }
}
    /* If unable to scan directory, mark this as a non-directory */
  }

if(use_RockRidge && this_dir == root && strcmp(s_entry->name, ".")  == 0)
  {
    deep_flag |= NEED_CE8 | NEED_SP16;  /* For extension record */
  }

/* Now figure out how much room this file will take in the
   directory */

1623#ifdef APPLE_HYB1
  /* if the file is HFS excluded, then we don't have an hfs_ent */
  if (apple_both && !have_rsrc && s_entry->hfs_ent) {
    if (S_ISREG(lstatbuf.st_mode)((lstatbuf.st_mode & 0170000) == 0100000)) {	/* it's a regular file */

/* fill in the rest of the HFS entry */
get_hfs_info(whole_path, short_name, s_entry);

/* if required, set ISO directory name from HFS name */ 
if (mac_name)
 iso9660_file_length(s_entry->hfs_ent->name, s_entry, 0); 

/* print details about the HFS file */
if (verbose > 2)
 print_hfs_info(s_entry);

/* copy the new ISO9660 name to the rsrc fork - if it exists */
if (s_entry->assoc)
 strcpy(s_entry->assoc->isorec.name, s_entry->isorec.name);

/* we can't handle hard links in the hybrid case, so we "uncache"
  the file. The downside to this is that hard linked files
  are added to the output image more than once (we've already
  done this for rsrc files) */
if (apple_hyb) {
 s_entry->inode = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
 s_entry->dev = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
}
    }
    else if (!(s_entry->isorec.flags[0] & 2)) { /* not a directory .. */

/* no mac equivalent, so ignore - have to be careful here, the
  hfs_ent may be also be for a relocated directory */
if (s_entry->hfs_ent && !(s_entry->de_flags & RELOCATED_DIRECTORY0x20))
   free(s_entry->hfs_ent);
s_entry->hfs_ent = NULL((void *)0);
    }

    /* if the rsrc size is zero, then we don't need the entry, so we
might as well delete it - this will only happen if we didn't
know the rsrc size from the rsrc file size */
    if(s_entry->assoc && s_entry->assoc->size == 0)
delete_rsrc_ent(s_entry);
  }

  if(apple_ext && s_entry->assoc) {
/* need Apple extensions for the resource fork as well */
generate_rock_ridge_attributes(whole_path,
			   short_name, s_entry->assoc,
			   &statbuf, &lstatbuf, deep_flag);
  }
  /* leave out resource fork for the time being */
  if (use_RockRidge && !have_rsrc) {
1676#else
  if(use_RockRidge) 
  {
1679#endif /* APPLE_HYB */
    generate_rock_ridge_attributes(whole_path,
		     short_name, s_entry,
		     &statbuf, &lstatbuf, deep_flag);
    
  }

return 1;
1687}


1690void FDECL2(generate_iso9660_directories, struct directory *, node, FILE*, outfile)generate_iso9660_directories(struct directory * node, FILE* outfile
){
struct directory * dpnt;

dpnt = node;

while (dpnt){
  if( dpnt->extent > session_start )
    {
generate_one_directory(dpnt, outfile);
    }
  if(dpnt->subdir) generate_iso9660_directories(dpnt->subdir, outfile);
  dpnt = dpnt->next;
}
1703}

1705/*
* Function:	find_or_create_directory
*
* Purpose:	Locate a directory entry in the tree, create if needed.
*
* Arguments:
*/
1712struct directory * FDECL4(find_or_create_directory, struct directory *, parent,find_or_create_directory(struct directory * parent, const char
 * path, struct directory_entry * de, int flag)
	  const char *, path,find_or_create_directory(struct directory * parent, const char
 * path, struct directory_entry * de, int flag)
	  struct directory_entry *, de, int, flag)find_or_create_directory(struct directory * parent, const char
 * path, struct directory_entry * de, int flag)
1715{
struct directory		* dpnt;
struct directory_entry	* orig_de;
struct directory		* next_brother;
const char                    * cpnt;
const char			* pnt;

orig_de = de;

pnt = strrchr(path, PATH_SEPARATOR'/');
if( pnt == NULL((void *)0) )
  {
    pnt = path;
  }
else
  {
    pnt++;
  }

if( parent != NULL((void *)0) )
  {
    dpnt = parent->subdir;

    while (dpnt)
{
 /*
  * Weird hack time - if there are two directories by the
  * same name in the reloc_dir, they are not treated as the
  * same thing unless the entire path matches completely.
  */
 if( flag && strcmp(dpnt->de_name, pnt) == 0 )
   {
     return dpnt;
   }
 dpnt = dpnt->next;
}
  }

/*
 * We don't know if we have a valid directory entry for this one
 * yet.  If not, we need to create one.
 */
if( de == NULL((void *)0) )
  {
    de = (struct directory_entry *) 
e_malloc(sizeof (struct directory_entry));
    memset(de, 0, sizeof(struct directory_entry));
    de->next            = parent->contents;
    parent->contents    = de;
    de->name            = strdup(pnt);
    de->filedir         = parent;
    de->isorec.flags[0] = 2;
    de->priority        = 32768;
    de->inode           = UNCACHED_INODE(sizeof(ino_t) >= 8 ? 0x7fffffffffffffffLL : 0x7fffffff);
    de->dev             = (dev_t) UNCACHED_DEVICE(sizeof(dev_t) >= 4 ? 0x7fffffff : 0x7fff);
    set_723(de->isorec.volume_sequence_number, volume_sequence_number);
    iso9660_file_length (pnt, de, 1);

    init_fstatbuf();
    /*
     * It doesn't exist for real, so we cannot add any Rock Ridge.
     */
    if(use_RockRidge)
{
 fstatbuf.st_mode = 0555 | S_IFDIR0040000;
 fstatbuf.st_nlink = 2;
 generate_rock_ridge_attributes("",
			 (char *) pnt, de,
			 &fstatbuf, 
			 &fstatbuf, 0);
}
    iso9660_date(de->isorec.date, fstatbuf.st_mtimest_mtim.tv_sec);
1787#ifdef APPLE_HYB1
    if (apple_both) {
/* give the directory an HFS entry */
hfsdirent *hfs_ent;
hfs_ent = (hfsdirent *)e_malloc(sizeof(hfsdirent));

/* fill in the defaults */
hfs_ent->flags = hfs_ent->fdflags = 0;
hfs_ent->crdate = fstatbuf.st_ctimest_ctim.tv_sec;
hfs_ent->mddate = fstatbuf.st_mtimest_mtim.tv_sec;
hfs_ent->dsize = hfs_ent->rsize = 0;

de->hfs_ent = hfs_ent;

/* get the Mac directory name */
get_hfs_dir(path, pnt, de);
    }
1804#endif /* APPLE_HYB */
  }

/*
 * If we don't have a directory for this one yet, then allocate it
 * now, and patch it into the tree in the appropriate place.
 */
dpnt             = (struct directory *) e_malloc(sizeof(struct directory));
memset(dpnt, 0, sizeof(struct directory));
dpnt->next       = NULL((void *)0);
dpnt->subdir     = NULL((void *)0);
dpnt->self       = de;
dpnt->contents   = NULL((void *)0);
dpnt->whole_name = strdup(path);
cpnt             = strrchr(path, PATH_SEPARATOR'/');
if(cpnt)
  cpnt++;
else
  cpnt = path;
dpnt->de_name    = strdup(cpnt);
dpnt->size       = 0;
dpnt->extent     = 0;
dpnt->jextent    = 0;
dpnt->jsize      = 0;
1828#ifdef APPLE_HYB1
dpnt->hfs_ent	   = de->hfs_ent;
1830#endif /*APPLE_HYB */

if( orig_de == NULL((void *)0) )
  {
    struct stat xstatbuf;
    int sts;

    /*
     * Now add a . and .. entry in the directory itself.
     * This is a little tricky - if the real directory
     * exists, we need to stat it first.  Otherwise, we
     * use the fictitious fstatbuf which points to the time
     * at which mkisofs was started.
     */
    sts = stat_filter(parent->whole_name, &xstatbuf);
    if( sts == 0 )
{
 attach_dot_entries(dpnt, &xstatbuf);
}
    else
{
 attach_dot_entries(dpnt, &fstatbuf);
}
  }

if(!parent || parent == root)
  {
    if (!root) 
{
 root = dpnt;  /* First time through for root directory only */
 root->depth = 0;
 root->parent = root;
} else {
 dpnt->depth = 1;
 if(!root->subdir)
   {
     root->subdir = dpnt;
   }
 else 
   {
     next_brother = root->subdir;
     while(next_brother->next) next_brother = next_brother->next;
     next_brother->next = dpnt;
   }
 dpnt->parent = parent;
}
  } 
else 
  {
    /* Come through here for  normal traversal of  tree */
1880#ifdef DEBUG
    fprintf(stderr(&__sF[2]),"%s(%d) ", path, dpnt->depth);
1882#endif
    if(parent->depth >  RR_relocation_depth) 
{
 fprintf(stderr(&__sF[2]),"Directories too deep  %s\n", path);
 exit(1);
}
    
    dpnt->parent = parent; 
    dpnt->depth = parent->depth + 1;
    
    if(!parent->subdir)
{
 parent->subdir = dpnt;
}
    else 
{
 next_brother = parent->subdir;
 while(next_brother->next) next_brother = next_brother->next;
 next_brother->next = dpnt;
}
  }

return dpnt;
1905}

1907/*
* Function:	delete_directory
*
* Purpose:	Locate a directory entry in the tree, create if needed.
*
* Arguments:
*/
1914static void FDECL2(delete_directory, struct directory *, parent, struct directory *, child)delete_directory(struct directory * parent, struct directory *
 child)
1915{
struct directory		* tdir;

if( child->contents != NULL((void *)0) )
  {
    fprintf(stderr(&__sF[2]), "Unable to delete non-empty directory\n");
    exit(1);
  }

free(child->whole_name);
child->whole_name = NULL((void *)0);

free(child->de_name);
child->de_name = NULL((void *)0);

1930#ifdef APPLE_HYB1
if (apple_both && child->hfs_ent)
  free(child->hfs_ent);
1933#endif /* APPLE_HYB */

if( parent->subdir == child )
  {
    parent->subdir = child->next;
  }
else
  {
    for( tdir = parent->subdir; tdir->next != NULL((void *)0); tdir = tdir->next )
{
 if( tdir->next == child )
   {
     tdir->next = child->next;
     break;
   }
}
    if( tdir == NULL((void *)0) )
{
 fprintf(stderr(&__sF[2]), "Unable to locate child directory in parent list\n");
 exit(1);
}
  }
free(child);
return;
1957}

1959int FDECL1(sort_tree, struct directory *, node)sort_tree(struct directory * node){
struct directory * dpnt;
int ret = 0;

dpnt = node;

while (dpnt){
  ret = sort_n_finish(dpnt);
  if( ret )
    {
break;
    }
  
  if(dpnt->subdir) sort_tree(dpnt->subdir);
  dpnt = dpnt->next;
}
return ret;
1976}

1978void FDECL1(dump_tree, struct directory *, node)dump_tree(struct directory * node){
struct directory * dpnt;

dpnt = node;

while (dpnt){
  fprintf(stderr(&__sF[2]),"%4d %5d %s\n",dpnt->extent, dpnt->size, dpnt->de_name);
  if(dpnt->subdir) dump_tree(dpnt->subdir);
  dpnt = dpnt->next;
}
1988}

1990void FDECL1(update_nlink_field, struct directory *, node)update_nlink_field(struct directory * node)
1991{
  struct directory		* dpnt;
  struct directory		* xpnt;
  struct directory_entry	* s_entry;
  int				  i;

  dpnt = node;
  
  while (dpnt)
1
Loop condition is true.  Entering loop body→
  {
if (dpnt->dir_flags & INHIBIT_ISO9660_ENTRY0x40) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
   dpnt = dpnt->next;
   continue;
}

/*
* First, count up the number of subdirectories this guy has.
*/
      for(i=0, xpnt = dpnt->subdir; xpnt; xpnt = xpnt->next)
4
←
Loop condition is false. Execution continues on line 2020→
          if ((xpnt->dir_flags & INHIBIT_ISO9660_ENTRY0x40) == 0)
              i++;
/*
* Next check to see if we have any relocated directories
* in this directory.   The nlink field will include these
* as real directories when they are properly relocated.
*
* In the non-rockridge disk, the relocated entries appear
* as zero length files.
*/
for(s_entry = dpnt->contents; s_entry; s_entry = s_entry->next)
5
←
Assuming pointer value is null→
6
←
Loop condition is false. Execution continues on line 2031→
{
if( (s_entry->de_flags  & RELOCATED_DIRECTORY0x20) != 0 &&
	(s_entry->de_flags  & INHIBIT_ISO9660_ENTRY0x40) == 0)
{
	i++;
}
}
/*
* Now update the field in the Rock Ridge entry.
*/
update_nlink(dpnt->self, i + 2);

/*
* Update the '.' entry for this directory.
*/
update_nlink(dpnt->contents, i + 2);
7
←
Passing null pointer value via 1st parameter 's_entry'→
8
←
Calling 'update_nlink'→

/*
* Update all of the '..' entries that point to this guy.
*/
for(xpnt = dpnt->subdir; xpnt; xpnt = xpnt->next)
   update_nlink(xpnt->contents->next, i + 2);

if(dpnt->subdir) update_nlink_field(dpnt->subdir);
dpnt = dpnt->next;
  }
2047}

2049/*
* something quick and dirty to locate a file given a path
* recursively walks down path in filename until it finds the
* directory entry for the desired file 
*/
2054struct directory_entry * FDECL2(search_tree_file, struct directory *,search_tree_file(struct directory * node, char * filename) 
		node,char *, filename)search_tree_file(struct directory * node, char * filename)
2056{
struct directory_entry * depnt;
struct directory	 * dpnt;
char			 * p1;
char			 * rest;
char			 * subdir;

/*
 * strip off next directory name from filename 
 */
subdir = strdup(filename);

if( (p1=strchr(subdir, '/')) == subdir )
  {
    fprintf(stderr(&__sF[2]),"call to search_tree_file with an absolute path, stripping\n");
    fprintf(stderr(&__sF[2]),"initial path separator. Hope this was intended...\n");
    memmove(subdir, subdir+1, strlen(subdir)-1);
    p1 = strchr(subdir, '/');
  }

/*
 * do we need to find a subdirectory 
 */
if (p1) 
  {
    *p1 = '\0';

2083#ifdef DEBUG_TORITO
    fprintf(stderr(&__sF[2]),"Looking for subdir called %s\n",p1); 
2085#endif

    rest = p1+1;

2089#ifdef DEBUG_TORITO
    fprintf(stderr(&__sF[2]),"Remainder of path name is now %s\n", rest); 
2091#endif
    
    dpnt = node->subdir;
   while( dpnt )
     {
2096#ifdef DEBUG_TORITO
fprintf(stderr(&__sF[2]),"%4d %5d %s\n", dpnt->extent, dpnt->size, 
 dpnt->de_name); 
2099#endif
if (!strcmp(subdir, dpnt->de_name)) 
  {
2102#ifdef DEBUG_TORITO
    fprintf(stderr(&__sF[2]),"Calling next level with filename = %s", rest); 
2104#endif
    return(search_tree_file( dpnt, rest ));
  }
dpnt = dpnt->next;
     }
    
   /* if we got here means we couldnt find the subdir */
   return (NULL((void *)0));
  }    
else 
  {
    /* 
     * look for a normal file now 
     */
    depnt = node->contents;
    while (depnt)
{
2121#ifdef DEBUG_TORITO
 fprintf(stderr(&__sF[2]),"%4d %5d %s\n",depnt->isorec.extent, 
  depnt->size, depnt->name); 
2124#endif
 if (!strcmp(filename, depnt->name)) 
   {
2127#ifdef DEBUG_TORITO
     fprintf(stderr(&__sF[2]),"Found our file %s", filename); 
2129#endif
     return(depnt);
   }
 depnt = depnt->next;
}
    /* 
     * if we got here means we couldnt find the subdir 
     */
    return (NULL((void *)0));
  }
fprintf(stderr(&__sF[2]),"We cant get here in search_tree_file :-/ \n");
2140}

2142void init_fstatbuf()
2143{
time_t		    current_time;

if(fstatbuf.st_ctimest_ctim.tv_sec == 0)
  {
    time (&current_time);
    if( rationalize )
{
 fstatbuf.st_uid = 0;
 fstatbuf.st_gid = 0;
}
    else
{
 fstatbuf.st_uid = getuid();
 fstatbuf.st_gid = getgid();
}
    fstatbuf.st_ctimest_ctim.tv_sec = current_time;
    fstatbuf.st_mtimest_mtim.tv_sec = current_time;
    fstatbuf.st_atimest_atim.tv_sec = current_time;
  }
2163}