![[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] / 43BSDTahoe / games / rogue|
Return to machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / games / rogue |
1.1 ! root 1: /* ! 2: * machdep.c ! 3: * ! 4: * This source herein may be modified and/or distributed by anybody who ! 5: * so desires, with the following restrictions: ! 6: * 1.) No portion of this notice shall be removed. ! 7: * 2.) Credit shall not be taken for the creation of this source. ! 8: * 3.) This code is not to be traded, sold, or used for personal ! 9: * gain or profit. ! 10: * ! 11: */ ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)machdep.c 5.2 (Berkeley) 11/25/87"; ! 15: #endif /* not lint */ ! 16: ! 17: /* Included in this file are all system dependent routines. Extensive use ! 18: * of #ifdef's will be used to compile the appropriate code on each system: ! 19: * ! 20: * UNIX: all UNIX systems. ! 21: * UNIX_BSD4_2: UNIX BSD 4.2 and later, UTEK, (4.1 BSD too?) ! 22: * UNIX_SYSV: UNIX system V ! 23: * UNIX_V7: UNIX version 7 ! 24: * ! 25: * All UNIX code should be included between the single "#ifdef UNIX" at the ! 26: * top of this file, and the "#endif" at the bottom. ! 27: * ! 28: * To change a routine to include a new UNIX system, simply #ifdef the ! 29: * existing routine, as in the following example: ! 30: * ! 31: * To make a routine compatible with UNIX system 5, change the first ! 32: * function to the second: ! 33: * ! 34: * md_function() ! 35: * { ! 36: * code; ! 37: * } ! 38: * ! 39: * md_function() ! 40: * { ! 41: * #ifdef UNIX_SYSV ! 42: * sys5code; ! 43: * #else ! 44: * code; ! 45: * #endif ! 46: * } ! 47: * ! 48: * Appropriate variations of this are of course acceptible. ! 49: * The use of "#elseif" is discouraged because of non-portability. ! 50: * If the correct #define doesn't exist, "UNIX_SYSV" in this case, make it up ! 51: * and insert it in the list at the top of the file. Alter the CFLAGS ! 52: * in you Makefile appropriately. ! 53: * ! 54: */ ! 55: ! 56: #ifdef UNIX ! 57: ! 58: #include <stdio.h> ! 59: #include <sys/types.h> ! 60: #include <sys/file.h> ! 61: #include <sys/stat.h> ! 62: #include <pwd.h> ! 63: ! 64: #ifdef UNIX_BSD4_2 ! 65: #include <sys/time.h> ! 66: #include <sgtty.h> ! 67: #endif ! 68: ! 69: #ifdef UNIX_SYSV ! 70: #include <time.h> ! 71: #include <termio.h> ! 72: #endif ! 73: ! 74: #include <signal.h> ! 75: #include "rogue.h" ! 76: ! 77: /* md_slurp: ! 78: * ! 79: * This routine throws away all keyboard input that has not ! 80: * yet been read. It is used to get rid of input that the user may have ! 81: * typed-ahead. ! 82: * ! 83: * This function is not necessary, so it may be stubbed. The might cause ! 84: * message-line output to flash by because the game has continued to read ! 85: * input without waiting for the user to read the message. Not such a ! 86: * big deal. ! 87: */ ! 88: ! 89: md_slurp() ! 90: { ! 91: long ln = 0; ! 92: ! 93: #ifdef UNIX_BSD4_2 ! 94: ioctl(0, FIONREAD, &ln); ! 95: #endif ! 96: #ifdef UNIX_SYSV ! 97: ioctl(0, TCFLSH, &ln); ! 98: ln = 0; ! 99: #endif ! 100: ! 101: ln += stdin->_cnt; ! 102: ! 103: for (; ln > 0; ln--) { ! 104: (void) getchar(); ! 105: } ! 106: } ! 107: ! 108: /* md_control_keyboard(): ! 109: * ! 110: * This routine is much like md_cbreak_no_echo_nonl() below. It sets up the ! 111: * keyboard for appropriate input. Specifically, it prevents the tty driver ! 112: * from stealing characters. For example, ^Y is needed as a command ! 113: * character, but the tty driver intercepts it for another purpose. Any ! 114: * such behavior should be stopped. This routine could be avoided if ! 115: * we used RAW mode instead of CBREAK. But RAW mode does not allow the ! 116: * generation of keyboard signals, which the program uses. ! 117: * ! 118: * The parameter 'mode' when true, indicates that the keyboard should ! 119: * be set up to play rogue. When false, it should be restored if ! 120: * necessary. ! 121: * ! 122: * This routine is not strictly necessary and may be stubbed. This may ! 123: * cause certain command characters to be unavailable. ! 124: */ ! 125: ! 126: md_control_keybord(mode) ! 127: boolean mode; ! 128: { ! 129: static boolean called_before = 0; ! 130: #ifdef UNIX_BSD4_2 ! 131: static struct ltchars ltc_orig; ! 132: static struct tchars tc_orig; ! 133: struct ltchars ltc_temp; ! 134: struct tchars tc_temp; ! 135: #endif ! 136: #ifdef UNIX_SYSV ! 137: static struct termio _oldtty; ! 138: struct termio _tty; ! 139: #endif ! 140: ! 141: if (!called_before) { ! 142: called_before = 1; ! 143: #ifdef UNIX_BSD4_2 ! 144: ioctl(0, TIOCGETC, &tc_orig); ! 145: ioctl(0, TIOCGLTC, <c_orig); ! 146: #endif ! 147: #ifdef UNIX_SYSV ! 148: ioctl(0, TCGETA, &_oldtty); ! 149: #endif ! 150: } ! 151: #ifdef UNIX_BSD4_2 ! 152: ltc_temp = ltc_orig; ! 153: tc_temp = tc_orig; ! 154: #endif ! 155: #ifdef UNIX_SYSV ! 156: _tty = _oldtty; ! 157: #endif ! 158: ! 159: if (!mode) { ! 160: #ifdef UNIX_BSD4_2 ! 161: ltc_temp.t_suspc = ltc_temp.t_dsuspc = -1; ! 162: ltc_temp.t_rprntc = ltc_temp.t_flushc = -1; ! 163: ltc_temp.t_werasc = ltc_temp.t_lnextc = -1; ! 164: tc_temp.t_startc = tc_temp.t_stopc = -1; ! 165: #endif ! 166: #ifdef UNIX_SYSV ! 167: _tty.c_cc[VSWTCH] = CNSWTCH; ! 168: #endif ! 169: } ! 170: #ifdef UNIX_BSD4_2 ! 171: ioctl(0, TIOCSETC, &tc_temp); ! 172: ioctl(0, TIOCSLTC, <c_temp); ! 173: #endif ! 174: #ifdef UNIX_SYSV ! 175: ioctl(0, TCSETA, &_tty); ! 176: #endif ! 177: } ! 178: ! 179: /* md_heed_signals(): ! 180: * ! 181: * This routine tells the program to call particular routines when ! 182: * certain interrupts/events occur: ! 183: * ! 184: * SIGINT: call onintr() to interrupt fight with monster or long rest. ! 185: * SIGQUIT: call byebye() to check for game termination. ! 186: * SIGHUP: call error_save() to save game when terminal hangs up. ! 187: * ! 188: * On VMS, SIGINT and SIGQUIT correspond to ^C and ^Y. ! 189: * ! 190: * This routine is not strictly necessary and can be stubbed. This will ! 191: * mean that the game cannot be interrupted properly with keyboard ! 192: * input, this is not usually critical. ! 193: */ ! 194: ! 195: md_heed_signals() ! 196: { ! 197: signal(SIGINT, onintr); ! 198: signal(SIGQUIT, byebye); ! 199: signal(SIGHUP, error_save); ! 200: } ! 201: ! 202: /* md_ignore_signals(): ! 203: * ! 204: * This routine tells the program to completely ignore the events mentioned ! 205: * in md_heed_signals() above. The event handlers will later be turned on ! 206: * by a future call to md_heed_signals(), so md_heed_signals() and ! 207: * md_ignore_signals() need to work together. ! 208: * ! 209: * This function should be implemented or the user risks interrupting ! 210: * critical sections of code, which could cause score file, or saved-game ! 211: * file, corruption. ! 212: */ ! 213: ! 214: md_ignore_signals() ! 215: { ! 216: signal(SIGQUIT, SIG_IGN); ! 217: signal(SIGINT, SIG_IGN); ! 218: signal(SIGHUP, SIG_IGN); ! 219: } ! 220: ! 221: /* md_get_file_id(): ! 222: * ! 223: * This function returns an integer that uniquely identifies the specified ! 224: * file. It need not check for the file's existence. In UNIX, the inode ! 225: * number is used. ! 226: * ! 227: * This function is used to identify saved-game files. ! 228: */ ! 229: ! 230: int ! 231: md_get_file_id(fname) ! 232: char *fname; ! 233: { ! 234: struct stat sbuf; ! 235: ! 236: if (stat(fname, &sbuf)) { ! 237: return(-1); ! 238: } ! 239: return((int) sbuf.st_ino); ! 240: } ! 241: ! 242: /* md_link_count(): ! 243: * ! 244: * This routine returns the number of hard links to the specified file. ! 245: * ! 246: * This function is not strictly necessary. On systems without hard links ! 247: * this routine can be stubbed by just returning 1. ! 248: */ ! 249: ! 250: int ! 251: md_link_count(fname) ! 252: char *fname; ! 253: { ! 254: struct stat sbuf; ! 255: ! 256: stat(fname, &sbuf); ! 257: return((int) sbuf.st_nlink); ! 258: } ! 259: ! 260: /* md_gct(): (Get Current Time) ! 261: * ! 262: * This function returns the current year, month(1-12), day(1-31), hour(0-23), ! 263: * minute(0-59), and second(0-59). This is used for identifying the time ! 264: * at which a game is saved. ! 265: * ! 266: * This function is not strictly necessary. It can be stubbed by returning ! 267: * zeros instead of the correct year, month, etc. If your operating ! 268: * system doesn't provide all of the time units requested here, then you ! 269: * can provide only those that it does, and return zeros for the others. ! 270: * If you cannot provide good time values, then users may be able to copy ! 271: * saved-game files and play them. ! 272: */ ! 273: ! 274: md_gct(rt_buf) ! 275: struct rogue_time *rt_buf; ! 276: { ! 277: struct tm *t, *localtime(); ! 278: long seconds; ! 279: ! 280: time(&seconds); ! 281: t = localtime(&seconds); ! 282: ! 283: rt_buf->year = t->tm_year; ! 284: rt_buf->month = t->tm_mon + 1; ! 285: rt_buf->day = t->tm_mday; ! 286: rt_buf->hour = t->tm_hour; ! 287: rt_buf->minute = t->tm_min; ! 288: rt_buf->second = t->tm_sec; ! 289: } ! 290: ! 291: /* md_gfmt: (Get File Modification Time) ! 292: * ! 293: * This routine returns a file's date of last modification in the same format ! 294: * as md_gct() above. ! 295: * ! 296: * This function is not strictly necessary. It is used to see if saved-game ! 297: * files have been modified since they were saved. If you have stubbed the ! 298: * routine md_gct() above by returning constant values, then you may do ! 299: * exactly the same here. ! 300: * Or if md_gct() is implemented correctly, but your system does not provide ! 301: * file modification dates, you may return some date far in the past so ! 302: * that the program will never know that a saved-game file being modified. ! 303: * You may also do this if you wish to be able to restore games from ! 304: * saved-games that have been modified. ! 305: */ ! 306: ! 307: md_gfmt(fname, rt_buf) ! 308: char *fname; ! 309: struct rogue_time *rt_buf; ! 310: { ! 311: struct stat sbuf; ! 312: long seconds; ! 313: struct tm *t; ! 314: ! 315: stat(fname, &sbuf); ! 316: seconds = (long) sbuf.st_mtime; ! 317: t = localtime(&seconds); ! 318: ! 319: rt_buf->year = t->tm_year; ! 320: rt_buf->month = t->tm_mon + 1; ! 321: rt_buf->day = t->tm_mday; ! 322: rt_buf->hour = t->tm_hour; ! 323: rt_buf->minute = t->tm_min; ! 324: rt_buf->second = t->tm_sec; ! 325: } ! 326: ! 327: /* md_df: (Delete File) ! 328: * ! 329: * This function deletes the specified file, and returns true (1) if the ! 330: * operation was successful. This is used to delete saved-game files ! 331: * after restoring games from them. ! 332: * ! 333: * Again, this function is not strictly necessary, and can be stubbed ! 334: * by simply returning 1. In this case, saved-game files will not be ! 335: * deleted and can be replayed. ! 336: */ ! 337: ! 338: boolean ! 339: md_df(fname) ! 340: char *fname; ! 341: { ! 342: if (unlink(fname)) { ! 343: return(0); ! 344: } ! 345: return(1); ! 346: } ! 347: ! 348: /* md_gln: (Get login name) ! 349: * ! 350: * This routine returns the login name of the user. This string is ! 351: * used mainly for identifying users in score files. ! 352: * ! 353: * A dummy string may be returned if you are unable to implement this ! 354: * function, but then the score file would only have one name in it. ! 355: */ ! 356: ! 357: char * ! 358: md_gln() ! 359: { ! 360: struct passwd *p, *getpwuid(); ! 361: ! 362: if (!(p = getpwuid(getuid()))) ! 363: return((char *)NULL); ! 364: return(p->pw_name); ! 365: } ! 366: ! 367: /* md_sleep: ! 368: * ! 369: * This routine causes the game to pause for the specified number of ! 370: * seconds. ! 371: * ! 372: * This routine is not particularly necessary at all. It is used for ! 373: * delaying execution, which is useful to this program at some times. ! 374: */ ! 375: ! 376: md_sleep(nsecs) ! 377: int nsecs; ! 378: { ! 379: (void) sleep(nsecs); ! 380: } ! 381: ! 382: /* md_getenv() ! 383: * ! 384: * This routine gets certain values from the user's environment. These ! 385: * values are strings, and each string is identified by a name. The names ! 386: * of the values needed, and their use, is as follows: ! 387: * ! 388: * TERMCAP ! 389: * The name of the users's termcap file, NOT the termcap entries ! 390: * themselves. This is used ONLY if the program is compiled with ! 391: * CURSES defined (-DCURSES). Even in this case, the program need ! 392: * not find a string for TERMCAP. If it does not, it will use the ! 393: * default termcap file as returned by md_gdtcf(); ! 394: * TERM ! 395: * The name of the users's terminal. This is used ONLY if the program ! 396: * is compiled with CURSES defined (-DCURSES). In this case, the string ! 397: * value for TERM must be found, or the routines in curses.c cannot ! 398: * function, and the program will quit. ! 399: * ROGUEOPTS ! 400: * A string containing the various game options. This need not be ! 401: * defined. ! 402: * HOME ! 403: * The user's home directory. This is only used when the user specifies ! 404: * '~' as the first character of a saved-game file. This string need ! 405: * not be defined. ! 406: * SHELL ! 407: * The user's favorite shell. If not found, "/bin/sh" is assumed. ! 408: * ! 409: * If your system does not provide a means of searching for these values, ! 410: * you will have to do it yourself. None of the values above really need ! 411: * to be defined except TERM when the program is compiled with CURSES ! 412: * defined. In this case, as a bare minimum, you can check the 'name' ! 413: * parameter, and if it is "TERM" find the terminal name and return that, ! 414: * else return zero. If the program is not compiled with CURSES, you can ! 415: * get by with simply always returning zero. Returning zero indicates ! 416: * that their is no defined value for the given string. ! 417: */ ! 418: ! 419: char * ! 420: md_getenv(name) ! 421: char *name; ! 422: { ! 423: char *value; ! 424: char *getenv(); ! 425: ! 426: value = getenv(name); ! 427: ! 428: return(value); ! 429: } ! 430: ! 431: /* md_malloc() ! 432: * ! 433: * This routine allocates, and returns a pointer to, the specified number ! 434: * of bytes. This routines absolutely MUST be implemented for your ! 435: * particular system or the program will not run at all. Return zero ! 436: * when no more memory can be allocated. ! 437: */ ! 438: ! 439: char * ! 440: md_malloc(n) ! 441: int n; ! 442: { ! 443: char *malloc(); ! 444: char *t; ! 445: ! 446: t = malloc(n); ! 447: return(t); ! 448: } ! 449: ! 450: /* md_gseed() (Get Seed) ! 451: * ! 452: * This function returns a seed for the random number generator (RNG). This ! 453: * seed causes the RNG to begin generating numbers at some point in it's ! 454: * sequence. Without a random seed, the RNG will generate the same set ! 455: * of numbers, and every game will start out exactly the same way. A good ! 456: * number to use is the process id, given by getpid() on most UNIX systems. ! 457: * ! 458: * You need to find some single random integer, such as: ! 459: * process id. ! 460: * current time (minutes + seconds) returned from md_gct(), if implemented. ! 461: * ! 462: * It will not help to return "get_rand()" or "rand()" or the return value of ! 463: * any pseudo-RNG. If you don't have a random number, you can just return 1, ! 464: * but this means your games will ALWAYS start the same way, and will play ! 465: * exactly the same way given the same input. ! 466: */ ! 467: ! 468: md_gseed() ! 469: { ! 470: return(getpid()); ! 471: } ! 472: ! 473: /* md_exit(): ! 474: * ! 475: * This function causes the program to discontinue execution and exit. ! 476: * This function must be implemented or the program will continue to ! 477: * hang when it should quit. ! 478: */ ! 479: ! 480: md_exit(status) ! 481: int status; ! 482: { ! 483: exit(status); ! 484: } ! 485: ! 486: /* md_lock(): ! 487: * ! 488: * This function is intended to give the user exclusive access to the ! 489: * score file. It does so by "creat"ing a lock file, which can only ! 490: * be created if it does not already exist. The file is deleted when ! 491: * score file processing is finished. The lock file should be located ! 492: * in the same directory as the score file. These full path names should ! 493: * be defined for any particular site in rogue.h. The constants SCORE_FILE ! 494: * and LOCK_FILE define these file names. ! 495: * ! 496: * When the parameter 'l' is non-zero (true), a lock is requested. Otherwise ! 497: * the lock is released by removing the lock file. ! 498: */ ! 499: ! 500: md_lock(l) ! 501: boolean l; ! 502: { ! 503: short tries; ! 504: char *lock_file = LOCK_FILE; ! 505: ! 506: if (l) { ! 507: for (tries = 0; tries < 5; tries++) { ! 508: if (md_get_file_id(lock_file) == -1) { ! 509: if (creat(lock_file, 0444) != -1) { ! 510: break; ! 511: } else { ! 512: message("cannot lock score file", 0); ! 513: } ! 514: } else { ! 515: message("waiting to lock score file", 0); ! 516: } ! 517: sleep(2); ! 518: } ! 519: } else { ! 520: (void) unlink(lock_file); ! 521: } ! 522: } ! 523: ! 524: /* md_shell(): ! 525: * ! 526: * This function spawns a shell for the user to use. When this shell is ! 527: * terminated, the game continues. Since this program may often be run ! 528: * setuid to gain access to privileged files, care is taken that the shell ! 529: * is run with the user's REAL user id, and not the effective user id. ! 530: * The effective user id is restored after the shell completes. ! 531: */ ! 532: ! 533: md_shell(shell) ! 534: char *shell; ! 535: { ! 536: long w[2]; ! 537: ! 538: if (!fork()) { ! 539: int uid; ! 540: ! 541: uid = getuid(); ! 542: setuid(uid); ! 543: execl(shell, shell, 0); ! 544: } ! 545: wait(w); ! 546: } ! 547: ! 548: /* If you have a viable curses/termlib library, then use it and don't bother ! 549: * implementing the routines below. And don't compile with -DCURSES. ! 550: */ ! 551: ! 552: #ifdef CURSES ! 553: ! 554: /* md_cbreak_no_echo_nonl: ! 555: * ! 556: * This routine sets up some terminal characteristics. The tty-driver ! 557: * must be told to: ! 558: * 1.) Not echo input. ! 559: * 2.) Transmit input characters immediately upon typing. (cbreak mode) ! 560: * 3.) Move the cursor down one line, without changing column, and ! 561: * without generating a carriage-return, when it ! 562: * sees a line-feed. This is only necessary if line-feed is ever ! 563: * used in the termcap 'do' (cursor down) entry, in which case, ! 564: * your system should must have a way of accomplishing this. ! 565: * ! 566: * When the parameter 'on' is true, the terminal is set up as specified ! 567: * above. When this parameter is false, the terminal is restored to the ! 568: * original state. ! 569: * ! 570: * Raw mode should not to be used. Keyboard signals/events/interrupts should ! 571: * be sent, although they are not strictly necessary. See notes in ! 572: * md_heed_signals(). ! 573: * ! 574: * This function must be implemented for rogue to run properly if the ! 575: * program is compiled with CURSES defined to use the enclosed curses ! 576: * emulation package. If you are not using this, then this routine is ! 577: * totally unnecessary. ! 578: * ! 579: * Notice that information is saved between calls. This is used to ! 580: * restore the terminal to an initial saved state. ! 581: * ! 582: */ ! 583: ! 584: md_cbreak_no_echo_nonl(on) ! 585: boolean on; ! 586: { ! 587: #ifdef UNIX_BSD4_2 ! 588: static struct sgttyb tty_buf; ! 589: static int tsave_flags; ! 590: ! 591: if (on) { ! 592: ioctl(0, TIOCGETP, &tty_buf); ! 593: tsave_flags = tty_buf.sg_flags; ! 594: tty_buf.sg_flags |= CBREAK; ! 595: tty_buf.sg_flags &= ~(ECHO | CRMOD); /* CRMOD: see note 3 above */ ! 596: ioctl(0, TIOCSETP, &tty_buf); ! 597: } else { ! 598: tty_buf.sg_flags = tsave_flags; ! 599: ioctl(0, TIOCSETP, &tty_buf); ! 600: } ! 601: #endif ! 602: #ifdef UNIX_SYSV ! 603: struct termio tty_buf; ! 604: static struct termio tty_save; ! 605: ! 606: if (on) { ! 607: ioctl(0, TCGETA, &tty_buf); ! 608: tty_save = tty_buf; ! 609: tty_buf.c_lflag &= ~(ICANON | ECHO); ! 610: tty_buf.c_oflag &= ~ONLCR; ! 611: tty_buf.c_cc[4] = 1; /* MIN */ ! 612: tty_buf.c_cc[5] = 2; /* TIME */ ! 613: ioctl(0, TCSETAF, &tty_buf); ! 614: } else { ! 615: ioctl(0, TCSETAF, &tty_save); ! 616: } ! 617: #endif ! 618: } ! 619: ! 620: /* md_gdtcf(): (Get Default Termcap File) ! 621: * ! 622: * This function is called ONLY when the program is compiled with CURSES ! 623: * defined. If you use your system's curses/termlib library, this function ! 624: * won't be called. On most UNIX systems, "/etc/termcap" suffices. ! 625: * ! 626: * If their is no such termcap file, then return 0, but in that case, you ! 627: * must have a TERMCAP file returned from md_getenv("TERMCAP"). The latter ! 628: * will override the value returned from md_gdtcf(). If the program is ! 629: * compiled with CURSES defined, and md_gdtcf() returns 0, and ! 630: * md_getenv("TERMCAP") returns 0, the program will have no terminal ! 631: * capability information and will quit. ! 632: */ ! 633: ! 634: char * ! 635: md_gdtcf() ! 636: { ! 637: return("/etc/termcap"); ! 638: } ! 639: ! 640: /* md_tstp(): ! 641: * ! 642: * This function puts the game to sleep and returns to the shell. This ! 643: * only applies to UNIX 4.2 and 4.3. For other systems, the routine should ! 644: * be provided as a do-nothing routine. md_tstp() will only be referenced ! 645: * in the code when compiled with CURSES defined. ! 646: * ! 647: */ ! 648: ! 649: md_tstp() ! 650: { ! 651: #ifdef UNIX_BSD4_2 ! 652: kill(0, SIGTSTP); ! 653: #endif ! 654: } ! 655: ! 656: #endif ! 657: ! 658: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.