-WARNS6 cleanups (3953 warnings)
[dragonfly.git] / games / rogue / machdep.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1988, 1993
3 * The Regents of the University of California. 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, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
1de703da
MD
35 *
36 * @(#)machdep.c 8.1 (Berkeley) 5/31/93
37 * $FreeBSD: src/games/rogue/machdep.c,v 1.6.2.1 2001/12/17 12:43:23 phantom Exp $
b28e2a8f 38 * $DragonFly: src/games/rogue/machdep.c,v 1.3 2006/09/02 19:31:07 pavalos Exp $
984263bc
MD
39 */
40
984263bc
MD
41/*
42 * machdep.c
43 *
44 * This source herein may be modified and/or distributed by anybody who
45 * so desires, with the following restrictions:
46 * 1.) No portion of this notice shall be removed.
47 * 2.) Credit shall not be taken for the creation of this source.
48 * 3.) This code is not to be traded, sold, or used for personal
49 * gain or profit.
50 *
51 */
52
53/* Included in this file are all system dependent routines. Extensive use
54 * of #ifdef's will be used to compile the appropriate code on each system:
55 *
56 * UNIX: all UNIX systems.
57 * UNIX_BSD4_2: UNIX BSD 4.2 and later, UTEK, (4.1 BSD too?)
58 * UNIX_SYSV: UNIX system V
59 * UNIX_V7: UNIX version 7
60 *
61 * All UNIX code should be included between the single "#ifdef UNIX" at the
62 * top of this file, and the "#endif" at the bottom.
63 *
64 * To change a routine to include a new UNIX system, simply #ifdef the
65 * existing routine, as in the following example:
66 *
67 * To make a routine compatible with UNIX system 5, change the first
68 * function to the second:
69 *
70 * md_function()
71 * {
72 * code;
73 * }
74 *
75 * md_function()
76 * {
77 * #ifdef UNIX_SYSV
78 * sys5code;
79 * #else
80 * code;
81 * #endif
82 * }
83 *
84 * Appropriate variations of this are of course acceptible.
85 * The use of "#elseif" is discouraged because of non-portability.
86 * If the correct #define doesn't exist, "UNIX_SYSV" in this case, make it up
87 * and insert it in the list at the top of the file. Alter the CFLAGS
88 * in you Makefile appropriately.
89 *
90 */
91
92#ifdef UNIX
93
94#include <stdio.h>
95#include <sys/types.h>
96#include <sys/file.h>
97#include <sys/stat.h>
b28e2a8f 98#include <sys/wait.h>
984263bc 99#include <pwd.h>
b28e2a8f 100#include <time.h>
984263bc
MD
101
102#ifdef UNIX_BSD4_2
103#include <sys/time.h>
104#include <sgtty.h>
105#endif
106
107#ifdef UNIX_SYSV
108#include <time.h>
109#include <termio.h>
110#endif
111
112#include <signal.h>
113#include <stdlib.h>
114#include <unistd.h>
115#include "rogue.h"
116#include "pathnames.h"
117
118/* md_slurp:
119 *
120 * This routine throws away all keyboard input that has not
121 * yet been read. It is used to get rid of input that the user may have
122 * typed-ahead.
123 *
124 * This function is not necessary, so it may be stubbed. The might cause
125 * message-line output to flash by because the game has continued to read
126 * input without waiting for the user to read the message. Not such a
127 * big deal.
128 */
129
b28e2a8f
PA
130void
131md_slurp(void)
984263bc 132{
b28e2a8f 133 fpurge(stdin);
984263bc
MD
134}
135
b28e2a8f 136/* md_control_keybord():
984263bc
MD
137 *
138 * This routine is much like md_cbreak_no_echo_nonl() below. It sets up the
139 * keyboard for appropriate input. Specifically, it prevents the tty driver
140 * from stealing characters. For example, ^Y is needed as a command
141 * character, but the tty driver intercepts it for another purpose. Any
142 * such behavior should be stopped. This routine could be avoided if
143 * we used RAW mode instead of CBREAK. But RAW mode does not allow the
144 * generation of keyboard signals, which the program uses.
145 *
146 * The parameter 'mode' when true, indicates that the keyboard should
147 * be set up to play rogue. When false, it should be restored if
148 * necessary.
149 *
150 * This routine is not strictly necessary and may be stubbed. This may
151 * cause certain command characters to be unavailable.
152 */
153
b28e2a8f
PA
154void
155md_control_keybord(boolean mode)
984263bc
MD
156{
157 static boolean called_before = 0;
158#ifdef UNIX_BSD4_2
159 static struct ltchars ltc_orig;
160 static struct tchars tc_orig;
161 struct ltchars ltc_temp;
162 struct tchars tc_temp;
163#endif
164#ifdef UNIX_SYSV
165 static struct termio _oldtty;
166 struct termio _tty;
167#endif
168
169 if (!called_before) {
170 called_before = 1;
171#ifdef UNIX_BSD4_2
172 ioctl(0, TIOCGETC, &tc_orig);
173 ioctl(0, TIOCGLTC, &ltc_orig);
174#endif
175#ifdef UNIX_SYSV
176 ioctl(0, TCGETA, &_oldtty);
177#endif
178 }
179#ifdef UNIX_BSD4_2
180 ltc_temp = ltc_orig;
181 tc_temp = tc_orig;
182#endif
183#ifdef UNIX_SYSV
184 _tty = _oldtty;
185#endif
186
187 if (!mode) {
188#ifdef UNIX_BSD4_2
189 ltc_temp.t_suspc = ltc_temp.t_dsuspc = -1;
190 ltc_temp.t_rprntc = ltc_temp.t_flushc = -1;
191 ltc_temp.t_werasc = ltc_temp.t_lnextc = -1;
192 tc_temp.t_startc = tc_temp.t_stopc = -1;
193#endif
194#ifdef UNIX_SYSV
195 _tty.c_cc[VSWTCH] = CNSWTCH;
196#endif
197 }
198#ifdef UNIX_BSD4_2
199 ioctl(0, TIOCSETC, &tc_temp);
200 ioctl(0, TIOCSLTC, &ltc_temp);
201#endif
202#ifdef UNIX_SYSV
203 ioctl(0, TCSETA, &_tty);
204#endif
205}
206
207/* md_heed_signals():
208 *
209 * This routine tells the program to call particular routines when
210 * certain interrupts/events occur:
211 *
212 * SIGINT: call onintr() to interrupt fight with monster or long rest.
213 * SIGQUIT: call byebye() to check for game termination.
214 * SIGHUP: call error_save() to save game when terminal hangs up.
215 *
216 * On VMS, SIGINT and SIGQUIT correspond to ^C and ^Y.
217 *
218 * This routine is not strictly necessary and can be stubbed. This will
219 * mean that the game cannot be interrupted properly with keyboard
220 * input, this is not usually critical.
221 */
222
b28e2a8f
PA
223void
224md_heed_signals(void)
984263bc 225{
b28e2a8f
PA
226 signal(SIGINT, (sig_t)onintr);
227 signal(SIGQUIT, (sig_t)byebye);
228 signal(SIGHUP, (sig_t)error_save);
984263bc
MD
229}
230
231/* md_ignore_signals():
232 *
233 * This routine tells the program to completely ignore the events mentioned
234 * in md_heed_signals() above. The event handlers will later be turned on
235 * by a future call to md_heed_signals(), so md_heed_signals() and
236 * md_ignore_signals() need to work together.
237 *
238 * This function should be implemented or the user risks interrupting
239 * critical sections of code, which could cause score file, or saved-game
240 * file, corruption.
241 */
242
b28e2a8f
PA
243void
244md_ignore_signals(void)
984263bc
MD
245{
246 signal(SIGQUIT, SIG_IGN);
247 signal(SIGINT, SIG_IGN);
248 signal(SIGHUP, SIG_IGN);
249}
250
251/* md_get_file_id():
252 *
253 * This function returns an integer that uniquely identifies the specified
254 * file. It need not check for the file's existence. In UNIX, the inode
255 * number is used.
256 *
257 * This function is used to identify saved-game files.
258 */
259
260int
b28e2a8f 261md_get_file_id(const char *fname)
984263bc
MD
262{
263 struct stat sbuf;
264
265 if (stat(fname, &sbuf)) {
266 return(-1);
267 }
268 return((int) sbuf.st_ino);
269}
270
271/* md_link_count():
272 *
273 * This routine returns the number of hard links to the specified file.
274 *
275 * This function is not strictly necessary. On systems without hard links
276 * this routine can be stubbed by just returning 1.
277 */
278
279int
b28e2a8f 280md_link_count(const char *fname)
984263bc
MD
281{
282 struct stat sbuf;
283
284 stat(fname, &sbuf);
285 return((int) sbuf.st_nlink);
286}
287
288/* md_gct(): (Get Current Time)
289 *
290 * This function returns the current year, month(1-12), day(1-31), hour(0-23),
291 * minute(0-59), and second(0-59). This is used for identifying the time
292 * at which a game is saved.
293 *
294 * This function is not strictly necessary. It can be stubbed by returning
295 * zeros instead of the correct year, month, etc. If your operating
296 * system doesn't provide all of the time units requested here, then you
297 * can provide only those that it does, and return zeros for the others.
298 * If you cannot provide good time values, then users may be able to copy
299 * saved-game files and play them.
300 */
301
b28e2a8f
PA
302void
303md_gct(struct rogue_time *rt_buf)
984263bc 304{
b28e2a8f 305 struct tm *t;
984263bc
MD
306 time_t seconds;
307
308 time(&seconds);
309 t = localtime(&seconds);
310
311 rt_buf->year = t->tm_year;
312 rt_buf->month = t->tm_mon + 1;
313 rt_buf->day = t->tm_mday;
314 rt_buf->hour = t->tm_hour;
315 rt_buf->minute = t->tm_min;
316 rt_buf->second = t->tm_sec;
317}
318
319/* md_gfmt: (Get File Modification Time)
320 *
321 * This routine returns a file's date of last modification in the same format
322 * as md_gct() above.
323 *
324 * This function is not strictly necessary. It is used to see if saved-game
325 * files have been modified since they were saved. If you have stubbed the
326 * routine md_gct() above by returning constant values, then you may do
327 * exactly the same here.
328 * Or if md_gct() is implemented correctly, but your system does not provide
329 * file modification dates, you may return some date far in the past so
330 * that the program will never know that a saved-game file being modified.
331 * You may also do this if you wish to be able to restore games from
332 * saved-games that have been modified.
333 */
334
b28e2a8f
PA
335void
336md_gfmt(const char *fname, struct rogue_time *rt_buf)
984263bc
MD
337{
338 struct stat sbuf;
339 time_t seconds;
340 struct tm *t;
341
342 stat(fname, &sbuf);
343 seconds = sbuf.st_mtime;
344 t = localtime(&seconds);
345
346 rt_buf->year = t->tm_year;
347 rt_buf->month = t->tm_mon + 1;
348 rt_buf->day = t->tm_mday;
349 rt_buf->hour = t->tm_hour;
350 rt_buf->minute = t->tm_min;
351 rt_buf->second = t->tm_sec;
352}
353
354/* md_df: (Delete File)
355 *
356 * This function deletes the specified file, and returns true (1) if the
357 * operation was successful. This is used to delete saved-game files
358 * after restoring games from them.
359 *
360 * Again, this function is not strictly necessary, and can be stubbed
361 * by simply returning 1. In this case, saved-game files will not be
362 * deleted and can be replayed.
363 */
364
365boolean
b28e2a8f 366md_df(const char *fname)
984263bc
MD
367{
368 if (unlink(fname)) {
369 return(0);
370 }
371 return(1);
372}
373
374/* md_gln: (Get login name)
375 *
376 * This routine returns the login name of the user. This string is
377 * used mainly for identifying users in score files.
378 *
379 * A dummy string may be returned if you are unable to implement this
380 * function, but then the score file would only have one name in it.
381 */
382
383const char *
b28e2a8f 384md_gln(void)
984263bc
MD
385{
386 struct passwd *p;
387 char *s;
388
389 if ((s = getlogin()))
390 return s;
391 if (!(p = getpwuid(getuid())))
392 return((char *)NULL);
393 return(p->pw_name);
394}
395
396/* md_sleep:
397 *
398 * This routine causes the game to pause for the specified number of
399 * seconds.
400 *
401 * This routine is not particularly necessary at all. It is used for
402 * delaying execution, which is useful to this program at some times.
403 */
404
b28e2a8f
PA
405void
406md_sleep(int nsecs)
984263bc 407{
b28e2a8f 408 sleep(nsecs);
984263bc
MD
409}
410
411/* md_getenv()
412 *
413 * This routine gets certain values from the user's environment. These
414 * values are strings, and each string is identified by a name. The names
415 * of the values needed, and their use, is as follows:
416 *
417 * ROGUEOPTS
418 * A string containing the various game options. This need not be
419 * defined.
420 * HOME
421 * The user's home directory. This is only used when the user specifies
422 * '~' as the first character of a saved-game file. This string need
423 * not be defined.
424 * SHELL
425 * The user's favorite shell. If not found, "/bin/sh" is assumed.
426 *
427 */
428
429char *
b28e2a8f 430md_getenv(const char *name)
984263bc
MD
431{
432 char *value;
433
434 value = getenv(name);
435
436 return(value);
437}
438
439/* md_malloc()
440 *
441 * This routine allocates, and returns a pointer to, the specified number
442 * of bytes. This routines absolutely MUST be implemented for your
443 * particular system or the program will not run at all. Return zero
444 * when no more memory can be allocated.
445 */
446
447char *
b28e2a8f 448md_malloc(int n)
984263bc
MD
449{
450 char *t;
451
452 t = malloc(n);
453 return(t);
454}
455
456/* md_gseed() (Get Seed)
457 *
458 * This function returns a seed for the random number generator (RNG). This
459 * seed causes the RNG to begin generating numbers at some point in it's
460 * sequence. Without a random seed, the RNG will generate the same set
461 * of numbers, and every game will start out exactly the same way. A good
462 * number to use is the process id, given by getpid() on most UNIX systems.
463 *
464 * You need to find some single random integer, such as:
465 * process id.
466 * current time (minutes + seconds) returned from md_gct(), if implemented.
467 *
468 * It will not help to return "get_rand()" or "rand()" or the return value of
469 * any pseudo-RNG. If you don't have a random number, you can just return 1,
470 * but this means your games will ALWAYS start the same way, and will play
471 * exactly the same way given the same input.
472 */
473
b28e2a8f
PA
474int
475md_gseed(void)
984263bc
MD
476{
477 time_t seconds;
478
479 time(&seconds);
480 return((int) seconds);
481}
482
483/* md_exit():
484 *
485 * This function causes the program to discontinue execution and exit.
486 * This function must be implemented or the program will continue to
487 * hang when it should quit.
488 */
489
b28e2a8f
PA
490void
491md_exit(int status)
984263bc
MD
492{
493 exit(status);
494}
495
496/* md_lock():
497 *
498 * This function is intended to give the user exclusive access to the score
499 * file. It does so by flock'ing the score file. The full path name of the
500 * score file should be defined for any particular site in rogue.h. The
501 * constants _PATH_SCOREFILE defines this file name.
502 *
503 * When the parameter 'l' is non-zero (true), a lock is requested. Otherwise
504 * the lock is released.
505 */
506
b28e2a8f
PA
507void
508md_lock(boolean l)
984263bc
MD
509{
510 static int fd;
511 short tries;
512
513 if (l) {
514 if ((fd = open(_PATH_SCOREFILE, O_RDONLY)) < 1) {
515 message("cannot lock score file", 0);
516 return;
517 }
518 for (tries = 0; tries < 5; tries++)
519 if (!flock(fd, LOCK_EX|LOCK_NB))
520 return;
521 } else {
b28e2a8f
PA
522 flock(fd, LOCK_NB);
523 close(fd);
984263bc
MD
524 }
525}
526
527/* md_shell():
528 *
529 * This function spawns a shell for the user to use. When this shell is
530 * terminated, the game continues. Since this program may often be run
531 * setuid to gain access to privileged files, care is taken that the shell
532 * is run with the user's REAL user id, and not the effective user id.
533 * The effective user id is restored after the shell completes.
534 */
535
b28e2a8f
PA
536void
537md_shell(const char *shell)
984263bc
MD
538{
539 long w[2];
540
541 if (!fork()) {
542 /* revoke */
543 setgid(getgid());
544 execl(shell, shell, 0);
545 }
b28e2a8f 546 wait((int *)w);
984263bc
MD
547}
548
549#endif /* UNIX */