![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mach_dep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / rogue5|
Return to mach_dep.c CVS log | Up to [contributed] / early-roguelike / rogue5 |
1.1 rubenllo 1: /*
2: * Various installation dependent routines
3: *
4: * @(#)mach_dep.c 4.37 (Berkeley) 05/23/83
5: *
6: * Rogue: Exploring the Dungeons of Doom
7: * Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn Wichman
8: * All rights reserved.
9: *
10: * See the file LICENSE.TXT for full copyright and licensing information.
11: */
12:
13: /*
14: * The various tuneable defines are:
15: *
16: * SCOREFILE Where/if the score file should live.
17: * ALLSCORES Score file is top ten scores, not top ten
18: * players. This is only useful when only a few
19: * people will be playing; otherwise the score file
20: * gets hogged by just a few people.
21: * NUMSCORES Number of scores in the score file (default 10).
22: * NUMNAME String version of NUMSCORES (first character
23: * should be capitalized) (default "Ten").
24: * MAXLOAD What (if any) the maximum load average should be
25: * when people are playing. Since it is divided
26: * by 10, to specify a load limit of 4.0, MAXLOAD
27: * should be "40". If defined, then
28: * LOADAV Should it use it's own routine to get
29: * the load average?
30: * NAMELIST If so, where does the system namelist
31: * hide?
32: * MAXUSERS What (if any) the maximum user count should be
33: * when people are playing. If defined, then
34: * UCOUNT Should it use it's own routine to count
35: * users?
36: * UTMP If so, where does the user list hide?
37: * CHECKTIME How often/if it should check during the game
38: * for high load average.
39: */
40:
41: #include <signal.h>
42: #include <sys/types.h>
43: #include <sys/stat.h>
44: #include <limits.h>
45: #include <string.h>
46: #include <fcntl.h>
47: #include <errno.h>
48: #include <time.h>
49: #include <curses.h>
50: #include "extern.h"
51:
52: #define NOOP(x) (x += 0)
53:
54: # ifndef NUMSCORES
55: # define NUMSCORES 10
56: # define NUMNAME "Ten"
57: # endif
58:
59: #ifdef CHECKTIME
60: static int num_checks = 0; /* times we've gone over in checkout() */
61: #endif /* CHECKTIME */
62:
63: /*
64: * init_check:
65: * Check out too see if it is proper to play the game now
66: */
67:
68: void
69: init_check(void)
70: {
71: #if defined(MAXLOAD) || defined(MAXUSERS)
72: if (too_much())
73: {
74: printf("Sorry, %s, but the system is too loaded now.\n", whoami);
75: printf("Try again later. Meanwhile, why not enjoy a%s %s?\n",
76: vowelstr(fruit), fruit);
77: if (author())
78: printf("However, since you're a good guy, it's up to you\n");
79: else
80: exit(1);
81: }
82: #endif
83: }
84:
85: /*
86: * open_score:
87: * Open up the score file for future use
88: */
89:
90: void
91: open_score(void)
92: {
93: #ifdef SCOREFILE
94: char *scorefile = SCOREFILE;
95:
96: numscores = NUMSCORES;
97: Numname = NUMNAME;
98:
99: #ifdef ALLSCORES
100: allscore = TRUE;
101: #else /* ALLSCORES */
102: allscore = FALSE;
103: #endif /* ALLSCORES */
104:
105: /*
106: * We drop setgid privileges after opening the score file, so subsequent
107: * open()'s will fail. Just reuse the earlier filehandle.
108: */
109:
110: if (scoreboard != NULL) {
111: rewind(scoreboard);
112: return;
113: }
114:
115: scoreboard = fopen(scorefile, "r+");
116:
117: if ((scoreboard == NULL) && (errno == ENOENT))
118: {
119: scoreboard = fopen(scorefile, "w+");
120: md_chmod(scorefile,0664);
121: }
122:
123: if (scoreboard == NULL) {
124: fprintf(stderr, "Could not open %s for writing: %s\n", scorefile, strerror(errno));
125: fflush(stderr);
126: }
127: #else
128: scoreboard = NULL;
129: #endif
130: }
131:
132: void
133: open_log(void)
134: {
135: #ifdef LOGFILE
136: logfi = fopen(LOGFILE, "a");
137: if (logfi == NULL)
138: {
139: fprintf(stderr, "Could not open %s for appending: %s\n", LOGFILE,
140: strerror(errno));
141: fflush(stderr);
142: }
143: #endif
144: return;
145: }
146:
147: /*
148: * getltchars:
149: * Get the local tty chars for later use
150: */
151:
152: void
153: getltchars(void)
154: {
155: got_ltc = TRUE;
156: orig_dsusp = md_dsuspchar();
157: md_setdsuspchar( md_suspchar() );
158: }
159:
160: /*
161: * setup:
162: * Get starting setup for all games
163: */
164:
165: void
166: setup(void)
167: {
168: #ifndef DUMP
169: md_onsignal_autosave();
170: #else
171: md_onsignal_default();
172: #endif
173:
174: #ifdef CHECKTIME
175: md_start_checkout_timer(CHECKTIME*60);
176: num_checks = 0;
177: #endif
178:
179: raw(); /* Raw mode */
180: noecho(); /* Echo off */
181: nonl();
182: keypad(stdscr,1);
183: getltchars(); /* get the local tty chars */
184: }
185:
186: /*
187: * resetltchars:
188: * Reset the local tty chars to original values.
189: */
190: void
191: resetltchars(void)
192: {
193: if (got_ltc) {
194: md_setdsuspchar(orig_dsusp);
195: }
196: }
197:
198: /*
199: * playltchars:
200: * Set local tty chars to the values we use when playing.
201: */
202: void
203: playltchars(void)
204: {
205: if (got_ltc) {
206: md_setdsuspchar( md_suspchar() );
207: }
208: }
209:
210: /*
211: * start_score:
212: * Start the scoring sequence
213: */
214:
215: void
216: start_score(void)
217: {
218: #ifdef CHECKTIME
219: md_stop_checkout_timer();
220: #endif
221: }
222:
223: /*
224: * is_symlink:
225: * See if the file has a symbolic link
226: */
227: int
228: is_symlink(char *sp)
229: {
230: #ifdef S_IFLNK
231: struct stat sbuf2;
232:
233: if (lstat(sp, &sbuf2) < 0)
234: return FALSE;
235: else
236: return ((sbuf2.st_mode & S_IFMT) != S_IFREG);
237: #else
238: NOOP(sp);
239: return FALSE;
240: #endif
241: }
242:
243: #if defined(MAXLOAD) || defined(MAXUSERS)
244: /*
245: * too_much:
246: * See if the system is being used too much for this game
247: */
248: int
249: too_much(void)
250: {
251: #ifdef MAXLOAD
252: double avec[3];
253: #else
254: int cnt;
255: #endif
256:
257: #ifdef MAXLOAD
258: md_loadav(avec);
259: if (avec[1] > (MAXLOAD / 10.0))
260: return TRUE;
261: #endif
262: #ifdef MAXUSERS
263: if (ucount() > MAXUSERS)
264: return TRUE;
265: #endif
266: return FALSE;
267: }
268:
269: /*
270: * author:
271: * See if a user is an author of the program
272: */
273: int
274: author(void)
275: {
276: #ifdef MASTER
277: if (wizard)
278: return TRUE;
279: #endif
280: switch (md_getuid())
281: {
282: case -1:
283: return TRUE;
284: default:
285: return FALSE;
286: }
287: }
288: #endif
289:
290: #ifdef CHECKTIME
291: /*
292: * checkout:
293: * Check each CHECKTIME seconds to see if the load is too high
294: */
295:
296: checkout(int sig)
297: {
298: char *msgs[] = {
299: "The load is too high to be playing. Please leave in %0.1f minutes",
300: "Please save your game. You have %0.1f minutes",
301: "Last warning. You have %0.1f minutes to leave",
302: };
303: int checktime;
304:
305: if (too_much())
306: {
307: if (author())
308: {
309: num_checks = 1;
310: chmsg("The load is rather high, O exaulted one");
311: }
312: else if (num_checks++ == 3)
313: fatal("Sorry. You took too long. You are dead\n");
314: checktime = (CHECKTIME * 60) / num_checks;
315: chmsg(msgs[num_checks - 1], ((double) checktime / 60.0));
316: }
317: else
318: {
319: if (num_checks)
320: {
321: num_checks = 0;
322: chmsg("The load has dropped back down. You have a reprieve");
323: }
324: checktime = (CHECKTIME * 60);
325: }
326:
327: md_start_checkout_timer(checktime);
328: }
329:
330: /*
331: * chmsg:
332: * checkout()'s version of msg. If we are in the middle of a
333: * shell, do a printf instead of a msg to a the refresh.
334: */
335: /* VARARGS1 */
336:
337: chmsg(char *fmt, int arg)
338: {
339: if (!in_shell)
340: msg(fmt, arg);
341: else
342: {
343: printf(fmt, arg);
344: putchar('\n');
345: fflush(stdout);
346: }
347: }
348: #endif
349:
350: #ifdef UCOUNT
351: /*
352: * ucount:
353: * count number of users on the system
354: */
355: #include <utmp.h>
356:
357: struct utmp buf;
358:
359: int
360: ucount(void)
361: {
362: struct utmp *up;
363: FILE *utmp;
364: int count;
365:
366: if ((utmp = fopen(UTMP, "r")) == NULL)
367: return 0;
368:
369: up = &buf;
370: count = 0;
371:
372: while (fread(up, 1, sizeof (*up), utmp) > 0)
373: if (buf.ut_name[0] != '\0')
374: count++;
375: fclose(utmp);
376: return count;
377: }
378: #endif
379:
380: /*
381: * lock_sc:
382: * lock the score file. If it takes too long, ask the user if
383: * they care to wait. Return TRUE if the lock is successful.
384: */
385: static FILE *lfd = NULL;
386: int
387: lock_sc(void)
388: {
389: #if defined(SCOREFILE) && defined(LOCKFILE)
390: int cnt;
391: struct stat sbuf;
392: char *lockfile = LOCKFILE;
393:
394: over:
395: if ((lfd=fopen(lockfile, "w+")) != NULL)
396: return TRUE;
397: for (cnt = 0; cnt < 5; cnt++)
398: {
399: md_sleep(1);
400: if ((lfd=fopen(lockfile, "w+")) != NULL)
401: return TRUE;
402: }
403: if (stat(lockfile, &sbuf) < 0)
404: {
405: lfd=fopen(lockfile, "w+");
406: return TRUE;
407: }
408: if (time(NULL) - sbuf.st_mtime > 10)
409: {
410: if (md_unlink(lockfile) < 0)
411: return FALSE;
412: goto over;
413: }
414: else
415: {
416: printf("The score file is very busy. Do you want to wait longer\n");
417: printf("for it to become free so your score can get posted?\n");
418: printf("If so, type \"y\"\n");
419: (void) fgets(prbuf, MAXSTR, stdin);
420: if (prbuf[0] == 'y')
421: for (;;)
422: {
423: if ((lfd=fopen(lockfile, "w+")) != 0)
424: return TRUE;
425: if (stat(lockfile, &sbuf) < 0)
426: {
427: lfd=fopen(lockfile, "w+");
428: return TRUE;
429: }
430: if (time(NULL) - sbuf.st_mtime > 10)
431: {
432: if (md_unlink(lockfile) < 0)
433: return FALSE;
434: }
435: md_sleep(1);
436: }
437: else
438: return FALSE;
439: }
440: #else
441: return TRUE;
442: #endif
443: }
444:
445: /*
446: * unlock_sc:
447: * Unlock the score file
448: */
449:
450: void
451: unlock_sc(void)
452: {
453: #if defined(SCOREFILE) && defined(LOCKFILE)
454: if (lfd != NULL)
455: fclose(lfd);
456: lfd = NULL;
457: md_unlink(LOCKFILE);
458: #endif
459: }
460:
461: /*
462: * flush_type:
463: * Flush typeahead for traps, etc.
464: */
465:
466: void
467: flush_type(void)
468: {
469: flushinp();
470: }