/* $OpenBSD: machdep.c,v 1.8 2002/07/18 07:13:57 pjanzen Exp $ */ /* $NetBSD: machdep.c,v 1.5 1995/04/28 23:49:22 mycroft Exp $ */ /* * Copyright (c) 1988, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Timothy C. Stoehr. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef lint #if 0 static char sccsid[] = "@(#)machdep.c 8.1 (Berkeley) 5/31/93"; #else static const char rcsid[] = "$OpenBSD: machdep.c,v 1.8 2002/07/18 07:13:57 pjanzen Exp $"; #endif #endif /* not lint */ /* * machdep.c * * This source herein may be modified and/or distributed by anybody who * so desires, with the following restrictions: * 1.) No portion of this notice shall be removed. * 2.) Credit shall not be taken for the creation of this source. * 3.) This code is not to be traded, sold, or used for personal * gain or profit. * */ /* Included in this file are all system dependent routines. */ #include #include #include #include #include #include #include #include #include #include #include "rogue.h" #include "pathnames.h" /* md_slurp: * * This routine throws away all keyboard input that has not * yet been read. It is used to get rid of input that the user may have * typed-ahead. * * This function is not necessary, so it may be stubbed. The might cause * message-line output to flash by because the game has continued to read * input without waiting for the user to read the message. Not such a * big deal. */ void md_slurp() { (void)fpurge(stdin); } /* md_heed_signals(): * * This routine tells the program to call particular routines when * certain interrupts/events occur: * * SIGINT: call onintr() to interrupt fight with monster or long rest. * SIGQUIT: call byebye() to check for game termination. * SIGHUP: call error_save() to save game when terminal hangs up. * * On VMS, SIGINT and SIGQUIT correspond to ^C and ^Y. * * This routine is not strictly necessary and can be stubbed. This will * mean that the game cannot be interrupted properly with keyboard * input, this is not usually critical. */ void md_heed_signals() { signal(SIGINT, onintr); signal(SIGQUIT, byebye); signal(SIGHUP, error_save); } /* md_ignore_signals(): * * This routine tells the program to completely ignore the events mentioned * in md_heed_signals() above. The event handlers will later be turned on * by a future call to md_heed_signals(), so md_heed_signals() and * md_ignore_signals() need to work together. * * This function should be implemented or the user risks interrupting * critical sections of code, which could cause score file, or saved-game * file, corruption. */ void md_ignore_signals() { signal(SIGQUIT, SIG_IGN); signal(SIGINT, SIG_IGN); signal(SIGHUP, SIG_IGN); } /* md_get_file_id(): * * This function returns an integer that uniquely identifies the specified * file. It need not check for the file's existence. In UNIX, the inode * number is used. * * This function is used to identify saved-game files. */ int md_get_file_id(fname) char *fname; { struct stat sbuf; if (stat(fname, &sbuf)) { return(-1); } return((int) sbuf.st_ino); } /* md_link_count(): * * This routine returns the number of hard links to the specified file. * * This function is not strictly necessary. On systems without hard links * this routine can be stubbed by just returning 1. */ int md_link_count(fname) char *fname; { struct stat sbuf; stat(fname, &sbuf); return((int) sbuf.st_nlink); } /* md_gct(): (Get Current Time) * * This function returns the current year, month(1-12), day(1-31), hour(0-23), * minute(0-59), and second(0-59). This is used for identifying the time * at which a game is saved. * * This function is not strictly necessary. It can be stubbed by returning * zeros instead of the correct year, month, etc. If your operating * system doesn't provide all of the time units requested here, then you * can provide only those that it does, and return zeros for the others. * If you cannot provide good time values, then users may be able to copy * saved-game files and play them. */ void md_gct(rt_buf) struct rogue_time *rt_buf; { struct tm *t; time_t seconds; time(&seconds); t = localtime(&seconds); rt_buf->year = t->tm_year; rt_buf->month = t->tm_mon + 1; rt_buf->day = t->tm_mday; rt_buf->hour = t->tm_hour; rt_buf->minute = t->tm_min; rt_buf->second = t->tm_sec; } /* md_gfmt: (Get File Modification Time) * * This routine returns a file's date of last modification in the same format * as md_gct() above. * * This function is not strictly necessary. It is used to see if saved-game * files have been modified since they were saved. If you have stubbed the * routine md_gct() above by returning constant values, then you may do * exactly the same here. * Or if md_gct() is implemented correctly, but your system does not provide * file modification dates, you may return some date far in the past so * that the program will never know that a saved-game file being modified. * You may also do this if you wish to be able to restore games from * saved-games that have been modified. */ void md_gfmt(fname, rt_buf) char *fname; struct rogue_time *rt_buf; { struct stat sbuf; time_t seconds; struct tm *t; stat(fname, &sbuf); seconds = (long) sbuf.st_mtime; t = localtime(&seconds); rt_buf->year = t->tm_year; rt_buf->month = t->tm_mon + 1; rt_buf->day = t->tm_mday; rt_buf->hour = t->tm_hour; rt_buf->minute = t->tm_min; rt_buf->second = t->tm_sec; } /* md_df: (Delete File) * * This function deletes the specified file, and returns true (1) if the * operation was successful. This is used to delete saved-game files * after restoring games from them. * * Again, this function is not strictly necessary, and can be stubbed * by simply returning 1. In this case, saved-game files will not be * deleted and can be replayed. */ boolean md_df(fname) char *fname; { if (unlink(fname)) { return(0); } return(1); } /* md_gln: (Get login name) * * This routine returns the login name of the user. This string is * used mainly for identifying users in score files. * * A dummy string may be returned if you are unable to implement this * function, but then the score file would only have one name in it. */ char * md_gln() { struct passwd *p; if (!(p = getpwuid(getuid()))) return((char *)NULL); return(p->pw_name); } /* md_sleep: * * This routine causes the game to pause for the specified number of * seconds. * * This routine is not particularly necessary at all. It is used for * delaying execution, which is useful to this program at some times. */ void md_sleep(nsecs) int nsecs; { (void) sleep(nsecs); } /* md_getenv() * * This routine gets certain values from the user's environment. These * values are strings, and each string is identified by a name. The names * of the values needed, and their use, is as follows: * * ROGUEOPTS * A string containing the various game options. This need not be * defined. * HOME * The user's home directory. This is only used when the user specifies * '~' as the first character of a saved-game file. This string need * not be defined. * SHELL * The user's favorite shell. If not found, "/bin/sh" is assumed. * * If your system does not provide a means of searching for these values, * you will have to do it yourself. None of the values above really need * to be defined. You can get by simply always returning zero, which * indicates that there is no defined value for the given string. */ char * md_getenv(name) char *name; { char *value; value = getenv(name); return(value); } /* md_malloc() * * This routine allocates, and returns a pointer to, the specified number * of bytes. This routines absolutely MUST be implemented for your * particular system or the program will not run at all. Return zero * when no more memory can be allocated. */ char * md_malloc(n) int n; { char *t; t = malloc(n); return(t); } /* md_gseed() (Get Seed) * * This function returns a seed for the random number generator (RNG). This * seed causes the RNG to begin generating numbers at some point in it's * sequence. Without a random seed, the RNG will generate the same set * of numbers, and every game will start out exactly the same way. A good * number to use is the process id, given by getpid() on most UNIX systems. * * You need to find some single random integer, such as: * process id. * current time (minutes + seconds) returned from md_gct(), if implemented. * * It will not help to return "get_rand()" or "rand()" or the return value of * any pseudo-RNG. If you don't have a random number, you can just return 1, * but this means your games will ALWAYS start the same way, and will play * exactly the same way given the same input. */ int md_gseed() { return(getpid()); } /* md_exit(): * * This function causes the program to discontinue execution and exit. * This function must be implemented or the program will continue to * hang when it should quit. */ void md_exit(status) int status; { exit(status); } /* md_lock(): * * This function is intended to give the user exclusive access to the score * file. It does so by flock'ing the score file. The full path name of the * score file should be defined for any particular site in rogue.h. The * constants _PATH_SCOREFILE defines this file name. * * When the parameter 'l' is non-zero (true), a lock is requested. Otherwise * the lock is released. */ void md_lock(l) boolean l; { extern gid_t gid, egid; static int fd; short tries; if (l) { setegid(egid); if ((fd = open(_PATH_SCOREFILE, O_RDONLY)) < 1) { setegid(gid); messagef(0, "cannot lock score file"); return; } setegid(gid); for (tries = 0; tries < 5; tries++) if (!flock(fd, LOCK_EX|LOCK_NB)) return; } else { (void)flock(fd, LOCK_NB); (void)close(fd); } } /* md_shell(): * * This function spawns a shell for the user to use. When this shell is * terminated, the game continues. * * It is important that the game not give the shell the privileges the * game uses to access the scores file. This version of the game runs * with privileges low by default; only the saved gid (if setgid) or uid * (if setuid) will be privileged, but that privilege is discarded by * exec(). */ void md_shell(shell) const char *shell; { int w; pid_t pid; pid = fork(); switch(pid) { case -1: break; case 0: execl(shell, shell, (char *)NULL); _exit(255); default: waitpid(pid, &w, 0); break; } }