xref: /netbsd-src/sbin/restore/interactive.c (revision daa5207d2584944709b3cba6eee4db745b3dd123)
1 /*	$NetBSD: interactive.c,v 1.31 2021/08/29 09:17:58 christos Exp $	*/
2 
3 /*
4  * Copyright (c) 1985, 1993
5  *	The Regents of the University of California.  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  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #include <sys/cdefs.h>
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)interactive.c	8.5 (Berkeley) 5/1/95";
36 #else
37 __RCSID("$NetBSD: interactive.c,v 1.31 2021/08/29 09:17:58 christos Exp $");
38 #endif
39 #endif /* not lint */
40 
41 #include <sys/param.h>
42 #include <sys/time.h>
43 #include <sys/stat.h>
44 
45 #include <ufs/ufs/dinode.h>
46 #include <ufs/ufs/dir.h>
47 #include <ufs/ffs/fs.h>
48 #include <protocols/dumprestore.h>
49 
50 #include <setjmp.h>
51 #include <glob.h>
52 #include <ctype.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 
57 #include "restore.h"
58 #include "extern.h"
59 
60 #define round(a, b) (((a) + (b) - 1) / (b) * (b))
61 
62 /*
63  * Things to handle interruptions.
64  */
65 static int runshell;
66 static jmp_buf reset;
67 static char *nextarg = NULL;
68 
69 /*
70  * Structure and routines associated with listing directories.
71  */
72 struct afile {
73 	ino_t	fnum;		/* inode number of file */
74 	char	*fname;		/* file name */
75 	size_t	len;		/* name length */
76 	char	prefix;		/* prefix character */
77 	char	postfix;	/* postfix character */
78 };
79 struct arglist {
80 	int	freeglob;	/* glob structure needs to be freed */
81 	int	argcnt;		/* next globbed argument to return */
82 	glob_t	glob;		/* globbing information */
83 	char	*cmd;		/* the current command */
84 };
85 
86 static char	*copynext(char *, char *);
87 static int	 fcmp(const void *, const void *);
88 static void	 formatf(struct afile *, int);
89 static void	 getcmd(char *, char *, char *, size_t, struct arglist *);
90 struct dirent	*glob_readdir(RST_DIR *dirp);
91 static int	 glob_stat(const char *, struct stat *);
92 static void	 mkentry(char *, struct direct *, struct afile *);
93 static void	 printlist(char *, char *);
94 
95 /*
96  * Read and execute commands from the terminal.
97  */
98 void
runcmdshell(void)99 runcmdshell(void)
100 {
101 	struct entry *np;
102 	ino_t ino;
103 	struct arglist arglist;
104 	char curdir[MAXPATHLEN];
105 	char name[MAXPATHLEN];
106 	char cmd[BUFSIZ];
107 
108 	arglist.freeglob = 0;
109 	arglist.argcnt = 0;
110 	arglist.glob.gl_flags = GLOB_ALTDIRFUNC;
111 	arglist.glob.gl_opendir = (void *)rst_opendir;
112 	arglist.glob.gl_readdir = (void *)glob_readdir;
113 	arglist.glob.gl_closedir = (void *)rst_closedir;
114 	arglist.glob.gl_lstat = glob_stat;
115 	arglist.glob.gl_stat = glob_stat;
116 	canon("/", curdir, sizeof(curdir));
117 loop:
118 	if (setjmp(reset) != 0) {
119 		if (arglist.freeglob != 0) {
120 			arglist.freeglob = 0;
121 			arglist.argcnt = 0;
122 			globfree(&arglist.glob);
123 		}
124 		nextarg = NULL;
125 		volno = 0;
126 	}
127 	runshell = 1;
128 	getcmd(curdir, cmd, name, sizeof(name), &arglist);
129 	switch (cmd[0]) {
130 	/*
131 	 * Add elements to the extraction list.
132 	 */
133 	case 'a':
134 		if (strncmp(cmd, "add", strlen(cmd)) != 0)
135 			goto bad;
136 		ino = dirlookup(name);
137 		if (ino == 0)
138 			break;
139 		if (ino == UFS_ROOTINO)
140 			dotflag = 1;
141 		if (mflag)
142 			pathcheck(name);
143 		treescan(name, ino, addfile);
144 		break;
145 	/*
146 	 * Change working directory.
147 	 */
148 	case 'c':
149 		if (strncmp(cmd, "cd", strlen(cmd)) != 0)
150 			goto bad;
151 		ino = dirlookup(name);
152 		if (ino == 0)
153 			break;
154 		if (inodetype(ino) == LEAF) {
155 			fprintf(stderr, "%s: not a directory\n", name);
156 			break;
157 		}
158 		(void) strcpy(curdir, name);
159 		break;
160 	/*
161 	 * Delete elements from the extraction list.
162 	 */
163 	case 'd':
164 		if (strncmp(cmd, "delete", strlen(cmd)) != 0)
165 			goto bad;
166 		np = lookupname(name);
167 		if (np == NULL || (np->e_flags & NEW) == 0) {
168 			fprintf(stderr, "%s: not on extraction list\n", name);
169 			break;
170 		}
171 		treescan(name, np->e_ino, deletefile);
172 		break;
173 	/*
174 	 * Extract the requested list.
175 	 */
176 	case 'e':
177 		if (strncmp(cmd, "extract", strlen(cmd)) != 0)
178 			goto bad;
179 		createfiles();
180 		createlinks();
181 		setdirmodes(0);
182 		if (dflag)
183 			checkrestore();
184 		volno = 0;
185 		break;
186 	/*
187 	 * List available commands.
188 	 */
189 	case 'h':
190 		if (strncmp(cmd, "help", strlen(cmd)) != 0)
191 			goto bad;
192 		/* FALLTHROUGH */
193 	case '?':
194 		fprintf(stderr, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
195 			"Available commands are:\n",
196 			"\tls [arg] - list directory\n",
197 			"\tcd arg - change directory\n",
198 			"\tpwd - print current directory\n",
199 			"\tadd [arg] - add `arg' to list of",
200 			" files to be extracted\n",
201 			"\tdelete [arg] - delete `arg' from",
202 			" list of files to be extracted\n",
203 			"\textract - extract requested files\n",
204 			"\tsetmodes - set modes of requested directories\n",
205 			"\tquit or xit - immediately exit program\n",
206 			"\twhat - list dump header information\n",
207 			"\tverbose - toggle verbose flag",
208 			" (useful with ``ls'')\n",
209 			"\thelp or `?' - print this list\n",
210 			"\tDebug - turn on debugging\n",
211 			"If no `arg' is supplied, the current",
212 			" directory is used\n");
213 		break;
214 	/*
215 	 * List a directory.
216 	 */
217 	case 'l':
218 		if (strncmp(cmd, "ls", strlen(cmd)) != 0)
219 			goto bad;
220 		printlist(name, curdir);
221 		break;
222 	/*
223 	 * Print current directory.
224 	 */
225 	case 'p':
226 		if (strncmp(cmd, "pwd", strlen(cmd)) != 0)
227 			goto bad;
228 		if (curdir[1] == '\0')
229 			fprintf(stderr, "/\n");
230 		else
231 			fprintf(stderr, "%s\n", &curdir[1]);
232 		break;
233 	/*
234 	 * Quit.
235 	 */
236 	case 'q':
237 		if (strncmp(cmd, "quit", strlen(cmd)) != 0)
238 			goto bad;
239 		return;
240 	case 'x':
241 		if (strncmp(cmd, "xit", strlen(cmd)) != 0)
242 			goto bad;
243 		return;
244 	/*
245 	 * Toggle verbose mode.
246 	 */
247 	case 'v':
248 		if (strncmp(cmd, "verbose", strlen(cmd)) != 0)
249 			goto bad;
250 		if (vflag) {
251 			fprintf(stderr, "verbose mode off\n");
252 			vflag = 0;
253 			break;
254 		}
255 		fprintf(stderr, "verbose mode on\n");
256 		vflag++;
257 		break;
258 	/*
259 	 * Just restore requested directory modes.
260 	 */
261 	case 's':
262 		if (strncmp(cmd, "setmodes", strlen(cmd)) != 0)
263 			goto bad;
264 		setdirmodes(FORCE);
265 		break;
266 	/*
267 	 * Print out dump header information.
268 	 */
269 	case 'w':
270 		if (strncmp(cmd, "what", strlen(cmd)) != 0)
271 			goto bad;
272 		printdumpinfo();
273 		break;
274 	/*
275 	 * Turn on debugging.
276 	 */
277 	case 'D':
278 		if (strncmp(cmd, "Debug", strlen(cmd)) != 0)
279 			goto bad;
280 		if (dflag) {
281 			fprintf(stderr, "debugging mode off\n");
282 			dflag = 0;
283 			break;
284 		}
285 		fprintf(stderr, "debugging mode on\n");
286 		dflag++;
287 		break;
288 	/*
289 	 * Unknown command.
290 	 */
291 	default:
292 	bad:
293 		fprintf(stderr, "%s: unknown command; type ? for help\n", cmd);
294 		break;
295 	}
296 	goto loop;
297 }
298 
299 /*
300  * Read and parse an interactive command.
301  * The first word on the line is assigned to "cmd". If
302  * there are no arguments on the command line, then "curdir"
303  * is returned as the argument. If there are arguments
304  * on the line they are returned one at a time on each
305  * successive call to getcmd. Each argument is first assigned
306  * to "name". If it does not start with "/" the pathname in
307  * "curdir" is prepended to it. Finally "canon" is called to
308  * eliminate any embedded ".." components.
309  */
310 static void
getcmd(char * curdir,char * cmd,char * name,size_t size,struct arglist * ap)311 getcmd(char *curdir, char *cmd, char *name, size_t size, struct arglist *ap)
312 {
313 	char *cp;
314 	static char input[BUFSIZ];
315 	char output[BUFSIZ * 2];
316 	int globretval;
317 #	define rawname input	/* save space by reusing input buffer */
318 
319 	/*
320 	 * Check to see if still processing arguments.
321 	 */
322 	if (ap->argcnt > 0)
323 		goto retnext;
324 	if (nextarg != NULL)
325 		goto getnext;
326 	/*
327 	 * Read a command line and trim off trailing white space.
328 	 */
329 	do	{
330 		fprintf(stderr, "%s > ", getprogname());
331 		(void) fflush(stderr);
332 		(void) fgets(input, BUFSIZ, terminal);
333 	} while (!feof(terminal) && input[0] == '\n');
334 	if (feof(terminal)) {
335 		(void) strlcpy(cmd, "quit", size);
336 		return;
337 	}
338 	for (cp = &input[strlen(input) - 2]; *cp == ' ' || *cp == '\t'; cp--)
339 		/* trim off trailing white space and newline */;
340 	*++cp = '\0';
341 	/*
342 	 * Copy the command into "cmd".
343 	 */
344 	cp = copynext(input, cmd);
345 	ap->cmd = cmd;
346 	/*
347 	 * If no argument, use curdir as the default.
348 	 */
349 	if (*cp == '\0') {
350 		(void) strlcpy(name, curdir, size);
351 		return;
352 	}
353 	nextarg = cp;
354 	/*
355 	 * Find the next argument.
356 	 */
357 getnext:
358 	cp = copynext(nextarg, rawname);
359 	if (*cp == '\0')
360 		nextarg = NULL;
361 	else
362 		nextarg = cp;
363 	/*
364 	 * If it is an absolute pathname, canonicalize it and return it.
365 	 */
366 	if (rawname[0] == '/') {
367 		canon(rawname, name, size);
368 	} else {
369 		/*
370 		 * For relative pathnames, prepend the current directory to
371 		 * it then canonicalize and return it.
372 		 */
373 		snprintf(output, sizeof(output), "%s/%s", curdir, rawname);
374 		canon(output, name, size);
375 	}
376 	if ((globretval = glob(name, GLOB_ALTDIRFUNC, NULL, &ap->glob)) < 0) {
377 		fprintf(stderr, "%s: %s: ", ap->cmd, name);
378 		switch (globretval) {
379 		case GLOB_NOSPACE:
380 			fprintf(stderr, "out of memory\n");
381 			break;
382 		case GLOB_NOMATCH:
383 			fprintf(stderr, "no filename match.\n");
384 			break;
385 		case GLOB_ABORTED:
386 			fprintf(stderr, "glob() aborted.\n");
387 			break;
388 		default:
389 			fprintf(stderr, "unknown error!\n");
390 			break;
391 		}
392 	}
393 	if (ap->glob.gl_pathc == 0)
394 		return;
395 	ap->freeglob = 1;
396 	ap->argcnt = ap->glob.gl_pathc;
397 
398 retnext:
399 	strlcpy(name, ap->glob.gl_pathv[ap->glob.gl_pathc - ap->argcnt], size);
400 	if (--ap->argcnt == 0) {
401 		ap->freeglob = 0;
402 		globfree(&ap->glob);
403 	}
404 #	undef rawname
405 }
406 
407 /*
408  * Strip off the next token of the input.
409  */
410 static char *
copynext(char * input,char * output)411 copynext(char *input, char *output)
412 {
413 	char *cp, *bp;
414 	char quote;
415 
416 	for (cp = input; *cp == ' ' || *cp == '\t'; cp++)
417 		/* skip to argument */;
418 	bp = output;
419 	while (*cp != ' ' && *cp != '\t' && *cp != '\0') {
420 		/*
421 		 * Handle back slashes.
422 		 */
423 		if (*cp == '\\') {
424 			if (*++cp == '\0') {
425 				fprintf(stderr,
426 					"command lines cannot be continued\n");
427 				continue;
428 			}
429 			*bp++ = *cp++;
430 			continue;
431 		}
432 		/*
433 		 * The usual unquoted case.
434 		 */
435 		if (*cp != '\'' && *cp != '"') {
436 			*bp++ = *cp++;
437 			continue;
438 		}
439 		/*
440 		 * Handle single and double quotes.
441 		 */
442 		quote = *cp++;
443 		while (*cp != quote && *cp != '\0')
444 			*bp++ = *cp++;
445 		if (*cp++ == '\0') {
446 			fprintf(stderr, "missing %c\n", quote);
447 			cp--;
448 			continue;
449 		}
450 	}
451 	*bp = '\0';
452 	return (cp);
453 }
454 
455 /*
456  * Canonicalize file names to always start with ``./'' and
457  * remove any imbedded "." and ".." components.
458  */
459 void
canon(const char * rawname,char * canonname,size_t len)460 canon(const char *rawname, char *canonname, size_t len)
461 {
462 	char *cp, *np;
463 
464 	if (strcmp(rawname, ".") == 0 || strncmp(rawname, "./", 2) == 0)
465 		(void) strcpy(canonname, "");
466 	else if (rawname[0] == '/')
467 		(void) strcpy(canonname, ".");
468 	else
469 		(void) strcpy(canonname, "./");
470 	if (strlen(canonname) + strlen(rawname) >= len) {
471 		fprintf(stderr, "canonname: not enough buffer space\n");
472 		exit(1);
473 	}
474 
475 	(void) strcat(canonname, rawname);
476 	/*
477 	 * Eliminate multiple and trailing '/'s
478 	 */
479 	for (cp = np = canonname; *np != '\0'; cp++) {
480 		*cp = *np++;
481 		while (*cp == '/' && *np == '/')
482 			np++;
483 	}
484 	*cp = '\0';
485 	if (*--cp == '/')
486 		*cp = '\0';
487 	/*
488 	 * Eliminate extraneous "." and ".." from pathnames.
489 	 */
490 	for (np = canonname; *np != '\0'; ) {
491 		np++;
492 		cp = np;
493 		while (*np != '/' && *np != '\0')
494 			np++;
495 		if (np - cp == 1 && *cp == '.') {
496 			cp--;
497 			(void) strcpy(cp, np);
498 			np = cp;
499 		}
500 		if (np - cp == 2 && strncmp(cp, "..", 2) == 0) {
501 			cp--;
502 			while (cp > &canonname[1] && *--cp != '/')
503 				/* find beginning of name */;
504 			(void) strcpy(cp, np);
505 			np = cp;
506 		}
507 	}
508 }
509 
510 /*
511  * Do an "ls" style listing of a directory
512  */
513 static void
printlist(char * name,char * basename)514 printlist(char *name, char *basename)
515 {
516 	struct afile *fp, *list, *listp;
517 	struct direct *dp;
518 	struct afile single;
519 	RST_DIR *dirp;
520 	int entries, len, namelen;
521 	char locname[MAXPATHLEN + 1];
522 
523 	dp = pathsearch(name);
524 	listp = NULL;
525 	if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) ||
526 	    (!vflag && dp->d_ino == UFS_WINO))
527 		return;
528 	if ((dirp = rst_opendir(name)) == NULL) {
529 		entries = 1;
530 		list = &single;
531 		mkentry(name, dp, list);
532 		len = strlen(basename) + 1;
533 		if (strlen(name) - len > single.len) {
534 			freename(single.fname);
535 			single.fname = savename(&name[len]);
536 			single.len = strlen(single.fname);
537 		}
538 	} else {
539 		entries = 0;
540 		while ((dp = rst_readdir(dirp)) != NULL)
541 			entries++;
542 		rst_closedir(dirp);
543 		list = (struct afile *)malloc(entries * sizeof(struct afile));
544 		if (list == NULL) {
545 			fprintf(stderr, "ls: out of memory\n");
546 			return;
547 		}
548 		if ((dirp = rst_opendir(name)) == NULL)
549 			panic("directory reopen failed\n");
550 		fprintf(stderr, "%s:\n", name);
551 		entries = 0;
552 		listp = list;
553 		namelen = snprintf(locname, sizeof(locname), "%s/", name);
554 		while ((dp = rst_readdir(dirp)) != NULL) {
555 			if (!dflag && TSTINO(dp->d_ino, dumpmap) == 0)
556 				continue;
557 			if (!vflag && (dp->d_ino == UFS_WINO ||
558 			     strcmp(dp->d_name, ".") == 0 ||
559 			     strcmp(dp->d_name, "..") == 0))
560 				continue;
561 			locname[namelen] = '\0';
562 			if (namelen + dp->d_namlen >= MAXPATHLEN) {
563 				fprintf(stderr, "%s%s: name exceeds %d char\n",
564 					locname, dp->d_name, MAXPATHLEN);
565 			} else {
566 				(void)strlcat(locname, dp->d_name, MAXPATHLEN);
567 				mkentry(locname, dp, listp++);
568 				entries++;
569 			}
570 		}
571 		rst_closedir(dirp);
572 		if (entries == 0) {
573 			fprintf(stderr, "\n");
574 			free(list);
575 			return;
576 		}
577 		qsort((char *)list, entries, sizeof(struct afile), fcmp);
578 	}
579 	formatf(list, entries);
580 	if (dirp != NULL) {
581 		for (fp = listp - 1; fp >= list; fp--)
582 			freename(fp->fname);
583 		fprintf(stderr, "\n");
584 		free(list);
585 	}
586 }
587 
588 /*
589  * Read the contents of a directory.
590  */
591 static void
mkentry(char * name,struct direct * dp,struct afile * fp)592 mkentry(char *name, struct direct *dp, struct afile *fp)
593 {
594 	char *cp;
595 	struct entry *np;
596 
597 	fp->fnum = dp->d_ino;
598 	fp->fname = savename(dp->d_name);
599 	for (cp = fp->fname; *cp; cp++)
600 		if (!vflag && !isprint((unsigned char)*cp))
601 			*cp = '?';
602 	fp->len = cp - fp->fname;
603 	if (dflag && TSTINO(fp->fnum, dumpmap) == 0)
604 		fp->prefix = '^';
605 	else if ((np = lookupname(name)) != NULL && (np->e_flags & NEW))
606 		fp->prefix = '*';
607 	else
608 		fp->prefix = ' ';
609 	switch(dp->d_type) {
610 
611 	default:
612 		fprintf(stderr, "Warning: undefined file type %d\n",
613 		    dp->d_type);
614 		/* FALLTHROUGH */
615 	case DT_REG:
616 		fp->postfix = ' ';
617 		break;
618 
619 	case DT_LNK:
620 		fp->postfix = '@';
621 		break;
622 
623 	case DT_FIFO:
624 	case DT_SOCK:
625 		fp->postfix = '=';
626 		break;
627 
628 	case DT_CHR:
629 	case DT_BLK:
630 		fp->postfix = '#';
631 		break;
632 
633 	case DT_WHT:
634 		fp->postfix = '%';
635 		break;
636 
637 	case DT_UNKNOWN:
638 	case DT_DIR:
639 		if (inodetype(dp->d_ino) == NODE)
640 			fp->postfix = '/';
641 		else
642 			fp->postfix = ' ';
643 		break;
644 	}
645 	return;
646 }
647 
648 /*
649  * Print out a pretty listing of a directory
650  */
651 static void
formatf(struct afile * list,int nentry)652 formatf(struct afile *list, int nentry)
653 {
654 	struct afile *fp, *endlist;
655 	int haveprefix, havepostfix;
656 	ino_t bigino;
657 	size_t width, w;
658 	int i, j, precision, columns, lines;
659 
660 	width = 0;
661 	haveprefix = 0;
662 	havepostfix = 0;
663 	precision = 0;
664 	bigino = UFS_ROOTINO;
665 	endlist = &list[nentry];
666 	for (fp = &list[0]; fp < endlist; fp++) {
667 		if (bigino < fp->fnum)
668 			bigino = fp->fnum;
669 		if (width < fp->len)
670 			width = fp->len;
671 		if (fp->prefix != ' ')
672 			haveprefix = 1;
673 		if (fp->postfix != ' ')
674 			havepostfix = 1;
675 	}
676 	if (haveprefix)
677 		width++;
678 	if (havepostfix)
679 		width++;
680 	if (vflag) {
681 		for (precision = 0, i = bigino; i > 0; i /= 10)
682 			precision++;
683 		width += precision + 1;
684 	}
685 	width++;
686 	columns = 81 / width;
687 	if (columns == 0)
688 		columns = 1;
689 	lines = (nentry + columns - 1) / columns;
690 	for (i = 0; i < lines; i++) {
691 		for (j = 0; j < columns; j++) {
692 			fp = &list[j * lines + i];
693 			if (vflag) {
694 				fprintf(stderr, "%*ju ", precision,
695 				    (uintmax_t)fp->fnum);
696 				fp->len += precision + 1;
697 			}
698 			if (haveprefix) {
699 				putc(fp->prefix, stderr);
700 				fp->len++;
701 			}
702 			fprintf(stderr, "%s", fp->fname);
703 			if (havepostfix) {
704 				putc(fp->postfix, stderr);
705 				fp->len++;
706 			}
707 			if (fp + lines >= endlist) {
708 				fprintf(stderr, "\n");
709 				break;
710 			}
711 			for (w = fp->len; w < width; w++)
712 				putc(' ', stderr);
713 		}
714 	}
715 }
716 
717 /*
718  * Skip over directory entries that are not on the tape
719  *
720  * First have to get definition of a dirent.
721  */
722 #undef DIRBLKSIZ
723 #include <dirent.h>
724 #undef d_ino
725 
726 struct dirent *
glob_readdir(RST_DIR * dirp)727 glob_readdir(RST_DIR *dirp)
728 {
729 	struct direct *dp;
730 	static struct dirent adirent;
731 
732 	while ((dp = rst_readdir(dirp)) != NULL) {
733 		if (!vflag && dp->d_fileno == UFS_WINO)
734 			continue;
735 		if (dflag || TSTINO(dp->d_fileno, dumpmap))
736 			break;
737 	}
738 	if (dp == NULL)
739 		return (NULL);
740 	adirent.d_fileno = dp->d_fileno;
741 	adirent.d_namlen = dp->d_namlen;
742 	memmove(adirent.d_name, dp->d_name, dp->d_namlen + 1);
743 	return (&adirent);
744 }
745 
746 /*
747  * Return st_mode information in response to stat or lstat calls
748  */
749 static int
glob_stat(const char * name,struct stat * stp)750 glob_stat(const char *name, struct stat *stp)
751 {
752 	struct direct *dp;
753 
754 	dp = pathsearch(name);
755 	if (dp == NULL || (!dflag && TSTINO(dp->d_fileno, dumpmap) == 0) ||
756 	    (!vflag && dp->d_fileno == UFS_WINO))
757 		return (-1);
758 	if (inodetype(dp->d_fileno) == NODE)
759 		stp->st_mode = S_IFDIR;
760 	else
761 		stp->st_mode = S_IFREG;
762 	return (0);
763 }
764 
765 /*
766  * Comparison routine for qsort.
767  */
768 static int
fcmp(const void * f1,const void * f2)769 fcmp(const void *f1, const void *f2)
770 {
771 	return (strcoll(((const struct afile *)f1)->fname,
772 	    ((const struct afile *)f2)->fname));
773 }
774 
775 /*
776  * respond to interrupts
777  */
778 void
779 /*ARGSUSED*/
onintr(int signo __unused)780 onintr(int signo __unused)
781 {
782 	if (command == 'i' && runshell)
783 		longjmp(reset, 1);
784 	if (reply("restore interrupted, continue") == FAIL)
785 		exit(1);
786 }
787