Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	sbin/ncheck_ffs/ncheck_ffs.c	Lines:	0	295	0.0 %
Date:	2017-11-07	Branches:	0	255	0.0 %


/*	$OpenBSD: ncheck_ffs.c,v 1.53 2016/05/28 23:46:06 tb Exp $	*/

/*-
 * Copyright (c) 1995, 1996 SigmaSoft, Th. Lockert <tholo@sigmasoft.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED ``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 AUTHOR 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.
 */

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

#include <sys/param.h>	/* MAXBSIZE DEV_BSIZE */
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include <sys/dkio.h>
#include <ufs/ffs/fs.h>
#include <ufs/ufs/dir.h>
#include <ufs/ufs/dinode.h>

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <limits.h>
#include <fstab.h>
#include <errno.h>
#include <err.h>
#include <util.h>

#define DIP(dp, field) \
    ((sblock->fs_magic == FS_UFS1_MAGIC) ? \
    ((struct ufs1_dinode *)(dp))->field : \
    ((struct ufs2_dinode *)(dp))->field)

char	*disk;		/* name of the disk file */
char	rdisk[PATH_MAX];/* resolved name of the disk file */
int	diskfd;		/* disk file descriptor */
struct	fs *sblock;	/* the file system super block */
char	sblock_buf[MAXBSIZE];
int	sblock_try[] = SBLOCKSEARCH; /* possible superblock locations */
ufsino_t *ilist;	/* list of inodes to check */
int	ninodes;	/* number of inodes in list */
int	sflag;		/* only suid and special files */
int	aflag;		/* print the . and .. entries too */
int	mflag;		/* verbose output */
int	iflag;		/* specific inode */
char	*format;	/* output format */

struct disklabel lab;

struct icache_s {
	ufsino_t	ino;
	union {
		struct ufs1_dinode dp1;
		struct ufs2_dinode dp2;
	} di;
} *icache;
int	nicache;
int	maxicache;

void addinode(ufsino_t inum);
void *getino(ufsino_t inum);
void findinodes(ufsino_t);
void bread(daddr_t, char *, int);
__dead void usage(void);
void scanonedir(ufsino_t, const char *);
void dirindir(ufsino_t, daddr_t, int, off_t *, const char *);
void searchdir(ufsino_t, daddr_t, long, off_t, const char *);
int matchino(const void *, const void *);
int matchcache(const void *, const void *);
void cacheino(ufsino_t, void *);
void *cached(ufsino_t);
int main(int, char *[]);
char *rawname(char *);
void format_entry(const char *, struct direct *);

/*
 * Check to see if the indicated inodes are the same
 */
int
matchino(const void *key, const void *val)
{
	ufsino_t k = *(ufsino_t *)key;
	ufsino_t v = *(ufsino_t *)val;

	if (k < v)
		return -1;
	else if (k > v)
		return 1;
	return 0;
}

/*
 * Check if the indicated inode match the entry in the cache
 */
int
matchcache(const void *key, const void *val)
{
	ufsino_t	ino = *(ufsino_t *)key;
	struct icache_s	*ic = (struct icache_s *)val;

	if (ino < ic->ino)
		return -1;
	else if (ino > ic->ino)
		return 1;
	return 0;
}

/*
 * Add an inode to the cached entries
 */
void
cacheino(ufsino_t ino, void *dp)
{
	if (nicache == maxicache) {
		struct icache_s *newicache;

		/* grow exponentially */
		maxicache += 10 + maxicache/2;
		newicache = reallocarray(icache, maxicache, sizeof(*icache));
		if (newicache == NULL)
			errx(1, "malloc");
		icache = newicache;

	}
	icache[nicache].ino = ino;
	if (sblock->fs_magic == FS_UFS1_MAGIC)
		icache[nicache++].di.dp1 = *(struct ufs1_dinode *)dp;
	else
		icache[nicache++].di.dp2 = *(struct ufs2_dinode *)dp;
}

/*
 * Get a cached inode
 */
void *
cached(ufsino_t ino)
{
	struct icache_s *ic;
	void *dp = NULL;

	ic = bsearch(&ino, icache, nicache, sizeof(*icache), matchcache);
	if (ic != NULL) {
		if (sblock->fs_magic == FS_UFS1_MAGIC)
			dp = &ic->di.dp1;
		else
			dp = &ic->di.dp2;
	}
	return (dp);
}

/*
 * Walk the inode list for a filesystem to find all allocated inodes
 * Remember inodes we want to give information about and cache all
 * inodes pointing to directories
 */
void
findinodes(ufsino_t maxino)
{
	ufsino_t ino;
	void *dp;
	mode_t mode;

	for (ino = ROOTINO; ino < maxino; ino++) {
		dp = getino(ino);
		mode = DIP(dp, di_mode) & IFMT;
		if (!mode)
			continue;
		if (mode == IFDIR)
			cacheino(ino, dp);
		if (iflag ||
		    (sflag && (mode == IFDIR ||
		     ((DIP(dp, di_mode) & (ISGID | ISUID)) == 0 &&
		      (mode == IFREG || mode == IFLNK)))))
			continue;
		addinode(ino);
	}
}

/*
 * Get a specified inode from disk.  Attempt to minimize reads to once
 * per cylinder group
 */
void *
getino(ufsino_t inum)
{
	static char *itab = NULL;
	static daddr_t iblk = -1;
	void *dp;
	size_t dsize;

	if (inum < ROOTINO || inum >= sblock->fs_ncg * sblock->fs_ipg)
		return NULL;
	if ((dp = cached(inum)) != NULL)
		return dp;
	if (sblock->fs_magic == FS_UFS1_MAGIC)
		dsize = sizeof(struct ufs1_dinode);
	else
		dsize = sizeof(struct ufs2_dinode);
	if ((inum / sblock->fs_ipg) != iblk || itab == NULL) {
		iblk = inum / sblock->fs_ipg;
		if (itab == NULL &&
		    (itab = reallocarray(NULL, sblock->fs_ipg, dsize)) == NULL)
			errx(1, "no memory for inodes");
		bread(fsbtodb(sblock, cgimin(sblock, iblk)), itab,
		      sblock->fs_ipg * dsize);
	}
	return itab + (inum % sblock->fs_ipg) * dsize;
}

/*
 * Read a chunk of data from the disk.
 * Try to recover from hard errors by reading in sector sized pieces.
 * Error recovery is attempted at most BREADEMAX times before seeking
 * consent from the operator to continue.
 */
int	breaderrors = 0;
#define	BREADEMAX 32

void
bread(daddr_t blkno, char *buf, int size)
{
	off_t offset;
 	int cnt, i;
	u_int32_t secsize = lab.d_secsize;

	offset = blkno * DEV_BSIZE;

loop:
	if ((cnt = pread(diskfd, buf, size, offset)) == size)
		return;
	if (blkno + (size / DEV_BSIZE) >
	    fsbtodb(sblock, sblock->fs_ffs1_size)) {
		/*
		 * Trying to read the final fragment.
		 *
		 * NB - dump only works in TP_BSIZE blocks, hence
		 * rounds `DEV_BSIZE' fragments up to TP_BSIZE pieces.
		 * It should be smarter about not actually trying to
		 * read more than it can get, but for the time being
		 * we punt and scale back the read only when it gets
		 * us into trouble. (mkm 9/25/83)
		 */
		size -= secsize;
		goto loop;
	}
	if (cnt == -1)
		warnx("read error from %s: %s: [block %lld]: count=%d",
		    disk, strerror(errno), (long long)blkno, size);
	else
		warnx("short read error from %s: [block %lld]: count=%d, "
		    "got=%d", disk, (long long)blkno, size, cnt);
	if (++breaderrors > BREADEMAX)
		errx(1, "More than %d block read errors from %s", BREADEMAX,
		    disk);
	/*
	 * Zero buffer, then try to read each sector of buffer separately.
	 */
	memset(buf, 0, size);
	for (i = 0; i < size; i += secsize, buf += secsize) {
		if ((cnt = pread(diskfd, buf, secsize, offset + i)) ==
		    secsize)
			continue;
		if (cnt == -1) {
			warnx("read error from %s: %s: [sector %lld]: "
			    "count=%u", disk, strerror(errno),
			    (long long)(offset + i) / DEV_BSIZE, secsize);
			continue;
		}
		warnx("short read error from %s: [sector %lld]: count=%u, "
		    "got=%d", disk, (long long)(offset + i) / DEV_BSIZE,
		    secsize, cnt);
	}
}

/*
 * Add an inode to the in-memory list of inodes to dump
 */
void
addinode(ufsino_t ino)
{
	ufsino_t *newilist;

	newilist = reallocarray(ilist, ninodes + 1, sizeof(*ilist));
	if (newilist == NULL)
		errx(4, "not enough memory to allocate tables");
	ilist = newilist;
	ilist[ninodes] = ino;
	ninodes++;
}

/*
 * Scan the directory pointer at by ino
 */
void
scanonedir(ufsino_t ino, const char *path)
{
	void *dp;
	off_t filesize;
	int i;

	if ((dp = cached(ino)) == NULL)
		return;
	filesize = (off_t)DIP(dp, di_size);
	for (i = 0; filesize > 0 && i < NDADDR; i++) {
		if (DIP(dp, di_db[i]) != 0) {
			searchdir(ino, DIP(dp, di_db[i]),
			    sblksize(sblock, DIP(dp, di_size), i),
			    filesize, path);
		}
		filesize -= sblock->fs_bsize;
	}
	for (i = 0; filesize > 0 && i < NIADDR; i++) {
		if (DIP(dp, di_ib[i]))
			dirindir(ino, DIP(dp, di_ib[i]), i, &filesize, path);
	}
}

/*
 * Read indirect blocks, and pass the data blocks to be searched
 * as directories.
 */
void
dirindir(ufsino_t ino, daddr_t blkno, int ind_level, off_t *filesizep,
    const char *path)
{
	int i;
	void *idblk;

	if ((idblk = malloc(sblock->fs_bsize)) == NULL)
		errx(1, "dirindir: cannot allocate indirect memory.\n");
	bread(fsbtodb(sblock, blkno), idblk, (int)sblock->fs_bsize);
	if (ind_level <= 0) {
		for (i = 0; *filesizep > 0 && i < NINDIR(sblock); i++) {
			if (sblock->fs_magic == FS_UFS1_MAGIC)
				blkno = ((int32_t *)idblk)[i];
			else
				blkno = ((int64_t *)idblk)[i];
			if (blkno != 0)
				searchdir(ino, blkno, sblock->fs_bsize,
				    *filesizep, path);
			*filesizep -= sblock->fs_bsize;
		}
	} else {
		ind_level--;
		for (i = 0; *filesizep > 0 && i < NINDIR(sblock); i++) {
			if (sblock->fs_magic == FS_UFS1_MAGIC)
				blkno = ((int32_t *)idblk)[i];
			else
				blkno = ((int64_t *)idblk)[i];
			if (blkno != 0)
				dirindir(ino, blkno, ind_level, filesizep,
				    path);
		}
	}
	free(idblk);
}

/*
 * Scan a disk block containing directory information looking to see if
 * any of the entries are on the dump list and to see if the directory
 * contains any subdirectories.
 */
void
searchdir(ufsino_t ino, daddr_t blkno, long size, off_t filesize,
    const char *path)
{
	char *dblk;
	struct direct *dp;
	void *di;
	mode_t mode;
	char *npath;
	ufsino_t subino;
	long loc;

	if ((dblk = malloc(sblock->fs_bsize)) == NULL)
		errx(1, "searchdir: cannot allocate directory memory.");
	bread(fsbtodb(sblock, blkno), dblk, (int)size);
	if (filesize < size)
		size = filesize;
	for (loc = 0; loc < size; ) {
		dp = (struct direct *)(dblk + loc);
		if (dp->d_reclen == 0) {
			warnx("corrupted directory, inode %llu",
			    (unsigned long long)ino);
			break;
		}
		loc += dp->d_reclen;
		if (dp->d_ino == 0)
			continue;
		if (dp->d_name[0] == '.') {
			if (!aflag && (dp->d_name[1] == '\0' ||
			    (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
				continue;
		}
		di = getino(dp->d_ino);
		mode = DIP(di, di_mode) & IFMT;
		subino = dp->d_ino;
		if (bsearch(&subino, ilist, ninodes, sizeof(*ilist), matchino)) {
			if (format) {
				format_entry(path, dp);
			} else {
				if (mflag)
					printf("mode %-6o uid %-5u gid %-5u ino ",
					    DIP(di, di_mode), DIP(di, di_uid),
					    DIP(di, di_gid));
				printf("%-7llu %s/%s%s\n",
				    (unsigned long long)dp->d_ino, path,
				    dp->d_name, mode == IFDIR ? "/." : "");
			}
		}
		if (mode == IFDIR) {
			if (dp->d_name[0] == '.') {
				if (dp->d_name[1] == '\0' ||
				    (dp->d_name[1] == '.' && dp->d_name[2] == '\0'))
				continue;
			}
			if (asprintf(&npath, "%s/%s", path, dp->d_name) == -1)
				errx(1, "malloc");
			scanonedir(dp->d_ino, npath);
			free(npath);
		}
	}
	free(dblk);
}

char *
rawname(char *name)
{
	static char newname[PATH_MAX];
	char *p;

	if ((p = strrchr(name, '/')) == NULL)
		return name;
	*p = '\0';
	strlcpy(newname, name, sizeof newname - 2);
	*p++ = '/';
	strlcat(newname, "/r", sizeof newname);
	strlcat(newname, p, sizeof newname);
	return(newname);
}

__dead void
usage(void)
{
	extern char *__progname;

	fprintf(stderr,
	    "usage: %s [-ams] [-f format] [-i number ...] filesystem\n",
	    __progname);
	exit(3);
}

int
main(int argc, char *argv[])
{
	struct stat stblock;
	struct fstab *fsp;
	unsigned long long ullval;
	ssize_t n;
	char *ep;
	int c, i;

	while ((c = getopt(argc, argv, "af:i:ms")) != -1)
		switch (c) {
		case 'a':
			aflag = 1;
			break;
		case 'i':
			iflag = 1;

			errno = 0;
			ullval = strtoull(optarg, &ep, 10);
			if (optarg[0] == '\0' || *ep != '\0')
				errx(1, "%s is not a number",
				    optarg);
			if ((errno == ERANGE && ullval == ULLONG_MAX) ||
			    (ufsino_t)ullval != ullval)
				errx(1, "%s is out of range",
				    optarg);
			addinode((ufsino_t)ullval);

			while (optind < argc) {
				errno = 0;
				ullval = strtoull(argv[optind], &ep, 10);
				if (argv[optind][0] == '\0' || *ep != '\0')
					break;
				if ((errno == ERANGE && ullval == ULLONG_MAX)
				    || (ufsino_t)ullval != ullval)
					errx(1, "%s is out of range",
					    argv[optind]);
				addinode((ufsino_t)ullval);
				optind++;
			}
			break;
		case 'f':
			format = optarg;
			break;
		case 'm':
			mflag = 1;
			break;
		case 's':
			sflag = 1;
			break;
		default:
			usage();
			exit(2);
		}
	if (optind != argc - 1 || (mflag && format))
		usage();

	disk = argv[optind];
	if ((diskfd = opendev(disk, O_RDONLY, 0, NULL)) >= 0) {
		if (fstat(diskfd, &stblock))
			err(1, "cannot stat %s", disk);
		if (S_ISCHR(stblock.st_mode))
			goto gotdev;
		close(diskfd);
	}

	if (realpath(disk, rdisk) == NULL)
		err(1, "cannot find real path for %s", disk);
	disk = rdisk;

	if (stat(disk, &stblock) < 0)
		err(1, "cannot stat %s", disk);

        if (S_ISBLK(stblock.st_mode)) {
		disk = rawname(disk);
	} else if (!S_ISCHR(stblock.st_mode)) {
		if ((fsp = getfsfile(disk)) == NULL)
			err(1, "could not find file system %s", disk);
                disk = rawname(fsp->fs_spec);
        }

	if ((diskfd = opendev(disk, O_RDONLY, 0, NULL)) < 0)
		err(1, "cannot open %s", disk);

gotdev:
	if (ioctl(diskfd, DIOCGDINFO, (char *)&lab) < 0)
		err(1, "ioctl (DIOCGDINFO)");
	if (ioctl(diskfd, DIOCGPDINFO, (char *)&lab) < 0)
		err(1, "ioctl (DIOCGPDINFO)");

	if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
		err(1, "pledge");

	sblock = (struct fs *)sblock_buf;
	for (i = 0; sblock_try[i] != -1; i++) {
		n = pread(diskfd, sblock, SBLOCKSIZE, (off_t)sblock_try[i]);
		if (n == SBLOCKSIZE && (sblock->fs_magic == FS_UFS1_MAGIC ||
		     (sblock->fs_magic == FS_UFS2_MAGIC &&
		      sblock->fs_sblockloc == sblock_try[i])) &&
		    sblock->fs_bsize <= MAXBSIZE &&
		    sblock->fs_bsize >= sizeof(struct fs))
			break;
	}
	if (sblock_try[i] == -1)
		errx(1, "cannot find filesystem superblock");

	findinodes(sblock->fs_ipg * sblock->fs_ncg);
	if (!format)
		printf("%s:\n", disk);
	scanonedir(ROOTINO, "");
	close(diskfd);
	exit (0);
}

void
format_entry(const char *path, struct direct *dp)
{
	static size_t size;
	static char *buf;
	char *src, *dst, *newbuf;
	int len;

	if (buf == NULL) {
		if ((buf = malloc(LINE_MAX)) == NULL)
			err(1, "malloc");
		size = LINE_MAX;
	}

	for (src = format, dst = buf; *src; src++) {
		/* Need room for at least one character in buf. */
		if (size <= dst - buf) {
		    expand_buf:
			if ((newbuf = reallocarray(buf, size, 2)) == NULL)
				err(1, "realloc");
			buf = newbuf;
			size = size * 2;
		}
		if (src[0] =='\\') {
			switch (src[1]) {
			case 'I':
				len = snprintf(dst, size - (dst - buf), "%llu",
				    (unsigned long long)dp->d_ino);
				if (len == -1 || len >= size - (dst - buf))
					goto expand_buf;
				dst += len;
				break;
			case 'P':
				len = snprintf(dst, size - (dst - buf), "%s/%s",
				    path, dp->d_name);
				if (len == -1 || len >= size - (dst - buf))
					goto expand_buf;
				dst += len;
				break;
			case '\\':
				*dst++ = '\\';
				break;
			case '0':
				/* XXX - support other octal numbers? */
				*dst++ = '\0';
				break;
			case 'a':
				*dst++ = '\a';
				break;
			case 'b':
				*dst++ = '\b';
				break;
			case 'e':
				*dst++ = '\e';
				break;
			case 'f':
				*dst++ = '\f';
				break;
			case 'n':
				*dst++ = '\n';
				break;
			case 'r':
				*dst++ = '\r';
				break;
			case 't':
				*dst++ = '\t';
				break;
			case 'v':
				*dst++ = '\v';
				break;
			default:
				*dst++ = src[1];
				break;
			}
			src++;
		} else
			*dst++ = *src;
	}
	fwrite(buf, dst - buf, 1, stdout);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: ncheck_ffs.c,v 1.53 2016/05/28 23:46:06 tb Exp $ */
2
3			/*-
4			* Copyright (c) 1995, 1996 SigmaSoft, Th. Lockert <tholo@sigmasoft.com>
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			*
16			* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
17			* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
18			* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
19			* THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20			* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21			* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22			* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23			* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24			* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25			* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26			*/
27
28			/*-
29			* Copyright (c) 1980, 1988, 1991, 1993
30			* The Regents of the University of California. All rights reserved.
31			*
32			* Redistribution and use in source and binary forms, with or without
33			* modification, are permitted provided that the following conditions
34			* are met:
35			* 1. Redistributions of source code must retain the above copyright
36			* notice, this list of conditions and the following disclaimer.
37			* 2. Redistributions in binary form must reproduce the above copyright
38			* notice, this list of conditions and the following disclaimer in the
39			* documentation and/or other materials provided with the distribution.
40			* 3. Neither the name of the University nor the names of its contributors
41			* may be used to endorse or promote products derived from this software
42			* without specific prior written permission.
43			*
44			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54			* SUCH DAMAGE.
55			*/
56
57			#include <sys/param.h> /* MAXBSIZE DEV_BSIZE */
58			#include <sys/time.h>
59			#include <sys/stat.h>
60			#include <sys/ioctl.h>
61			#include <sys/disklabel.h>
62			#include <sys/dkio.h>
63			#include <ufs/ffs/fs.h>
64			#include <ufs/ufs/dir.h>
65			#include <ufs/ufs/dinode.h>
66
67			#include <stdio.h>
68			#include <stdlib.h>
69			#include <fcntl.h>
70			#include <string.h>
71			#include <ctype.h>
72			#include <unistd.h>
73			#include <limits.h>
74			#include <fstab.h>
75			#include <errno.h>
76			#include <err.h>
77			#include <util.h>
78
79			#define DIP(dp, field) \
80			((sblock->fs_magic == FS_UFS1_MAGIC) ? \
81			((struct ufs1_dinode *)(dp))->field : \
82			((struct ufs2_dinode *)(dp))->field)
83
84			char disk; / name of the disk file */
85			char rdisk[PATH_MAX];/* resolved name of the disk file */
86			int diskfd; /* disk file descriptor */
87			struct fs sblock; / the file system super block */
88			char sblock_buf[MAXBSIZE];
89			int sblock_try[] = SBLOCKSEARCH; /* possible superblock locations */
90			ufsino_t ilist; / list of inodes to check */
91			int ninodes; /* number of inodes in list */
92			int sflag; /* only suid and special files */
93			int aflag; /* print the . and .. entries too */
94			int mflag; /* verbose output */
95			int iflag; /* specific inode */
96			char format; / output format */
97
98			struct disklabel lab;
99
100			struct icache_s {
101			ufsino_t ino;
102			union {
103			struct ufs1_dinode dp1;
104			struct ufs2_dinode dp2;
105			} di;
106			} *icache;
107			int nicache;
108			int maxicache;
109
110			void addinode(ufsino_t inum);
111			void *getino(ufsino_t inum);
112			void findinodes(ufsino_t);
113			void bread(daddr_t, char *, int);
114			__dead void usage(void);
115			void scanonedir(ufsino_t, const char *);
116			void dirindir(ufsino_t, daddr_t, int, off_t , const char );
117			void searchdir(ufsino_t, daddr_t, long, off_t, const char *);
118			int matchino(const void , const void );
119			int matchcache(const void , const void );
120			void cacheino(ufsino_t, void *);
121			void *cached(ufsino_t);
122			int main(int, char *[]);
123			char rawname(char );
124			void format_entry(const char , struct direct );
125
126			/*
127			* Check to see if the indicated inodes are the same
128			*/
129			int
130			matchino(const void key, const void val)
131			{
132			ufsino_t k = (ufsino_t )key;
133			ufsino_t v = (ufsino_t )val;
134
135			if (k < v)
136			return -1;
137			else if (k > v)
138			return 1;
139			return 0;
140			}
141
142			/*
143			* Check if the indicated inode match the entry in the cache
144			*/
145			int
146			matchcache(const void key, const void val)
147			{
148			ufsino_t ino = (ufsino_t )key;
149			struct icache_s ic = (struct icache_s )val;
150
151			if (ino < ic->ino)
152			return -1;
153			else if (ino > ic->ino)
154			return 1;
155			return 0;
156			}
157
158			/*
159			* Add an inode to the cached entries
160			*/
161			void
162			cacheino(ufsino_t ino, void *dp)
163			{
164			if (nicache == maxicache) {
165			struct icache_s *newicache;
166
167			/* grow exponentially */
168			maxicache += 10 + maxicache/2;
169			newicache = reallocarray(icache, maxicache, sizeof(*icache));
170			if (newicache == NULL)
171			errx(1, "malloc");
172			icache = newicache;
173
174			}
175			icache[nicache].ino = ino;
176			if (sblock->fs_magic == FS_UFS1_MAGIC)
177			icache[nicache++].di.dp1 = (struct ufs1_dinode )dp;
178			else
179			icache[nicache++].di.dp2 = (struct ufs2_dinode )dp;
180			}
181
182			/*
183			* Get a cached inode
184			*/
185			void *
186			cached(ufsino_t ino)
187			{
188			struct icache_s *ic;
189			void *dp = NULL;
190
191			ic = bsearch(&ino, icache, nicache, sizeof(*icache), matchcache);
192			if (ic != NULL) {
193			if (sblock->fs_magic == FS_UFS1_MAGIC)
194			dp = &ic->di.dp1;
195			else
196			dp = &ic->di.dp2;
197			}
198			return (dp);
199			}
200
201			/*
202			* Walk the inode list for a filesystem to find all allocated inodes
203			* Remember inodes we want to give information about and cache all
204			* inodes pointing to directories
205			*/
206			void
207			findinodes(ufsino_t maxino)
208			{
209			ufsino_t ino;
210			void *dp;
211			mode_t mode;
212
213			for (ino = ROOTINO; ino < maxino; ino++) {
214			dp = getino(ino);
215			mode = DIP(dp, di_mode) & IFMT;
216			if (!mode)
217			continue;
218			if (mode == IFDIR)
219			cacheino(ino, dp);
220			if (iflag \|\|
221			(sflag && (mode == IFDIR \|\|
222			((DIP(dp, di_mode) & (ISGID \| ISUID)) == 0 &&
223			(mode == IFREG \|\| mode == IFLNK)))))
224			continue;
225			addinode(ino);
226			}
227			}
228
229			/*
230			* Get a specified inode from disk. Attempt to minimize reads to once
231			* per cylinder group
232			*/
233			void *
234			getino(ufsino_t inum)
235			{
236			static char *itab = NULL;
237			static daddr_t iblk = -1;
238			void *dp;
239			size_t dsize;
240
241			if (inum < ROOTINO \|\| inum >= sblock->fs_ncg * sblock->fs_ipg)
242			return NULL;
243			if ((dp = cached(inum)) != NULL)
244			return dp;
245			if (sblock->fs_magic == FS_UFS1_MAGIC)
246			dsize = sizeof(struct ufs1_dinode);
247			else
248			dsize = sizeof(struct ufs2_dinode);
249			if ((inum / sblock->fs_ipg) != iblk \|\| itab == NULL) {
250			iblk = inum / sblock->fs_ipg;
251			if (itab == NULL &&
252			(itab = reallocarray(NULL, sblock->fs_ipg, dsize)) == NULL)
253			errx(1, "no memory for inodes");
254			bread(fsbtodb(sblock, cgimin(sblock, iblk)), itab,
255			sblock->fs_ipg * dsize);
256			}
257			return itab + (inum % sblock->fs_ipg) * dsize;
258			}
259
260			/*
261			* Read a chunk of data from the disk.
262			* Try to recover from hard errors by reading in sector sized pieces.
263			* Error recovery is attempted at most BREADEMAX times before seeking
264			* consent from the operator to continue.
265			*/
266			int breaderrors = 0;
267			#define BREADEMAX 32
268
269			void
270			bread(daddr_t blkno, char *buf, int size)
271			{
272			off_t offset;
273			int cnt, i;
274			u_int32_t secsize = lab.d_secsize;
275
276			offset = blkno * DEV_BSIZE;
277
278			loop:
279			if ((cnt = pread(diskfd, buf, size, offset)) == size)
280			return;
281			if (blkno + (size / DEV_BSIZE) >
282			fsbtodb(sblock, sblock->fs_ffs1_size)) {
283			/*
284			* Trying to read the final fragment.
285			*
286			* NB - dump only works in TP_BSIZE blocks, hence
287			* rounds `DEV_BSIZE' fragments up to TP_BSIZE pieces.
288			* It should be smarter about not actually trying to
289			* read more than it can get, but for the time being
290			* we punt and scale back the read only when it gets
291			* us into trouble. (mkm 9/25/83)
292			*/
293			size -= secsize;
294			goto loop;
295			}
296			if (cnt == -1)
297			warnx("read error from %s: %s: [block %lld]: count=%d",
298			disk, strerror(errno), (long long)blkno, size);
299			else
300			warnx("short read error from %s: [block %lld]: count=%d, "
301			"got=%d", disk, (long long)blkno, size, cnt);
302			if (++breaderrors > BREADEMAX)
303			errx(1, "More than %d block read errors from %s", BREADEMAX,
304			disk);
305			/*
306			* Zero buffer, then try to read each sector of buffer separately.
307			*/
308			memset(buf, 0, size);
309			for (i = 0; i < size; i += secsize, buf += secsize) {
310			if ((cnt = pread(diskfd, buf, secsize, offset + i)) ==
311			secsize)
312			continue;
313			if (cnt == -1) {
314			warnx("read error from %s: %s: [sector %lld]: "
315			"count=%u", disk, strerror(errno),
316			(long long)(offset + i) / DEV_BSIZE, secsize);
317			continue;
318			}
319			warnx("short read error from %s: [sector %lld]: count=%u, "
320			"got=%d", disk, (long long)(offset + i) / DEV_BSIZE,
321			secsize, cnt);
322			}
323			}
324
325			/*
326			* Add an inode to the in-memory list of inodes to dump
327			*/
328			void
329			addinode(ufsino_t ino)
330			{
331			ufsino_t *newilist;
332
333			newilist = reallocarray(ilist, ninodes + 1, sizeof(*ilist));
334			if (newilist == NULL)
335			errx(4, "not enough memory to allocate tables");
336			ilist = newilist;
337			ilist[ninodes] = ino;
338			ninodes++;
339			}
340
341			/*
342			* Scan the directory pointer at by ino
343			*/
344			void
345			scanonedir(ufsino_t ino, const char *path)
346			{
347			void *dp;
348			off_t filesize;
349			int i;
350
351			if ((dp = cached(ino)) == NULL)
352			return;
353			filesize = (off_t)DIP(dp, di_size);
354			for (i = 0; filesize > 0 && i < NDADDR; i++) {
355			if (DIP(dp, di_db[i]) != 0) {
356			searchdir(ino, DIP(dp, di_db[i]),
357			sblksize(sblock, DIP(dp, di_size), i),
358			filesize, path);
359			}
360			filesize -= sblock->fs_bsize;
361			}
362			for (i = 0; filesize > 0 && i < NIADDR; i++) {
363			if (DIP(dp, di_ib[i]))
364			dirindir(ino, DIP(dp, di_ib[i]), i, &filesize, path);
365			}
366			}
367
368			/*
369			* Read indirect blocks, and pass the data blocks to be searched
370			* as directories.
371			*/
372			void
373			dirindir(ufsino_t ino, daddr_t blkno, int ind_level, off_t *filesizep,
374			const char *path)
375			{
376			int i;
377			void *idblk;
378
379			if ((idblk = malloc(sblock->fs_bsize)) == NULL)
380			errx(1, "dirindir: cannot allocate indirect memory.\n");
381			bread(fsbtodb(sblock, blkno), idblk, (int)sblock->fs_bsize);
382			if (ind_level <= 0) {
383			for (i = 0; *filesizep > 0 && i < NINDIR(sblock); i++) {
384			if (sblock->fs_magic == FS_UFS1_MAGIC)
385			blkno = ((int32_t *)idblk)[i];
386			else
387			blkno = ((int64_t *)idblk)[i];
388			if (blkno != 0)
389			searchdir(ino, blkno, sblock->fs_bsize,
390			*filesizep, path);
391			*filesizep -= sblock->fs_bsize;
392			}
393			} else {
394			ind_level--;
395			for (i = 0; *filesizep > 0 && i < NINDIR(sblock); i++) {
396			if (sblock->fs_magic == FS_UFS1_MAGIC)
397			blkno = ((int32_t *)idblk)[i];
398			else
399			blkno = ((int64_t *)idblk)[i];
400			if (blkno != 0)
401			dirindir(ino, blkno, ind_level, filesizep,
402			path);
403			}
404			}
405			free(idblk);
406			}
407
408			/*
409			* Scan a disk block containing directory information looking to see if
410			* any of the entries are on the dump list and to see if the directory
411			* contains any subdirectories.
412			*/
413			void
414			searchdir(ufsino_t ino, daddr_t blkno, long size, off_t filesize,
415			const char *path)
416			{
417			char *dblk;
418			struct direct *dp;
419			void *di;
420			mode_t mode;
421			char *npath;
422			ufsino_t subino;
423			long loc;
424
425			if ((dblk = malloc(sblock->fs_bsize)) == NULL)
426			errx(1, "searchdir: cannot allocate directory memory.");
427			bread(fsbtodb(sblock, blkno), dblk, (int)size);
428			if (filesize < size)
429			size = filesize;
430			for (loc = 0; loc < size; ) {
431			dp = (struct direct *)(dblk + loc);
432			if (dp->d_reclen == 0) {
433			warnx("corrupted directory, inode %llu",
434			(unsigned long long)ino);
435			break;
436			}
437			loc += dp->d_reclen;
438			if (dp->d_ino == 0)
439			continue;
440			if (dp->d_name[0] == '.') {
441			if (!aflag && (dp->d_name[1] == '\0' \|\|
442			(dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
443			continue;
444			}
445			di = getino(dp->d_ino);
446			mode = DIP(di, di_mode) & IFMT;
447			subino = dp->d_ino;
448			if (bsearch(&subino, ilist, ninodes, sizeof(*ilist), matchino)) {
449			if (format) {
450			format_entry(path, dp);
451			} else {
452			if (mflag)
453			printf("mode %-6o uid %-5u gid %-5u ino ",
454			DIP(di, di_mode), DIP(di, di_uid),
455			DIP(di, di_gid));
456			printf("%-7llu %s/%s%s\n",
457			(unsigned long long)dp->d_ino, path,
458			dp->d_name, mode == IFDIR ? "/." : "");
459			}
460			}
461			if (mode == IFDIR) {
462			if (dp->d_name[0] == '.') {
463			if (dp->d_name[1] == '\0' \|\|
464			(dp->d_name[1] == '.' && dp->d_name[2] == '\0'))
465			continue;
466			}
467			if (asprintf(&npath, "%s/%s", path, dp->d_name) == -1)
468			errx(1, "malloc");
469			scanonedir(dp->d_ino, npath);
470			free(npath);
471			}
472			}
473			free(dblk);
474			}
475
476			char *
477			rawname(char *name)
478			{
479			static char newname[PATH_MAX];
480			char *p;
481
482			if ((p = strrchr(name, '/')) == NULL)
483			return name;
484			*p = '\0';
485			strlcpy(newname, name, sizeof newname - 2);
486			*p++ = '/';
487			strlcat(newname, "/r", sizeof newname);
488			strlcat(newname, p, sizeof newname);
489			return(newname);
490			}
491
492			__dead void
493			usage(void)
494			{
495			extern char *__progname;
496
497			fprintf(stderr,
498			"usage: %s [-ams] [-f format] [-i number ...] filesystem\n",
499			__progname);
500			exit(3);
501			}
502
503			int
504			main(int argc, char *argv[])
505			{
506			struct stat stblock;
507			struct fstab *fsp;
508			unsigned long long ullval;
509			ssize_t n;
510			char *ep;
511			int c, i;
512
513			while ((c = getopt(argc, argv, "af:i:ms")) != -1)
514			switch (c) {
515			case 'a':
516			aflag = 1;
517			break;
518			case 'i':
519			iflag = 1;
520
521			errno = 0;
522			ullval = strtoull(optarg, &ep, 10);
523			if (optarg[0] == '\0' \|\| *ep != '\0')
524			errx(1, "%s is not a number",
525			optarg);
526			if ((errno == ERANGE && ullval == ULLONG_MAX) \|\|
527			(ufsino_t)ullval != ullval)
528			errx(1, "%s is out of range",
529			optarg);
530			addinode((ufsino_t)ullval);
531
532			while (optind < argc) {
533			errno = 0;
534			ullval = strtoull(argv[optind], &ep, 10);
535			if (argv[optind][0] == '\0' \|\| *ep != '\0')
536			break;
537			if ((errno == ERANGE && ullval == ULLONG_MAX)
538			\|\| (ufsino_t)ullval != ullval)
539			errx(1, "%s is out of range",
540			argv[optind]);
541			addinode((ufsino_t)ullval);
542			optind++;
543			}
544			break;
545			case 'f':
546			format = optarg;
547			break;
548			case 'm':
549			mflag = 1;
550			break;
551			case 's':
552			sflag = 1;
553			break;
554			default:
555			usage();
556			exit(2);
557			}
558			if (optind != argc - 1 \|\| (mflag && format))
559			usage();
560
561			disk = argv[optind];
562			if ((diskfd = opendev(disk, O_RDONLY, 0, NULL)) >= 0) {
563			if (fstat(diskfd, &stblock))
564			err(1, "cannot stat %s", disk);
565			if (S_ISCHR(stblock.st_mode))
566			goto gotdev;
567			close(diskfd);
568			}
569
570			if (realpath(disk, rdisk) == NULL)
571			err(1, "cannot find real path for %s", disk);
572			disk = rdisk;
573
574			if (stat(disk, &stblock) < 0)
575			err(1, "cannot stat %s", disk);
576
577			if (S_ISBLK(stblock.st_mode)) {
578			disk = rawname(disk);
579			} else if (!S_ISCHR(stblock.st_mode)) {
580			if ((fsp = getfsfile(disk)) == NULL)
581			err(1, "could not find file system %s", disk);
582			disk = rawname(fsp->fs_spec);
583			}
584
585			if ((diskfd = opendev(disk, O_RDONLY, 0, NULL)) < 0)
586			err(1, "cannot open %s", disk);
587
588			gotdev:
589			if (ioctl(diskfd, DIOCGDINFO, (char *)&lab) < 0)
590			err(1, "ioctl (DIOCGDINFO)");
591			if (ioctl(diskfd, DIOCGPDINFO, (char *)&lab) < 0)
592			err(1, "ioctl (DIOCGPDINFO)");
593
594			if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
595			err(1, "pledge");
596
597			sblock = (struct fs *)sblock_buf;
598			for (i = 0; sblock_try[i] != -1; i++) {
599			n = pread(diskfd, sblock, SBLOCKSIZE, (off_t)sblock_try[i]);
600			if (n == SBLOCKSIZE && (sblock->fs_magic == FS_UFS1_MAGIC \|\|
601			(sblock->fs_magic == FS_UFS2_MAGIC &&
602			sblock->fs_sblockloc == sblock_try[i])) &&
603			sblock->fs_bsize <= MAXBSIZE &&
604			sblock->fs_bsize >= sizeof(struct fs))
605			break;
606			}
607			if (sblock_try[i] == -1)
608			errx(1, "cannot find filesystem superblock");
609
610			findinodes(sblock->fs_ipg * sblock->fs_ncg);
611			if (!format)
612			printf("%s:\n", disk);
613			scanonedir(ROOTINO, "");
614			close(diskfd);
615			exit (0);
616			}
617
618			void
619			format_entry(const char path, struct direct dp)
620			{
621			static size_t size;
622			static char *buf;
623			char src, dst, *newbuf;
624			int len;
625
626			if (buf == NULL) {
627			if ((buf = malloc(LINE_MAX)) == NULL)
628			err(1, "malloc");
629			size = LINE_MAX;
630			}
631
632			for (src = format, dst = buf; *src; src++) {
633			/* Need room for at least one character in buf. */
634			if (size <= dst - buf) {
635			expand_buf:
636			if ((newbuf = reallocarray(buf, size, 2)) == NULL)
637			err(1, "realloc");
638			buf = newbuf;
639			size = size * 2;
640			}
641			if (src[0] =='\\') {
642			switch (src[1]) {
643			case 'I':
644			len = snprintf(dst, size - (dst - buf), "%llu",
645			(unsigned long long)dp->d_ino);
646			if (len == -1 \|\| len >= size - (dst - buf))
647			goto expand_buf;
648			dst += len;
649			break;
650			case 'P':
651			len = snprintf(dst, size - (dst - buf), "%s/%s",
652			path, dp->d_name);
653			if (len == -1 \|\| len >= size - (dst - buf))
654			goto expand_buf;
655			dst += len;
656			break;
657			case '\\':
658			*dst++ = '\\';
659			break;
660			case '0':
661			/* XXX - support other octal numbers? */
662			*dst++ = '\0';
663			break;
664			case 'a':
665			*dst++ = '\a';
666			break;
667			case 'b':
668			*dst++ = '\b';
669			break;
670			case 'e':
671			*dst++ = '\e';
672			break;
673			case 'f':
674			*dst++ = '\f';
675			break;
676			case 'n':
677			*dst++ = '\n';
678			break;
679			case 'r':
680			*dst++ = '\r';
681			break;
682			case 't':
683			*dst++ = '\t';
684			break;
685			case 'v':
686			*dst++ = '\v';
687			break;
688			default:
689			*dst++ = src[1];
690			break;
691			}
692			src++;
693			} else
694			dst++ = src;
695			}
696			fwrite(buf, dst - buf, 1, stdout);
697			}