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