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