xref: /freebsd/sbin/restore/utilities.c (revision 380a989b3223d455375b4fae70fd0b9bdd43bafb)
1 /*
2  * Copyright (c) 1983, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 
34 #ifndef lint
35 #if 0
36 static char sccsid[] = "@(#)utilities.c	8.5 (Berkeley) 4/28/95";
37 #endif
38 static const char rcsid[] =
39 	"$Id$";
40 #endif /* not lint */
41 
42 #include <sys/param.h>
43 #include <sys/stat.h>
44 
45 #include <ufs/ufs/dinode.h>
46 #include <ufs/ufs/dir.h>
47 
48 #include <errno.h>
49 #include <stdio.h>
50 #include <string.h>
51 #include <unistd.h>
52 
53 #include "restore.h"
54 #include "extern.h"
55 
56 /*
57  * Insure that all the components of a pathname exist.
58  */
59 void
60 pathcheck(name)
61 	char *name;
62 {
63 	register char *cp;
64 	struct entry *ep;
65 	char *start;
66 
67 	start = strchr(name, '/');
68 	if (start == 0)
69 		return;
70 	for (cp = start; *cp != '\0'; cp++) {
71 		if (*cp != '/')
72 			continue;
73 		*cp = '\0';
74 		ep = lookupname(name);
75 		if (ep == NULL) {
76 			/* Safe; we know the pathname exists in the dump. */
77 			ep = addentry(name, pathsearch(name)->d_ino, NODE);
78 			newnode(ep);
79 		}
80 		ep->e_flags |= NEW|KEEP;
81 		*cp = '/';
82 	}
83 }
84 
85 /*
86  * Change a name to a unique temporary name.
87  */
88 void
89 mktempname(ep)
90 	register struct entry *ep;
91 {
92 	char oldname[MAXPATHLEN];
93 
94 	if (ep->e_flags & TMPNAME)
95 		badentry(ep, "mktempname: called with TMPNAME");
96 	ep->e_flags |= TMPNAME;
97 	(void) strcpy(oldname, myname(ep));
98 	freename(ep->e_name);
99 	ep->e_name = savename(gentempname(ep));
100 	ep->e_namlen = strlen(ep->e_name);
101 	renameit(oldname, myname(ep));
102 }
103 
104 /*
105  * Generate a temporary name for an entry.
106  */
107 char *
108 gentempname(ep)
109 	struct entry *ep;
110 {
111 	static char name[MAXPATHLEN];
112 	struct entry *np;
113 	long i = 0;
114 
115 	for (np = lookupino(ep->e_ino);
116 	    np != NULL && np != ep; np = np->e_links)
117 		i++;
118 	if (np == NULL)
119 		badentry(ep, "not on ino list");
120 	(void) sprintf(name, "%s%ld%lu", TMPHDR, i, (u_long)ep->e_ino);
121 	return (name);
122 }
123 
124 /*
125  * Rename a file or directory.
126  */
127 void
128 renameit(from, to)
129 	char *from, *to;
130 {
131 	if (!Nflag && rename(from, to) < 0) {
132 		fprintf(stderr, "warning: cannot rename %s to %s: %s\n",
133 		    from, to, strerror(errno));
134 		return;
135 	}
136 	vprintf(stdout, "rename %s to %s\n", from, to);
137 }
138 
139 /*
140  * Create a new node (directory).
141  */
142 void
143 newnode(np)
144 	struct entry *np;
145 {
146 	char *cp;
147 
148 	if (np->e_type != NODE)
149 		badentry(np, "newnode: not a node");
150 	cp = myname(np);
151 	if (!Nflag && mkdir(cp, 0777) < 0 && !uflag) {
152 		np->e_flags |= EXISTED;
153 		fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
154 		return;
155 	}
156 	vprintf(stdout, "Make node %s\n", cp);
157 }
158 
159 /*
160  * Remove an old node (directory).
161  */
162 void
163 removenode(ep)
164 	register struct entry *ep;
165 {
166 	char *cp;
167 
168 	if (ep->e_type != NODE)
169 		badentry(ep, "removenode: not a node");
170 	if (ep->e_entries != NULL)
171 		badentry(ep, "removenode: non-empty directory");
172 	ep->e_flags |= REMOVED;
173 	ep->e_flags &= ~TMPNAME;
174 	cp = myname(ep);
175 	if (!Nflag && rmdir(cp) < 0) {
176 		fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
177 		return;
178 	}
179 	vprintf(stdout, "Remove node %s\n", cp);
180 }
181 
182 /*
183  * Remove a leaf.
184  */
185 void
186 removeleaf(ep)
187 	register struct entry *ep;
188 {
189 	char *cp;
190 
191 	if (ep->e_type != LEAF)
192 		badentry(ep, "removeleaf: not a leaf");
193 	ep->e_flags |= REMOVED;
194 	ep->e_flags &= ~TMPNAME;
195 	cp = myname(ep);
196 	if (!Nflag && unlink(cp) < 0) {
197 		fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
198 		return;
199 	}
200 	vprintf(stdout, "Remove leaf %s\n", cp);
201 }
202 
203 /*
204  * Create a link.
205  */
206 int
207 linkit(existing, new, type)
208 	char *existing, *new;
209 	int type;
210 {
211 
212 	/* if we want to unlink first, do it now so *link() won't fail */
213 	if (uflag && !Nflag)
214 		(void)unlink(new);
215 
216 	if (type == SYMLINK) {
217 		if (!Nflag && symlink(existing, new) < 0) {
218 			fprintf(stderr,
219 			    "warning: cannot create symbolic link %s->%s: %s\n",
220 			    new, existing, strerror(errno));
221 			return (FAIL);
222 		}
223 	} else if (type == HARDLINK) {
224 		int ret;
225 
226 		if (!Nflag && (ret = link(existing, new)) < 0) {
227 			struct stat s;
228 
229 			/*
230 			 * Most likely, the schg flag is set.  Clear the
231 			 * flags and try again.
232 			 */
233 			if (stat(existing, &s) == 0 && s.st_flags != 0 &&
234 			    chflags(existing, 0) == 0) {
235 				ret = link(existing, new);
236 				chflags(existing, s.st_flags);
237 			}
238 			if (ret < 0) {
239 				fprintf(stderr, "warning: cannot create "
240 				    "hard link %s->%s: %s\n",
241 				    new, existing, strerror(errno));
242 				return (FAIL);
243 			}
244 		}
245 	} else {
246 		panic("linkit: unknown type %d\n", type);
247 		return (FAIL);
248 	}
249 	vprintf(stdout, "Create %s link %s->%s\n",
250 		type == SYMLINK ? "symbolic" : "hard", new, existing);
251 	return (GOOD);
252 }
253 
254 /*
255  * Create a whiteout.
256  */
257 int
258 addwhiteout(name)
259 	char *name;
260 {
261 
262 	if (!Nflag && mknod(name, S_IFWHT, 0) < 0) {
263 		fprintf(stderr, "warning: cannot create whiteout %s: %s\n",
264 		    name, strerror(errno));
265 		return (FAIL);
266 	}
267 	vprintf(stdout, "Create whiteout %s\n", name);
268 	return (GOOD);
269 }
270 
271 /*
272  * Delete a whiteout.
273  */
274 void
275 delwhiteout(ep)
276 	register struct entry *ep;
277 {
278 	char *name;
279 
280 	if (ep->e_type != LEAF)
281 		badentry(ep, "delwhiteout: not a leaf");
282 	ep->e_flags |= REMOVED;
283 	ep->e_flags &= ~TMPNAME;
284 	name = myname(ep);
285 	if (!Nflag && undelete(name) < 0) {
286 		fprintf(stderr, "warning: cannot delete whiteout %s: %s\n",
287 		    name, strerror(errno));
288 		return;
289 	}
290 	vprintf(stdout, "Delete whiteout %s\n", name);
291 }
292 
293 /*
294  * find lowest number file (above "start") that needs to be extracted
295  */
296 ino_t
297 lowerbnd(start)
298 	ino_t start;
299 {
300 	register struct entry *ep;
301 
302 	for ( ; start < maxino; start++) {
303 		ep = lookupino(start);
304 		if (ep == NULL || ep->e_type == NODE)
305 			continue;
306 		if (ep->e_flags & (NEW|EXTRACT))
307 			return (start);
308 	}
309 	return (start);
310 }
311 
312 /*
313  * find highest number file (below "start") that needs to be extracted
314  */
315 ino_t
316 upperbnd(start)
317 	ino_t start;
318 {
319 	register struct entry *ep;
320 
321 	for ( ; start > ROOTINO; start--) {
322 		ep = lookupino(start);
323 		if (ep == NULL || ep->e_type == NODE)
324 			continue;
325 		if (ep->e_flags & (NEW|EXTRACT))
326 			return (start);
327 	}
328 	return (start);
329 }
330 
331 /*
332  * report on a badly formed entry
333  */
334 void
335 badentry(ep, msg)
336 	register struct entry *ep;
337 	char *msg;
338 {
339 
340 	fprintf(stderr, "bad entry: %s\n", msg);
341 	fprintf(stderr, "name: %s\n", myname(ep));
342 	fprintf(stderr, "parent name %s\n", myname(ep->e_parent));
343 	if (ep->e_sibling != NULL)
344 		fprintf(stderr, "sibling name: %s\n", myname(ep->e_sibling));
345 	if (ep->e_entries != NULL)
346 		fprintf(stderr, "next entry name: %s\n", myname(ep->e_entries));
347 	if (ep->e_links != NULL)
348 		fprintf(stderr, "next link name: %s\n", myname(ep->e_links));
349 	if (ep->e_next != NULL)
350 		fprintf(stderr,
351 		    "next hashchain name: %s\n", myname(ep->e_next));
352 	fprintf(stderr, "entry type: %s\n",
353 		ep->e_type == NODE ? "NODE" : "LEAF");
354 	fprintf(stderr, "inode number: %lu\n", (u_long)ep->e_ino);
355 	panic("flags: %s\n", flagvalues(ep));
356 }
357 
358 /*
359  * Construct a string indicating the active flag bits of an entry.
360  */
361 char *
362 flagvalues(ep)
363 	register struct entry *ep;
364 {
365 	static char flagbuf[BUFSIZ];
366 
367 	(void) strcpy(flagbuf, "|NIL");
368 	flagbuf[0] = '\0';
369 	if (ep->e_flags & REMOVED)
370 		(void) strcat(flagbuf, "|REMOVED");
371 	if (ep->e_flags & TMPNAME)
372 		(void) strcat(flagbuf, "|TMPNAME");
373 	if (ep->e_flags & EXTRACT)
374 		(void) strcat(flagbuf, "|EXTRACT");
375 	if (ep->e_flags & NEW)
376 		(void) strcat(flagbuf, "|NEW");
377 	if (ep->e_flags & KEEP)
378 		(void) strcat(flagbuf, "|KEEP");
379 	if (ep->e_flags & EXISTED)
380 		(void) strcat(flagbuf, "|EXISTED");
381 	return (&flagbuf[1]);
382 }
383 
384 /*
385  * Check to see if a name is on a dump tape.
386  */
387 ino_t
388 dirlookup(name)
389 	const char *name;
390 {
391 	struct direct *dp;
392 	ino_t ino;
393 
394 	ino = ((dp = pathsearch(name)) == NULL) ? 0 : dp->d_ino;
395 
396 	if (ino == 0 || TSTINO(ino, dumpmap) == 0)
397 		fprintf(stderr, "%s is not on the tape\n", name);
398 	return (ino);
399 }
400 
401 /*
402  * Elicit a reply.
403  */
404 int
405 reply(question)
406 	char *question;
407 {
408 	char c;
409 
410 	do	{
411 		fprintf(stderr, "%s? [yn] ", question);
412 		(void) fflush(stderr);
413 		c = getc(terminal);
414 		while (c != '\n' && getc(terminal) != '\n')
415 			if (feof(terminal))
416 				return (FAIL);
417 	} while (c != 'y' && c != 'n');
418 	if (c == 'y')
419 		return (GOOD);
420 	return (FAIL);
421 }
422 
423 /*
424  * handle unexpected inconsistencies
425  */
426 #if __STDC__
427 #include <stdarg.h>
428 #else
429 #include <varargs.h>
430 #endif
431 
432 void
433 #if __STDC__
434 panic(const char *fmt, ...)
435 #else
436 panic(fmt, va_alist)
437 	char *fmt;
438 	va_dcl
439 #endif
440 {
441 	va_list ap;
442 #if __STDC__
443 	va_start(ap, fmt);
444 #else
445 	va_start(ap);
446 #endif
447 
448 	vfprintf(stderr, fmt, ap);
449 	if (yflag)
450 		return;
451 	if (reply("abort") == GOOD) {
452 		if (reply("dump core") == GOOD)
453 			abort();
454 		done(1);
455 	}
456 }
457