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

Bug Summary

File:	src/gnu/usr.sbin/mkhybrid/mkhybrid/../src/multi.c
Warning:	line 861, column 12 Null pointer passed as 1st argument to string comparison function

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 multi.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/multi.c

1/*
* File multi.c - scan existing iso9660 image and merge into 
* iso9660 filesystem.  Used for multisession support.
*
* Written by Eric Youngdale (1996).
*
* 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.  
*/

22#include <stdlib.h>
23#include <string.h>
24#include <time.h>
25#include <errno(*__errno()).h>
26#include <sys/types.h>
27#include <sys/stat.h>

29#include "config.h"

31#ifndef VMS

33#ifdef HAVE_UNISTD_H1
34#include <unistd.h>
35#endif

37#else
38#include <sys/file.h>
39#include <vms/fabdef.h>
40#include "vms.h"
41extern char * strdup(const char *);
42#endif

44#include "mkisofs.h"
45#include "iso9660.h"

47#define TF_CREATE1 1
48#define TF_MODIFY2 2
49#define TF_ACCESS4 4
50#define TF_ATTRIBUTES8 8

52static int  isonum_711 __PR((unsigned char * p))(unsigned char * p);
53static int  isonum_721 __PR((unsigned char * p))(unsigned char * p);
54static int  isonum_723 __PR((unsigned char * p))(unsigned char * p);
55static int  isonum_731 __PR((unsigned char * p))(unsigned char * p);

57static int  DECL(merge_old_directory_into_tree, (struct directory_entry *,merge_old_directory_into_tree (struct directory_entry *, struct
 directory *)
				 struct directory *))merge_old_directory_into_tree (struct directory_entry *, struct
 directory *);

60#ifdef	__STDC__1
61static int
62isonum_711 (unsigned char * p)
63#else
64static int
65isonum_711 (p)
unsigned char * p;
67#endif
68{
return (*p & 0xff);
70}

72#ifdef	__STDC__1
73static int
74isonum_721 (unsigned char * p)
75#else
76static int
77isonum_721 (p)
unsigned char * p;
79#endif
80{
return ((p[0] & 0xff) | ((p[1] & 0xff) << 8));
82}

84#ifdef	__STDC__1
85static int
86isonum_723 (unsigned char * p)
87#else
88static int
89isonum_723 (p)
unsigned char * p;
91#endif
92{
93#if 0
if (p[0] != p[3] || p[1] != p[2]) {
fprintf (stderr(&__sF[2]), "invalid format 7.2.3 number\n");
exit (1);
}
98#endif
return (isonum_721 (p));
100}

102#ifdef	__STDC__1
103static int
104isonum_731 (unsigned char * p)
105#else
106static int
107isonum_731 (p)
unsigned char * p;
109#endif
110{
return ((p[0] & 0xff)
| ((p[1] & 0xff) << 8)
| ((p[2] & 0xff) << 16)
| ((p[3] & 0xff) << 24));
115}

117#ifdef	__STDC__1
118int
119isonum_733 (unsigned char * p)
120#else
121int
122isonum_733 (p)
unsigned char * p;
124#endif
125{
return (isonum_731 (p));
127}

129FILE * in_image = NULL((void *)0);

131#ifndef	USE_SCG
132/*
* Don't define readsecs if mkisofs is linked with
* the SCSI library.
* readsecs() will be implemented as SCSI command in this case.
*
* Use global var in_image directly in readsecs()
* the SCSI equivalent will not use a FILE* for I/O.
*
* The main point of this pointless abstraction is that Solaris won't let
* you read 2K sectors from the cdrom driver.  The fact that 99.9% of the
* discs out there have a 2K sectorsize doesn't seem to matter that much.
* Anyways, this allows the use of a scsi-generics type of interface on
* Solaris.
*/
146#ifdef	__STDC__1
147static int
148readsecs(int startsecno, void *buffer, int sectorcount)
149#else
150static int
151readsecs(startsecno, buffer, sectorcount)
int	startsecno;
void	*buffer;
int	sectorcount;
155#endif
156{
int	f = fileno(in_image)(!__isthreaded ? ((in_image)->_file) : (fileno)(in_image));

if (lseek(f, (off_t)startsecno * SECTOR_SIZE(2048), 0) == (off_t)-1) {
fprintf(stderr(&__sF[2])," Seek error on old image\n");
exit(10);
}
return (read(f, buffer, sectorcount * SECTOR_SIZE(2048)));
164}
165#endif

167/*
* Parse the RR attributes so we can find the file name.
*/
170static int 
171FDECL3(parse_rr, unsigned char *, pnt, int, len, struct directory_entry *,dpnt)parse_rr(unsigned char * pnt, int len, struct directory_entry
 * dpnt)
172{
int cont_extent, cont_offset, cont_size;
char name_buf[256];

cont_extent = cont_offset = cont_size = 0;

while(len >= 4){
16
←
Loop condition is false. Execution continues on line 207→
if(pnt[3] != 1) {
  fprintf(stderr(&__sF[2]),"**BAD RRVERSION");
  return -1;
};
if(strncmp((char *) pnt, "NM", 2) == 0) {
  strncpy(name_buf, (char *) pnt+5, pnt[2] - 5);
  name_buf[pnt[2] - 5] = 0;
  dpnt->name = strdup(name_buf);
  dpnt->got_rr_name = 1;
  return 0;
}

if(strncmp((char *) pnt, "CE", 2) == 0) {
	cont_extent = isonum_733(pnt+4);
	cont_offset = isonum_733(pnt+12);
	cont_size = isonum_733(pnt+20);
};

len -= pnt[2];
pnt += pnt[2];
if(len <= 3 && cont_extent) {
  unsigned char sector[SECTOR_SIZE(2048)];
  readsecs(cont_extent, sector, 1);
  parse_rr(&sector[cont_offset], cont_size, dpnt);
};
};

/* Fall back to the iso name if no RR name found */
if (dpnt->name16.1
Field 'name' is equal to NULL
 == NULL((void *)0)) {
17
←
Taking true branch→
 char *cp;

 strcpy(name_buf, dpnt->isorec.name);
 cp = strchr(name_buf, ';');
 if (cp != NULL((void *)0)) {
18
←
Assuming 'cp' is equal to NULL→
19
←
Taking false branch→
   *cp = '\0';
 }

 dpnt->name = strdup(name_buf);
20
←
Value assigned to field 'name'→
}

return 0;
220} /* parse_rr */


223static int 
224FDECL4(check_rr_dates, struct directory_entry *, dpnt,check_rr_dates(struct directory_entry * dpnt, struct directory_entry
 * current, struct stat * statbuf, struct stat * lstatbuf) 
     struct directory_entry *, current,check_rr_dates(struct directory_entry * dpnt, struct directory_entry
 * current, struct stat * statbuf, struct stat * lstatbuf) 
     struct stat *, statbuf,check_rr_dates(struct directory_entry * dpnt, struct directory_entry
 * current, struct stat * statbuf, struct stat * lstatbuf) 
     struct stat *,lstatbuf)check_rr_dates(struct directory_entry * dpnt, struct directory_entry
 * current, struct stat * statbuf, struct stat * lstatbuf)
228{
int cont_extent, cont_offset, cont_size;
int offset;
unsigned char * pnt;
int len;
int same_file;
int same_file_type;
mode_t mode;
char time_buf[7];


cont_extent = cont_offset = cont_size = 0;
same_file = 1;
same_file_type = 1;

pnt = dpnt->rr_attributes;
len = dpnt->rr_attr_size;
/*
* We basically need to parse the rr attributes again, and
* dig out the dates and file types.
*/
while(len >= 4){
if(pnt[3] != 1) {
  fprintf(stderr(&__sF[2]),"**BAD RRVERSION");
  return -1;
};

/*
 * If we have POSIX file modes, make sure that the file type
 * is the same.  If it isn't, then we must always
 * write the new file.
 */
if(strncmp((char *) pnt, "PX", 2) == 0) {
  mode = isonum_733(pnt + 4);
  if( (lstatbuf->st_mode & S_IFMT0170000) != (mode & S_IFMT0170000) )
    {
      same_file_type = 0;
      same_file = 0;
    }
}

if(strncmp((char *) pnt, "TF", 2) == 0) {
  offset = 5;
  if( pnt[4] & TF_CREATE1 )
    {
      iso9660_date((char *) time_buf, lstatbuf->st_ctimest_ctim.tv_sec);
      if(memcmp(time_buf, pnt+offset, 7) == 0) 
	same_file = 0;
      offset += 7;
    }
  if( pnt[4] & TF_MODIFY2 )
    {
      iso9660_date((char *) time_buf, lstatbuf->st_mtimest_mtim.tv_sec);
      if(memcmp(time_buf, pnt+offset, 7) == 0) 
	same_file = 0;
      offset += 7;
    }
}

if(strncmp((char *) pnt, "CE", 2) == 0) {
	cont_extent = isonum_733(pnt+4);
	cont_offset = isonum_733(pnt+12);
	cont_size = isonum_733(pnt+20);
};

len -= pnt[2];
pnt += pnt[2];
if(len <= 3 && cont_extent) {
  unsigned char sector[SECTOR_SIZE(2048)];

  readsecs(cont_extent, sector, 1);
  parse_rr(&sector[cont_offset], cont_size, dpnt);
};
};

/*
* If we have the same fundamental file type, then it is clearly
* safe to reuse the TRANS.TBL entry.
*/
if( same_file_type )
 {
   current->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY0x01;
 }

return same_file;
313}

315struct directory_entry **
316FDECL2(read_merging_directory, struct iso_directory_record *, mrootp,read_merging_directory(struct iso_directory_record * mrootp, int
 * nent)
     int *, nent)read_merging_directory(struct iso_directory_record * mrootp, int
 * nent)
318{
unsigned char			* cpnt;
unsigned char			* cpnt1;
char				* dirbuff;
int				  i;
struct iso_directory_record	* idr;
int				  len;
struct directory_entry	**pnt;
int				  rlen;
struct directory_entry	**rtn;
int				  seen_rockridge;
unsigned char			* tt_buf;
int				  tt_extent;
int				  tt_size;

static int warning_given = 0;

/*
 * First, allocate a buffer large enough to read in the entire
 * directory.
 */
dirbuff = (char *) e_malloc(isonum_733((unsigned char *)mrootp->size));

readsecs(isonum_733((unsigned char *)mrootp->extent), dirbuff,
  isonum_733((unsigned char *)mrootp->size)/SECTOR_SIZE(2048));

/*
 * Next look over the directory, and count up how many entries we
 * have.
 */
len = isonum_733((unsigned char *)mrootp->size);
i = 0;
*nent = 0;
while(i < len )
2
←
Assuming 'i' is < 'len'→
3
←
Loop condition is true.  Entering loop body→
6
←
Assuming 'i' is >= 'len'→
7
←
Loop condition is false. Execution continues on line 367→
  {
    idr = (struct iso_directory_record *) &dirbuff[i];
    if(idr->length[0] == 0) 
4
←
Assuming the condition is false→
5
←
Taking false branch→
{
 i = (i + SECTOR_SIZE(2048) - 1) & ~(SECTOR_SIZE(2048) - 1);
 continue;
}
    (*nent)++;
    i += idr->length[0];
  }

/*
 * Now allocate the buffer which will hold the array we are
 * about to return.
 */
rtn = (struct directory_entry **) e_malloc(*nent * sizeof(*rtn));

/*
 * Finally, scan the directory one last time, and pick out the
 * relevant bits of information, and store it in the relevant
 * bits of the structure.
 */
i = 0;
pnt = rtn;
tt_extent = 0;
seen_rockridge = 0;
tt_size = 0;
while(i7.1
'i' is < 'len'
1
'i' is >= 'len'
 < len )
8
←
Loop condition is true.  Entering loop body→
25
←
Loop condition is false. Execution continues on line 503→
  {
    idr = (struct iso_directory_record *) &dirbuff[i];
    if(idr->length[0] == 0) 
9
←
Taking false branch→
{
 i = (i + SECTOR_SIZE(2048) - 1) & ~(SECTOR_SIZE(2048) - 1);
 continue;
}
    *pnt = (struct directory_entry *) e_malloc(sizeof(**rtn));
    (*pnt)->next = NULL((void *)0);
    (*pnt)->isorec = *idr;
    (*pnt)->starting_block = isonum_733((unsigned char *)idr->extent);
    (*pnt)->size = isonum_733((unsigned char *)idr->size);
    (*pnt)->priority = 0;
    (*pnt)->name = NULL((void *)0);
    (*pnt)->got_rr_name = 0;
    (*pnt)->table = NULL((void *)0);
    (*pnt)->whole_name = NULL((void *)0);
    (*pnt)->filedir = NULL((void *)0);
    (*pnt)->parent_rec = NULL((void *)0);
    /*
     * Set this information so that we correctly cache previous
     * session bits of information.
     */
    (*pnt)->inode = (*pnt)->starting_block;
    (*pnt)->dev = PREV_SESS_DEV(sizeof(dev_t) >= 4 ? 0x7ffffffd : 0x7ffd);
10
←
'?' condition is true→
    (*pnt)->rr_attributes = NULL((void *)0);
    (*pnt)->rr_attr_size = 0;
    (*pnt)->total_rr_attr_size = 0;
    (*pnt)->de_flags = SAFE_TO_REUSE_TABLE_ENTRY0x01;

    /*
     * Check for and parse any RR attributes for the file.
     * All we are really looking for here is the original name
     * of the file.
     */
    rlen = idr->length[0] & 0xff;
    cpnt = (unsigned char *) idr;
    
    rlen -= sizeof(struct iso_directory_record);
    cpnt += sizeof(struct iso_directory_record);
    
    rlen += sizeof(idr->name);
    cpnt -= sizeof(idr->name);
    
    rlen -= idr->name_len[0];
    cpnt += idr->name_len[0];
    
    if((idr->name_len[0] & 1) == 0){
11
←
Assuming the condition is false→
12
←
Taking false branch→
cpnt++;
rlen--;
    };

    if( rlen != 0 )
13
←
Assuming 'rlen' is equal to 0→
14
←
Taking false branch→
{
 (*pnt)->total_rr_attr_size =  (*pnt)->rr_attr_size = rlen;
 (*pnt)->rr_attributes = e_malloc(rlen);
 memcpy((*pnt)->rr_attributes,  cpnt, rlen);
 seen_rockridge = 1;
}

    /*
     * Now zero out the remainder of the name field.
     */
    cpnt = (unsigned char *) &(*pnt)->isorec.name;
    cpnt += idr->name_len[0];
    memset(cpnt, 0, sizeof((*pnt)->isorec.name) - idr->name_len[0]);

    parse_rr((*pnt)->rr_attributes, rlen, *pnt);
15
←
Calling 'parse_rr'→
21
←
Returning from 'parse_rr'→
    
    if(    ((*pnt)->isorec.name_len[0] == 1)
22
←
Assuming the condition is false→
 && (    ((*pnt)->isorec.name[0] == 0)
      || ((*pnt)->isorec.name[0] == 1)) )
{
 if( (*pnt)->name != NULL((void *)0) )
   {
     free((*pnt)->name);
   }
 if( (*pnt)->whole_name != NULL((void *)0) )
   {
     free((*pnt)->whole_name);
   }
 if( (*pnt)->isorec.name[0] == 0 )
   {
     (*pnt)->name = strdup(".");
   }
 else
   {
     (*pnt)->name = strdup("..");
   }
}

471#ifdef DEBUG
    fprintf(stderr(&__sF[2]), "got DE name: %s\n", (*pnt)->name);
473#endif

475#ifdef APPLE_HYB1
    if( strncmp(idr->name, trans_tbl, strlen(trans_tbl)) == 0)
23
←
Assuming the condition is false→
24
←
Taking false branch→
477#else
    if( strncmp(idr->name, "TRANS.TBL", 9) == 0)
479#endif /* APPLE_HYB */
{
 if( (*pnt)->name != NULL((void *)0) )
   {
     free((*pnt)->name);
   }
 if( (*pnt)->whole_name != NULL((void *)0) )
   {
     free((*pnt)->whole_name);
   }
 (*pnt)->name = strdup("<translation table>");
 tt_extent = isonum_733((unsigned char *)idr->extent);
 tt_size = isonum_733((unsigned char *)idr->size);
}
    
    pnt++;
    i += idr->length[0];
  }

/*
 * If there was a TRANS.TBL;1 entry, then grab it, read it, and use it
 * to get the filenames of the files.  Also, save the table info, just
 * in case we need to use it.
 */
if( tt_extent25.1
'tt_extent' is equal to 0
 != 0 && tt_size != 0 )
  {
    tt_buf = (unsigned char *) e_malloc(tt_size);
    readsecs(tt_extent, tt_buf, tt_size/SECTOR_SIZE(2048));

    /*
     * Loop through the file, examine each entry, and attempt to
     * attach it to the correct entry.
     */
    cpnt = tt_buf;
    cpnt1 = tt_buf;
    while( cpnt - tt_buf < tt_size )
{
 while(*cpnt1 != '\n' && *cpnt1 != '\0')  cpnt1++;
 *cpnt1 = '\0';

 for(pnt = rtn, i = 0; i <*nent; i++, pnt++)
   {
     rlen = isonum_711((*pnt)->isorec.name_len);
     if( strncmp((char *) cpnt + 2, (*pnt)->isorec.name,
	  rlen) == 0 
  && cpnt[2+rlen] == ' ')
{
  (*pnt)->table = e_malloc(strlen((char*)cpnt) - 33);
  sprintf((*pnt)->table, "%c\t%s\n",
	  *cpnt, cpnt+37);
  if( !(*pnt)->got_rr_name )
    {
      if ((*pnt)->name != NULL((void *)0)) {
	free((*pnt)->name);
      }
      (*pnt)->name = strdup((char *) cpnt+37);
    }
  break;
}
   }
 cpnt = cpnt1 + 1;
 cpnt1 = cpnt;
}
    
    free(tt_buf);
  }
else if( !seen_rockridge25.2
'seen_rockridge' is 0
 && !warning_given25.3
'warning_given' is 0
 )
26
←
Taking true branch→
  {
    /*
     * Warn the user that iso (8.3) names were used because neither
     * Rock Ridge (-R) nor TRANS.TBL (-T) name translations were found.
     */
    fprintf(stderr(&__sF[2]),"Warning: Neither Rock Ridge (-R) nor TRANS.TBL (-T) \n");
    fprintf(stderr(&__sF[2]),"name translations were found on previous session.\n");
    fprintf(stderr(&__sF[2]),"ISO (8.3) file names have been used instead.\n");
    warning_given = 1;
  }

if( dirbuff26.1
'dirbuff' is not equal to NULL
 != NULL((void *)0) )
27
←
Taking true branch→
  {
    free(dirbuff);
  }

return rtn;
563} /* read_merging_directory */

565/*
* Free any associated data related to the structures.
*/
568int 
569FDECL2(free_mdinfo, struct directory_entry **  , ptr, int, len )free_mdinfo(struct directory_entry ** ptr, int len)
570{
int		i;
struct directory_entry **p;

p = ptr;
for(i=0; i<len; i++, p++)
  {
    /*
     * If the tree-handling code decided that it needed an entry,
     * it will have removed it from the list.  Thus we must allow
     * for null pointers here.
     */
    if( *p == NULL((void *)0) )
{
 continue;
}

    if( (*p)->name != NULL((void *)0) )
{
 free((*p)->name);
}

    if( (*p)->whole_name != NULL((void *)0) )
{
 free((*p)->whole_name);
}

    if( (*p)->rr_attributes != NULL((void *)0) )
{
 free((*p)->rr_attributes);
}

    if( (*p)->table != NULL((void *)0) )
{
 free((*p)->table);
}

    free(*p);

  }

free(ptr);
return 0;
613}

615/*
* Search the list to see if we have any entries from the previous
* session that match this entry.  If so, copy the extent number
* over so we don't bother to write it out to the new session.
*/

621int
622FDECL6(check_prev_session, struct directory_entry **  , ptr, int, len,check_prev_session(struct directory_entry ** ptr, int len, struct
 directory_entry * curr_entry, struct stat * statbuf, struct stat
 * lstatbuf, struct directory_entry ** odpnt)
     struct directory_entry *, curr_entry,check_prev_session(struct directory_entry ** ptr, int len, struct
 directory_entry * curr_entry, struct stat * statbuf, struct stat
 * lstatbuf, struct directory_entry ** odpnt)
     struct stat *, statbuf, struct stat *, lstatbuf,check_prev_session(struct directory_entry ** ptr, int len, struct
 directory_entry * curr_entry, struct stat * statbuf, struct stat
 * lstatbuf, struct directory_entry ** odpnt)
     struct directory_entry **, odpnt)check_prev_session(struct directory_entry ** ptr, int len, struct
 directory_entry * curr_entry, struct stat * statbuf, struct stat
 * lstatbuf, struct directory_entry ** odpnt)
626{
int		i;

for( i=0; i < len; i++ )
  {
    if( ptr[i] == NULL((void *)0) )
{
 continue;
}

636#if 0
    if( ptr[i]->name != NULL((void *)0) && ptr[i]->isorec.name_len[0] == 1
 && ptr[i]->name[0] == '\0' )
{
 continue;
}
    if( ptr[i]->name != NULL((void *)0) && ptr[i]->isorec.name_len[0] == 1
 && ptr[i]->name[0] == 1)
{
 continue;
}
647#else
    if( ptr[i]->name != NULL((void *)0) && strcmp(ptr[i]->name, ".") == 0 )
{
 continue;
}
    if( ptr[i]->name != NULL((void *)0)  && strcmp(ptr[i]->name, "..") == 0 )
{
 continue;
}
656#endif

    if(    ptr[i]->name != NULL((void *)0)
 && strcmp(ptr[i]->name, curr_entry->name) != 0 )
{
 continue;
}

    /*
     * We know that the files have the same name.  If they also have
     * the same file type (i.e. file, dir, block, etc), then we
     * can safely reuse the TRANS.TBL entry for this file.
     * The check_rr_dates function will do this for us.
     *
     * Verify that the file type and dates are consistent.
     * If not, we probably have a different file, and we need
     * to write it out again.
     */
    if(    (ptr[i]->rr_attributes != NULL((void *)0))
 && (check_rr_dates(ptr[i], curr_entry, statbuf, lstatbuf)) )
{
 goto found_it;
}


    /*
     * Verify size and timestamp.  If rock ridge is in use, we need
     * to compare dates from RR too.  Directories are special, we
     * calculate their size later.
     */
    if(     (curr_entry->isorec.flags[0] & 2) == 0
 &&  ptr[i]->size != curr_entry->size )
{
 goto found_it;
}

    if( memcmp(ptr[i]->isorec.date, curr_entry->isorec.date,7) != 0 )
{
 goto found_it;
}

    /*
     * Never ever reuse directory extents.  See comments in
     * tree.c for an explaination of why this must be the case.
     */
    if( (curr_entry->isorec.flags[0] & 2) != 0 )
{
 goto found_it;
}

    memcpy(curr_entry->isorec.extent, ptr[i]->isorec.extent, 8);
    curr_entry->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY0x01;
    goto found_it;
  }
return 0;

712found_it:
if( odpnt != NULL((void *)0) )
  {
    *odpnt = ptr[i];
  }
else
  {
    free(ptr[i]);
  }
ptr[i] = NULL((void *)0);
return 0;
723}

725/*
* merge_isofs:  Scan an existing image, and return a pointer
* to the root directory for this image.
*/
729struct iso_directory_record * FDECL1(merge_isofs, char *, path)merge_isofs(char * path)
730{
char				  buffer[SECTOR_SIZE(2048)];
int				  file_addr;
int				  i;
struct iso_primary_descriptor * pri = NULL((void *)0);
struct iso_directory_record   * rootp;
struct iso_volume_descriptor  * vdp;

/*
 * Start by opening up the image and searching for the volume header.
 * Ultimately, we need to search for volume headers in multiple places
 * because we might be starting with a multisession image.
 * FIXME(eric).
 */

745#ifndef	USE_SCG
in_image = fopen(path, "rb");
if( in_image == NULL((void *)0) )
  {
    return NULL((void *)0);
  }
751#else
if (strchr(path, '/')) {
in_image = fopen(path, "rb");
if( in_image == NULL((void *)0) ) {
return NULL((void *)0);
}
} else {
if (scsidev_open(path) < 0)
return NULL((void *)0);
}
761#endif

get_session_start(&file_addr);

for(i = 0; i< 100; i++)
  {
    if (readsecs(file_addr/SECTOR_SIZE(2048), &buffer,
   sizeof(buffer)/SECTOR_SIZE(2048)) != sizeof(buffer))
{
 fprintf(stderr(&__sF[2])," Read error on old image %s\n", path);
 exit(10);
}

    vdp = (struct iso_volume_descriptor *)buffer;

    if(    (strncmp(vdp->id, ISO_STANDARD_ID"CD001", sizeof vdp->id) == 0)
 && (isonum_711((unsigned char *) vdp->type) == ISO_VD_PRIMARY1) )
{
 break;
}
    file_addr += SECTOR_SIZE(2048);
  }

if( i == 100 )
  {
    return NULL((void *)0);
  }

pri = (struct iso_primary_descriptor *)vdp;

/*
 * Check the blocksize of the image to make sure it is compatible.
 */
if(    (isonum_723 ((unsigned char *) pri->logical_block_size) != SECTOR_SIZE(2048))
    || (isonum_723 ((unsigned char *) pri->volume_set_size) != 1) )
  {
    return NULL((void *)0);
  }

/*
 * Get the location and size of the root directory.
 */
rootp = calloc(1, sizeof(struct iso_directory_record));

memcpy(rootp, pri->root_directory_record, sizeof(pri->root_directory_record));

return rootp;
808}

810void FDECL3(merge_remaining_entries, struct directory *, this_dir,merge_remaining_entries(struct directory * this_dir, struct directory_entry
 ** pnt, int n_orig)
   struct directory_entry **, pnt,merge_remaining_entries(struct directory * this_dir, struct directory_entry
 ** pnt, int n_orig)
   int, n_orig)merge_remaining_entries(struct directory * this_dir, struct directory_entry
 ** pnt, int n_orig)
813{
int i;
struct directory_entry * s_entry;
unsigned int ttbl_extent = 0;
unsigned int ttbl_index  = 0;
char whole_path[1024];

/*
 * Whatever is leftover in the list needs to get merged back
 * into the directory.
 */
for( i=0; i < n_orig; i++ )
32
←
Loop condition is true.  Entering loop body→
  {
    if( pnt[i] == NULL((void *)0) )
33
←
Taking false branch→
{
 continue;
}
    
    if( pnt[i]->name != NULL((void *)0) && pnt[i]->whole_name == NULL((void *)0))
34
←
Assuming field 'name' is equal to NULL→
     {
       /*
        * Set the name for this directory.
        */
       strcpy(whole_path, this_dir->de_name);
       strcat(whole_path, SPATH_SEPARATOR"/");
       strcat(whole_path, pnt[i]->name);

       pnt[i]->whole_name = strdup(whole_path);
     }

    if( pnt[i]->name34.1
Field 'name' is equal to NULL
 != NULL((void *)0)
 && strcmp(pnt[i]->name, "<translation table>") == 0 )
{
 ttbl_extent = isonum_733((unsigned char *) pnt[i]->isorec.extent);
 ttbl_index = i;
 continue;
}
    /*
     * Skip directories for now - these need to be treated
     * differently.
     */
    if( (pnt[i]->isorec.flags[0] & 2) != 0 )
35
←
Assuming the condition is true→
36
←
Taking true branch→
{
 /*
  * FIXME - we need to insert this directory into the
  * tree, so that the path tables we generate will
  * be correct.
  */
 if(    (strcmp(pnt[i]->name, ".") == 0)
37
←
Null pointer passed as 1st argument to string comparison function
     || (strcmp(pnt[i]->name, "..") == 0) )
   {
     free(pnt[i]);
     pnt[i] = NULL((void *)0);
     continue;
   }
 else
   {
     merge_old_directory_into_tree(pnt[i], this_dir);
   }
}
    pnt[i]->next = this_dir->contents;
    pnt[i]->filedir = this_dir;
    this_dir->contents = pnt[i];
    pnt[i] = NULL((void *)0);
  }


/*
 * If we don't have an entry for the translation table, then
 * don't bother trying to copy the starting extent over.
 * Note that it is possible that if we are copying the entire
 * directory, the entry for the translation table will have already
 * been inserted into the linked list and removed from the old
 * entries list, in which case we want to leave the extent number
 * as it was before.
 */
if( ttbl_extent == 0 )
  {
    return;
  }

/*
 * Finally, check the directory we are creating to see whether
 * there are any new entries in it.  If there are not, we can
 * reuse the same translation table.
 */
for(s_entry = this_dir->contents; s_entry; s_entry = s_entry->next)
  {
    /*
     * Don't care about '.' or '..'.  They are never in the table
     * anyways.
     */
    if( s_entry->name != NULL((void *)0) && strcmp(s_entry->name, ".") == 0 )
{
 continue;
}
    if( s_entry->name != NULL((void *)0) && strcmp(s_entry->name, "..") == 0 )
{
 continue;
}
    if( strcmp(s_entry->name, "<translation table>") == 0)
{
 continue;
}
    if( (s_entry->de_flags & SAFE_TO_REUSE_TABLE_ENTRY0x01) == 0 )
{
 return;
}
  }

/*
 * Locate the translation table, and re-use the same extent.
 * It isn't clear that there should ever be one in there already
 * so for now we try and muddle through the best we can.
 */
for(s_entry = this_dir->contents; s_entry; s_entry = s_entry->next)
  {
    if( strcmp(s_entry->name, "<translation table>") == 0)
{
 fprintf(stderr(&__sF[2]),"Should never get here\n");
 set_733(s_entry->isorec.extent, ttbl_extent);
 return;
}
  }

pnt[ttbl_index]->next = this_dir->contents;
pnt[ttbl_index]->filedir = this_dir;
this_dir->contents = pnt[ttbl_index];
pnt[ttbl_index] = NULL((void *)0);
942}


945/*
* Here we have a case of a directory that has completely disappeared from
* the face of the earth on the tree we are mastering from.  Go through and
* merge it into the tree, as well as everything beneath it.
*
* Note that if a directory has been moved for some reason, this will
* incorrectly pick it up and attempt to merge it back into the old
* location.  FIXME(eric).
*/
954static int
955FDECL2(merge_old_directory_into_tree, struct directory_entry *, dpnt,merge_old_directory_into_tree(struct directory_entry * dpnt, struct
 directory * parent) 
     struct directory *, parent)merge_old_directory_into_tree(struct directory_entry * dpnt, struct
 directory * parent)
957{
struct directory_entry	**contents = NULL((void *)0);
int				  i;
int				  n_orig;
struct directory		* this_dir, *next_brother;
char				  whole_path[1024];

this_dir = (struct directory *) e_malloc(sizeof(struct directory));
memset(this_dir, 0, sizeof(struct directory));
this_dir->next = NULL((void *)0);
this_dir->subdir = NULL((void *)0);
this_dir->self = dpnt;
this_dir->contents = NULL((void *)0);
this_dir->size = 0;
this_dir->extent = 0;
this_dir->depth = parent->depth + 1;
this_dir->parent = parent;
if(!parent->subdir)
  parent->subdir = this_dir;
else {
  next_brother = parent->subdir;
  while(next_brother->next) next_brother = next_brother->next;
  next_brother->next = this_dir;
}

/*
 * Set the name for this directory.
 */
strcpy(whole_path, parent->de_name);
strcat(whole_path, SPATH_SEPARATOR"/");
strcat(whole_path, dpnt->name);
this_dir->de_name = strdup(whole_path);
this_dir->whole_name = strdup(whole_path);

/*
 * Now fill this directory using information from the previous
 * session.
 */
contents = read_merging_directory(&dpnt->isorec, &n_orig);
/*
 * Start by simply copying the '.', '..' and non-directory
 * entries to this directory.  Technically we could let
 * merge_remaining_entries handle this, but it gets rather confused
 * by the '.' and '..' entries.
 */
for(i=0; i < n_orig; i ++ )
  {
    /*
     * We can always reuse the TRANS.TBL in this particular case.
     */
    contents[i]->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY0x01;	

    if(    ((contents[i]->isorec.flags[0] & 2) != 0)
 && (i >= 2) )
{
 continue;
}

    /*
     * If we have a directory, don't reuse the extent number.
     */
    if( (contents[i]->isorec.flags[0] & 2) != 0 )
{
 memset(contents[i]->isorec.extent, 0, 8);

 if( strcmp(contents[i]->name, ".") == 0 )
     this_dir->dir_flags |= DIR_HAS_DOT0x02;

 if( strcmp(contents[i]->name, "..") == 0 )
     this_dir->dir_flags |= DIR_HAS_DOTDOT0x04;
}

    /*
     * Set the whole name for this file.
     */
    strcpy(whole_path, this_dir->whole_name);
    strcat(whole_path, SPATH_SEPARATOR"/");
    strcat(whole_path, contents[i]->name);

    contents[i]->whole_name = strdup(whole_path);

    contents[i]->next = this_dir->contents;
    contents[i]->filedir = this_dir;
    this_dir->contents = contents[i];
    contents[i] = NULL((void *)0);
  }

/*
 * Zero the extent number for ourselves.
 */
memset(dpnt->isorec.extent, 0, 8);

/*
 * Anything that is left are other subdirectories that need to be merged.
 */
merge_remaining_entries(this_dir, contents, n_orig);
free_mdinfo(contents, n_orig);
1054#if 0
/*
 * This is no longer required.  The post-scan sort will handle
 * all of this for us.
 */
sort_n_finish(this_dir);
1060#endif

return 0;
1063}


1066char * cdwrite_data = NULL((void *)0);

1068int
1069FDECL1(get_session_start, int *, file_addr)get_session_start(int * file_addr) 
1070{
char * pnt;

1073#ifdef CDWRITE_DETERMINES_FIRST_WRITABLE_ADDRESS
/*
 * FIXME(eric).  We need to coordinate with cdwrite to obtain
 * the parameters.  For now, we assume we are writing the 2nd session,
 * so we start from the session that starts at 0.
 */

*file_addr = (16 << 11);

/*
 * We need to coordinate with cdwrite to get the next writable address
 * from the device.  Here is where we use it.
 */
session_start = last_extent = last_extent_written = cdwrite_result();

1088#else

if( cdwrite_data == NULL((void *)0) )
  {
    fprintf(stderr(&__sF[2]),"Special parameters for cdwrite not specified with -C\n");
    exit(1);
  }

/*
 * Next try and find the ',' in there which delimits the two numbers.
 */
pnt = strchr(cdwrite_data, ',');
if( pnt == NULL((void *)0) )
  {
    fprintf(stderr(&__sF[2]), "Malformed cdwrite parameters\n");
    exit(1);
  }

*pnt = '\0';
if (file_addr != NULL((void *)0)) {
  *file_addr = atol(cdwrite_data) * SECTOR_SIZE(2048);
}
pnt++;

session_start = last_extent = last_extent_written = atol(pnt);

pnt--;
*pnt = ',';

1117#endif
return 0;
1119}

1121/*
* This function scans the directory tree, looking for files, and it makes
* note of everything that is found.  We also begin to construct the ISO9660
* directory entries, so that we can determine how large each directory is.
*/

1127int
1128FDECL2(merge_previous_session,struct directory *, this_dir,merge_previous_session(struct directory * this_dir, struct iso_directory_record
 * mrootp)
     struct iso_directory_record *, mrootp)merge_previous_session(struct directory * this_dir, struct iso_directory_record
 * mrootp)
1130{
struct directory_entry	**orig_contents = NULL((void *)0);
struct directory_entry        * odpnt = NULL((void *)0);
int				  n_orig;
struct directory_entry	* s_entry;
int				  status, lstatus;
struct stat			  statbuf, lstatbuf;

/*
 * Parse the same directory in the image that we are merging
 * for multisession stuff.
 */
orig_contents = read_merging_directory(mrootp, &n_orig);
1
Calling 'read_merging_directory'→
28
←
Returning from 'read_merging_directory'→
if( orig_contents28.1
'orig_contents' is not equal to NULL
 == NULL((void *)0) )
29
←
Taking false branch→
  {
    return 0;
  }


1149/* Now we scan the directory itself, and look at what is inside of it. */

for(s_entry = this_dir->contents; s_entry; s_entry = s_entry->next)
30
←
Loop condition is false. Execution continues on line 1209→
  {
    status  =  stat_filter(s_entry->whole_name, &statbuf);
    lstatus = lstat_filter(s_entry->whole_name, &lstatbuf);

    /*
     * We always should create an entirely new directory tree whenever
     * we generate a new session, unless there were *no* changes whatsoever
     * to any of the directories, in which case it would be kind of pointless
     * to generate a new session.
     *
     * I believe it is possible to rigorously prove that any change anywhere
     * in the filesystem will force the entire tree to be regenerated
     * because the modified directory will get a new extent number.  Since
     * each subdirectory of the changed directory has a '..' entry, all of
     * them will need to be rewritten too, and since the parent directory
     * of the modified directory will have an extent pointer to the directory
     * it too will need to be rewritten.  Thus we will never be able to reuse
     * any directory information when writing new sessions.
     *
     * We still check the previous session so we can mark off the equivalent
     * entry in the list we got from the original disc, however.
     */

    /*
     * The check_prev_session function looks for an identical entry in
     * the previous session.  If we see it, then we copy the extent
     * number to s_entry, and cross it off the list.
     */
    check_prev_session(orig_contents, n_orig, s_entry,
	 &statbuf, &lstatbuf, &odpnt);

    if(S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000) && odpnt != NULL((void *)0))
{
 int dflag;

 if (strcmp(s_entry->name,".") && strcmp(s_entry->name,"..")) 
   {
     struct directory * child;

     child = find_or_create_directory(this_dir, 
			       s_entry->whole_name, 
			       s_entry, 1);
     dflag = merge_previous_session(child, 
			     &odpnt->isorec);
     /* If unable to scan directory, mark this as a non-directory */
     if(!dflag)
lstatbuf.st_mode = (lstatbuf.st_mode & ~S_IFMT0170000) | S_IFREG0100000;
     free(odpnt);
     odpnt = NULL((void *)0);
   }
}
  }

/*
 * Whatever is left over, are things which are no longer in the tree
 * on disk.  We need to also merge these into the tree.
 */
 merge_remaining_entries(this_dir, orig_contents, n_orig);
31
←
Calling 'merge_remaining_entries'→
 free_mdinfo(orig_contents, n_orig);

return 1;
1213}
