]>
git.wh0rd.org - dump.git/blob - restore/dirs.c
2 * Ported to Linux's Second Extended File System as part of the
3 * dump and restore backup suit
4 * Remy Card <card@Linux.EU.Org>, 1994-1997
5 * Stelian Pop <pop@cybercable.fr>, 1999
10 * Copyright (c) 1983, 1993
11 * The Regents of the University of California. All rights reserved.
12 * (c) UNIX System Laboratories, Inc.
13 * All or some portions of this file are derived from material licensed
14 * to the University of California by American Telephone and Telegraph
15 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
16 * the permission of UNIX System Laboratories, Inc.
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 3. All advertising materials mentioning features or use of this software
27 * must display the following acknowledgement:
28 * This product includes software developed by the University of
29 * California, Berkeley and its contributors.
30 * 4. Neither the name of the University nor the names of its contributors
31 * may be used to endorse or promote products derived from this software
32 * without specific prior written permission.
34 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
35 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
49 static char sccsid
[] = "@(#)dirs.c 8.7 (Berkeley) 5/1/95";
51 static const char rcsid
[] =
52 "$Id: dirs.c,v 1.2 1999/10/11 12:53:23 stelian Exp $";
55 #include <sys/param.h>
60 #include <linux/ext2_fs.h>
61 #include <bsdcompat.h>
63 #include <ufs/ufs/dinode.h>
64 #include <ufs/ufs/dir.h>
65 #endif /* __linux__ */
66 #include <protocols/dumprestore.h>
78 #include <machine/endian.h>
81 #include "pathnames.h"
86 * Symbol table of directories read from tape.
89 #define INOHASH(val) (val % HASHSIZE)
91 struct inotab
*t_next
;
96 static struct inotab
*inotab
[HASHSIZE
];
99 * Information retained about directories.
103 struct timeval timep
[2];
111 * Definitions for library routines operating on directories.
114 #define DIRBLKSIZ 1024
119 char dd_buf
[DIRBLKSIZ
];
123 * Global variables for this file.
126 static FILE *df
, *mf
;
127 static RST_DIR
*dirp
;
128 static char dirfile
[MAXPATHLEN
] = "#"; /* No file */
129 static char modefile
[MAXPATHLEN
] = "#"; /* No file */
130 static char dot
[2] = "."; /* So it can be modified */
133 * Format of old style directories.
138 char d_name
[ODIRSIZ
];
142 static struct inotab
*allocinotab
__P((ino_t
, struct new_bsd_inode
*, long));
144 static struct inotab
*allocinotab
__P((ino_t
, struct dinode
*, long));
146 static void dcvt
__P((struct odirect
*, struct direct
*));
147 static void flushent
__P((void));
148 static struct inotab
*inotablookup
__P((ino_t
));
149 static RST_DIR
*opendirfile
__P((const char *));
150 static void putdir
__P((char *, long));
151 static void putent
__P((struct direct
*));
152 static void rst_seekdir
__P((RST_DIR
*, long, long));
153 static long rst_telldir
__P((RST_DIR
*));
154 static struct direct
*searchdir
__P((ino_t
, char *));
157 * Extract directory contents, building up a directory structure
158 * on disk for extraction by name.
159 * If genmode is requested, save mode, owner, and times for all
160 * directories on the tape.
168 register struct new_bsd_inode
*ip
;
170 register struct dinode
*ip
;
173 struct direct nulldir
;
176 vprintf(stdout
, "Extract directories from tape\n");
177 (void) sprintf(dirfile
, "%s/rstdir%ld", tmpdir
, dumpdate
);
178 if (command
!= 'r' && command
!= 'R') {
179 (void *) strcat(dirfile
, "-XXXXXX");
180 fd
= mkstemp(dirfile
);
182 fd
= open(dirfile
, O_RDWR
|O_CREAT
|O_EXCL
, 0666);
183 if (fd
== -1 || (df
= fdopen(fd
, "w")) == NULL
) {
186 warn("%s - cannot create directory temporary\nfopen", dirfile
);
190 (void) sprintf(modefile
, "%s/rstmode%ld", tmpdir
, dumpdate
);
191 if (command
!= 'r' && command
!= 'R') {
192 (void *) strcat(modefile
, "-XXXXXX");
193 fd
= mkstemp(modefile
);
195 fd
= open(modefile
, O_RDWR
|O_CREAT
|O_EXCL
, 0666);
196 if (fd
== -1 || (mf
= fdopen(fd
, "w")) == NULL
) {
199 warn("%s - cannot create modefile\nfopen", modefile
);
204 nulldir
.d_type
= DT_DIR
;
205 nulldir
.d_namlen
= 1;
206 (void) strcpy(nulldir
.d_name
, "/");
207 nulldir
.d_reclen
= DIRSIZ(0, &nulldir
);
209 curfile
.name
= "<directory file - name unknown>";
210 curfile
.action
= USING
;
212 if (ip
== NULL
|| (ip
->di_mode
& IFMT
) != IFDIR
) {
214 dirp
= opendirfile(dirfile
);
216 fprintf(stderr
, "opendirfile: %s\n",
222 panic("Root directory is not on tape\n");
225 itp
= allocinotab(curfile
.ino
, ip
, seekpt
);
226 getfile(putdir
, xtrnull
);
229 itp
->t_size
= seekpt
- itp
->t_seekpt
;
234 * skip over all the directories on the tape
240 while (curfile
.dip
&& (curfile
.dip
->di_mode
& IFMT
) == IFDIR
) {
246 * Recursively find names and inumbers of all files in subtree
247 * pname and pass them off to be processed.
250 treescan(pname
, ino
, todo
)
253 long (*todo
) __P((char *, ino_t
, int));
255 register struct inotab
*itp
;
256 register struct direct
*dp
;
259 char locname
[MAXPATHLEN
+ 1];
261 itp
= inotablookup(ino
);
264 * Pname is name of a simple file or an unchanged directory.
266 (void) (*todo
)(pname
, ino
, LEAF
);
270 * Pname is a dumped directory name.
272 if ((*todo
)(pname
, ino
, NODE
) == FAIL
)
275 * begin search through the directory
276 * skipping over "." and ".."
278 (void) strncpy(locname
, pname
, sizeof(locname
) - 1);
279 locname
[sizeof(locname
) - 1] = '\0';
280 (void) strncat(locname
, "/", sizeof(locname
) - strlen(locname
));
281 namelen
= strlen(locname
);
282 rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
283 dp
= rst_readdir(dirp
); /* "." */
284 if (dp
!= NULL
&& strcmp(dp
->d_name
, ".") == 0)
285 dp
= rst_readdir(dirp
); /* ".." */
287 fprintf(stderr
, "Warning: `.' missing from directory %s\n",
289 if (dp
!= NULL
&& strcmp(dp
->d_name
, "..") == 0)
290 dp
= rst_readdir(dirp
); /* first real entry */
292 fprintf(stderr
, "Warning: `..' missing from directory %s\n",
294 bpt
= rst_telldir(dirp
);
296 * a zero inode signals end of directory
299 locname
[namelen
] = '\0';
300 if (namelen
+ dp
->d_namlen
>= sizeof(locname
)) {
301 fprintf(stderr
, "%s%s: name exceeds %d char\n",
302 locname
, dp
->d_name
, sizeof(locname
) - 1);
304 (void) strncat(locname
, dp
->d_name
, (int)dp
->d_namlen
);
305 treescan(locname
, dp
->d_ino
, todo
);
306 rst_seekdir(dirp
, bpt
, itp
->t_seekpt
);
308 dp
= rst_readdir(dirp
);
309 bpt
= rst_telldir(dirp
);
314 * Lookup a pathname which is always assumed to start from the ROOTINO.
318 const char *pathname
;
322 char *path
, *name
, buffer
[MAXPATHLEN
];
324 strcpy(buffer
, pathname
);
330 while ((name
= strsep(&path
, "/")) != NULL
&& *name
!= '\0') {
331 if ((dp
= searchdir(ino
, name
)) == NULL
)
339 * Lookup the requested name in directory inum.
340 * Return its inode number if found, zero if it does not exist.
342 static struct direct
*
343 searchdir(inum
, name
)
347 register struct direct
*dp
;
348 register struct inotab
*itp
;
351 itp
= inotablookup(inum
);
354 rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
357 dp
= rst_readdir(dirp
);
360 } while (dp
->d_namlen
!= len
|| strncmp(dp
->d_name
, name
, len
) != 0);
365 * Put the directory entries in the directory file
372 struct direct cvtbuf
;
373 register struct odirect
*odp
;
374 struct odirect
*eodp
;
375 register struct direct
*dp
;
379 eodp
= (struct odirect
*)&buf
[size
];
380 for (odp
= (struct odirect
*)buf
; odp
< eodp
; odp
++)
381 if (odp
->d_ino
!= 0) {
386 for (loc
= 0; loc
< size
; ) {
387 dp
= (struct direct
*)(buf
+ loc
);
389 printf ("reclen = %d, namlen = %d, type = %d\n",
390 dp
->d_reclen
, dp
->d_namlen
, dp
->d_type
);
393 swabst((u_char
*)"ls", (u_char
*) dp
);
394 if (oldinofmt
&& dp
->d_ino
!= 0) {
397 swabst((u_char
*)"s", (u_char
*)&dp
->d_namlen
);
399 # if BYTE_ORDER == BIG_ENDIAN
401 dp
->d_namlen
= dp
->d_type
;
404 dp
->d_namlen
= dp
->d_type
;
406 #endif /* __linux__ */
407 dp
->d_type
= DT_UNKNOWN
;
411 * Horrible hack to read FreeBSD 2.0 dumps
414 swabst((u_char
*)"6bs", (u_char
*) dp
);
415 #endif /* __linux__ */
417 printf ("reclen = %d, namlen = %d, type = %d\n",
418 dp
->d_reclen
, dp
->d_namlen
, dp
->d_type
);
420 i
= DIRBLKSIZ
- (loc
& (DIRBLKSIZ
- 1));
421 if ((dp
->d_reclen
& 0x3) != 0 ||
423 dp
->d_reclen
< DIRSIZ(0, dp
) ||
424 dp
->d_namlen
> NAME_MAX
) {
425 vprintf(stdout
, "Mangled directory: ");
426 if ((dp
->d_reclen
& 0x3) != 0)
428 "reclen not multiple of 4 ");
429 if (dp
->d_reclen
< DIRSIZ(0, dp
))
431 "reclen less than DIRSIZ (%d < %d) ",
432 dp
->d_reclen
, DIRSIZ(0, dp
));
433 if (dp
->d_namlen
> NAME_MAX
)
435 "reclen name too big (%d > %d) ",
436 dp
->d_namlen
, NAME_MAX
);
437 vprintf(stdout
, "\n");
442 if (dp
->d_ino
!= 0) {
450 * These variables are "local" to the following two functions.
452 char dirbuf
[DIRBLKSIZ
];
457 * add a new directory entry to a file.
463 dp
->d_reclen
= DIRSIZ(0, dp
);
464 if (dirloc
+ dp
->d_reclen
> DIRBLKSIZ
) {
465 ((struct direct
*)(dirbuf
+ prev
))->d_reclen
=
467 (void) fwrite(dirbuf
, 1, DIRBLKSIZ
, df
);
470 memmove(dirbuf
+ dirloc
, dp
, (long)dp
->d_reclen
);
472 dirloc
+= dp
->d_reclen
;
476 * flush out a directory that is finished.
481 ((struct direct
*)(dirbuf
+ prev
))->d_reclen
= DIRBLKSIZ
- prev
;
482 (void) fwrite(dirbuf
, (int)dirloc
, 1, df
);
489 register struct odirect
*odp
;
490 register struct direct
*ndp
;
493 memset(ndp
, 0, (long)(sizeof *ndp
));
494 ndp
->d_ino
= odp
->d_ino
;
495 ndp
->d_type
= DT_UNKNOWN
;
496 (void) strncpy(ndp
->d_name
, odp
->d_name
, ODIRSIZ
);
497 ndp
->d_namlen
= strlen(ndp
->d_name
);
498 ndp
->d_reclen
= DIRSIZ(0, ndp
);
502 * Seek to an entry in a directory.
503 * Only values returned by rst_telldir should be passed to rst_seekdir.
504 * This routine handles many directories in a single file.
505 * It takes the base of the directory in the file, plus
506 * the desired seek offset into it.
509 rst_seekdir(dirp
, loc
, base
)
510 register RST_DIR
*dirp
;
514 if (loc
== rst_telldir(dirp
))
518 fprintf(stderr
, "bad seek pointer to rst_seekdir %ld\n", loc
);
519 (void) lseek(dirp
->dd_fd
, base
+ (loc
& ~(DIRBLKSIZ
- 1)), SEEK_SET
);
520 dirp
->dd_loc
= loc
& (DIRBLKSIZ
- 1);
521 if (dirp
->dd_loc
!= 0)
522 dirp
->dd_size
= read(dirp
->dd_fd
, dirp
->dd_buf
, DIRBLKSIZ
);
526 * get next entry in a directory.
530 register RST_DIR
*dirp
;
532 register struct direct
*dp
;
535 if (dirp
->dd_loc
== 0) {
536 dirp
->dd_size
= read(dirp
->dd_fd
, dirp
->dd_buf
,
538 if (dirp
->dd_size
<= 0) {
539 dprintf(stderr
, "error reading directory\n");
543 if (dirp
->dd_loc
>= dirp
->dd_size
) {
547 dp
= (struct direct
*)(dirp
->dd_buf
+ dirp
->dd_loc
);
548 if (dp
->d_reclen
== 0 ||
549 dp
->d_reclen
> DIRBLKSIZ
+ 1 - dirp
->dd_loc
) {
550 dprintf(stderr
, "corrupted directory: bad reclen %d\n",
554 dirp
->dd_loc
+= dp
->d_reclen
;
555 if (dp
->d_ino
== 0 && strcmp(dp
->d_name
, "/") == 0)
557 if (dp
->d_ino
>= maxino
) {
558 dprintf(stderr
, "corrupted directory: bad inum %d\n",
567 * Simulate the opening of a directory
577 if ((ino
= dirlookup(name
)) > 0 &&
578 (itp
= inotablookup(ino
)) != NULL
) {
579 dirp
= opendirfile(dirfile
);
580 rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
587 * In our case, there is nothing to do when closing a directory.
594 (void)close(dirp
->dd_fd
);
600 * Simulate finding the current offset in the directory.
606 return ((long)lseek(dirp
->dd_fd
,
607 (off_t
)0, SEEK_CUR
) - dirp
->dd_size
+ dirp
->dd_loc
);
611 * Open a directory file.
617 register RST_DIR
*dirp
;
620 if ((fd
= open(name
, O_RDONLY
)) == -1)
622 if ((dirp
= malloc(sizeof(RST_DIR
))) == NULL
) {
632 * Set the mode, owner, and times for all new or changed directories
639 struct modeinfo node
;
643 vprintf(stdout
, "Set directory mode, owner, and times.\n");
644 if (command
== 'r' || command
== 'R')
645 (void) sprintf(modefile
, "%s/rstmode%ld", tmpdir
, dumpdate
);
646 if (modefile
[0] == '#') {
647 panic("modefile not defined\n");
648 fprintf(stderr
, "directory mode, owner, and times not set\n");
651 mf
= fopen(modefile
, "r");
653 fprintf(stderr
, "fopen: %s\n", strerror(errno
));
654 fprintf(stderr
, "cannot open mode file %s\n", modefile
);
655 fprintf(stderr
, "directory mode, owner, and times not set\n");
660 (void) fread((char *)&node
, 1, sizeof(struct modeinfo
), mf
);
663 ep
= lookupino(node
.ino
);
664 if (command
== 'i' || command
== 'x') {
667 if ((flags
& FORCE
) == 0 && ep
->e_flags
& EXISTED
) {
671 if (node
.ino
== ROOTINO
&&
672 reply("set owner/mode for '.'") == FAIL
)
676 panic("cannot find directory inode %d\n", node
.ino
);
679 (void) chown(cp
, node
.uid
, node
.gid
);
680 (void) chmod(cp
, node
.mode
);
682 (void) setflags(cp
, node
.flags
);
684 (void) chflags(cp
, node
.flags
);
686 utimes(cp
, node
.timep
);
691 panic("error setting directory modes\n");
696 * Generate a literal copy of a directory.
699 genliteraldir(name
, ino
)
703 register struct inotab
*itp
;
704 int ofile
, dp
, i
, size
;
707 itp
= inotablookup(ino
);
709 panic("Cannot find directory inode %d named %s\n", ino
, name
);
710 if ((ofile
= open(name
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0666)) < 0) {
711 fprintf(stderr
, "%s: ", name
);
712 (void) fflush(stderr
);
713 fprintf(stderr
, "cannot create file: %s\n", strerror(errno
));
716 rst_seekdir(dirp
, itp
->t_seekpt
, itp
->t_seekpt
);
717 dp
= dup(dirp
->dd_fd
);
718 for (i
= itp
->t_size
; i
> 0; i
-= BUFSIZ
) {
719 size
= i
< BUFSIZ
? i
: BUFSIZ
;
720 if (read(dp
, buf
, (int) size
) == -1) {
722 "write error extracting inode %ld, name %s\n",
723 curfile
.ino
, curfile
.name
);
724 fprintf(stderr
, "read: %s\n", strerror(errno
));
727 if (!Nflag
&& write(ofile
, buf
, (int) size
) == -1) {
729 "write error extracting inode %ld, name %s\n",
730 curfile
.ino
, curfile
.name
);
731 fprintf(stderr
, "write: %s\n", strerror(errno
));
741 * Determine the type of an inode
749 itp
= inotablookup(ino
);
756 * Allocate and initialize a directory inode entry.
757 * If requested, save its pertinent mode, owner, and time info.
759 static struct inotab
*
760 allocinotab(ino
, dip
, seekpt
)
763 struct new_bsd_inode
*dip
;
769 register struct inotab
*itp
;
770 struct modeinfo node
;
772 itp
= calloc(1, sizeof(struct inotab
));
774 panic("no memory directory table\n");
775 itp
->t_next
= inotab
[INOHASH(ino
)];
776 inotab
[INOHASH(ino
)] = itp
;
778 itp
->t_seekpt
= seekpt
;
783 node
.timep
[0].tv_sec
= dip
->di_atime
.tv_sec
;
784 node
.timep
[0].tv_usec
= dip
->di_atime
.tv_usec
;
785 node
.timep
[1].tv_sec
= dip
->di_mtime
.tv_sec
;
786 node
.timep
[1].tv_usec
= dip
->di_mtime
.tv_usec
;
787 #else /* __linux__ */
788 node
.timep
[0].tv_sec
= dip
->di_atime
;
789 node
.timep
[0].tv_usec
= dip
->di_atimensec
/ 1000;
790 node
.timep
[1].tv_sec
= dip
->di_mtime
;
791 node
.timep
[1].tv_usec
= dip
->di_mtimensec
/ 1000;
792 #endif /* __linux__ */
793 node
.mode
= dip
->di_mode
;
794 node
.flags
= dip
->di_flags
;
795 node
.uid
= dip
->di_uid
;
796 node
.gid
= dip
->di_gid
;
797 (void) fwrite((char *)&node
, 1, sizeof(struct modeinfo
), mf
);
802 * Look up an inode in the table of directories
804 static struct inotab
*
808 register struct inotab
*itp
;
810 for (itp
= inotab
[INOHASH(ino
)]; itp
!= NULL
; itp
= itp
->t_next
)
811 if (itp
->t_ino
== ino
)
825 if (modefile
[0] != '#')
826 (void) unlink(modefile
);
827 if (dirfile
[0] != '#')
828 (void) unlink(dirfile
);