![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to machdep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / old / rogue|
Return to machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / old / rogue |
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: char copyright[] =
9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)machdep.c 5.3 (Berkeley) 5/29/89";
15: #endif not lint
16:
17: /*
18: * Various installation dependent routines
19: *
20: * $Revision: 1.7 $, $Date: 85/04/05 11:33:30 $
21: */
22:
23: /*
24: * The various tuneable defines are:
25: *
26: * SCOREFILE Where/if the score file should live.
27: * ALLSCORES Score file is top ten scores, not top ten
28: * players. This is only useful when only a few
29: * people will be playing; otherwise the score file
30: * gets hogged by just a few people.
31: * NUMSCORES Number of scores in the score file (default 10).
32: * NUMNAME String version of NUMSCORES (first character
33: * should be capitalized) (default "Ten").
34: * MAXLOAD What (if any) the maximum load average should be
35: * when people are playing.
36: * LOADAV Should it use it's own routine to get
37: * the load average?
38: * NAMELIST If so, where does the system namelist
39: * hide?
40: * MAXUSERS What (if any) the maximum user count should be
41: * when people are playing. If defined, then
42: * UCOUNT Should it use it's own routine to count
43: * users?
44: * UTMP If so, where does the user list hide?
45: * CHECKTIME How often/if it should check during the game
46: * for high load average.
47: * WARNTIME How much time between warnings when load gets
48: * too high (if not defined, it is the same as
49: * CHECKTIME).
50: */
51:
52: # include <curses.h>
53: # include "machdep.h"
54: # include <signal.h>
55: # include <sys/types.h>
56: # include <sys/stat.h>
57: # include <sys/file.h>
58:
59: # undef LOADAV /* use getloadavg() by default */
60:
61: # ifdef SCOREFILE
62:
63: static char *Lockfile = "/tmp/.fredlock";
64:
65: # ifndef NUMSCORES
66: # define NUMSCORES 10
67: # define NUMNAME "Ten"
68: # endif NUMSCORES
69:
70: unsigned int Numscores = NUMSCORES;
71:
72: char *Numname = NUMNAME;
73:
74: # ifdef ALLSCORES
75: bool Allscore = TRUE;
76: # else ALLSCORES
77: bool Allscore = FALSE;
78: # endif ALLSCORES
79:
80: # endif SCOREFILE
81:
82: # ifdef CHECKTIME
83: static int Num_checks; /* times we've gone over in checkout() */
84:
85: # ifndef WARNTIME
86: # define WARNTIME CHECKTIME
87: # endif
88: # endif CHECKTIME
89:
90: /*
91: * init_check:
92: * Check out too see if it is proper to play the game now
93: */
94: init_check()
95: {
96: # if defined(MAXLOAD) || defined(MAXUSERS)
97: if (too_much()) {
98: printf("Sorry, %s, but the system is too loaded now.\n",
99: Whoami);
100: printf("Try again later. Meanwhile, why not enjoy a%s %s?\n",
101: vowelstr(Fruit), Fruit);
102: if (author())
103: printf("However, since you're a good guy, it's up to you\n");
104: else
105: exit(1);
106: }
107: # endif defined(MAXLOAD) || defined(MAXUSERS)
108: }
109:
110: /*
111: * open_score:
112: * Open up the score file for future use, and then
113: * setuid(getuid()) in case we are running setuid.
114: */
115: open_score()
116: {
117: # ifdef SCOREFILE
118: Fd = open(SCOREFILE, 2);
119: # else SCOREFILE
120: Fd = -1;
121: # endif SCOREFILE
122: setuid(getuid());
123: setgid(getgid());
124: }
125:
126: /*
127: * setup:
128: * Get starting setup for all games
129: */
130: setup()
131: {
132: extern int auto_save(), quit(), endit(), tstp();
133: # ifdef CHECKTIME
134: extern int heckout();
135: # endif CHECKTIME
136:
137: signal(SIGHUP, auto_save);
138: # ifndef DUMP
139: signal(SIGILL, auto_save);
140: signal(SIGTRAP, auto_save);
141: signal(SIGIOT, auto_save);
142: signal(SIGEMT, auto_save);
143: signal(SIGFPE, auto_save);
144: signal(SIGBUS, auto_save);
145: signal(SIGSEGV, auto_save);
146: signal(SIGSYS, auto_save);
147: signal(SIGTERM, auto_save);
148: # endif DUMP
149:
150: signal(SIGINT, quit);
151: # ifndef DUMP
152: signal(SIGQUIT, endit);
153: # endif DUMP
154: # ifdef CHECKTIME
155: signal(SIGALRM, checkout);
156: alarm(CHECKTIME * 60);
157: Num_checks = 0;
158: # endif CHECKTIME
159: crmode(); /* Cbreak mode */
160: noecho(); /* Echo off */
161: nonl();
162: # ifdef TIOCGLTC
163: getltchars(); /* get the local tty chars */
164: # endif TIOCGLTC
165: }
166:
167: /*
168: * getltchars:
169: * Get the local tty chars for later use
170: */
171: getltchars()
172: {
173: # ifdef TIOCGLTC
174: ioctl(1, TIOCGLTC, &Ltc);
175: Got_ltc = TRUE;
176: Orig_dsusp = Ltc.t_dsuspc;
177: if (Orig_dsusp == CTRL(Y)) {
178: Ltc.t_dsuspc = Ltc.t_suspc;
179: ioctl(1, TIOCSLTC, &Ltc);
180: }
181: # endif TIOCGLTC
182: }
183:
184: /*
185: * start_score:
186: * Start the scoring sequence
187: */
188: start_score()
189: {
190: # ifdef CHECKTIME
191: signal(SIGALRM, SIG_IGN); /* NOSTRICT */
192: # endif CHECKTIME
193: }
194:
195: /*
196: * symlink:
197: * See if the file has a symbolic link
198: */
199: symlink(sp)
200: char *sp;
201: {
202: # ifdef S_IFLNK
203: struct stat sbuf2;
204:
205: if (lstat(sp, &sbuf2) < 0)
206: return FALSE;
207: else
208: return ((sbuf2.st_mode & S_IFMT) != S_IFREG);
209: # else S_IFLNK
210: return FALSE;
211: # endif S_IFLNK
212: }
213:
214: # if defined(MAXLOAD) || defined(MAXUSERS)
215: /*
216: * too_much:
217: * See if the system is being used too much for this game
218: */
219: too_much()
220: {
221: # ifdef MAXLOAD
222: double avec[3];
223: # endif MAXLOAD
224: # ifdef MAXUSERS
225: register int cnt;
226: # endif MAXUSERS
227:
228: # ifdef MAXLOAD
229: # ifdef LOADAV
230: loadav(avec);
231: # else
232: if (getloadavg(avec, sizeof(avec)/sizeof(avec[0])) < 0)
233: avec[0] = avec[1] = avec[2] = 0.0;
234: # endif
235: if (avec[1] > MAXLOAD)
236: return TRUE;
237: # endif MAXLOAD
238: # ifdef MAXUSERS
239: if (ucount() > MAXUSERS)
240: return TRUE;
241: # endif MAXUSERS
242: return FALSE;
243: }
244:
245: /*
246: * author:
247: * See if a user is an author of the program
248: */
249: author()
250: {
251: # ifdef MASTER
252: if (Wizard)
253: return TRUE;
254: # endif MASTER
255: switch (getuid())
256: {
257: case -1:
258: return TRUE;
259: default:
260: return FALSE;
261: }
262: }
263: # endif defined(MAXLOAD) || defined(MAXUSERS)
264:
265: # ifdef CHECKTIME
266: /*
267: * checkout:
268: * Check each CHECKTIME seconds to see if the load is too high
269: */
270: checkout()
271: {
272: int checktime;
273: static char *msgs[] = {
274: "The load is too high to be playing. Please leave in %.2f minutes",
275: "Please save your game. You have %.2f minutes",
276: "Last warning. You have %.2f minutes to leave",
277: };
278:
279: signal(SIGALRM, checkout);
280: if (too_much()) {
281: if (author()) {
282: Num_checks = 1;
283: chmsg("The load is rather high, O exaulted one");
284: }
285: else if (Num_checks++ == 3)
286: fatal("Sorry. You took too long. You are dead\n");
287: checktime = (WARNTIME * 60) / Num_checks;
288: alarm(checktime);
289: chmsg(msgs[Num_checks - 1], ((double) checktime / 60.0));
290: }
291: else {
292: if (Num_checks) {
293: Num_checks = 0;
294: chmsg("The load has dropped back down. You have a reprieve");
295: }
296: alarm(CHECKTIME * 60);
297: }
298: }
299:
300: /*
301: * chmsg:
302: * checkout()'s version of msg. If we are in the middle of a
303: * shell, do a printf instead of a msg to avoid the refresh.
304: */
305: /* VARARGS1 */
306: chmsg(fmt, arg)
307: char *fmt;
308: int arg;
309: {
310: if (!In_shell)
311: msg(fmt, arg);
312: else {
313: printf(fmt, arg);
314: putchar('\n');
315: fflush(stdout);
316: }
317: }
318: # endif defined(MAXLOAD) || defined(MAXUSERS)
319:
320: # ifdef LOADAV
321: /*
322: * loadav:
323: * Looking up load average in core (for system where the loadav()
324: * system call isn't defined
325: */
326:
327: # include <nlist.h>
328:
329: struct nlist avenrun = {
330: "_avenrun"
331: };
332:
333: # ifndef NAMELIST
334: # define NAMELIST "/vmunix"
335: # endif
336:
337: loadav(avg)
338: register double *avg;
339: {
340: register int kmem;
341:
342: if ((kmem = open("/dev/kmem", 0)) < 0)
343: goto bad;
344: nlist(NAMELIST, &avenrun);
345: if (avenrun.n_type == 0) {
346: close(kmem);
347: bad:
348: avg[0] = 0.0;
349: avg[1] = 0.0;
350: avg[2] = 0.0;
351: return;
352: }
353:
354: lseek(kmem, (long) avenrun.n_value, 0);
355: read(kmem, (char *) avg, 3 * sizeof (double));
356: close(kmem);
357: }
358: # endif LOADAV
359:
360: # ifdef UCOUNT
361: /*
362: * ucount:
363: * Count number of users on the system
364: */
365: # include <utmp.h>
366:
367: struct utmp buf;
368:
369: ucount()
370: {
371: register struct utmp *up;
372: register FILE *utmp;
373: register int count;
374:
375: if ((utmp = fopen(UTMP, "r")) == NULL)
376: return 0;
377:
378: up = &buf;
379: count = 0;
380:
381: while (fread(up, 1, sizeof (*up), utmp) > 0)
382: if (buf.ut_name[0] != '\0')
383: count++;
384: fclose(utmp);
385: return count;
386: }
387: # endif UCOUNT
388:
389: /*
390: * lock_sc:
391: * lock the score file. If it takes too long, ask the user if
392: * they care to wait. Return TRUE if the lock is successful.
393: */
394: lock_sc()
395: {
396: # ifdef SCOREFILE
397: # ifdef LOCK_EX
398: return (flock(Fd, LOCK_EX) >= 0);
399: # else LOCK_EX
400: register int cnt;
401: static struct stat sbuf;
402:
403: over:
404: close(8); /* just in case there are no files left */
405: if (creat(Lockfile, 0000) >= 0)
406: return TRUE;
407: for (cnt = 0; cnt < 5; cnt++) {
408: sleep(1);
409: if (creat(Lockfile, 0000) >= 0)
410: return TRUE;
411: }
412: if (stat(Lockfile, &sbuf) < 0) {
413: creat(Lockfile, 0000);
414: return TRUE;
415: }
416: if (time(NULL) - sbuf.st_mtime > 10) {
417: if (unlink(Lockfile) < 0)
418: return FALSE;
419: goto over;
420: }
421: else {
422: printf("The score file is very busy. Do you want to wait longer\n");
423: printf("for it to become free so your score can get posted?\n");
424: printf("If so, type \"y\"\n");
425: fgets(Prbuf, MAXSTR, stdin);
426: if (Prbuf[0] == 'y')
427: for (;;) {
428: if (creat(Lockfile, 0000) >= 0)
429: return TRUE;
430: if (stat(Lockfile, &sbuf) < 0) {
431: creat(Lockfile, 0000);
432: return TRUE;
433: }
434: if (time(NULL) - sbuf.st_mtime > 10)
435: if (unlink(Lockfile) < 0)
436: return FALSE;
437: sleep(1);
438: }
439: else
440: return FALSE;
441: }
442: # endif LOCK_EX
443: # endif SCOREFILE
444: }
445:
446: /*
447: * unlock_sc:
448: * Unlock the score file
449: */
450: unlock_sc()
451: {
452: # ifdef SCOREFILE
453: # ifdef LOCK_EX
454: flock(Fd, LOCK_UN);
455: #else
456: unlink(Lockfile);
457: # endif
458: # endif
459: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.