/*
* dvch.c -- device cache functions for lsof library
*/
/*
* Copyright 1997 Purdue Research Foundation, West Lafayette, Indiana
* 47907. All rights reserved.
*
* Written by Victor A. Abell
*
* This software is not subject to any license of the American Telephone
* and Telegraph Company or the Regents of the University of California.
*
* Permission is granted to anyone to use this software for any purpose on
* any computer system, and to alter it and redistribute it freely, subject
* to the following restrictions:
*
* 1. Neither the authors nor Purdue University are responsible for any
* consequences of the use of this software.
*
* 2. The origin of this software must not be misrepresented, either by
* explicit claim or by omission. Credit to the authors and Purdue
* University must appear in documentation and sources.
*
* 3. Altered versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 4. This notice may not be removed or altered.
*/
#include "../machine.h"
#if defined(HASDCACHE)
# if !defined(lint)
static char copyright[] =
"@(#) Copyright 1997 Purdue Research Foundation.\nAll rights reserved.\n";
static char *rcsid = "$Id: dvch.c,v 1.16 2008/10/21 16:12:36 abe Exp $";
# endif /* !defined(lint) */
#include "../lsof.h"
/*
* dvch.c - module that contains common device cache functions
*
* The caller may define the following:
*
* DCACHE_CLONE is the name of the function that reads and writes the
* clone section of the device cache file. The clone
* section follows the device section. If DCACHE_CLONE
* isn't defined, but HAS_STD_CLONE is defined to be 1,
* DCACHE_CLONE defaults to the local static function
* rw_clone_sect() that reads and writes a standard
* clone cache.
*
* DCACHE_CLR is the name of the function that clears the clone and
* pseudo caches when reading the device cache fails. If
* DCACHE_CLR isn't defined, but HAS_STD_CLONE is defined
* to be 1, DCACHE_CLR defaults to the local static
* function clr_sect() that clears a standard clone cache.
*
* DCACHE_PSEUDO is the name of the function that reads and writes
* the pseudo section of the device cache file. The
* pseudo section follows the device section and the
* clone section, if there is one.
*
* DVCH_CHOWN if the dialect has no fchown() function, so
* chown() must be used instead.
*
* DVCH_DEVPATH if the path to the device directory isn't "/dev".
*
* DVCH_EXPDEV if st_rdev must be expanded with the expdev()
* macro before use. (This is an EP/IX artifact.)
*
* HASBLKDEV if block device information is stored in BDevtp[].
*/
/*
* Local definitions
*/
# if !defined(DVCH_DEVPATH)
#define DVCH_DEVPATH "/dev"
# endif /* !defined(DVCH_DEVPATH) */
/*
* Local storage
*/
static int crctbl[CRC_TBLL]; /* crc partial results table */
/*
* Local function prototypes
*/
#undef DCACHE_CLR_LOCAL
# if !defined(DCACHE_CLR)
# if defined(HAS_STD_CLONE) && HAS_STD_CLONE==1
#define DCACHE_CLR clr_sect
#define DCACHE_CLR_LOCAL 1
_PROTOTYPE(static void clr_sect,(void));
# endif /* defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 */
# endif /* !defined(DCACHE_CLR) */
#undef DCACHE_CLONE_LOCAL
# if !defined(DCACHE_CLONE)
# if defined(HAS_STD_CLONE) && HAS_STD_CLONE==1
#define DCACHE_CLONE rw_clone_sect
#define DCACHE_CLONE_LOCAL 1
_PROTOTYPE(static int rw_clone_sect,(int m));
# endif /* defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 */
# endif /*!defined(DCACHE_CLONE) */
# if defined(HASBLKDEV)
/*
* alloc_bdcache() - allocate block device cache
*/
void
alloc_bdcache()
{
if (!(BDevtp = (struct l_dev *)calloc((MALLOC_S)BNdev,
sizeof(struct l_dev))))
{
(void) fprintf(stderr, "%s: no space for block devices\n", Pn);
Exit(1);
}
if (!(BSdev = (struct l_dev **)malloc((MALLOC_S)(sizeof(struct l_dev *)
* BNdev))))
{
(void) fprintf(stderr, "%s: no space for block device pointers\n",
Pn);
Exit(1);
}
}
# endif /* defined(HASBLKDEV) */
/*
* alloc_dcache() - allocate device cache
*/
void
alloc_dcache()
{
if (!(Devtp = (struct l_dev *)calloc((MALLOC_S)Ndev,
sizeof(struct l_dev))))
{
(void) fprintf(stderr, "%s: no space for devices\n", Pn);
Exit(1);
}
if (!(Sdev = (struct l_dev **)malloc((MALLOC_S)(sizeof(struct l_dev *)
* Ndev))))
{
(void) fprintf(stderr, "%s: no space for device pointers\n",
Pn);
Exit(1);
}
}
/*
* clr_devtab() - clear the device tables and free their space
*/
void
clr_devtab()
{
int i;
if (Devtp) {
for (i = 0; i < Ndev; i++) {
if (Devtp[i].name) {
(void) free((FREE_P *)Devtp[i].name);
Devtp[i].name = (char *)NULL;
}
}
(void) free((FREE_P *)Devtp);
Devtp = (struct l_dev *)NULL;
}
if (Sdev) {
(void) free((FREE_P *)Sdev);
Sdev = (struct l_dev **)NULL;
}
Ndev = 0;
# if defined(HASBLKDEV)
if (BDevtp) {
for (i = 0; i < BNdev; i++) {
if (BDevtp[i].name) {
(void) free((FREE_P *)BDevtp[i].name);
BDevtp[i].name = (char *)NULL;
}
}
(void) free((FREE_P *)BDevtp);
BDevtp = (struct l_dev *)NULL;
}
if (BSdev) {
(void) free((FREE_P *)BSdev);
BSdev = (struct l_dev **)NULL;
}
BNdev = 0;
# endif /* defined(HASBLKDEV) */
}
# if defined(DCACHE_CLR_LOCAL)
/*
* clr_sect() - clear cached standard clone sections
*/
static void
clr_sect()
{
struct clone *c, *c1;
if (Clone) {
for (c = Clone; c; c = c1) {
c1 = c->next;
(void) free((FREE_P *)c);
}
Clone = (struct clone *)NULL;
}
}
# endif /* defined(DCACHE_CLR_LOCAL) */
/*
* crc(b, l, s) - compute a crc for a block of bytes
*/
void
crc(b, l, s)
char *b; /* block address */
int l; /* length */
unsigned *s; /* sum */
{
char *cp; /* character pointer */
char *lm; /* character limit pointer */
unsigned sum; /* check sum */
cp = b;
lm = cp + l;
sum = *s;
do {
sum ^= ((int) *cp++) & 0xff;
sum = (sum >> 8) ^ crctbl[sum & 0xff];
} while (cp < lm);
*s = sum;
}
/*
* crcbld - build the CRC-16 partial results table
*/
void
crcbld()
{
int bit; /* temporary bit value */
unsigned entry; /* entry under construction */
int i; /* polynomial table index */
int j; /* bit shift count */
for(i = 0; i < CRC_TBLL; i++) {
entry = i;
for (j = 1; j <= CRC_BITS; j++) {
bit = entry & 1;
entry >>= 1;
if (bit)
entry ^= CRC_POLY;
}
crctbl[i] = entry;
}
}
/*
* dcpath() - define device cache file paths
*/
int
dcpath(rw, npw)
int rw; /* read (1) or write (2) mode */
int npw; /* inhibit (0) or enable (1) no
* path warning message */
{
char buf[MAXPATHLEN+1], *cp1, *cp2, hn[MAXPATHLEN+1];
int endf;
int i, j;
int l = 0;
int ierr = 0; /* intermediate error state */
int merr = 0; /* malloc error state */
struct passwd *p = (struct passwd *)NULL;
static short wenv = 1; /* HASENVDC warning state */
static short wpp = 1; /* HASPERSDCPATH warning state */
/*
* Release any space reserved by previous path calls to dcpath().
*/
if (DCpath[1]) {
(void) free((FREE_P *)DCpath[1]);
DCpath[1] = (char *)NULL;
}
if (DCpath[3]) {
(void) free((FREE_P *)DCpath[3]);
DCpath[3] = (char *)NULL;
}
/*
* If a path was specified via -D, it's character address will have been
* stored in DCpathArg by ctrl_dcache(). Use that address if the real UID
* of this process is root, or the mode is read, or the process is neither
* setuid-root nor setgid.
*/
if (Myuid == 0 || rw == 1 || (!Setuidroot && !Setgid))
DCpath[0] = DCpathArg;
else
DCpath[0] = (char *)NULL;
# if defined(HASENVDC)
/*
* If HASENVDC is defined, get its value from the environment, unless this
* is a setuid-root process, or the real UID of the process is 0, or the
* mode is write and the process is setgid.
*/
if ((cp1 = getenv(HASENVDC)) && (l = strlen(cp1)) > 0
&& !Setuidroot && Myuid && (rw == 1 || !Setgid)) {
if (!(cp2 = mkstrcpy(cp1, (MALLOC_S *)NULL))) {
(void) fprintf(stderr,
"%s: no space for device cache path: %s=", Pn, HASENVDC);
safestrprt(cp1, stderr, 1);
merr = 1;
} else
DCpath[1] = cp2;
} else if (cp1 && l > 0) {
if (!Fwarn && wenv) {
(void) fprintf(stderr,
"%s: WARNING: ignoring environment: %s=", Pn, HASENVDC);
safestrprt(cp1, stderr, 1);
}
wenv = 0;
}
# endif /* defined(HASENVDC) */
# if defined(HASSYSDC)
/*
* If HASSYSDC is defined, record the path of the system-wide device
* cache file, unless the mode is write.
*/
if (rw != 2)
DCpath[2] = HASSYSDC;
else
DCpath[2] = (char *)NULL;
# endif /* defined(HASSYSDC) */
# if defined(HASPERSDC)
/*
* If HASPERSDC is defined, form a personal device cache path by
* interpreting the conversions specified in it.
*
* Get (HASPERSDCPATH) from the environment and add it to the home directory
* path, if possible.
*/
for (cp1 = HASPERSDC, endf = i = 0; *cp1 && !endf; cp1++) {
if (*cp1 != '%') {
/*
* If the format character isn't a `%', copy it.
*/
if (i < (int)sizeof(buf)) {
buf[i++] = *cp1;
continue;
} else {
ierr = 2;
break;
}
}
/*
* `%' starts a conversion; the next character specifies
* the conversion type.
*/
cp1++;
switch (*cp1) {
/*
* Two consecutive `%' characters convert to one `%'
* character in the output.
*/
case '%':
if (i < (int)sizeof(buf))
buf[i++] = '%';
else
ierr = 2;
break;
/*
* ``%0'' defines a root boundary. If the effective
* (setuid-root) or real UID of the process is root, any
* path formed to this point is discarded and path formation
* begins with the next character.
*
* If neither the effective nor the real UID is root, path
* formation ends.
*
* This allows HASPERSDC to specify one path for non-root
* UIDs and another for the root (effective or real) UID.
*/
case '0':
if (Setuidroot || !Myuid)
i = 0;
else
endf = 1;
break;
/*
* ``%h'' converts to the home directory.
*/
case 'h':
if (!p && !(p = getpwuid(Myuid))) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't get home dir for UID: %d\n",
Pn, (int)Myuid);
ierr = 1;
break;
}
if ((i + (l = strlen(p->pw_dir))) >= (int)sizeof(buf)) {
ierr = 2;
break;
}
(void) strcpy(&buf[i], p->pw_dir);
i += l;
if (i > 0 && buf[i - 1] == '/' && *(cp1 + 1)) {
/*
* If the home directory ends in a '/' and the next format
* character is a '/', delete the '/' at the end of the home
* directory.
*/
i--;
buf[i] = '\0';
}
break;
/*
* ``%l'' converts to the full host name.
*
* ``%L'' converts to the first component (characters up
* to the first `.') of the host name.
*/
case 'l':
case 'L':
if (gethostname(hn, sizeof(hn) - 1) < 0) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: no gethostname for %%l or %%L: %s\n",
Pn, strerror(errno));
ierr = 1;
break;
}
hn[sizeof(hn) - 1] = '\0';
if (*cp1 == 'L' && (cp2 = strchr(hn, '.')) && cp2 > hn)
*cp2 = '\0';
j = strlen(hn);
if ((j + i) < (int)sizeof(buf)) {
(void) strcpy(&buf[i], hn);
i += j;
} else
ierr = 2;
break;
/*
* ``%p'' converts to the contents of LSOFPERSDCPATH, followed
* by a '/'.
*
* It is ignored when:
*
* The lsof process is setuid-root;
* The real UID of the lsof process is 0;
* The mode is write and the process is setgid.
*/
case 'p':
# if defined(HASPERSDCPATH)
if ((cp2 = getenv(HASPERSDCPATH))
&& (l = strlen(cp2)) > 0
&& !Setuidroot
&& Myuid
&& (rw == 1 || !Setgid))
{
if (i && buf[i - 1] == '/' && *cp2 == '/') {
cp2++;
l--;
}
if ((i + l) < ((int)sizeof(buf) - 1)) {
(void) strcpy(&buf[i], cp2);
i += l;
if (buf[i - 1] != '/') {
if (i < ((int)sizeof(buf) - 2)) {
buf[i++] = '/';
buf[i] = '\0';
} else
ierr = 2;
}
} else
ierr = 2;
} else {
if (cp2 && l > 0) {
if (!Fwarn && wpp) {
(void) fprintf(stderr,
"%s: WARNING: ignoring environment: %s",
Pn, HASPERSDCPATH);
safestrprt(cp2, stderr, 1);
}
wpp = 0;
}
}
# else /* !defined(HASPERSDCPATH) */
if (!Fwarn && wpp)
(void) fprintf(stderr,
"%s: WARNING: HASPERSDCPATH disabled: %s\n",
Pn, HASPERSDC);
ierr = 1;
wpp = 0;
# endif /* defined(HASPERSDCPATH) */
break;
/*
* ``%u'' converts to the login name of the real UID of the
* lsof process.
*/
case 'u':
if (!p && !(p = getpwuid(Myuid))) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't get login name for UID: %d\n",
Pn, (int)Myuid);
ierr = 1;
break;
}
if ((i + (l = strlen(p->pw_name))) >= (int)sizeof(buf)) {
ierr = 2;
break;
}
(void) strcpy(&buf[i], p->pw_name);
i += l;
break;
/*
* ``%U'' converts to the real UID of the lsof process.
*/
case 'U':
(void) snpf(hn, sizeof(hn), "%d", (int)Myuid);
if ((i + (l = strlen(hn))) >= (int)sizeof(buf))
ierr = 2;
else {
(void) strcpy(&buf[i], hn);
i += l;
}
break;
default:
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: bad conversion (%%%c): %s\n",
Pn, *cp1, HASPERSDC);
ierr = 1;
}
if (endf || ierr > 1)
break;
}
if (ierr) {
/*
* If there was an intermediate error of some type, handle it.
* A type 1 intermediate error has already been noted with a
* warning message. A type 2 intermediate error requires the
* issuing of a buffer overlow warning message.
*/
if (ierr == 2 && !Fwarn)
(void) fprintf(stderr,
"%s: WARNING: device cache path too large: %s\n",
Pn, HASPERSDC);
i = 0;
}
buf[i] = '\0';
/*
* If there is one, allocate space for the personal device cache path,
* copy buf[] to it, and store its pointer in DCpath[3].
*/
if (i) {
if (!(cp1 = mkstrcpy(buf, (MALLOC_S *)NULL))) {
(void) fprintf(stderr,
"%s: no space for device cache path: ", Pn);
safestrprt(buf, stderr, 1);
merr = 1;
} else
DCpath[3] = cp1;
}
# endif /* defined(HASPERSDC) */
/*
* Quit if there was a malloc() error. The appropriate error message
* will have been issued to stderr.
*/
if (merr)
Exit(1);
/*
* Return the index of the first defined path. Since DCpath[] is arranged
* in priority order, searching it beginning to end follows priority.
* Return an error indication if the search discloses no path name.
*/
for (i = 0; i < MAXDCPATH; i++) {
if (DCpath[i])
return(i);
}
if (!Fwarn && npw)
(void) fprintf(stderr,
"%s: WARNING: can't form any device cache path\n", Pn);
return(-1);
}
/*
* open_dcache() - open device cache file
*/
int
open_dcache(m, r, s)
int m; /* mode: 1 = read; 2 = write */
int r; /* create DCpath[] if 0, reuse if 1 */
struct stat *s; /* stat() receiver */
{
char buf[128];
char *w = (char *)NULL;
/*
* Get the device cache file paths.
*/
if (!r) {
if ((DCpathX = dcpath(m, 1)) < 0)
return(1);
}
/*
* Switch to the requested open() action.
*/
switch (m) {
case 1:
/*
* Check for access permission.
*/
if (!is_readable(DCpath[DCpathX], 0)) {
if (DCpathX == 2 && errno == ENOENT)
return(2);
if (!Fwarn)
(void) fprintf(stderr, ACCESSERRFMT,
Pn, DCpath[DCpathX], strerror(errno));
return(1);
}
/*
* Open for reading.
*/
if ((DCfd = open(DCpath[DCpathX], O_RDONLY, 0)) < 0) {
if (DCstate == 3 && errno == ENOENT)
return(1);
cant_open:
(void) fprintf(stderr,
"%s: WARNING: can't open %s: %s\n",
Pn, DCpath[DCpathX], strerror(errno));
return(1);
}
if (stat(DCpath[DCpathX], s) != 0) {
cant_stat:
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't stat(%s): %s\n",
Pn, DCpath[DCpathX], strerror(errno));
close_exit:
(void) close(DCfd);
DCfd = -1;
return(1);
}
if ((int)(s->st_mode & 07777) != ((DCpathX == 2) ? 0644 : 0600)) {
(void) snpf(buf, sizeof(buf), "doesn't have %04o modes",
(DCpathX == 2) ? 0644 : 0600);
w = buf;
} else if ((s->st_mode & S_IFMT) != S_IFREG)
w = "isn't a regular file";
else if (!s->st_size)
w = "is empty";
if (w) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: %s %s.\n", Pn, DCpath[DCpathX], w);
goto close_exit;
}
return(0);
case 2:
/*
* Open for writing: first unlink any previous version; then
* open exclusively, specifying it's an error if the file exists.
*/
if (unlink(DCpath[DCpathX]) < 0) {
if (errno != ENOENT) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't unlink %s: %s\n",
Pn, DCpath[DCpathX], strerror(errno));
return(1);
}
}
if ((DCfd = open(DCpath[DCpathX], O_RDWR|O_CREAT|O_EXCL, 0600)) < 0)
goto cant_open;
/*
* If the real user is not root, but the process is setuid-root,
* change the ownerships of the file to the real ones.
*/
if (Myuid && Setuidroot) {
# if defined(DVCH_CHOWN)
if (chown(DCpath[DCpathX], Myuid, getgid()) < 0)
# else /* !defined(DVCH_CHOWN) */
if (fchown(DCfd, Myuid, getgid()) < 0)
# endif /* defined(DVCH_CHOWN) */
{
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't change ownerships of %s: %s\n",
Pn, DCpath[DCpathX], strerror(errno));
}
}
if (!Fwarn && DCstate != 1 && !DCunsafe)
(void) fprintf(stderr,
"%s: WARNING: created device cache file: %s\n",
Pn, DCpath[DCpathX]);
if (stat(DCpath[DCpathX], s) != 0) {
(void) unlink(DCpath[DCpathX]);
goto cant_stat;
}
return(0);
default:
/*
* Oops!
*/
(void) fprintf(stderr, "%s: internal error: open_dcache=%d\n",
Pn, m);
Exit(1);
}
return(1);
}
/*
* read_dcache() - read device cache file
*/
int
read_dcache()
{
char buf[MAXPATHLEN*2], cbuf[64], *cp;
int i, len, ov;
struct stat sb, devsb;
/*
* Open the device cache file.
*
* If the open at HASSYSDC fails because the file doesn't exist, and
* the real UID of this process is not zero, try to open a device cache
* file at HASPERSDC.
*/
if ((ov = open_dcache(1, 0, &sb)) != 0) {
if (DCpathX == 2) {
if (ov == 2 && DCpath[3]) {
DCpathX = 3;
if (open_dcache(1, 1, &sb) != 0)
return(1);
} else
return(1);
} else
return(1);
}
/*
* If the open device cache file's last mtime/ctime isn't greater than
* DVCH_DEVPATH's mtime/ctime, ignore it, unless -Dr was specified.
*/
if (stat(DVCH_DEVPATH, &devsb) != 0) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't stat(%s): %s\n",
Pn, DVCH_DEVPATH, strerror(errno));
} else {
if (sb.st_mtime <= devsb.st_mtime || sb.st_ctime <= devsb.st_ctime)
DCunsafe = 1;
}
if (!(DCfs = fdopen(DCfd, "r"))) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't fdopen(%s)\n", Pn, DCpath[DCpathX]);
(void) close(DCfd);
DCfd = -1;
return(1);
}
/*
* Read the section count line; initialize the CRC table;
* validate the section count line.
*/
if (!fgets(buf, sizeof(buf), DCfs)) {
cant_read:
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't fread %s: %s\n", Pn, DCpath[DCpathX],
strerror(errno));
read_close:
(void) fclose(DCfs);
DCfd = -1;
DCfs = (FILE *)NULL;
(void) clr_devtab();
# if defined(DCACHE_CLR)
(void) DCACHE_CLR();
# endif /* defined(DCACHE_CLR) */
return(1);
}
(void) crcbld();
DCcksum = 0;
(void) crc(buf, strlen(buf), &DCcksum);
i = 1;
cp = "";
# if defined(HASBLKDEV)
i++;
cp = "s";
# endif /* defined(HASBLKDEV) */
# if defined(DCACHE_CLONE)
i++;
cp = "s";
# endif /* defined(DCACHE_CLONE) */
# if defined(DCACHE_PSEUDO)
i++;
cp = "s";
# endif /* defined(DCACHE_PSEUDO) */
(void) snpf(cbuf, sizeof(cbuf), "%d section%s", i, cp);
len = strlen(cbuf);
(void) snpf(&cbuf[len], sizeof(cbuf) - len, ", dev=%lx\n",
(long)DevDev);
if (!strncmp(buf, cbuf, len) && (buf[len] == '\n')) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: no /dev device in %s: line ", Pn,
DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
if (strcmp(buf, cbuf)) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: bad section count line in %s: line ",
Pn, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
/*
* Read device section header and validate it.
*/
if (!fgets(buf, sizeof(buf), DCfs))
goto cant_read;
(void) crc(buf, strlen(buf), &DCcksum);
len = strlen("device section: ");
if (strncmp(buf, "device section: ", len) != 0) {
read_dhdr:
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: bad device section header in %s: line ",
Pn, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
/*
* Compute the device count; allocate Sdev[] and Devtp[] space.
*/
if ((Ndev = atoi(&buf[len])) < 1)
goto read_dhdr;
alloc_dcache();
/*
* Read the device lines and store their information in Devtp[].
* Construct the Sdev[] pointers to Devtp[].
*/
for (i = 0; i < Ndev; i++) {
if (!fgets(buf, sizeof(buf), DCfs)) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't read device %d from %s\n",
Pn, i + 1, DCpath[DCpathX]);
goto read_close;
}
(void) crc(buf, strlen(buf), &DCcksum);
/*
* Convert hexadecimal device number.
*/
if (!(cp = x2dev(buf, &Devtp[i].rdev)) || *cp != ' ') {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: device %d: bad device in %s: line ",
Pn, i + 1, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
/*
* Convert inode number.
*/
for (cp++, Devtp[i].inode = (INODETYPE)0; *cp != ' '; cp++) {
if (*cp < '0' || *cp > '9') {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: device %d: bad inode # in %s: line ",
Pn, i + 1, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
Devtp[i].inode = (INODETYPE)((Devtp[i].inode * 10)
+ (int)(*cp - '0'));
}
/*
* Get path name; allocate space for it; copy it; store the
* pointer in Devtp[]; clear verify status; construct the Sdev[]
* pointer to Devtp[].
*/
if ((len = strlen(++cp)) < 2 || *(cp + len - 1) != '\n') {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: device %d: bad path in %s: line ",
Pn, i + 1, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
*(cp + len - 1) = '\0';
if (!(Devtp[i].name = mkstrcpy(cp, (MALLOC_S *)NULL))) {
(void) fprintf(stderr,
"%s: device %d: no space for path: line ", Pn, i + 1);
safestrprt(buf, stderr, 1+4+8);
Exit(1);
}
Devtp[i].v = 0;
Sdev[i] = &Devtp[i];
}
# if defined(HASBLKDEV)
/*
* Read block device section header and validate it.
*/
if (!fgets(buf, sizeof(buf), DCfs))
goto cant_read;
(void) crc(buf, strlen(buf), &DCcksum);
len = strlen("block device section: ");
if (strncmp(buf, "block device section: ", len) != 0) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: bad block device section header in %s: line ",
Pn, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
/*
* Compute the block device count; allocate BSdev[] and BDevtp[] space.
*/
if ((BNdev = atoi(&buf[len])) > 0) {
alloc_bdcache();
/*
* Read the block device lines and store their information in BDevtp[].
* Construct the BSdev[] pointers to BDevtp[].
*/
for (i = 0; i < BNdev; i++) {
if (!fgets(buf, sizeof(buf), DCfs)) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't read block device %d from %s\n",
Pn, i + 1, DCpath[DCpathX]);
goto read_close;
}
(void) crc(buf, strlen(buf), &DCcksum);
/*
* Convert hexadecimal device number.
*/
if (!(cp = x2dev(buf, &BDevtp[i].rdev)) || *cp != ' ') {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: block dev %d: bad device in %s: line ",
Pn, i + 1, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
/*
* Convert inode number.
*/
for (cp++, BDevtp[i].inode = (INODETYPE)0; *cp != ' '; cp++) {
if (*cp < '0' || *cp > '9') {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: block dev %d: bad inode # in %s: line ",
Pn, i + 1, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
BDevtp[i].inode = (INODETYPE)((BDevtp[i].inode * 10)
+ (int)(*cp - '0'));
}
/*
* Get path name; allocate space for it; copy it; store the
* pointer in BDevtp[]; clear verify status; construct the BSdev[]
* pointer to BDevtp[].
*/
if ((len = strlen(++cp)) < 2 || *(cp + len - 1) != '\n') {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: block dev %d: bad path in %s: line",
Pn, i + 1, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
*(cp + len - 1) = '\0';
if (!(BDevtp[i].name = mkstrcpy(cp, (MALLOC_S *)NULL))) {
(void) fprintf(stderr,
"%s: block dev %d: no space for path: line", Pn, i + 1);
safestrprt(buf, stderr, 1+4+8);
Exit(1);
}
BDevtp[i].v = 0;
BSdev[i] = &BDevtp[i];
}
}
# endif /* defined(HASBLKDEV) */
# if defined(DCACHE_CLONE)
/*
* Read the clone section.
*/
if (DCACHE_CLONE(1))
goto read_close;
# endif /* defined(DCACHE_CLONE) */
# if defined(DCACHE_PSEUDO)
/*
* Read the pseudo section.
*/
if (DCACHE_PSEUDO(1))
goto read_close;
# endif /* defined(DCACHE_PSEUDO) */
/*
* Read and check the CRC section; it must be the last thing in the file.
*/
(void) snpf(cbuf, sizeof(cbuf), "CRC section: %x\n", DCcksum);
if (!fgets(buf, sizeof(buf), DCfs) || strcmp(buf, cbuf) != 0) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: bad CRC section in %s: line ",
Pn, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
if (fgets(buf, sizeof(buf), DCfs)) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: WARNING: data follows CRC section in %s: line ",
Pn, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
goto read_close;
}
/*
* Check one device entry at random -- the randomness based on our
* PID.
*/
i = (int)(Mypid % Ndev);
if (stat(Devtp[i].name, &sb) != 0
# if defined(DVCH_EXPDEV)
|| expdev(sb.st_rdev) != Devtp[i].rdev
# else /* !defined(DVCH_EXPDEV) */
|| sb.st_rdev != Devtp[i].rdev
# endif /* defined(DVCH_EXPDEV) */
|| sb.st_ino != Devtp[i].inode) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: device cache mismatch: %s\n",
Pn, Devtp[i].name);
goto read_close;
}
/*
* Close the device cache file and return OK.
*/
(void) fclose(DCfs);
DCfd = -1;
DCfs = (FILE *)NULL;
return(0);
}
# if defined(DCACHE_CLONE_LOCAL)
/*
* rw_clone_sect() - read/write the device cache file clone section
*/
static int
rw_clone_sect(m)
int m; /* mode: 1 = read; 2 = write */
{
char buf[MAXPATHLEN*2], *cp, *cp1;
struct clone *c;
struct l_dev *dp;
int i, j, len, n;
if (m == 1) {
/*
* Read the clone section header and validate it.
*/
if (!fgets(buf, sizeof(buf), DCfs)) {
bad_clone_sect:
if (!Fwarn) {
(void) fprintf(stderr,
"%s: bad clone section header in %s: line ",
Pn, DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
return(1);
}
(void) crc(buf, strlen(buf), &DCcksum);
len = strlen("clone section: ");
if (strncmp(buf, "clone section: ", len) != 0)
goto bad_clone_sect;
if ((n = atoi(&buf[len])) < 0)
goto bad_clone_sect;
/*
* Read the clone section lines and create the Clone list.
*/
for (i = 0; i < n; i++) {
if (fgets(buf, sizeof(buf), DCfs) == NULL) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: no %d clone line in %s: line ", Pn, i + 1,
DCpath[DCpathX]);
safestrprt(buf, stderr, 1+4+8);
}
return(1);
}
(void) crc(buf, strlen(buf), &DCcksum);
/*
* Assemble Devtp[] index and make sure it's correct.
*/
for (cp = buf, j = 0; *cp != ' '; cp++) {
if (*cp < '0' || *cp > '9') {
bad_clone_index:
if (!Fwarn) {
(void) fprintf(stderr,
"%s: clone %d: bad cached device index: line ",
Pn, i + 1);
safestrprt(buf, stderr, 1+4+8);
}
return(1);
}
j = (j * 10) + (int)(*cp - '0');
}
if (j < 0 || j >= Ndev || (cp1 = strchr(++cp, '\n')) == NULL)
goto bad_clone_index;
if (strncmp(cp, Devtp[j].name, (cp1 - cp)) != 0)
goto bad_clone_index;
/*
* Allocate and complete a clone structure.
*/
if (!(c = (struct clone *)malloc(sizeof(struct clone)))) {
(void) fprintf(stderr,
"%s: clone %d: no space for cached clone: line ", Pn,
i + 1);
safestrprt(buf, stderr, 1+4+8);
Exit(1);
}
c->dx = j;
c->next = Clone;
Clone = c;
}
return(0);
} else if (m == 2) {
/*
* Write the clone section header.
*/
for (c = Clone, n = 0; c; c = c->next, n++)
;
(void) snpf(buf, sizeof(buf), "clone section: %d\n", n);
if (wr2DCfd(buf, &DCcksum))
return(1);
/*
* Write the clone section lines.
*/
for (c = Clone; c; c = c->next) {
for (dp = &Devtp[c->dx], j = 0; j < Ndev; j++) {
if (dp == Sdev[j])
break;
}
if (j >= Ndev) {
if (!Fwarn) {
(void) fprintf(stderr,
"%s: can't make index for clone: ", Pn);
safestrprt(dp->name, stderr, 1);
}
(void) unlink(DCpath[DCpathX]);
(void) close(DCfd);
DCfd = -1;
return(1);
}
(void) snpf(buf, sizeof(buf), "%d %s\n", j, dp->name);
if (wr2DCfd(buf, &DCcksum))
return(1);
}
return(0);
}
/*
* A shouldn't-happen case: mode neither 1 nor 2.
*/
(void) fprintf(stderr, "%s: internal rw_clone_sect error: %d\n",
Pn, m);
Exit(1);
return(1); /* This useless return(1) keeps some
* compilers happy. */
}
# endif /* defined(DCACHE_CLONE_LOCAL) */
/*
* write_dcache() - write device cache file
*/
void
write_dcache()
{
char buf[MAXPATHLEN*2], *cp;
struct l_dev *dp;
int i;
struct stat sb;
/*
* Open the cache file; set up the CRC table; write the section count.
*/
if (open_dcache(2, 0, &sb))
return;
i = 1;
cp = "";
# if defined(HASBLKDEV)
i++;
cp = "s";
# endif /* defined(HASBLKDEV) */
# if defined(DCACHE_CLONE)
i++;
cp = "s";
# endif /* defined(DCACHE_CLONE) */
# if defined(DCACHE_PSEUDO)
i++;
cp = "s";
# endif /* defined(DCACHE_PSEUDO) */
(void) snpf(buf, sizeof(buf), "%d section%s, dev=%lx\n", i, cp,
(long)DevDev);
(void) crcbld();
DCcksum = 0;
if (wr2DCfd(buf, &DCcksum))
return;
/*
* Write the device section from the contents of Sdev[] and Devtp[].
*/
(void) snpf(buf, sizeof(buf), "device section: %d\n", Ndev);
if (wr2DCfd(buf, &DCcksum))
return;
for (i = 0; i < Ndev; i++) {
dp = Sdev[i];
(void) snpf(buf, sizeof(buf), "%lx %ld %s\n", (long)dp->rdev,
(long)dp->inode, dp->name);
if (wr2DCfd(buf, &DCcksum))
return;
}
# if defined(HASBLKDEV)
/*
* Write the block device section from the contents of BSdev[] and BDevtp[].
*/
(void) snpf(buf, sizeof(buf), "block device section: %d\n", BNdev);
if (wr2DCfd(buf, &DCcksum))
return;
if (BNdev) {
for (i = 0; i < BNdev; i++) {
dp = BSdev[i];
(void) snpf(buf, sizeof(buf), "%lx %ld %s\n", (long)dp->rdev,
(long)dp->inode, dp->name);
if (wr2DCfd(buf, &DCcksum))
return;
}
}
# endif /* defined(HASBLKDEV) */
# if defined(DCACHE_CLONE)
/*
* Write the clone section.
*/
if (DCACHE_CLONE(2))
return;
# endif /* defined(DCACHE_CLONE) */
# if defined(DCACHE_PSEUDO)
/*
* Write the pseudo section.
*/
if (DCACHE_PSEUDO(2))
return;
# endif /* defined(DCACHE_PSEUDO) */
/*
* Write the CRC section and close the file.
*/
(void) snpf(buf, sizeof(buf), "CRC section: %x\n", DCcksum);
if (wr2DCfd(buf, (unsigned *)NULL))
return;
if (close(DCfd) != 0) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't close %s: %s\n",
Pn, DCpath[DCpathX], strerror(errno));
(void) unlink(DCpath[DCpathX]);
DCfd = -1;
}
DCfd = -1;
/*
* If the previous reading of the previous device cache file marked it
* "unsafe," drop that marking and record that the device cache file was
* rebuilt.
*/
if (DCunsafe) {
DCunsafe = 0;
DCrebuilt = 1;
}
}
/*
* wr2DCfd() - write to the DCfd file descriptor
*/
int
wr2DCfd(b, c)
char *b; /* buffer */
unsigned *c; /* checksum receiver */
{
int bl, bw;
bl = strlen(b);
if (c)
(void) crc(b, bl, c);
while (bl > 0) {
if ((bw = write(DCfd, b, bl)) < 0) {
if (!Fwarn)
(void) fprintf(stderr,
"%s: WARNING: can't write to %s: %s\n",
Pn, DCpath[DCpathX], strerror(errno));
(void) unlink(DCpath[DCpathX]);
(void) close(DCfd);
DCfd = -1;
return(1);
}
b += bw;
bl -= bw;
}
return(0);
}
#else /* !defined(HASDCACHE) */
char dvch_d1[] = "d"; char *dvch_d2 = dvch_d1;
#endif /* defined(HASDCACHE) */