Annotation of early-roguelike/rogue4/mach_dep.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Various installation dependent routines
! 3: *
! 4: * @(#)mach_dep.c 4.23 (Berkeley) 5/19/82
! 5: *
! 6: * Rogue: Exploring the Dungeons of Doom
! 7: * Copyright (C) 1980, 1981, 1982 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: * MAXLOAD What (if any) the maximum load average should be
! 18: * when people are playing. If defined, then
! 19: * LOADAV Should rogue define it's own routine to
! 20: * get the load average?
! 21: * NAMELIST If so, where does the system namelist hide?
! 22: * MAXUSERS What (if any) the maximum user count should be
! 23: * when people are playing. If defined, then
! 24: * UCOUNT Should rogue define it's own routine to
! 25: * count users?
! 26: * UTMP If so, where does the user list hide?
! 27: * CHECKTIME How often/if rogue should check during the game
! 28: * for high load average.
! 29: */
! 30:
! 31: #include <limits.h>
! 32: #include <stdlib.h>
! 33: #include <stdio.h>
! 34: #include <curses.h>
! 35: #include <time.h>
! 36: #include <signal.h>
! 37: #include <sys/stat.h>
! 38: #include <fcntl.h>
! 39: #include <string.h>
! 40: #include <errno.h>
! 41:
! 42: #ifdef CHECKTIME
! 43: #include <unistd.h>
! 44: #endif
! 45:
! 46: #include "rogue.h"
! 47:
! 48: int num_checks; /* times we've gone over in checkout() */
! 49:
! 50: #ifdef SCOREFILE
! 51: #ifdef LOCKFILE
! 52: static char *lockfile = LOCKFILE;
! 53: #endif
! 54: #endif
! 55:
! 56: int too_much(void);
! 57: bool author(void);
! 58: void checkout(int s);
! 59: void chmsg(char *fmt, int arg);
! 60:
! 61: /*
! 62: * init_check:
! 63: * Check out too see if it is proper to play the game now
! 64: */
! 65: void
! 66: init_check(void)
! 67: {
! 68: if (too_much())
! 69: {
! 70: printf("Sorry, %s, but the system is too loaded now.\n", whoami);
! 71: printf("Try again later. Meanwhile, why not enjoy a%s %s?\n",
! 72: vowelstr(fruit), fruit);
! 73: if (author())
! 74: printf("However, since you're a good guy, it's up to you\n");
! 75: else
! 76: exit(1);
! 77: }
! 78: }
! 79:
! 80: /*
! 81: * open_score:
! 82: * Open up the score file for future use, and then
! 83: * setuid(getuid()) in case we are running setuid.
! 84: */
! 85: void
! 86: open_score(void)
! 87: {
! 88: #ifdef SCOREFILE
! 89: score_file = fopen(SCOREFILE, "r+");
! 90: if ((score_file == NULL) && (errno == ENOENT)) {
! 91: score_file = fopen(SCOREFILE, "w+");
! 92: }
! 93: #else
! 94: score_file = NULL;
! 95: #endif
! 96: if (!use_savedir)
! 97: md_normaluser();
! 98: return;
! 99: }
! 100:
! 101: void
! 102: open_log(void)
! 103: {
! 104: #ifdef LOGFILE
! 105: log_file = fopen(LOGFILE, "a");
! 106: #else
! 107: log_file = NULL;
! 108: #endif
! 109: return;
! 110: }
! 111:
! 112: /*
! 113: * setup:
! 114: * Get starting setup for all games
! 115: */
! 116: void
! 117: setup(void)
! 118: {
! 119: void auto_save(), quit(), endit(), tstp();
! 120:
! 121: /*
! 122: * make sure that large terminals don't overflow the bounds
! 123: * of the program
! 124: */
! 125: if (LINES > MAXLINES)
! 126: LINES = MAXLINES;
! 127: if (COLS > MAXCOLS)
! 128: COLS = MAXCOLS;
! 129:
! 130: #ifdef SIGHUP
! 131: signal(SIGHUP, auto_save);
! 132: #endif
! 133: #ifndef DUMP
! 134: signal(SIGILL, auto_save);
! 135: #ifdef SIGTRAP
! 136: signal(SIGTRAP, auto_save);
! 137: #endif
! 138: #ifdef SIGIOT
! 139: signal(SIGIOT, auto_save);
! 140: #endif
! 141: #ifdef SIGEMT
! 142: signal(SIGEMT, auto_save);
! 143: #endif
! 144: signal(SIGFPE, auto_save);
! 145: #ifdef SIGBUS
! 146: signal(SIGBUS, auto_save);
! 147: #endif
! 148: /* Don't bother saving a game that segfaulted. */
! 149: signal(SIGSEGV, SIG_DFL);
! 150: #ifdef SIGSYS
! 151: signal(SIGSYS, auto_save);
! 152: #endif
! 153: signal(SIGTERM, auto_save);
! 154: #endif
! 155:
! 156: signal(SIGINT, quit);
! 157: #ifndef DUMP
! 158: #ifdef SIGQUIT
! 159: signal(SIGQUIT, endit);
! 160: #endif
! 161: #endif
! 162: #ifdef CHECKTIME
! 163: signal(SIGALRM, checkout);
! 164: alarm(CHECKTIME * 60);
! 165: num_checks = 0;
! 166: #endif
! 167: nonl();
! 168: crmode(); /* Cbreak mode */
! 169: noecho(); /* Echo off */
! 170: }
! 171:
! 172: /*
! 173: * start_score:
! 174: * Start the scoring sequence
! 175: */
! 176: void
! 177: start_score(void)
! 178: {
! 179: #ifdef SIGALRM
! 180: signal(SIGALRM, SIG_IGN);
! 181: #endif
! 182: }
! 183:
! 184: /*
! 185: * issymlink:
! 186: * See if the file has a symbolic link
! 187: */
! 188: bool
! 189: issymlink(char *sp)
! 190: {
! 191: #ifdef S_IFLNK
! 192: struct stat sbuf2;
! 193:
! 194: if (lstat(sp, &sbuf2) < 0)
! 195: return FALSE;
! 196: else
! 197: return ((sbuf2.st_mode & S_IFMT) != S_IFREG);
! 198: #else
! 199: return FALSE;
! 200: #endif
! 201: }
! 202:
! 203: /*
! 204: * too_much:
! 205: * See if the system is being used too much for this game
! 206: */
! 207: int
! 208: too_much(void)
! 209: {
! 210: #ifdef MAXLOAD
! 211: double avec[3];
! 212:
! 213: if (md_getloadavg(avec) == 0)
! 214: if (avec[2] > (MAXLOAD / 10.0))
! 215: return(1);
! 216: #endif
! 217: #ifdef MAXUSERS
! 218: if (md_ucount() > MAXUSERS)
! 219: return(1) ;
! 220: #endif
! 221: return(0);
! 222: }
! 223:
! 224: /*
! 225: * author:
! 226: * See if a user is an author of the program
! 227: */
! 228: bool
! 229: author(void)
! 230: {
! 231: #ifdef WIZARD
! 232: if (wizard)
! 233: return TRUE;
! 234: #endif
! 235: switch (md_getuid())
! 236: {
! 237: case 0:
! 238: return TRUE;
! 239: default:
! 240: return FALSE;
! 241: }
! 242: }
! 243:
! 244: /*
! 245: * checkout:
! 246: * Check each CHECKTIME seconds to see if the load is too high
! 247: */
! 248: void
! 249: checkout(int s)
! 250: {
! 251: static char *msgs[] = {
! 252: "The load is too high to be playing. Please leave in %0.1f minutes",
! 253: "Please save your game. You have %0.1f minutes",
! 254: "Last warning. You have %0.1f minutes to leave",
! 255: };
! 256: int checktime = 0;
! 257:
! 258: #ifdef SIGALRM
! 259: signal(SIGALRM, checkout);
! 260: #endif
! 261:
! 262: if (too_much())
! 263: {
! 264: if (author())
! 265: {
! 266: num_checks = 1;
! 267: chmsg("The load is rather high, O exaulted one", 0);
! 268: }
! 269: else if (num_checks++ == 3)
! 270: fatal("Sorry. You took to long. You are dead\n");
! 271:
! 272: #ifdef CHECKTIME
! 273: checktime = (CHECKTIME * 60) / num_checks;
! 274: #ifdef SIGALRM
! 275: alarm(checktime);
! 276: #endif
! 277: #endif
! 278:
! 279: chmsg(msgs[num_checks - 1], ((double) checktime / 60.0));
! 280: }
! 281: else
! 282: {
! 283: if (num_checks)
! 284: {
! 285: num_checks = 0;
! 286: chmsg("The load has dropped back down. You have a reprieve", 0);
! 287: }
! 288: #ifdef CHECKTIME
! 289: #ifdef SIGALRM
! 290: alarm(CHECKTIME * 60);
! 291: #endif
! 292: #endif
! 293: }
! 294: }
! 295:
! 296: /*
! 297: * chmsg:
! 298: * checkout()'s version of msg. If we are in the middle of a
! 299: * shell, do a printf instead of a msg to avoid the refresh.
! 300: */
! 301: void
! 302: chmsg(char *fmt, int arg)
! 303: {
! 304: if (in_shell)
! 305: {
! 306: printf(fmt, arg);
! 307: putchar('\n');
! 308: fflush(stdout);
! 309: }
! 310: else
! 311: msg(fmt, arg);
! 312: }
! 313:
! 314: /*
! 315: * lock_sc:
! 316: * lock the score file. If it takes too long, ask the user if
! 317: * they care to wait. Return TRUE if the lock is successful.
! 318: */
! 319: bool
! 320: lock_sc(void)
! 321: {
! 322: #ifdef SCOREFILE
! 323: #ifdef LOCKFILE
! 324: register int cnt;
! 325: static struct stat sbuf;
! 326:
! 327: over:
! 328: if (creat(lockfile, 0000) > 0)
! 329: return TRUE;
! 330: for (cnt = 0; cnt < 5; cnt++)
! 331: {
! 332: md_sleep(1);
! 333: if (creat(lockfile, 0000) > 0)
! 334: return TRUE;
! 335: }
! 336: if (stat(lockfile, &sbuf) < 0)
! 337: {
! 338: creat(lockfile, 0000);
! 339: return TRUE;
! 340: }
! 341: if (time(NULL) - sbuf.st_mtime > 10)
! 342: {
! 343: if (md_unlink(lockfile) < 0)
! 344: return FALSE;
! 345: goto over;
! 346: }
! 347: else
! 348: {
! 349: printf("The score file is very busy. Do you want to wait longer\n");
! 350: printf("for it to become free so your score can get posted?\n");
! 351: printf("If so, type \"y\"\n");
! 352: fgets(prbuf, MAXSTR, stdin);
! 353: if (prbuf[0] == 'y')
! 354: for (;;)
! 355: {
! 356: if (creat(lockfile, 0000) > 0)
! 357: return TRUE;
! 358: if (stat(lockfile, &sbuf) < 0)
! 359: {
! 360: creat(lockfile, 0000);
! 361: return TRUE;
! 362: }
! 363: if (time(NULL) - sbuf.st_mtime > 10)
! 364: {
! 365: if (md_unlink(lockfile) < 0)
! 366: return FALSE;
! 367: }
! 368: md_sleep(1);
! 369: }
! 370: else
! 371: return FALSE;
! 372: }
! 373: #endif
! 374: #endif
! 375: return TRUE;
! 376: }
! 377:
! 378: /*
! 379: * unlock_sc:
! 380: * Unlock the score file
! 381: */
! 382: void
! 383: unlock_sc(void)
! 384: {
! 385: #ifdef SCOREFILE
! 386: #ifdef LOCKFILE
! 387: md_unlink(lockfile);
! 388: #endif
! 389: #endif
! 390: }
! 391:
! 392: /*
! 393: * flush_type:
! 394: * Flush typeahead for traps, etc.
! 395: */
! 396: void
! 397: flush_type(void)
! 398: {
! 399: flushinp();
! 400: }
CVSweb
![[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 / rogue4