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