![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to utilities.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / restore|
Return to utilities.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / restore |
1.1 root 1: /*
2: * Copyright (c) 1983 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)utilities.c 5.6 (Berkeley) 6/1/90";
22: #endif /* not lint */
23:
24: #include "restore.h"
25:
26: /*
27: * Insure that all the components of a pathname exist.
28: */
29: pathcheck(name)
30: char *name;
31: {
32: register char *cp;
33: struct entry *ep;
34: char *start;
35:
36: start = index(name, '/');
37: if (start == 0)
38: return;
39: for (cp = start; *cp != '\0'; cp++) {
40: if (*cp != '/')
41: continue;
42: *cp = '\0';
43: ep = lookupname(name);
44: if (ep == NIL) {
45: ep = addentry(name, psearch(name), NODE);
46: newnode(ep);
47: }
48: ep->e_flags |= NEW|KEEP;
49: *cp = '/';
50: }
51: }
52:
53: /*
54: * Change a name to a unique temporary name.
55: */
56: mktempname(ep)
57: register struct entry *ep;
58: {
59: char oldname[MAXPATHLEN];
60:
61: if (ep->e_flags & TMPNAME)
62: badentry(ep, "mktempname: called with TMPNAME");
63: ep->e_flags |= TMPNAME;
64: (void) strcpy(oldname, myname(ep));
65: freename(ep->e_name);
66: ep->e_name = savename(gentempname(ep));
67: ep->e_namlen = strlen(ep->e_name);
68: renameit(oldname, myname(ep));
69: }
70:
71: /*
72: * Generate a temporary name for an entry.
73: */
74: char *
75: gentempname(ep)
76: struct entry *ep;
77: {
78: static char name[MAXPATHLEN];
79: struct entry *np;
80: long i = 0;
81:
82: for (np = lookupino(ep->e_ino); np != NIL && np != ep; np = np->e_links)
83: i++;
84: if (np == NIL)
85: badentry(ep, "not on ino list");
86: (void) sprintf(name, "%s%d%d", TMPHDR, i, ep->e_ino);
87: return (name);
88: }
89:
90: /*
91: * Rename a file or directory.
92: */
93: renameit(from, to)
94: char *from, *to;
95: {
96: if (!Nflag && rename(from, to) < 0) {
97: fprintf(stderr, "Warning: cannot rename %s to %s", from, to);
98: (void) fflush(stderr);
99: perror("");
100: return;
101: }
102: vprintf(stdout, "rename %s to %s\n", from, to);
103: }
104:
105: /*
106: * Create a new node (directory).
107: */
108: newnode(np)
109: struct entry *np;
110: {
111: char *cp;
112:
113: if (np->e_type != NODE)
114: badentry(np, "newnode: not a node");
115: cp = myname(np);
116: if (!Nflag && mkdir(cp, 0777) < 0) {
117: np->e_flags |= EXISTED;
118: fprintf(stderr, "Warning: ");
119: (void) fflush(stderr);
120: perror(cp);
121: return;
122: }
123: vprintf(stdout, "Make node %s\n", cp);
124: }
125:
126: /*
127: * Remove an old node (directory).
128: */
129: removenode(ep)
130: register struct entry *ep;
131: {
132: char *cp;
133:
134: if (ep->e_type != NODE)
135: badentry(ep, "removenode: not a node");
136: if (ep->e_entries != NIL)
137: badentry(ep, "removenode: non-empty directory");
138: ep->e_flags |= REMOVED;
139: ep->e_flags &= ~TMPNAME;
140: cp = myname(ep);
141: if (!Nflag && rmdir(cp) < 0) {
142: fprintf(stderr, "Warning: ");
143: (void) fflush(stderr);
144: perror(cp);
145: return;
146: }
147: vprintf(stdout, "Remove node %s\n", cp);
148: }
149:
150: /*
151: * Remove a leaf.
152: */
153: removeleaf(ep)
154: register struct entry *ep;
155: {
156: char *cp;
157:
158: if (ep->e_type != LEAF)
159: badentry(ep, "removeleaf: not a leaf");
160: ep->e_flags |= REMOVED;
161: ep->e_flags &= ~TMPNAME;
162: cp = myname(ep);
163: if (!Nflag && unlink(cp) < 0) {
164: fprintf(stderr, "Warning: ");
165: (void) fflush(stderr);
166: perror(cp);
167: return;
168: }
169: vprintf(stdout, "Remove leaf %s\n", cp);
170: }
171:
172: /*
173: * Create a link.
174: */
175: linkit(existing, new, type)
176: char *existing, *new;
177: int type;
178: {
179:
180: if (type == SYMLINK) {
181: if (!Nflag && symlink(existing, new) < 0) {
182: fprintf(stderr,
183: "Warning: cannot create symbolic link %s->%s: ",
184: new, existing);
185: (void) fflush(stderr);
186: perror("");
187: return (FAIL);
188: }
189: } else if (type == HARDLINK) {
190: if (!Nflag && link(existing, new) < 0) {
191: fprintf(stderr,
192: "Warning: cannot create hard link %s->%s: ",
193: new, existing);
194: (void) fflush(stderr);
195: perror("");
196: return (FAIL);
197: }
198: } else {
199: panic("linkit: unknown type %d\n", type);
200: return (FAIL);
201: }
202: vprintf(stdout, "Create %s link %s->%s\n",
203: type == SYMLINK ? "symbolic" : "hard", new, existing);
204: return (GOOD);
205: }
206:
207: /*
208: * find lowest number file (above "start") that needs to be extracted
209: */
210: ino_t
211: lowerbnd(start)
212: ino_t start;
213: {
214: register struct entry *ep;
215:
216: for ( ; start < maxino; start++) {
217: ep = lookupino(start);
218: if (ep == NIL || ep->e_type == NODE)
219: continue;
220: if (ep->e_flags & (NEW|EXTRACT))
221: return (start);
222: }
223: return (start);
224: }
225:
226: /*
227: * find highest number file (below "start") that needs to be extracted
228: */
229: ino_t
230: upperbnd(start)
231: ino_t start;
232: {
233: register struct entry *ep;
234:
235: for ( ; start > ROOTINO; start--) {
236: ep = lookupino(start);
237: if (ep == NIL || ep->e_type == NODE)
238: continue;
239: if (ep->e_flags & (NEW|EXTRACT))
240: return (start);
241: }
242: return (start);
243: }
244:
245: /*
246: * report on a badly formed entry
247: */
248: badentry(ep, msg)
249: register struct entry *ep;
250: char *msg;
251: {
252:
253: fprintf(stderr, "bad entry: %s\n", msg);
254: fprintf(stderr, "name: %s\n", myname(ep));
255: fprintf(stderr, "parent name %s\n", myname(ep->e_parent));
256: if (ep->e_sibling != NIL)
257: fprintf(stderr, "sibling name: %s\n", myname(ep->e_sibling));
258: if (ep->e_entries != NIL)
259: fprintf(stderr, "next entry name: %s\n", myname(ep->e_entries));
260: if (ep->e_links != NIL)
261: fprintf(stderr, "next link name: %s\n", myname(ep->e_links));
262: if (ep->e_next != NIL)
263: fprintf(stderr, "next hashchain name: %s\n", myname(ep->e_next));
264: fprintf(stderr, "entry type: %s\n",
265: ep->e_type == NODE ? "NODE" : "LEAF");
266: fprintf(stderr, "inode number: %ld\n", ep->e_ino);
267: panic("flags: %s\n", flagvalues(ep));
268: }
269:
270: /*
271: * Construct a string indicating the active flag bits of an entry.
272: */
273: char *
274: flagvalues(ep)
275: register struct entry *ep;
276: {
277: static char flagbuf[BUFSIZ];
278:
279: (void) strcpy(flagbuf, "|NIL");
280: flagbuf[0] = '\0';
281: if (ep->e_flags & REMOVED)
282: (void) strcat(flagbuf, "|REMOVED");
283: if (ep->e_flags & TMPNAME)
284: (void) strcat(flagbuf, "|TMPNAME");
285: if (ep->e_flags & EXTRACT)
286: (void) strcat(flagbuf, "|EXTRACT");
287: if (ep->e_flags & NEW)
288: (void) strcat(flagbuf, "|NEW");
289: if (ep->e_flags & KEEP)
290: (void) strcat(flagbuf, "|KEEP");
291: if (ep->e_flags & EXISTED)
292: (void) strcat(flagbuf, "|EXISTED");
293: return (&flagbuf[1]);
294: }
295:
296: /*
297: * Check to see if a name is on a dump tape.
298: */
299: ino_t
300: dirlookup(name)
301: char *name;
302: {
303: ino_t ino;
304:
305: ino = psearch(name);
306: if (ino == 0 || BIT(ino, dumpmap) == 0)
307: fprintf(stderr, "%s is not on tape\n", name);
308: return (ino);
309: }
310:
311: /*
312: * Elicit a reply.
313: */
314: reply(question)
315: char *question;
316: {
317: char c;
318:
319: do {
320: fprintf(stderr, "%s? [yn] ", question);
321: (void) fflush(stderr);
322: c = getc(terminal);
323: while (c != '\n' && getc(terminal) != '\n')
324: if (feof(terminal))
325: return (FAIL);
326: } while (c != 'y' && c != 'n');
327: if (c == 'y')
328: return (GOOD);
329: return (FAIL);
330: }
331:
332: /*
333: * handle unexpected inconsistencies
334: */
335: /* VARARGS1 */
336: panic(msg, d1, d2)
337: char *msg;
338: long d1, d2;
339: {
340:
341: fprintf(stderr, msg, d1, d2);
342: if (yflag)
343: return;
344: if (reply("abort") == GOOD) {
345: if (reply("dump core") == GOOD)
346: abort();
347: done(1);
348: }
349: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.