![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dropt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / notes / src|
Return to dropt.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / notes / src |
1.1 root 1: #include "parms.h"
2: #include "structs.h"
3:
4: #ifdef RCSIDENT
5: static char rcsid[] = "$Header: dropt.c,v 1.7.0.1 85/09/09 18:31:21 notes Rel $";
6: #endif RCSIDENT
7:
8: #define BUFSZ 128
9:
10: /*
11: * this file processes the director options.
12: *
13: * call: contains the io pointer to the file.
14: *
15: * allows continued access only if the user if a director.
16: *
17: * the functions of the director options includes:
18: * 1) granting/denial of director priviledges
19: * 2) granting/denial of regular access priviledges
20: * 3) changing the director message
21: * 4) writing a policy note
22: *
23: * Returns: -1 normally
24: * -4 if the user hit cntrl d ( to total exit)
25: *
26: * original author/outliner : Ray Essick may 29, 1981
27: *
28: */
29:
30: static int anonrow, /* allow anon */
31: openrow, /* is open */
32: archrow, /* is archive */
33: keeprow, /* expire action */
34: dirmsgrow, /* expire w/dirmsg */
35: netrow, /* networked */
36: expirerow, /* expire age */
37: longrow, /* longest ok text */
38: worksetrow; /* working set */
39: static int lastrow;
40:
41: direct (io) struct io_f *io;
42: {
43: int i; /* scratch */
44: int c;
45: long expires;
46: long workset;
47: long textlength; /* scratch */
48: char title[DMLEN + 1]; /* hold new director message */
49: char ntitle[NNLEN + 1]; /* hold note file title */
50: struct note_f note;
51: struct auth_f auth; /* author of policy note */
52: struct daddr_f where;
53: char *r,
54: buff[BUFSZ + 1];
55: int buffptr;
56: int start,
57: end,
58: nnotes,
59: nresps;
60: int redraw; /* paint screen */
61:
62: if (allow (io, DRCTOK) == 0)
63: {
64: at (0, PROMPTMSGX);
65: printf ("Sorry, you are not a director");
66: fflush (stdout);
67: sleep (2);
68: return (-1);
69: }
70:
71: redraw = 1;
72: while (1)
73: {
74: if (redraw)
75: dirplot (io);
76: getkey: /* suck in a key */
77: at (-1, 1);
78: printf ("Option: \010");
79: c = gchar (); /* get command */
80: printf ("\010 "); /* overwrite the character */
81: redraw = 0; /* draw if want it */
82: switch (c)
83: {
84: case '?':
85: case 'h':
86: help (DIRHLP);
87: redraw++;
88: break;
89:
90: case 'r': /* replot the screen */
91: case '\f': /* control-L also */
92: redraw++;
93: break;
94:
95: #ifdef K_KEY
96: case 'k': /* same as q */
97: #endif K_KEY
98: case 'q': /* leave */
99: return (-1);
100:
101: case '\004':
102: return QUITFAST; /* Universal exit */
103:
104: case '!': /* give him a shell */
105: gshell ();
106: redraw++;
107: break;
108:
109: case 'p': /* run access lists */
110: if (accessedit (io) == QUITFAST)
111: return QUITFAST; /* doit */
112: redraw++;
113: break; /* skipt out of the loop */
114:
115: case 'a': /* toggle anonymous option */
116: locknf (io, DSCRLOCK); /* lock the thing for a minute */
117: getdscr (io, &io -> descr); /* get up to date descriptor */
118: if (io -> descr.d_stat & ANONOK)
119: io -> descr.d_stat &= NOT ANONOK;
120: else
121: io -> descr.d_stat |= ANONOK;
122: putdscr (io, &io -> descr);
123: unlocknf (io, DSCRLOCK);
124: at (anonrow, 18);
125: printf (io -> descr.d_stat & ANONOK ? "ON " : "OFF");
126: redraw = 0;
127: break;
128:
129: case 'A': /* Archive option */
130: locknf (io, DSCRLOCK); /* lock the thing for a minute */
131: getdscr (io, &io -> descr); /* get up to date descriptor */
132: if (io -> descr.d_stat & ISARCH)
133: io -> descr.d_stat &= NOT ISARCH;
134: else
135: io -> descr.d_stat |= ISARCH;
136: putdscr (io, &io -> descr);
137: unlocknf (io, DSCRLOCK);
138: at (archrow, 18);
139: printf (io -> descr.d_stat & ISARCH ? "YES" : "NO ");
140: redraw = 0;
141: break;
142:
143: case 'l': /* message length */
144: while (1)
145: {
146: at (lastrow, 10);
147: printf ("New Maximum Message Size: ");
148: ceol (); /* clear to eol */
149: if (gline (buff, BUFSZ) == 1) /* empty line */
150: {
151: at (lastrow + 1, 10);
152: printf ("Maximum Message Size Unchanged");
153: goto getkey;
154: }
155: if (sscanf (buff, "%ld", &textlength) == 1)
156: {
157: if (textlength <= HARDMAX) /* too big? */
158: break;
159: else
160: {
161: at (lastrow + 1, 10);
162: printf ("Maximum Allowed is %d", HARDMAX);
163: continue;
164: }
165: }
166: at (lastrow + 1, 10);
167: printf ("Enter an integer or <return>");
168: }
169: locknf (io, DSCRLOCK); /* CRITICAL SECTION */
170: getdscr (io, &io -> descr); /* update descriptor */
171: io -> descr.d_longnote = textlength; /* new value */
172: putdscr (io, &io -> descr);
173: unlocknf (io, DSCRLOCK); /* all done ... */
174: at (longrow, 27);
175: printf ("%ld bytes ", io -> descr.d_longnote);
176: redraw = 0;
177: break;
178:
179: case 'c': /* compress the notefile */
180: redraw = 0;
181: if (io -> descr.d_stat & OPEN)
182: {
183: at (lastrow, 10);
184: printf ("Notefile must be closed to compress");
185: break;
186: }
187: else
188: {
189: at (lastrow, 10);
190: if (askyn ("Really Compress? (y/n) ") != 'y')
191: {
192: at (lastrow + 1, 10);
193: printf ("Compress not done");
194: break;
195: }
196: at (lastrow + 1, 1);
197: printf ("Compressing ");
198: if (compress (io, LOCKIT, 1, &nnotes, &nresps) >= 0)
199: {
200: dirplot (io); /* show it */
201: at (-3, 1);
202: printf ("Compress left %d notes and %d responses",
203: nnotes, nresps);
204: }
205: else
206: {
207: dirplot (io); /* show page */
208: at (-3, 1);
209: printf ("Compress not done");
210: }
211: break;
212: }
213: break;
214:
215: case 'e': /* change expiration time */
216: while (1)
217: {
218: at (lastrow, 10);
219: printf ("New Expiration time: ");
220: ceol (); /* clear to eol */
221: if (gline (buff, BUFSZ) == 1) /* empty line */
222: {
223: at (lastrow + 1, 10);
224: printf ("Expiration Threshold Unchanged");
225: goto getkey;
226: }
227: if (!strcmp (buff, "Never") || !strcmp (buff, "never") ||
228: !strcmp (buff, "NEVER"))
229: {
230: expires = NEVER;
231: break;
232: }
233: if (!strcmp (buff, "Default") || !strcmp (buff, "default") ||
234: !strcmp (buff, "DEFAULT"))
235: {
236: expires = 0;
237: break;
238: }
239: if (sscanf (buff, "%ld", &expires) == 1)
240: {
241: break;
242: }
243:
244: at (lastrow + 1, 10);
245: printf ("Want `default', `never', or a number");
246: at (lastrow + 2, 10);
247: printf ("<return> to leave unchanged");
248: }
249:
250: locknf (io, DSCRLOCK); /* critical section */
251: getdscr (io, &io -> descr);
252: io -> descr.d_archtime = expires; /* update */
253: putdscr (io, &io -> descr); /* replace */
254: unlocknf (io, DSCRLOCK); /* leave critical */
255: at (expirerow, 27);
256: switch ((int) (io -> descr.d_archtime)) /* update screen */
257: {
258: case NEVER:
259: printf ("Never ");
260: break;
261: case 0:
262: printf ("Default ");
263: break;
264: default:
265: printf ("%ld days ", io -> descr.d_archtime);
266: break;
267: }
268: redraw = 0;
269: break;
270:
271: case 'W': /* working Set size */
272: while (1)
273: {
274: at (lastrow, 10);
275: printf ("New Working Set Size: ");
276: ceol (); /* clear to eol */
277: if (gline (buff, BUFSZ) == 1) /* empty line */
278: {
279: at (lastrow + 1, 10);
280: printf ("Working Set Size Unchanged");
281: goto getkey;
282: }
283: if (!strcmp (buff, "Default") || !strcmp (buff, "default") ||
284: !strcmp (buff, "DEFAULT"))
285: {
286: workset = 0;
287: break;
288: }
289: if (sscanf (buff, "%ld", &workset) == 1)
290: {
291: break;
292: }
293:
294: at (lastrow + 1, 10);
295: printf ("Want `default' or a number");
296: at (lastrow + 2, 10);
297: printf ("<return> to leave unchanged");
298: }
299:
300: locknf (io, DSCRLOCK); /* critical section */
301: getdscr (io, &io -> descr);
302: io -> descr.d_workset = workset; /* update */
303: putdscr (io, &io -> descr); /* replace */
304: unlocknf (io, DSCRLOCK); /* leave critical */
305: at (worksetrow, 27);
306: switch ((int) io -> descr.d_workset)
307: {
308: case 0:
309: printf ("Default ");
310: break;
311: default:
312: printf ("%ld Notes ", io -> descr.d_workset);
313: }
314: redraw = 0;
315: break;
316:
317: case 'E': /* keep/delete/default */
318: locknf (io, DSCRLOCK); /* critical section */
319: getdscr (io, &io -> descr);
320: switch ((int) io -> descr.d_archkeep) /* change it */
321: {
322: case KEEPNO:
323: io -> descr.d_archkeep = KEEPYES;
324: break;
325: case KEEPYES:
326: io -> descr.d_archkeep = KEEPDFLT;
327: break;
328: case KEEPDFLT:
329: default:
330: io -> descr.d_archkeep = KEEPNO;
331: break;
332: }
333: putdscr (io, &io -> descr); /* replace */
334: unlocknf (io, DSCRLOCK); /* leave critical */
335: at (keeprow, 27);
336: switch ((int) io -> descr.d_archkeep) /* update display */
337: {
338: case KEEPYES:
339: printf ("ARCHIVE");
340: break;
341: case KEEPNO:
342: printf ("DELETE ");
343: break;
344: case KEEPDFLT:
345: printf ("Default");
346: break;
347: default:
348: printf ("UNKNOWN");
349: break;
350: }
351: redraw = 0;
352: break;
353:
354: case 'D': /* Archive dirmsg */
355: locknf (io, DSCRLOCK); /* critical section */
356: getdscr (io, &io -> descr);
357: switch ((int) io -> descr.d_dmesgstat) /* change it */
358: {
359: case DIRNOCARE:
360: io -> descr.d_dmesgstat = DIRON;
361: break;
362: case DIRON:
363: io -> descr.d_dmesgstat = DIROFF;
364: break;
365: case DIROFF:
366: io -> descr.d_dmesgstat = DIRDFLT;
367: break;
368: case DIRDFLT:
369: default:
370: io -> descr.d_dmesgstat = DIRNOCARE;
371: break;
372: }
373: putdscr (io, &io -> descr); /* replace */
374: unlocknf (io, DSCRLOCK); /* leave critical */
375: at (dirmsgrow, 27);
376: switch ((int) io -> descr.d_dmesgstat)
377: {
378: case DIRNOCARE:
379: printf ("NOCARE ");
380: break;
381: case DIRON:
382: printf ("ON ");
383: break;
384: case DIROFF:
385: printf ("OFF ");
386: break;
387: case DIRDFLT:
388: printf ("Default ");
389: break;
390: default:
391: printf ("UNKNOWN ");
392: break;
393: }
394: redraw = 0;
395: break;
396:
397: case 'o': /* toggle open status */
398: locknf (io, DSCRLOCK);
399: getdscr (io, &io -> descr);
400: if (io -> descr.d_stat & OPEN)
401: io -> descr.d_stat &= NOT OPEN;
402: else
403: io -> descr.d_stat |= OPEN;
404: putdscr (io, &io -> descr);
405: unlocknf (io, DSCRLOCK);
406: at (openrow, 18);
407: printf (io -> descr.d_stat & OPEN ? "OPEN " : "CLOSED");
408: redraw = 0;
409: break;
410:
411: case 'n': /* toggle network status */
412: locknf (io, DSCRLOCK);
413: getdscr (io, &io -> descr);
414: if (io -> descr.d_stat & NETWRKD)
415: {
416: io -> descr.d_stat &= NOT NETWRKD;
417: }
418: else
419: {
420: io -> descr.d_stat |= NETWRKD;
421: }
422: putdscr (io, &io -> descr);
423: unlocknf (io, DSCRLOCK);
424: at (netrow, 18);
425: printf (io -> descr.d_stat & NETWRKD ? "YES" : "NO ");
426: redraw = 0;
427: break;
428:
429:
430: case 'm': /* collect a new director message */
431: redraw++;
432: at (lastrow, 10);
433: printf ("Enter new director message");
434: at (lastrow + 2, 10);
435: for (i = 0; i < DMLEN; i++)
436: printf ("-");
437: at (lastrow + 1, 10);
438: i = gline (title, DMLEN - 1); /* grab message */
439: if (i <= 1)
440: break; /* no new message */
441: locknf (io, DSCRLOCK); /* mutual exclusion */
442: getdscr (io, &io -> descr); /* get up-to-date */
443: strncpy (io -> descr.d_drmes, title, DMLEN);/* replace */
444: putdscr (io, &io -> descr);
445: unlocknf (io, DSCRLOCK); /* uncritical now */
446: break;
447:
448: case 't': /* write title for note file */
449: redraw++;
450: at (lastrow, 10);
451: printf ("Enter new title for notefile");
452: at (lastrow + 2, 10);
453: for (i = 0; i < NNLEN; i++)
454: printf ("-");
455: at (lastrow + 1, 10);
456: i = gline (ntitle, NNLEN - 1); /* suck the title */
457: if (i <= 1)
458: break; /* no new message */
459: locknf (io, DSCRLOCK); /* MUTEX */
460: getdscr (io, &io -> descr); /* current descr */
461: strncpy (io -> descr.d_title, ntitle, NNLEN);/* update */
462: putdscr (io, &io -> descr); /* and replace */
463: unlocknf (io, DSCRLOCK); /* uncritical now */
464: break;
465:
466: case 'w': /* let him write a new policy note */
467: if (io -> descr.d_plcy)
468: {
469: at (0, PROMPTMSGX);
470: if (askyn ("Rewrite policy? (y/n) :") == 'n')
471: {
472: redraw++;
473: break;
474: }
475: }
476: at (0, PROMPTMSGX);
477: printf ("\nEdit New Policy Text:\n");
478: if (gettext (io, &where, (FILE *) NULL, EDIT) == 0)
479: {
480: redraw++;
481: break;
482: }
483: r = title;
484: strcpy (title, "POLICY NOTE");
485: gettime (¬e.n_date); /* date of writing */
486: getname (&auth, 0); /* get author */
487: putnote (io, &where, title, 0, ¬e, &auth, 1, 1, 1, System, 1);
488: dspnote (io, ¬e, 0); /* show it to him */
489: redraw++;
490: break;
491:
492: case 'z': /* zap a lot of notes/responses */
493: case 'u': /* undelete a bunch */
494: {
495: char *action; /* del/undel */
496:
497: redraw++; /* want to repaint */
498: action = c == 'z' ? "delete" : "un-delete";/* for prompts */
499: at (lastrow, 1);
500: printf ("Enter list of notes to %s: ", action);
501: gline (buff, BUFSZ); /* grab line */
502: at (lastrow + 1, 1);
503: printf ("Going to %s: %s", action, buff);
504: at (lastrow + 2, 1);
505: if (askyn ("Do you really want to do that? ") != 'y')
506: break; /* chicken out */
507: buffptr = 0;
508: at (lastrow + 3, 1);
509: while (listget (buff, &buffptr, &start, &end))
510: {
511: if (start > end)
512: {
513: printf ("IGNORING %d-%d", start, end);
514: continue;
515: }
516: if (start == end)
517: printf ("%d ", start);
518: else
519: printf ("%d-%d ", start, end);
520: mdelete (io, start, end, c == 'z');/* zap those */
521: }
522: goto getkey; /* leave this stuff on screen */
523: }
524:
525: default:
526: printf ("\07");
527: redraw = 0;
528: goto getkey; /* hit a bad key */
529:
530: }
531: }
532: }
533: /*
534: * dirplot - Plot the notesfile status
535: */
536:
537: dirplot (io)
538: struct io_f *io;
539: {
540: int atrow;
541: int atcol;
542:
543: erase ();
544: center (io -> descr.d_title, NNLEN, 1, 40 - NNLEN / 2);
545: center (io -> descr.d_drmes, DMLEN, 2, 40 - DMLEN / 2);
546: atrow = 4; /* start filling in */
547: atcol = 1;
548: at (anonrow = atrow++, atcol);
549: printf ("(a) Anonymous: "); /* at (3,18); */
550: printf (io -> descr.d_stat & ANONOK ? "ON" : "OFF");
551: at (openrow = atrow++, atcol);
552: printf ("(o) Notesfile: "); /* at(4,18); */
553: printf (io -> descr.d_stat & OPEN ? "OPEN " : "CLOSED");
554: at (netrow = atrow++, atcol);
555: printf ("(n) Networked: "); /* at(5,18); */
556: printf (io -> descr.d_stat & NETWRKD ? "YES" : "NO ");
557: at (archrow = atrow++, atcol);
558: printf ("(A) Is Archive: "); /* at(6,18); */
559: printf (io -> descr.d_stat & ISARCH ? "YES" : "NO");
560: at (expirerow = atrow++, atcol);
561: printf ("(e) Expiration Threshold: "); /* at (6,27); */
562: switch ((int) (io -> descr.d_archtime))
563: {
564: case NEVER:
565: printf ("Never");
566: break;
567: case 0:
568: printf ("Default");
569: break;
570: default:
571: printf ("%ld days", io -> descr.d_archtime);
572: break;
573: }
574: at (keeprow = atrow++, atcol);
575: printf ("(E) Expiration Action: "); /* at(?,27); */
576: switch ((int) io -> descr.d_archkeep)
577: {
578: case KEEPYES:
579: printf ("ARCHIVE");
580: break;
581: case KEEPNO:
582: printf ("DELETE ");
583: break;
584: case KEEPDFLT:
585: printf ("Default");
586: break;
587: default:
588: printf ("UNKNOWN");
589: break;
590: }
591: at (dirmsgrow = atrow++, atcol);
592: printf ("(D) Expire with Dirmsg: "); /* at (?,27) */
593: switch ((int) io -> descr.d_dmesgstat)
594: {
595: case DIRNOCARE:
596: printf ("NOCARE ");
597: break;
598: case DIRON:
599: printf ("ON ");
600: break;
601: case DIROFF:
602: printf ("OFF ");
603: break;
604: case DIRDFLT:
605: printf ("Default ");
606: break;
607: default:
608: printf ("UNKNOWN ");
609: break;
610: }
611: at (worksetrow = atrow++, atcol);
612: printf ("(W) Working Set Size: "); /* at (5,27) */
613: switch ((int) io -> descr.d_workset)
614: {
615: case 0:
616: printf ("Default");
617: break;
618: default:
619: printf ("%ld Notes", io -> descr.d_workset);
620: }
621: at (longrow = atrow++, atcol);
622: printf ("(l) Maximum text/article: "); /* at (6,27) */
623: printf ("%ld bytes", io -> descr.d_longnote);
624:
625: lastrow = atrow; /* for queries */
626:
627: /*
628: * Second Column
629: */
630:
631: atrow = 4;
632: atcol = 40;
633: at (atrow++, atcol);
634: printf ("Policy Note Exists: %s", io -> descr.d_plcy ? "YES" : "NO");
635: at (atrow++, atcol);
636: printf ("Next note in slot: %d", io -> descr.d_nnote + 1);
637: at (atrow++, atcol);
638: printf ("Deleted Notes (holes): %ld ", io -> descr.d_delnote);
639: at (atrow++, atcol);
640: printf ("Deleted Responses (holes): %ld ", io -> descr.d_delresp);
641: /*
642: * Should we show more statistics here?
643: * Things like orphans, adoptions, etc.
644: */
645:
646: if (atrow > lastrow)
647: lastrow = atrow;
648: lastrow++;
649: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.