/usr/src/sbin/restore/dirs.c

Bug Summary

File:	src/sbin/restore/dirs.c
Warning:	line 545, column 26 The right operand of '-' is a garbage value

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 dirs.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/sbin/restore/obj -resource-dir /usr/local/lib/clang/13.0.0 -D RRESTORE -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/restore/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/sbin/restore/dirs.c

1/*	$OpenBSD: dirs.c,v 1.42 2019/06/28 13:32:46 deraadt Exp $	*/
2/*	$NetBSD: dirs.c,v 1.26 1997/07/01 05:37:49 lukem Exp $	*/

4/*
* Copyright (c) 1983, 1993
*	The Regents of the University of California.  All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

38#include <sys/stat.h>
39#include <sys/time.h>

41#include <ufs/ffs/fs.h>
42#include <ufs/ufs/dinode.h>
43#include <ufs/ufs/dir.h>
44#include <protocols/dumprestore.h>

46#include <endian.h>
47#include <err.h>
48#include <errno(*__errno()).h>
49#include <fcntl.h>
50#include <paths.h>
51#include <stdio.h>
52#include <stdlib.h>
53#include <string.h>
54#include <unistd.h>
55#include <limits.h>

57#include "restore.h"
58#include "extern.h"

60/*
* Symbol table of directories read from tape.
*/
63#define HASHSIZE1000	1000
64#define INOHASH(val)(val % 1000) (val % HASHSIZE1000)
65struct inotab {
struct	inotab *t_next;
ino_t	t_ino;
int32_t	t_seekpt;
int32_t	t_size;
70};
71static struct inotab *inotab[HASHSIZE1000];

73/*
* Information retained about directories.
*/
76struct modeinfo {
ino_t ino;
struct timespec ctimep[2];
struct timespec mtimep[2];
mode_t mode;
uid_t uid;
gid_t gid;
u_int flags;
84};

86/*
* Definitions for library routines operating on directories.
*/
89#undef DIRBLKSIZ1024
90#define DIRBLKSIZ1024 1024
91struct rstdirdesc {
int	dd_fd;
int32_t	dd_loc;
int32_t	dd_size;
char	dd_buf[DIRBLKSIZ1024];
96};

98/*
* Global variables for this file.
*/
101static long	seekpt;
102static FILE	*df, *mf;
103static RST_DIR	*dirp;
104static char	dirfile[PATH_MAX1024] = "#";	/* No file */
105static char	modefile[PATH_MAX1024] = "#";	/* No file */
106static char	dot[2] = ".";			/* So it can be modified */

108/*
* Format of old style directories.
*/
111#define ODIRSIZ14 14
112struct odirect {
u_short	d_ino;
char	d_name[ODIRSIZ14];
115};

117static struct inotab	*allocinotab(FILE *, struct context *, long);
118static void		 dcvt(struct odirect *, struct direct *);
119static void		 flushent(void);
120static struct inotab	*inotablookup(ino_t);
121static RST_DIR		*opendirfile(const char *);
122static void		 putdir(char *, size_t);
123static void		 putent(struct direct *);
124static void		 rst_seekdir(RST_DIR *, long, long);
125static long		 rst_telldir(RST_DIR *);
126static struct direct	*searchdir(ino_t, char *);

128/*
*	Extract directory contents, building up a directory structure
*	on disk for extraction by name.
*	If genmode is requested, save mode, owner, and times for all
*	directories on the tape.
*/
134void
135extractdirs(int genmode)
136{
int i;
struct inotab *itp;
struct direct nulldir;
int fd;

Vprintfif (vflag) fprintf(stdout(&__sF[1]), "Extract directories from tape\n");
(void)snprintf(dirfile, sizeof(dirfile), "%s/rstdir%lld", tmpdir,
   (long long)dumpdate);
if (command != 'r' && command != 'R') {
strlcat(dirfile, "-XXXXXXXXXX", sizeof(dirfile));
fd = mkstemp(dirfile);
} else
fd = open(dirfile, O_RDWR0x0002|O_CREAT0x0200|O_EXCL0x0800, 0666);
if (fd == -1 || (df = fdopen(fd, "w")) == NULL((void *)0)) {
int saved_errno = errno(*__errno());
if (fd != -1)
	close(fd);
errc(1, saved_errno,
    "cannot create directory temporary %s", dirfile);
}
if (genmode != 0) {
(void)snprintf(modefile, sizeof(modefile), "%s/rstmode%lld",
    tmpdir, (long long)dumpdate);
if (command != 'r' && command != 'R') {
	strlcat(modefile, "-XXXXXXXXXX", sizeof(modefile));
	fd = mkstemp(modefile);
} else
	fd = open(modefile, O_RDWR0x0002|O_CREAT0x0200|O_EXCL0x0800, 0666);
if (fd == -1 || (mf = fdopen(fd, "w")) == NULL((void *)0)) {
	int saved_errno = errno(*__errno());
	if (fd != -1)
		close(fd);
	errc(1, saved_errno,
	    "cannot create modefile %s", modefile);
}
}
nulldir.d_ino = 0;
nulldir.d_type = DT_DIR4;
nulldir.d_namlen = 1;
nulldir.d_name[0] = '/';
nulldir.d_name[1] = '\0';
nulldir.d_reclen = DIRSIZ(0, &nulldir)((0) ? ((sizeof(struct direct) - (255 +1)) + (((&nulldir)
->d_type+1 + 3) &~ 3)) : ((sizeof(struct direct) - (255
 +1)) + (((&nulldir)->d_namlen+1 + 3) &~ 3)));
for (;;) {
curfile.name = "<directory file - name unknown>";
curfile.action = USING1;
if (curfile.mode == 0 || (curfile.mode & IFMT0170000) != IFDIR0040000) {
	(void)fclose(df);
	dirp = opendirfile(dirfile);
	if (dirp == NULL((void *)0))
		warn("opendirfile");
	if (mf != NULL((void *)0))
		(void)fclose(mf);
	i = dirlookup(dot);
	if (i == 0)
		panic("Root directory is not on tape\n");
	return;
}
itp = allocinotab(mf, &curfile, seekpt);
getfile(putdir, xtrnull);
putent(&nulldir);
flushent();
itp->t_size = seekpt - itp->t_seekpt;
}
200}

202/*
* skip over all the directories on the tape
*/
205void
206skipdirs(void)
207{

while (curfile.ino && (curfile.mode & IFMT0170000) == IFDIR0040000) {
skipfile();
}
212}

214/*
*	Recursively find names and inumbers of all files in subtree
*	pname and pass them off to be processed.
*/
218void
219treescan(char *pname, ino_t ino, long (*todo)(char *, ino_t, int))
220{
struct inotab *itp;
struct direct *dp;
size_t namelen;
long bpt;
char locname[PATH_MAX1024 + 1];

itp = inotablookup(ino);
if (itp == NULL((void *)0)) {
/*
 * Pname is name of a simple file or an unchanged directory.
 */
(void)(*todo)(pname, ino, LEAF1);
return;
}
/*
* Pname is a dumped directory name.
*/
if ((*todo)(pname, ino, NODE2) == FAIL0)
return;
/*
* begin search through the directory
* skipping over "." and ".."
*/
namelen = strlcpy(locname, pname, sizeof(locname));
if (namelen >= sizeof(locname) - 1)
namelen = sizeof(locname) - 2;
locname[namelen++] = '/';
locname[namelen] = '\0';
rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
dp = rst_readdir(dirp); /* "." */
if (dp != NULL((void *)0) && strcmp(dp->d_name, ".") == 0)
dp = rst_readdir(dirp); /* ".." */
else
fprintf(stderr(&__sF[2]), "Warning: `.' missing from directory %s\n",
	pname);
if (dp != NULL((void *)0) && strcmp(dp->d_name, "..") == 0)
dp = rst_readdir(dirp); /* first real entry */
else
fprintf(stderr(&__sF[2]), "Warning: `..' missing from directory %s\n",
	pname);
bpt = rst_telldir(dirp);
/*
* a zero inode signals end of directory
*/
while (dp != NULL((void *)0)) {
locname[namelen] = '\0';
if (namelen + dp->d_namlen >= sizeof(locname)) {
	fprintf(stderr(&__sF[2]), "%s%s: name exceeds %zd char\n",
		locname, dp->d_name, sizeof(locname) - 1);
} else {
	(void)strlcat(locname, dp->d_name, sizeof(locname));
	treescan(locname, dp->d_ino, todo);
	rst_seekdir(dirp, bpt, itp->t_seekpt);
}
dp = rst_readdir(dirp);
bpt = rst_telldir(dirp);
}
278}

280/*
* Lookup a pathname which is always assumed to start from the ROOTINO.
*/
283struct direct *
284pathsearch(const char *pathname)
285{
ino_t ino;
struct direct *dp;
char *path, *name, buffer[PATH_MAX1024];

strlcpy(buffer, pathname, sizeof buffer);
path = buffer;
ino = ROOTINO((ufsino_t)2);
while (*path == '/')
path++;
dp = NULL((void *)0);
while ((name = strsep(&path, "/")) != NULL((void *)0) && *name != '\0') {
if ((dp = searchdir(ino, name)) == NULL((void *)0))
	return (NULL((void *)0));
ino = dp->d_ino;
}
return (dp);
302}

304/*
* Lookup the requested name in directory inum.
* Return its inode number if found, zero if it does not exist.
*/
308static struct direct *
309searchdir(ino_t inum, char *name)
310{
struct direct *dp;
struct inotab *itp;
int len;

itp = inotablookup(inum);
if (itp == NULL((void *)0))
return (NULL((void *)0));
rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
len = strlen(name);
do {
dp = rst_readdir(dirp);
if (dp == NULL((void *)0))
	return (NULL((void *)0));
} while (dp->d_namlen != len || strncmp(dp->d_name, name, len) != 0);
return (dp);
326}

328/*
* Put the directory entries in the directory file
*/
331static void
332putdir(char *buf, size_t size)
333{
struct direct cvtbuf;
struct odirect *odp;
struct odirect *eodp;
struct direct *dp;
size_t loc, i;

if (cvtflag) {
eodp = (struct odirect *)&buf[size];
for (odp = (struct odirect *)buf; odp < eodp; odp++)
	if (odp->d_ino != 0) {
		dcvt(odp, &cvtbuf);
		putent(&cvtbuf);
	}
} else {
for (loc = 0; loc < size; ) {
	dp = (struct direct *)(buf + loc);
	if (Bcvt) {
		dp->d_ino = swap32(dp->d_ino)(__uint32_t)(__builtin_constant_p(dp->d_ino) ? (__uint32_t
)(((__uint32_t)(dp->d_ino) & 0xff) << 24 | ((__uint32_t
)(dp->d_ino) & 0xff00) << 8 | ((__uint32_t)(dp->
d_ino) & 0xff0000) >> 8 | ((__uint32_t)(dp->d_ino
) & 0xff000000) >> 24) : __swap32md(dp->d_ino));
		dp->d_reclen = swap16(dp->d_reclen)(__uint16_t)(__builtin_constant_p(dp->d_reclen) ? (__uint16_t
)(((__uint16_t)(dp->d_reclen) & 0xffU) << 8 | ((
__uint16_t)(dp->d_reclen) & 0xff00U) >> 8) : __swap16md
(dp->d_reclen));
	}
	if (oldinofmt && dp->d_ino != 0) {
355#				if BYTE_ORDER1234 == BIG_ENDIAN4321
			if (Bcvt)
				dp->d_namlen = dp->d_type;
358#				else
			if (!Bcvt)
				dp->d_namlen = dp->d_type;
361#				endif
		dp->d_type = DT_UNKNOWN0;
	}
	i = DIRBLKSIZ1024 - (loc & (DIRBLKSIZ1024 - 1));
	if ((dp->d_reclen & 0x3) != 0 ||
	    dp->d_reclen > i ||
	    dp->d_reclen < DIRSIZ(0, dp)((0) ? ((sizeof(struct direct) - (255 +1)) + (((dp)->d_type
+1 + 3) &~ 3)) : ((sizeof(struct direct) - (255 +1)) + ((
(dp)->d_namlen+1 + 3) &~ 3))) ||
	    dp->d_namlen > NAME_MAX255) {
		Vprintfif (vflag) fprintf(stdout(&__sF[1]), "Mangled directory: ");
		if ((dp->d_reclen & 0x3) != 0)
			Vprintfif (vflag) fprintf(stdout(&__sF[1]),
			   "reclen not multiple of 4 ");
		if (dp->d_reclen < DIRSIZ(0, dp)((0) ? ((sizeof(struct direct) - (255 +1)) + (((dp)->d_type
+1 + 3) &~ 3)) : ((sizeof(struct direct) - (255 +1)) + ((
(dp)->d_namlen+1 + 3) &~ 3))))
			Vprintfif (vflag) fprintf(stdout(&__sF[1]),
			   "reclen less than DIRSIZ (%u < %u) ",
			   (unsigned)dp->d_reclen,
			   (unsigned)DIRSIZ(0, dp)((0) ? ((sizeof(struct direct) - (255 +1)) + (((dp)->d_type
+1 + 3) &~ 3)) : ((sizeof(struct direct) - (255 +1)) + ((
(dp)->d_namlen+1 + 3) &~ 3))));
		if (dp->d_namlen > NAME_MAX255)
			Vprintfif (vflag) fprintf(stdout(&__sF[1]),
			   "reclen name too big (%u > %u) ",
			   (unsigned)dp->d_namlen, NAME_MAX255);
		Vprintfif (vflag) fprintf(stdout(&__sF[1]), "\n");
		loc += i;
		continue;
	}
	loc += dp->d_reclen;
	if (dp->d_ino != 0) {
		putent(dp);
	}
}
}
392}

394/*
* These variables are "local" to the following two functions.
*/
397char dirbuf[DIRBLKSIZ1024];
398long dirloc = 0;
399long prev = 0;

401/*
* add a new directory entry to a file.
*/
404static void
405putent(struct direct *dp)
406{
dp->d_reclen = DIRSIZ(0, dp)((0) ? ((sizeof(struct direct) - (255 +1)) + (((dp)->d_type
+1 + 3) &~ 3)) : ((sizeof(struct direct) - (255 +1)) + ((
(dp)->d_namlen+1 + 3) &~ 3)));
if (dirloc + dp->d_reclen > DIRBLKSIZ1024) {
((struct direct *)(dirbuf + prev))->d_reclen =
    DIRBLKSIZ1024 - prev;
(void)fwrite(dirbuf, 1, DIRBLKSIZ1024, df);
dirloc = 0;
}
memcpy(dirbuf + dirloc, dp, dp->d_reclen);
prev = dirloc;
dirloc += dp->d_reclen;
417}

419/*
* flush out a directory that is finished.
*/
422static void
423flushent(void)
424{
((struct direct *)(dirbuf + prev))->d_reclen = DIRBLKSIZ1024 - prev;
(void)fwrite(dirbuf, dirloc, 1, df);
seekpt = ftell(df);
dirloc = 0;
429}

431static void
432dcvt(struct odirect *odp, struct direct *ndp)
433{

memset(ndp, 0, sizeof *ndp);
if (Bcvt)
   ndp->d_ino = swap16(odp->d_ino)(__uint16_t)(__builtin_constant_p(odp->d_ino) ? (__uint16_t
)(((__uint16_t)(odp->d_ino) & 0xffU) << 8 | ((__uint16_t
)(odp->d_ino) & 0xff00U) >> 8) : __swap16md(odp->
d_ino));
else
   ndp->d_ino = odp->d_ino;
ndp->d_type = DT_UNKNOWN0;
(void)strncpy(ndp->d_name, odp->d_name, ODIRSIZ14);
ndp->d_namlen = strlen(ndp->d_name);
ndp->d_reclen = DIRSIZ(0, ndp)((0) ? ((sizeof(struct direct) - (255 +1)) + (((ndp)->d_type
+1 + 3) &~ 3)) : ((sizeof(struct direct) - (255 +1)) + ((
(ndp)->d_namlen+1 + 3) &~ 3)));
444}

446/*
* Seek to an entry in a directory.
* Only values returned by rst_telldir should be passed to rst_seekdir.
* This routine handles many directories in a single file.
* It takes the base of the directory in the file, plus
* the desired seek offset into it.
*/
453static void
454rst_seekdir(RST_DIR *dirp, long loc, long base)
455{

if (loc == rst_telldir(dirp))
12
←
Calling 'rst_telldir'→
return;
loc -= base;
if (loc < 0)
fprintf(stderr(&__sF[2]), "bad seek pointer to rst_seekdir %ld\n", loc);
(void)lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ1024 - 1)), SEEK_SET0);
dirp->dd_loc = loc & (DIRBLKSIZ1024 - 1);
if (dirp->dd_loc != 0)
dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ1024);
466}

468/*
* get next entry in a directory.
*/
471struct direct *
472rst_readdir(RST_DIR *dirp)
473{
struct direct *dp;

for (;;) {
if (dirp->dd_loc == 0) {
	dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
	    DIRBLKSIZ1024);
	if (dirp->dd_size <= 0) {
		Dprintfif (dflag) fprintf(stderr(&__sF[2]), "error reading directory\n");
		return (NULL((void *)0));
	}
}
if (dirp->dd_loc >= dirp->dd_size) {
	dirp->dd_loc = 0;
	continue;
}
dp = (struct direct *)(dirp->dd_buf + dirp->dd_loc);
if (dp->d_reclen == 0 ||
    dp->d_reclen > DIRBLKSIZ1024 + 1 - dirp->dd_loc) {
	Dprintfif (dflag) fprintf(stderr(&__sF[2]), "corrupted directory: bad reclen %d\n",
		dp->d_reclen);
	return (NULL((void *)0));
}
dirp->dd_loc += dp->d_reclen;
if (dp->d_ino == 0 && strcmp(dp->d_name, "/") == 0)
	return (NULL((void *)0));
if (dp->d_ino >= maxino) {
	Dprintfif (dflag) fprintf(stderr(&__sF[2]), "corrupted directory: bad inum %llu\n",
	    (unsigned long long)dp->d_ino);
	continue;
}
return (dp);
}
506}

508/*
* Simulate the opening of a directory
*/
511RST_DIR *
512rst_opendir(const char *name)
513{
struct inotab *itp;
RST_DIR *dirp;
ino_t ino;

if ((ino = dirlookup(name)) > 0 &&
1
Assuming the condition is true→
3
←
Taking true branch→
   (itp = inotablookup(ino)) != NULL((void *)0)) {
2
←
Assuming the condition is true→
dirp = opendirfile(dirfile);
4
←
Calling 'opendirfile'→
10
←
Returning from 'opendirfile'→
rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
11
←
Calling 'rst_seekdir'→
return (dirp);
}
return (NULL((void *)0));
525}

527/*
* In our case, there is nothing to do when closing a directory.
*/
530void
531rst_closedir(RST_DIR *dirp)
532{
(void)close(dirp->dd_fd);
free(dirp);
return;
536}

538/*
* Simulate finding the current offset in the directory.
*/
541static long
542rst_telldir(RST_DIR *dirp)
543{
return ((long)lseek(dirp->dd_fd,
   (off_t)0, SEEK_CUR1) - dirp->dd_size + dirp->dd_loc);
13
←
The right operand of '-' is a garbage value
546}

548/*
* Open a directory file.
*/
551static RST_DIR *
552opendirfile(const char *name)
553{
RST_DIR *dirp;
int fd;

if ((fd = open(name, O_RDONLY0x0000)) == -1)
5
←
Assuming the condition is false→
6
←
Taking false branch→
return (NULL((void *)0));
if ((dirp = malloc(sizeof(RST_DIR))) == NULL((void *)0)) {
7
←
Uninitialized value stored to field 'dd_size'→
8
←
Assuming the condition is false→
9
←
Taking false branch→
(void)close(fd);
return (NULL((void *)0));
}
dirp->dd_fd = fd;
dirp->dd_loc = 0;
return (dirp);
566}

568/*
* Set the mode, owner, and times for all new or changed directories
*/
571void
572setdirmodes(int flags)
573{
FILE *mf;
struct modeinfo node;
struct entry *ep;
char *cp;

Vprintfif (vflag) fprintf(stdout(&__sF[1]), "Set directory mode, owner, and times.\n");
if (command == 'r' || command == 'R')
(void)snprintf(modefile, sizeof(modefile), "%s/rstmode%lld",
    tmpdir, (long long)dumpdate);
if (modefile[0] == '#') {
panic("modefile not defined\n");
fputs("directory mode, owner, and times not set\n", stderr(&__sF[2]));
return;
}
mf = fopen(modefile, "r");
if (mf == NULL((void *)0)) {
warn("fopen");
fprintf(stderr(&__sF[2]), "cannot open mode file %s\n", modefile);
fprintf(stderr(&__sF[2]), "directory mode, owner, and times not set\n");
return;
}
clearerr(mf)(!__isthreaded ? ((void)((mf)->_flags &= ~(0x0040|0x0020
))) : (clearerr)(mf));
for (;;) {
(void)fread((char *)&node, 1, sizeof(struct modeinfo), mf);
if (feof(mf)(!__isthreaded ? (((mf)->_flags & 0x0020) != 0) : (feof
)(mf)))
	break;
ep = lookupino(node.ino);
if (command == 'i' || command == 'x') {
	if (ep == NULL((void *)0))
		continue;
	if ((flags & FORCE0x0001) == 0 && ep->e_flags & EXISTED0x0040) {
		ep->e_flags &= ~NEW0x0002;
		continue;
	}
	if (node.ino == ROOTINO((ufsino_t)2) &&
   	    reply("set owner/mode for '.'") == FAIL0)
		continue;
}
if (ep == NULL((void *)0)) {
	panic("cannot find directory inode %llu\n",
	    (unsigned long long)node.ino);
} else {
	if (!Nflag) {
		cp = myname(ep);
		(void)chown(cp, node.uid, node.gid);
		(void)chmod(cp, node.mode);
		(void)chflags(cp, node.flags);
		(void)utimensat(AT_FDCWD-100, cp, node.ctimep, 0);
		(void)utimensat(AT_FDCWD-100, cp, node.mtimep, 0);
	}
	ep->e_flags &= ~NEW0x0002;
}
}
if (ferror(mf)(!__isthreaded ? (((mf)->_flags & 0x0040) != 0) : (ferror
)(mf)))
panic("error setting directory modes\n");
(void)fclose(mf);
630}

632/*
* Generate a literal copy of a directory.
*/
635int
636genliteraldir(char *name, ino_t ino)
637{
struct inotab *itp;
int ofile, dp, i, size;
char buf[BUFSIZ1024];

itp = inotablookup(ino);
if (itp == NULL((void *)0))
panic("Cannot find directory inode %llu named %s\n",
    (unsigned long long)ino, name);
if ((ofile = open(name, O_WRONLY0x0001 | O_CREAT0x0200 | O_TRUNC0x0400, 0666)) == -1) {
warn("%s: cannot create file", name);
return (FAIL0);
}
rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
dp = dup(dirp->dd_fd);
for (i = itp->t_size; i > 0; i -= BUFSIZ1024) {
size = i < BUFSIZ1024 ? i : BUFSIZ1024;
if (read(dp, buf, size) == -1)
	err(1, "read error extracting inode %llu, name %s",
	    (unsigned long long)curfile.ino, curfile.name);
xtrfile(buf, size);
}
(void)close(dp);
(void)close(ofile);
return (GOOD1);
662}

664/*
* Determine the type of an inode
*/
667int
668inodetype(ino_t ino)
669{
struct inotab *itp;

itp = inotablookup(ino);
if (itp == NULL((void *)0))
return (LEAF1);
return (NODE2);
676}

678/*
* Allocate and initialize a directory inode entry.
* If requested, save its pertinent mode, owner, and time info.
*/
682static struct inotab *
683allocinotab(FILE *mf, struct context *ctxp, long seekpt)
684{
struct inotab	*itp;
struct modeinfo node;

itp = calloc(1, sizeof(struct inotab));
if (itp == NULL((void *)0))
panic("no memory directory table\n");
itp->t_next = inotab[INOHASH(ctxp->ino)(ctxp->ino % 1000)];
inotab[INOHASH(ctxp->ino)(ctxp->ino % 1000)] = itp;
itp->t_ino = ctxp->ino;
itp->t_seekpt = seekpt;
if (mf == NULL((void *)0))
return (itp);
node.ino = ctxp->ino;
node.mtimep[0].tv_sec = ctxp->atime_sec;
node.mtimep[0].tv_nsec = ctxp->atime_nsec;
node.mtimep[1].tv_sec = ctxp->mtime_sec;
node.mtimep[1].tv_nsec = ctxp->mtime_nsec;
node.ctimep[0].tv_sec = ctxp->atime_sec;
node.ctimep[0].tv_nsec = ctxp->atime_nsec;
node.ctimep[1].tv_sec = ctxp->birthtime_sec;
node.ctimep[1].tv_nsec = ctxp->birthtime_nsec;
node.mode = ctxp->mode;
node.flags = ctxp->file_flags;
node.uid = ctxp->uid;
node.gid = ctxp->gid;
(void)fwrite((char *)&node, 1, sizeof(struct modeinfo), mf);
return (itp);
712}

714/*
* Look up an inode in the table of directories
*/
717static struct inotab *
718inotablookup(ino_t ino)
719{
struct inotab *itp;

for (itp = inotab[INOHASH(ino)(ino % 1000)]; itp != NULL((void *)0); itp = itp->t_next)
if (itp->t_ino == ino)
	return (itp);
return (NULL((void *)0));
726}

728/*
* Clean up and exit
*/
731void
732cleanup(void)
733{

closemt();
if (modefile[0] != '#')
(void)unlink(modefile);
if (dirfile[0] != '#')
(void)unlink(dirfile);
740}