![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dumpoptr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / etc / dump|
Return to dumpoptr.c CVS log | Up to [CSRG BSD Unix] / 42BSD / etc / dump |
1.1 root 1: static char *sccsid = "@(#)dumpoptr.c 1.8 (Berkeley) 6/19/83";
2:
3: #include "dump.h"
4:
5: /*
6: * This is from /usr/include/grp.h
7: * That defined struct group, which conflicts
8: * with the struct group defined in param.h
9: */
10: struct Group { /* see getgrent(3) */
11: char *gr_name;
12: char *gr_passwd;
13: int gr_gid;
14: char **gr_mem;
15: };
16: struct Group *getgrnam();
17: /*
18: * Query the operator; This fascist piece of code requires
19: * an exact response.
20: * It is intended to protect dump aborting by inquisitive
21: * people banging on the console terminal to see what is
22: * happening which might cause dump to croak, destroying
23: * a large number of hours of work.
24: *
25: * Every 2 minutes we reprint the message, alerting others
26: * that dump needs attention.
27: */
28: int timeout;
29: char *attnmessage; /* attemtion message */
30: query(question)
31: char *question;
32: {
33: char replybuffer[64];
34: int back;
35: FILE *mytty;
36:
37: if ( (mytty = fopen("/dev/tty", "r")) == NULL){
38: msg("fopen on /dev/tty fails\n");
39: abort();
40: }
41: attnmessage = question;
42: timeout = 0;
43: alarmcatch();
44: for(;;){
45: if ( fgets(replybuffer, 63, mytty) == NULL){
46: if (ferror(mytty)){
47: clearerr(mytty);
48: continue;
49: }
50: } else if ( (strcmp(replybuffer, "yes\n") == 0) ||
51: (strcmp(replybuffer, "Yes\n") == 0)){
52: back = 1;
53: goto done;
54: } else if ( (strcmp(replybuffer, "no\n") == 0) ||
55: (strcmp(replybuffer, "No\n") == 0)){
56: back = 0;
57: goto done;
58: } else {
59: msg("\"Yes\" or \"No\" ONLY!\n");
60: alarmcatch();
61: }
62: }
63: done:
64: /*
65: * Turn off the alarm, and reset the signal to trap out..
66: */
67: alarm(0);
68: if (signal(SIGALRM, sigalrm) == SIG_IGN)
69: signal(SIGALRM, SIG_IGN);
70: fclose(mytty);
71: return(back);
72: }
73: /*
74: * Alert the console operator, and enable the alarm clock to
75: * sleep for 2 minutes in case nobody comes to satisfy dump
76: */
77: alarmcatch()
78: {
79: if (timeout)
80: msgtail("\n");
81: msg("NEEDS ATTENTION: %s: (\"yes\" or \"no\") ",
82: attnmessage);
83: signal(SIGALRM, alarmcatch);
84: alarm(120);
85: timeout = 1;
86: }
87: /*
88: * Here if an inquisitive operator interrupts the dump program
89: */
90: interrupt()
91: {
92: msg("Interrupt received. Do >>>YOU<<< know what are you doing?\n");
93: if (query("Do you really want to abort dump?"))
94: dumpabort();
95: signal(SIGINT, interrupt);
96: }
97:
98: /*
99: * The following variables and routines manage alerting
100: * operators to the status of dump.
101: * This works much like wall(1) does.
102: */
103: struct Group *gp;
104:
105: /*
106: * Get the names from the group entry "operator" to notify.
107: */
108: set_operators()
109: {
110: if (!notify) /*not going to notify*/
111: return;
112: gp = getgrnam(OPGRENT);
113: endgrent();
114: if (gp == (struct Group *)0){
115: msg("No entry in /etc/group for %s.\n",
116: OPGRENT);
117: notify = 0;
118: return;
119: }
120: }
121:
122: struct tm *localtime();
123: struct tm *localclock;
124:
125: /*
126: * We fork a child to do the actual broadcasting, so
127: * that the process control groups are not messed up
128: */
129: broadcast(message)
130: char *message;
131: {
132: time_t clock;
133: FILE *f_utmp;
134: struct utmp utmp;
135: int nusers;
136: char **np;
137: int pid, s;
138:
139: switch (pid = fork()) {
140: case -1:
141: return;
142: case 0:
143: break;
144: default:
145: while (wait(&s) != pid)
146: continue;
147: return;
148: }
149:
150: if (!notify || gp == 0)
151: exit(0);
152: clock = time(0);
153: localclock = localtime(&clock);
154:
155: if((f_utmp = fopen("/etc/utmp", "r")) == NULL) {
156: msg("Cannot open /etc/utmp\n");
157: return;
158: }
159:
160: nusers = 0;
161: while (!feof(f_utmp)){
162: if (fread(&utmp, sizeof (struct utmp), 1, f_utmp) != 1)
163: break;
164: if (utmp.ut_name[0] == 0)
165: continue;
166: nusers++;
167: for (np = gp->gr_mem; *np; np++){
168: if (strncmp(*np, utmp.ut_name, sizeof(utmp.ut_name)) != 0)
169: continue;
170: /*
171: * Do not send messages to operators on dialups
172: */
173: if (strncmp(utmp.ut_line, DIALUP, strlen(DIALUP)) == 0)
174: continue;
175: #ifdef DEBUG
176: msg("Message to %s at %s\n",
177: utmp.ut_name, utmp.ut_line);
178: #endif DEBUG
179: sendmes(utmp.ut_line, message);
180: }
181: }
182: fclose(f_utmp);
183: Exit(0); /* the wait in this same routine will catch this */
184: /* NOTREACHED */
185: }
186:
187: sendmes(tty, message)
188: char *tty, *message;
189: {
190: char t[50], buf[BUFSIZ];
191: register char *cp;
192: register int c, ch;
193: int msize;
194: FILE *f_tty;
195:
196: msize = strlen(message);
197: strcpy(t, "/dev/");
198: strcat(t, tty);
199:
200: if((f_tty = fopen(t, "w")) != NULL) {
201: setbuf(f_tty, buf);
202: fprintf(f_tty, "\nMessage from the dump program to all operators at %d:%02d ...\r\n\n"
203: ,localclock->tm_hour
204: ,localclock->tm_min);
205: for (cp = message, c = msize; c-- > 0; cp++) {
206: ch = *cp;
207: if (ch == '\n')
208: putc('\r', f_tty);
209: putc(ch, f_tty);
210: }
211: fclose(f_tty);
212: }
213: }
214:
215: /*
216: * print out an estimate of the amount of time left to do the dump
217: */
218:
219: time_t tschedule = 0;
220:
221: timeest()
222: {
223: time_t tnow, deltat;
224:
225: time (&tnow);
226: if (tnow >= tschedule){
227: tschedule = tnow + 300;
228: if (blockswritten < 500)
229: return;
230: deltat = tstart_writing - tnow +
231: (((1.0*(tnow - tstart_writing))/blockswritten) * esize);
232: msg("%3.2f%% done, finished in %d:%02d\n",
233: (blockswritten*100.0)/esize,
234: deltat/3600, (deltat%3600)/60);
235: }
236: }
237:
238: int blocksontape()
239: {
240: /*
241: * esize: total number of blocks estimated over all reels
242: * blockswritten: blocks actually written, over all reels
243: * etapes: estimated number of tapes to write
244: *
245: * tsize: blocks can write on this reel
246: * asize: blocks written on this reel
247: * tapeno: number of tapes written so far
248: */
249: if (tapeno == etapes)
250: return(esize - (etapes - 1)*tsize);
251: return(tsize);
252: }
253:
254: /* VARARGS1 */
255: /* ARGSUSED */
256: msg(fmt, a1, a2, a3, a4, a5)
257: char *fmt;
258: int a1, a2, a3, a4, a5;
259: {
260: fprintf(stderr," DUMP: ");
261: #ifdef TDEBUG
262: fprintf(stderr,"pid=%d ", getpid());
263: #endif
264: fprintf(stderr, fmt, a1, a2, a3, a4, a5);
265: fflush(stdout);
266: fflush(stderr);
267: }
268:
269: /* VARARGS1 */
270: /* ARGSUSED */
271: msgtail(fmt, a1, a2, a3, a4, a5)
272: char *fmt;
273: int a1, a2, a3, a4, a5;
274: {
275: fprintf(stderr, fmt, a1, a2, a3, a4, a5);
276: }
277: /*
278: * Tell the operator what has to be done;
279: * we don't actually do it
280: */
281:
282: struct fstab *
283: allocfsent(fs)
284: register struct fstab *fs;
285: {
286: register struct fstab *new;
287: register char *cp;
288: char *malloc();
289:
290: new = (struct fstab *)malloc(sizeof (*fs));
291: cp = malloc(strlen(fs->fs_file) + 1);
292: strcpy(cp, fs->fs_file);
293: new->fs_file = cp;
294: cp = malloc(strlen(fs->fs_type) + 1);
295: strcpy(cp, fs->fs_type);
296: new->fs_type = cp;
297: cp = malloc(strlen(fs->fs_spec) + 1);
298: strcpy(cp, fs->fs_spec);
299: new->fs_spec = cp;
300: new->fs_passno = fs->fs_passno;
301: new->fs_freq = fs->fs_freq;
302: return (new);
303: }
304:
305: struct pfstab {
306: struct pfstab *pf_next;
307: struct fstab *pf_fstab;
308: };
309:
310: static struct pfstab *table = NULL;
311:
312: getfstab()
313: {
314: register struct fstab *fs;
315: register struct pfstab *pf;
316:
317: if (setfsent() == 0) {
318: msg("Can't open %s for dump table information.\n", FSTAB);
319: return;
320: }
321: while (fs = getfsent()) {
322: if (strcmp(fs->fs_type, FSTAB_RW) &&
323: strcmp(fs->fs_type, FSTAB_RO) &&
324: strcmp(fs->fs_type, FSTAB_RQ))
325: continue;
326: fs = allocfsent(fs);
327: pf = (struct pfstab *)malloc(sizeof (*pf));
328: pf->pf_fstab = fs;
329: pf->pf_next = table;
330: table = pf;
331: }
332: endfsent();
333: }
334:
335: /*
336: * Search in the fstab for a file name.
337: * This file name can be either the special or the path file name.
338: *
339: * The entries in the fstab are the BLOCK special names, not the
340: * character special names.
341: * The caller of fstabsearch assures that the character device
342: * is dumped (that is much faster)
343: *
344: * The file name can omit the leading '/'.
345: */
346: struct fstab *
347: fstabsearch(key)
348: char *key;
349: {
350: register struct pfstab *pf;
351: register struct fstab *fs;
352: char *rawname();
353:
354: if (table == NULL)
355: return ((struct fstab *)0);
356: for (pf = table; pf; pf = pf->pf_next) {
357: fs = pf->pf_fstab;
358: if (strcmp(fs->fs_file, key) == 0)
359: return (fs);
360: if (strcmp(fs->fs_spec, key) == 0)
361: return (fs);
362: if (strcmp(rawname(fs->fs_spec), key) == 0)
363: return (fs);
364: if (key[0] != '/'){
365: if (*fs->fs_spec == '/' &&
366: strcmp(fs->fs_spec + 1, key) == 0)
367: return (fs);
368: if (*fs->fs_file == '/' &&
369: strcmp(fs->fs_file + 1, key) == 0)
370: return (fs);
371: }
372: }
373: return (0);
374: }
375:
376: /*
377: * Tell the operator what to do
378: */
379: lastdump(arg)
380: char arg; /* w ==> just what to do; W ==> most recent dumps */
381: {
382: char *lastname;
383: char *date;
384: register int i;
385: time_t tnow;
386: register struct fstab *dt;
387: int dumpme;
388: register struct idates *itwalk;
389:
390: int idatesort();
391:
392: time(&tnow);
393: getfstab(); /* /etc/fstab input */
394: inititimes(); /* /etc/dumpdates input */
395: qsort(idatev, nidates, sizeof(struct idates *), idatesort);
396:
397: if (arg == 'w')
398: fprintf(stdout, "Dump these file systems:\n");
399: else
400: fprintf(stdout, "Last dump(s) done (Dump '>' file systems):\n");
401: lastname = "??";
402: ITITERATE(i, itwalk){
403: if (strncmp(lastname, itwalk->id_name, sizeof(itwalk->id_name)) == 0)
404: continue;
405: date = (char *)ctime(&itwalk->id_ddate);
406: date[16] = '\0'; /* blast away seconds and year */
407: lastname = itwalk->id_name;
408: dt = fstabsearch(itwalk->id_name);
409: dumpme = ( (dt != 0)
410: && (dt->fs_freq != 0)
411: && (itwalk->id_ddate < tnow - (dt->fs_freq*DAY)));
412: if ( (arg != 'w') || dumpme)
413: fprintf(stdout,"%c %8s\t(%6s) Last dump: Level %c, Date %s\n",
414: dumpme && (arg != 'w') ? '>' : ' ',
415: itwalk->id_name,
416: dt ? dt->fs_file : "",
417: itwalk->id_incno,
418: date
419: );
420: }
421: }
422:
423: int idatesort(p1, p2)
424: struct idates **p1, **p2;
425: {
426: int diff;
427:
428: diff = strncmp((*p1)->id_name, (*p2)->id_name, sizeof((*p1)->id_name));
429: if (diff == 0)
430: return ((*p2)->id_ddate - (*p1)->id_ddate);
431: else
432: return (diff);
433: }
434:
435: int max(a,b)
436: int a, b;
437: {
438: return(a>b?a:b);
439: }
440: int min(a,b)
441: int a, b;
442: {
443: return(a<b?a:b);
444: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.