* 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
* 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. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. 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
static char sccsid
[] = "@(#)dirs.c 8.2 (Berkeley) 1/21/94";
#include <ufs/ufs/dinode.h>
#include <protocols/dumprestore.h>
* Symbol table of directories read from tape.
#define INOHASH(val) (val % HASHSIZE)
static struct inotab
*inotab
[HASHSIZE
];
* Information retained about directories.
* Definitions for library routines operating on directories.
* Global variables for this file.
static char dirfile
[32] = "#"; /* No file */
static char modefile
[32] = "#"; /* No file */
static char dot
[2] = "."; /* So it can be modified */
* Format of old style directories.
static struct inotab
*allocinotab
__P((ino_t
, struct dinode
*, long));
static void dcvt
__P((struct odirect
*, struct direct
*));
static void flushent
__P((void));
static struct inotab
*inotablookup
__P((ino_t
));
static RST_DIR
*opendirfile
__P((const char *));
static void putdir
__P((char *, long));
static void putent
__P((struct direct
*));
static void rst_seekdir
__P((RST_DIR
*, long, long));
static long rst_telldir
__P((RST_DIR
*));
static struct direct
*searchdir
__P((ino_t
, char *));
* 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.
register struct dinode
*ip
;
vprintf(stdout
, "Extract directories from tape\n");
(void) sprintf(dirfile
, "%s/rstdir%d", _PATH_TMP
, dumpdate
);
df
= fopen(dirfile
, "w");
"restore: %s - cannot create directory temporary\n",
fprintf(stderr
, "fopen: %s\n", strerror(errno
));
(void) sprintf(modefile
, "%s/rstmode%d", _PATH_TMP
, dumpdate
);
mf
= fopen(modefile
, "w");
"restore: %s - cannot create modefile \n",
fprintf(stderr
, "fopen: %s\n", strerror(errno
));
(void) strcpy(nulldir
.d_name
, "/");
nulldir
.d_reclen
= DIRSIZ(0, &nulldir
);
curfile
.name
= "<directory file - name unknown>";
if (ip
== NULL
|| (ip
->di_mode
& IFMT
) != IFDIR
) {
dirp
= opendirfile(dirfile
);
fprintf(stderr
, "opendirfile: %s\n",
panic("Root directory is not on tape\n");
itp
= allocinotab(curfile
.ino
, ip
, seekpt
);
getfile(putdir
, xtrnull
);
itp
->t_size
= seekpt
- itp
->t_seekpt
;
* skip over all the directories on the tape
while ((curfile
.dip
->di_mode
& IFMT
) == IFDIR
) {
* Recursively find names and inumbers of all files in subtree
* pname and pass them off to be processed.
treescan(pname
, ino
, todo
)
long (*todo
) __P((char *, ino_t
, int));
register struct inotab
*itp
;
register struct direct
*dp
;
char locname
[MAXPATHLEN
+ 1];
* Pname is name of a simple file or an unchanged directory.
(void) (*todo
)(pname
, ino
, LEAF
);
* Pname is a dumped directory name.
if ((*todo
)(pname
, ino
, NODE
) == FAIL
)
* begin search through the directory
* skipping over "." and ".."
(void) strncpy(locname
, pname
, MAXPATHLEN
);
(void) strncat(locname
, "/", MAXPATHLEN
);
namelen
= strlen(locname
);
rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
dp
= rst_readdir(dirp
); /* "." */
if (dp
!= NULL
&& strcmp(dp
->d_name
, ".") == 0)
dp
= rst_readdir(dirp
); /* ".." */
fprintf(stderr
, "Warning: `.' missing from directory %s\n",
if (dp
!= NULL
&& strcmp(dp
->d_name
, "..") == 0)
dp
= rst_readdir(dirp
); /* first real entry */
fprintf(stderr
, "Warning: `..' missing from directory %s\n",
* a zero inode signals end of directory
while (dp
!= NULL
&& dp
->d_ino
!= 0) {
if (namelen
+ dp
->d_namlen
>= MAXPATHLEN
) {
fprintf(stderr
, "%s%s: name exceeds %d char\n",
locname
, dp
->d_name
, MAXPATHLEN
);
(void) strncat(locname
, dp
->d_name
, (int)dp
->d_namlen
);
treescan(locname
, dp
->d_ino
, todo
);
rst_seekdir(dirp
, bpt
, itp
->t_seekpt
);
fprintf(stderr
, "corrupted directory: %s.\n", locname
);
* Lookup a pathname which is always assumed to start from the ROOTINO.
char *path
, *name
, buffer
[MAXPATHLEN
];
strcpy(buffer
, pathname
);
while ((name
= strsep(&path
, "/")) != NULL
&& *name
!= NULL
) {
if ((dp
= searchdir(ino
, name
)) == NULL
)
* Lookup the requested name in directory inum.
* Return its inode number if found, zero if it does not exist.
register struct direct
*dp
;
register struct inotab
*itp
;
itp
= inotablookup(inum
);
rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
if (dp
== NULL
|| dp
->d_ino
== 0)
} while (dp
->d_namlen
!= len
|| strncmp(dp
->d_name
, name
, len
) != 0);
* Put the directory entries in the directory file
register struct odirect
*odp
;
register struct direct
*dp
;
eodp
= (struct odirect
*)&buf
[size
];
for (odp
= (struct odirect
*)buf
; odp
< eodp
; odp
++)
for (loc
= 0; loc
< size
; ) {
dp
= (struct direct
*)(buf
+ loc
);
swabst((u_char
*)"l2s", (u_char
*) dp
);
swabst((u_char
*)"ls", (u_char
*) dp
);
i
= DIRBLKSIZ
- (loc
& (DIRBLKSIZ
- 1));
if ((dp
->d_reclen
& 0x3) != 0 ||
dp
->d_reclen
< DIRSIZ(0, dp
) ||
dp
->d_namlen
> NAME_MAX
) {
vprintf(stdout
, "Mangled directory: ");
if ((dp
->d_reclen
& 0x3) != 0)
"reclen not multiple of 4 ");
if (dp
->d_reclen
< DIRSIZ(0, dp
))
"reclen less than DIRSIZ (%d < %d) ",
dp
->d_reclen
, DIRSIZ(0, dp
));
if (dp
->d_namlen
> NAME_MAX
)
"reclen name too big (%d > %d) ",
* These variables are "local" to the following two functions.
* add a new directory entry to a file.
dp
->d_reclen
= DIRSIZ(0, dp
);
if (dirloc
+ dp
->d_reclen
> DIRBLKSIZ
) {
((struct direct
*)(dirbuf
+ prev
))->d_reclen
=
(void) fwrite(dirbuf
, 1, DIRBLKSIZ
, df
);
bcopy((char *)dp
, dirbuf
+ dirloc
, (long)dp
->d_reclen
);
* flush out a directory that is finished.
((struct direct
*)(dirbuf
+ prev
))->d_reclen
= DIRBLKSIZ
- prev
;
(void) fwrite(dirbuf
, (int)dirloc
, 1, df
);
register struct odirect
*odp
;
register struct direct
*ndp
;
bzero((char *)ndp
, (long)(sizeof *ndp
));
ndp
->d_type
= DT_UNKNOWN
;
(void) strncpy(ndp
->d_name
, odp
->d_name
, ODIRSIZ
);
ndp
->d_namlen
= strlen(ndp
->d_name
);
ndp
->d_reclen
= DIRSIZ(0, ndp
);
* 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.
rst_seekdir(dirp
, loc
, base
)
if (loc
== rst_telldir(dirp
))
fprintf(stderr
, "bad seek pointer to rst_seekdir %d\n", loc
);
(void) lseek(dirp
->dd_fd
, base
+ (loc
& ~(DIRBLKSIZ
- 1)), SEEK_SET
);
dirp
->dd_loc
= loc
& (DIRBLKSIZ
- 1);
dirp
->dd_size
= read(dirp
->dd_fd
, dirp
->dd_buf
, DIRBLKSIZ
);
* get next entry in a directory.
register struct direct
*dp
;
dirp
->dd_size
= read(dirp
->dd_fd
, dirp
->dd_buf
,
if (dirp
->dd_size
<= 0) {
dprintf(stderr
, "error reading directory\n");
if (dirp
->dd_loc
>= dirp
->dd_size
) {
dp
= (struct direct
*)(dirp
->dd_buf
+ dirp
->dd_loc
);
dp
->d_reclen
> DIRBLKSIZ
+ 1 - dirp
->dd_loc
) {
dprintf(stderr
, "corrupted directory: bad reclen %d\n",
dirp
->dd_loc
+= dp
->d_reclen
;
if (dp
->d_ino
== 0 && strcmp(dp
->d_name
, "/") != 0)
if (dp
->d_ino
>= maxino
) {
dprintf(stderr
, "corrupted directory: bad inum %d\n",
* Simulate the opening of a directory
if ((ino
= dirlookup(name
)) > 0 &&
(itp
= inotablookup(ino
)) != NULL
) {
dirp
= opendirfile(dirfile
);
rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
* In our case, there is nothing to do when closing a directory.
(void)close(dirp
->dd_fd
);
* Simulate finding the current offset in the directory.
return ((long)lseek(dirp
->dd_fd
,
(off_t
)0, SEEK_CUR
) - dirp
->dd_size
+ dirp
->dd_loc
);
if ((fd
= open(name
, O_RDONLY
)) == -1)
if ((dirp
= malloc(sizeof(RST_DIR
))) == NULL
) {
* Set the mode, owner, and times for all new or changed directories
vprintf(stdout
, "Set directory mode, owner, and times.\n");
(void) sprintf(modefile
, "%s/rstmode%d", _PATH_TMP
, dumpdate
);
mf
= fopen(modefile
, "r");
fprintf(stderr
, "fopen: %s\n", strerror(errno
));
fprintf(stderr
, "cannot open mode file %s\n", modefile
);
fprintf(stderr
, "directory mode, owner, and times not set\n");
(void) fread((char *)&node
, 1, sizeof(struct modeinfo
), mf
);
ep
= lookupino(node
.ino
);
if (command
== 'i' || command
== 'x') {
if ((flags
& FORCE
) == 0 && ep
->e_flags
& EXISTED
) {
if (node
.ino
== ROOTINO
&&
reply("set owner/mode for '.'") == FAIL
)
panic("cannot find directory inode %d\n", node
.ino
);
(void) chown(cp
, node
.uid
, node
.gid
);
(void) chmod(cp
, node
.mode
);
panic("error setting directory modes\n");
* Generate a literal copy of a directory.
register struct inotab
*itp
;
panic("Cannot find directory inode %d named %s\n", ino
, name
);
if ((ofile
= creat(name
, 0666)) < 0) {
fprintf(stderr
, "%s: ", name
);
fprintf(stderr
, "cannot create file: %s\n", strerror(errno
));
rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
for (i
= itp
->t_size
; i
> 0; i
-= BUFSIZ
) {
size
= i
< BUFSIZ
? i
: BUFSIZ
;
if (read(dp
, buf
, (int) size
) == -1) {
"write error extracting inode %d, name %s\n",
curfile
.ino
, curfile
.name
);
fprintf(stderr
, "read: %s\n", strerror(errno
));
if (!Nflag
&& write(ofile
, buf
, (int) size
) == -1) {
"write error extracting inode %d, name %s\n",
curfile
.ino
, curfile
.name
);
fprintf(stderr
, "write: %s\n", strerror(errno
));
* Determine the type of an inode
* Allocate and initialize a directory inode entry.
* If requested, save its pertinent mode, owner, and time info.
allocinotab(ino
, dip
, seekpt
)
register struct inotab
*itp
;
itp
= calloc(1, sizeof(struct inotab
));
panic("no memory directory table\n");
itp
->t_next
= inotab
[INOHASH(ino
)];
inotab
[INOHASH(ino
)] = itp
;
node
.timep
[0].tv_sec
= dip
->di_atime
.ts_sec
;
node
.timep
[0].tv_usec
= dip
->di_atime
.ts_nsec
/ 1000;
node
.timep
[1].tv_sec
= dip
->di_mtime
.ts_sec
;
node
.timep
[1].tv_usec
= dip
->di_mtime
.ts_nsec
/ 1000;
node
.mode
= dip
->di_mode
;
(void) fwrite((char *)&node
, 1, sizeof(struct modeinfo
), mf
);
* Look up an inode in the table of directories
register struct inotab
*itp
;
for (itp
= inotab
[INOHASH(ino
)]; itp
!= NULL
; itp
= itp
->t_next
)