lars@myab.UUCP (lars) (03/13/86)
#--------CUT---------CUT---------CUT---------CUT--------#
#########################################################
# #
# This is a shell archive file. To extract files: #
# #
# 1) Make a directory for the files. #
# 2) Write a file, such as "file.shar", containing #
# this archive file into the directory. #
# 3) Type "sh file.shar". Do not use csh. #
# #
#########################################################
#
#
echo x - scab.c
sed 's/^Z//' >scab.c <<\STUNKYFLUFF
Z#ifndef lint
Zstatic char rcsid[] = "$Header: scab.c,v 2.1 85/04/10 17:31:37 matt Stab $";
Z#endif
Z/*
Z *
Z * search
Z *
Z * multi-player and multi-system search and destroy.
Z *
Z * Original by Greg Ordy 1979
Z * Rewrite by Sam Leffler 1981
Z * Socket code by Dave Pare 1983
Z * Ported & improved
Z * by Matt Crawford 1985
Z *
Z * routines that handle scabs - players deserving of
Z * "special" attention.
Z *
Z * Copyright (c) 1979
Z *
Z */
Z
Z#include "defines.h"
Z#include "structs.h"
Z
Z
Zvoid makescab(p)
Zregister t_player *p;
Z{
Z extern t_alien alien[NALIEN];
Z extern t_player *whoscab;
Z void enterscab();
Z register t_alien *pa;
Z
Z p->scabcount++;
Z if (p->scabcount > 2)
Z enterscab(p);
Z for (pa = alien; pa < &alien[NALIEN]; pa++) {
Z if (pa->type != SHANK)
Z continue;
Z pa->aname = NAMESH;
Z pa->whotoget = (thing *)p;
Z }
Z whoscab = p;
Z}
Z
Zvoid seescab(p)
Zregister t_player *p;
Z{
Z extern t_player *whoscab;
Z extern void pstatus();
Z
Z if (whoscab == NOBODY)
Z pstatus(p, "Currently no SCAB.");
Z else
Z pstatus(p, "Current SCAB-- %s", p->plname);
Z}
Z
Zstatic void enterscab(p)
Zregister t_player *p;
Z{}
STUNKYFLUFF
set `sum < scab.c`
if test 19833 != $1
then
echo scab.c: Error. number of characters is: $1, should be: 19833.
fi
#
#
echo x - score.c
sed 's/^Z//' >score.c <<\STUNKYFLUFF
Z#ifndef lint
Zstatic char rcsid[] = "$Header: score.c,v 2.1 85/04/10 17:31:40 matt Stab $";
Z#endif
Z/*
Z *
Z * search
Z *
Z * multi-player and multi-system search and destroy.
Z *
Z * Original by Dave Pare 1983
Z * Ported & improved
Z * by Matt Crawford 1985
Z *
Z * routine to update player scores, formerly handled in
Z * search.c, but now moved to the daemon's care.
Z *
Z * Copyright (c) 1983
Z *
Z * $Log: score.c,v $
Z * Revision 2.1 85/04/10 17:31:40 matt
Z * Major de-linting and minor restructuring.
Z *
Z */
Z
Z#include <stdio.h>
Z#include <sys/types.h>
Z#include <sys/file.h>
Z
Z#include "defines.h"
Z#include "structs.h"
Z
Zvoid putplayer(p)
Zregister t_player *p;
Z{
Z extern long lseek();
Z extern char *strcpy();
Z extern int pfd;
Z int index;
Z int found;
Z t_totals entry;
Z
Z found = 0;
Z (void)lseek(pfd, 0L, 0);
Z for (index=0; read(pfd, (char *)&entry, sizeof(t_totals)) > 0; index++)
Z if (!strcmp(p->plname, entry.ptname)) {
Z found++;
Z break;
Z }
Z if (!found) {
Z bzero((char *)&entry, sizeof(entry));
Z strcpy(entry.ptname, p->plname);
Z } else
Z (void)lseek(pfd, (long)(index * sizeof(t_totals)), 0);
Z if (p->status.killed == TRUE)
Z entry.ptkilled++;
Z if (entry.ptbest < p->points)
Z entry.ptbest = p->points;
Z entry.ptpoints += p->points;
Z entry.ptgames++;
Z entry.pthits += p->phits;
Z entry.ptkills += p->pkills;
Z entry.ptahits += p->ahits;
Z entry.ptlast = p->points;
Z write(pfd, (char *)&entry, sizeof(t_totals));
Z}
STUNKYFLUFF
set `sum < score.c`
if test 47665 != $1
then
echo score.c: Error. number of characters is: $1, should be: 47665.
fi
#
#
echo x - search.c
sed 's/^Z//' >search.c <<\STUNKYFLUFF
Z#ifndef lint
Zstatic char rcsid[] = "$Header: search.c,v 2.4 85/08/06 19:20:08 matt Exp $";
Z#endif
Z/*
Z * search
Z *
Z * multi-player and multi-system search and destroy.
Z *
Z * Original by Dave Pare 1983
Z * Ported & improved by Matt Crawford 1985
Z * Ported by Lars Pensjo 1985
Z * Ported & improved by Tore Fahlstrom 1985
Z *
Z * The player process. Search tries to connect to the daemon via a message
Z * queue. It gathers data about the player and sends it along to the daemon.
Z * Termcap routines taken from the original SVR2 source.
Z *
Z * Copyright (c) 1983
Z */
Z
Z#include <fcntl.h>
Z#include <stdio.h>
Z#include <sys/types.h>
Z#include <sys/stat.h>
Z#include <sys/file.h>
Z#include <ctype.h>
Z#include <signal.h>
Z#include <time.h>
Z#include <sys/ipc.h>
Z#include <sys/msg.h>
Z#include <pwd.h>
Z
Z#include "defines.h"
Z#include "structs.h"
Z
Z#define XQZERO 0 /* flag value: Nothing dangerous done */
Z#define XQINIT 1 /* flag value: done savetty */
Z#define XQCONN 2 /* flag value: deamon servs this player */
Z#define XQDISC 3 /* flag value: deamon ignore this player */
Zint xqstat = XQZERO; /* Make it possible to close down all shit */
Z
Zstruct message omesg; /* buffer for outgoing messages */
Zstruct message imesg; /* buffer for incoming messages */
Zstruct message amesg; /* buffer for ack messages */
Z
Zint fd; /* the terminal - opened from "/dev/tty" */
Zt_file player; /* who are we, what does our term look like */
Zint sock; /* socket to daemon */
Zint uid; /* user id -- well, not the real one */
Zint owner = 0; /* True if owner is playing */
Z
Z
Zmain(argc, argv)
Zint argc;
Zchar *argv[];
Z{
Z extern catchsignal ();
Z char *strcpy(), *strncpy();
Z int pid;
Z int apa;
Z
Z register int n; /* read count register */
Z int sendok = TRUE; /* did we get away the last message */
Z int acknok = TRUE; /* did a rcve before send */
Z
Z if (geteuid() == OWNERID) {
Z owner = 1;
Z setuid(OWNERID);
Z goto skip; /* Skip boring things */
Z }
Z /*
Z * Start up daemon if not running
Z */
Z if (!excl("/tmp/SEARCH")) {
Z printf("Starting daemon...\n");
Z system("/usr/games/lib/search/searchd");
Z printf("Done\n");
Z }
Z
Z if (!isatty(0) || !isatty(1))
Z fatal("You must have a terminal to play search!\n");
Z
Zskip:
Z /*
Z * Set all the signals
Z */
Z if (owner) {
Z (void) signal(SIGINT, SIG_IGN);
Z (void) signal(SIGTERM, SIG_IGN);
Z (void) signal(SIGHUP, SIG_IGN);
Z (void) signal(SIGPIPE, SIG_IGN);
Z } else {
Z (void) signal(SIGINT, catchsignal);
Z (void) signal(SIGTERM, SIG_IGN);
Z (void) signal(SIGHUP, catchsignal);
Z (void) signal(SIGPIPE, catchsignal);
Z }
Z
Z /*
Z * Compute a search-user-id. It must be larger than 1 because 0
Z * and 1 are special. 0 is notused. 1 is used for new players and
Z * therefore used only once in the game.
Z * Uid is also a multiple of 3, because the messages sent to the
Z * deamon have an even type (uid) and the messages recieved have an
Z * odd type (uid+1).
Z */
Z uid = 3 * getpid() + 3;
Z
Z /*
Z * Try to open a channel to the deamon (if it is up and running)
Z */
Z for (apa = 0; (sock = getid()) < 0; apa++) {
Z if (apa == 5) {
Z if (!owner) printf("Can't start daemon\n");
Z exit(1);
Z }
Z sleep(3);
Z }
Z
Z /*
Z * Call initscr() to make use of handy functions. Save the old term
Z * characteristics. It is also advisable to do all terminal dependent
Z * operations here in search and not in the deamon.
Z * Set up terminal modes for game
Z */
Z savetty ();
Z xqstat = XQINIT;
Z cbreak();
Z noecho();
Z
Z
Z /*
Z * Open our own tty for both reading & writing - makes it
Z * much easier to do ioctls since we only have to do them on
Z * the one fd now.
Z */
Z if (!owner)
Z if ((fd=open("/dev/tty", O_RDWR , 0)) < 0)
Z fatal("Cannot open your tty\n");
Z
Z /*
Z * Now set up the player structure for transmission to the daemon.
Z */
Z if (owner) (void) strcpy(player.p_name, "search");
Z else (void) strcpy(player.p_name, (getpwuid (getuid ()))->pw_name);
Z player.uid = uid;
Z if (termcap(&player))
Z fatal("Terminal unsuitable for play!\n");
Z
Z /*
Z * Transmit all the info we've gathered to the daemon
Z */
Z omesg.mtype = 1; /* special type used only here */
Z omesg.ident = uid; /* to tell the deamon who I am */
Z if (sizeof(player) > (sizeof(omesg) - 8))
Z fatal("Prog. error: player struct > sizeof omesg.\n");
Z bcopy(omesg.text, &player, sizeof(player));
Z if (msgsnd(sock, &omesg, (sizeof(player) + 8), 0) == -1)
Z fatal("Startup request failed!\n");
Z xqstat = XQCONN;
Z
Z omesg.mtype = uid;
Z imesg.mtype = uid + 1;
Z amesg.mtype = uid + 2;
Z if (!owner) pid = fork();
Z /* When owner is playing, don't read from keyboard */
Z if(!owner && !pid){
Z /* child */
Z (void) signal(SIGINT, SIG_DFL);
Z (void) signal(SIGTERM, SIG_IGN);
Z (void) signal(SIGHUP, SIG_DFL);
Z (void) signal(SIGPIPE, SIG_DFL);
Z /*
Z ** just read from the keyboard, send to deamon and wait for ack.
Z */
Z for (;;) {
Z
Z /* No use of reading more than QSIZE characters because
Z * the deamon input queue cannot take more than that.
Z */
Z if ((n=read(fd, omesg.text, QSIZE)) == -1)
Z fatal("Terminal read failed!\n");
Z omesg.text[n] = '\0'; /* remove in the future */
Z if (msgsnd(sock,&omesg,8+n,0) == -1) {
Z fatal("msgsnd failed!\n");
Z }
Z /*
Z * Wait for ack.
Z */
Z if (msgrcv(sock,&amesg,sizeof amesg,uid+2,0)!= -1) {
Z switch (amesg.text[0]) {
Z default:
Z fatal("ack gets funny!\n");
Z break;
Z case 1:
Z /* Acknowledge -- ok to send next message */
Z break;
Z }
Z } else
Z fatal("msgrcv ack failed!\n");
Z }
Z } else {
Z /* parent */
Z /*
Z ** read from deamon and write it on the screen
Z */
Z for(;;){
Z if (msgrcv(sock,&imesg,sizeof imesg,uid+1,0)!= -1) {
Z switch (imesg.text[0]) {
Z default:
Z /* Output for your screen */
Z if (owner) update(imesg.text);
Z else write(fd, imesg.text, strlen(imesg.text));
Z break;
Z case 0:
Z /* The deamon is finished with you */
Z xqstat = XQDISC;
Z if (owner) fatal("");
Z /* Kill child */
Z kill(pid,SIGINT);
Z fatal("Welcome back to search!\n");
Z }
Z } else
Z fatal("msgrcv failed!\n");
Z }
Z }
Z}
Z
Zcatchsignal ()
Z{
Z if (getuid() == OWNERID || geteuid() == OWNERID) {
Z printf("PID %d, uid %d, euid %d, owner %d\n",
Z getpid(), getuid(), geteuid(), owner);
Z abort();
Z }
Z fatal("Signal caught -- execution terminated.\n");
Z}
Z
Zfatal (godbye)
Z char *godbye;
Z{
Z /*
Z * Do the tty reset right away, no need to wait...
Z */
Z if (xqstat != XQZERO)
Z resetty ();
Z if (xqstat == XQCONN || xqstat == XQDISC) {
Z /*
Z * Read back all output not yet read by deamon
Z * Got to fix in the future so I know if I have sent any
Z * messages that need to get acknowledge, or shall that
Z * be done in the deamon. Maybe the deamon should read
Z * back both channels.
Z */
Z while(msgrcv(sock,&imesg,sizeof imesg,uid+2,IPC_NOWAIT) != -1);
Z while(msgrcv(sock,&imesg,sizeof imesg,uid+1,IPC_NOWAIT) != -1);
Z while(msgrcv(sock,&imesg,sizeof imesg,uid,IPC_NOWAIT) != -1);
Z }
Z if (!owner) write (fd, godbye, strlen (godbye));
Z if (xqstat == XQCONN) {
Z /* Need a nl -- the game was running */
Z if (!owner) write (fd, "\n", 1);
Z /*
Z * Tell deamon that we are leaving now
Z */
Z omesg.text[0] = '\0'; /* remove in the future */
Z if (msgsnd (sock, &omesg, 8+1, 0) == -1) {
Z char *tellem =
Z "Failed to tell deamon that I'm leaving!\n";
Z if (!owner) write (fd, tellem, sizeof (tellem));
Z exit(xqstat == XQDISC ? 0 : 10 + xqstat);
Z }
Z for(;;)
Z if (msgrcv(sock,&imesg,sizeof imesg,uid+1,0)!= -1) {
Z switch (imesg.text[0]) {
Z default:
Z /* Output for your screen */
Z if (!owner)
Z write(fd, imesg.text, strlen(imesg.text));
Z break;
Z case 0:
Z exit(xqstat == XQDISC ? 0 : 10 + xqstat);
Z }
Z } else break;
Z }
Z exit(xqstat == XQDISC ? 0 : 10 + xqstat);
Z}
Z
Z
Zstatic char buf[1024], *bp = buf;
Zstruct init {
Z char *i_name; /* termcap name */
Z char *i_dest; /* where to put the result */
Z short i_size; /* sizeof associated buffer */
Z short i_pad; /* padding flag: 0=no, 1=P, 2=P* */
Z} list[] = {
Z { "bc", player.p_BC, sizeof(player.p_BC), 0 },
Z { "up", player.p_UP, sizeof(player.p_UP), 0 },
Z { "cm", player.p_CM, sizeof(player.p_CM), 1 },
Z { "ce", player.p_CE, sizeof(player.p_CE), 1 },
Z { "cl", player.p_CL, sizeof(player.p_CL), 2 },
Z { NULLCH, NULLCH, 0, 0 }
Z};
Z
Z/*
Z * Build up the termcap description needed by searchd
Z */
Zint termcap(p)
Zregister t_file *p;
Z{
Z register char *cp;
Z register int lines, cols;
Z register struct init *pi = list;
Z char *term, tbuf[BUFSIZ];
Z extern char *getenv(), *tgetstr();
Z int getstring();
Z
Z p->p_speed = 9600;
Z if ((term = getenv("TERM")) != NULL && tgetent(tbuf, term) > 0) {
Z if (cp = tgetstr("pc", &bp))
Z p->p_PC = *cp;
Z cols = tgetnum("co", &bp);
Z lines = tgetnum("li", &bp);
Z while (pi->i_size != 0) {
Z getstring(pi);
Z pi++;
Z }
Z return(*p->p_CM == '\0' || *p->p_CL == '\0' || cols < 80 ||
Z lines < 24);
Z }
Z return(1);
Z}
Z
Z/*
Z * Termcap support routine
Z */
Zgetstring(pi)
Zregister struct init *pi;
Z{
Z register char *cp = tgetstr(pi->i_name, &bp);
Z
Z if (cp == NULL)
Z return;
Z if ( pi->i_pad ) {
Z while ( strchr( "0123456789.", *cp ) )
Z cp++;
Z if ( pi->i_pad == 2 && *cp == '*' )
Z cp++;
Z }
Z if ( strlen(cp) >= pi->i_size )
Z fatal("Prog. error: Long termcap entry found!\n");
Z (void) strncpy(pi->i_dest, cp , pi->i_size);
Z}
Z
Zgetid() {
Z int key;
Z
Z if ((key = ftok("/tmp/SEARCH", 0)) == -1) {
Z return -1;
Z }
Z return msgget(key, 0);
Z}
Z
Zbcopy(to, from, n)
Zregister char *to, *from;
Z{
Z while (n--) *to++ = *from++;
Z}
Z#include <termio.h>
Ztypedef struct termio SGTTY;
Z#include <term.h>
Z#include <stdio.h>
Z
Z/*
Z------------------------------------------------------------------------------
Z * There are a few problems in conection with the use of curses,
Z * I don't know why, but the routines below does exactly what you
Z * want them do. The same routines in curses does not.
Z------------------------------------------------------------------------------
Z */
Z
Zstatic struct termio oldti, newti;
Zcbreak () { newti.c_lflag &= ~ICANON; newti.c_cc[VMIN] = 1;
Z newti.c_cc[VTIME] = 1; ioctl (1, TCSETA, &newti); }
Znocbreak () { newti.c_lflag |= ICANON; newti.c_cc[VEOF] = oldti.c_cc[VEOF];
Z newti.c_cc[VEOL] = oldti.c_cc[VEOL]; ioctl (1, TCSETA, &newti); }
Zecho () { newti. c_lflag |= ECHO; ioctl (1, TCSETA, &newti); }
Znoecho () { newti.c_lflag &= ~ECHO; ioctl (1, TCSETA, &newti); }
Zresetty () { newti = oldti; ioctl (1, TCSETA, &newti); }
Zsavetty () { ioctl (1, TCGETA, &oldti); newti = oldti; }
Z
Zupdate(str)
Zchar *str;
Z{
Z}
STUNKYFLUFF
set `sum < search.c`
if test 18423 != $1
then
echo search.c: Error. number of characters is: $1, should be: 18423.
fi
#
#
echo x - searchwho.c
sed 's/^Z//' >searchwho.c <<\STUNKYFLUFF
Z#ifndef lint
Zstatic char rcsid[] = "$Header: searchwho.c,v 2.2 85/08/15 13:37:49 matt Exp $";
Z#endif
Z/*
Z *
Z * searchwho
Z *
Z * multi-player and multi-system search and destroy.
Z *
Z * Original by Dave Pare 1983
Z * Ported & improved
Z * by Matt Crawford 1985
Z *
Z * who is playing search
Z *
Z * Copyright (c) 1983
Z *
Z * $Log: searchwho.c,v $
Z * Revision 2.2 85/08/15 13:37:49 matt
Z * Limit dtabsiz to an int's worth of bits.
Z *
Z * Revision 2.1 85/04/10 17:31:55 matt
Z * Major de-linting and minor restructuring.
Z *
Z * Revision 1.3 85/02/10 02:06:33 matt
Z * Allow a port to be specified, as for search itself.
Z *
Z * Revision 1.2 85/02/09 23:50:40 matt
Z * Eliminated the dependence on the value of the mask after
Z * select() times out. Use the return value to distinguish
Z * a timeout!!
Z *
Z */
Z
Z#include <stdio.h>
Z#include <sys/param.h> /* includes <sys/types.h> and <signal.h> */
Z#include <sys/stat.h>
Z#include <sys/file.h>
Z#include <sgtty.h>
Z#include <ctype.h>
Z#include <pwd.h>
Z#include <sys/time.h>
Z#include <errno.h>
Z#include <sys/socket.h>
Z#include <sys/un.h>
Z
Z#include "defines.h"
Z#include "structs.h"
Z
Z
Zextern int errno;
Zint dtabsiz; /* how many fd's here? */
Zint sock; /* socket to daemon */
Z
Zmain(argc, argv)
Zint argc;
Zchar *argv[];
Z{
Z void reset();
Z register int cc; /* returned from all sorts of calls */
Z register int i; /* general purpose register */
Z register int sockmask;
Z register char buf[4096];/* misc buffer for i/o */
Z int mask; /* masks used in select() calls */
Z struct timeval timeout;/* time outs for select calls */
Z int save_mask; /* don't calculate mask each time */
Z int first_time; /* for printing header */
Z int junk;
Z struct sockaddr loc_addr;/* local socket address */
Z
Z dtabsiz = getdtablesize();
Z /*
Z * set all the signals
Z */
Z (void) signal(SIGINT, SIG_IGN);
Z (void) signal(SIGTERM, SIG_IGN);
Z (void) signal(SIGQUIT, reset);
Z (void) signal(SIGHUP, reset);
Z (void) signal(SIGPIPE, reset);
Z (void) signal(SIGALRM, reset);
Z (void) signal(SIGTSTP, SIG_IGN);
Z (void) signal(SIGSTOP, SIG_IGN);
Z sock = socket(AF_UNIX, SOCK_STREAM, 0);
Z if (sock < 0) {
Z perror("search, socket");
Z exit(1);
Z }
Z /*
Z * connect to the local search daemon thru the lock
Z * file (usually /tmp/slock for historical reasons)
Z */
Z if (connect(sock, &loc_addr, sizeof(loc_addr))) {
Z printf("no local search daemon running\n");
Z exit(1);
Z }
Z /*
Z * daemon knows that a 1 byte message 'w' is from "searchwho".
Z */
Z if (write(sock, "w", 1) != 1) {
Z perror("write");
Z printf("searchwho: bad connect on socket\n");
Z exit(1);
Z }
Z /*
Z * set up all the stuff for the select loop
Z */
Z sockmask = 1 << sock;
Z save_mask = sockmask;
Z timeout.tv_usec = 0L;
Z timeout.tv_sec = 3L;
Z /*
Z * just in case nobody's there
Z */
Z alarm(20);
Z first_time = 1;
Z for (;;) {
Z mask = save_mask;
Z i = select(dtabsiz, &mask, 0, 0, &timeout);
Z if (i < 0) {
Z if (errno = EINTR)
Z continue;
Z perror("select");
Z }
Z /*
Z * nope - no data waiting. select() timed out.
Z */
Z if (!i) {
Z printf("no data yet, we'll wait a bit longer...\n");
Z fflush(stdout);
Z continue;
Z }
Z if (!(sockmask & mask))
Z continue;
Z /*
Z * input waiting from the daemon - read it in and
Z * write it to the screen (stdout).
Z */
Z alarm (3);
Z if (fgets(buf, 80, &_iob[sock]) != NULL) {
Z /*
Z * when you get zero characters from a socket that
Z * had input waiting, it means that the socket was
Z * closed down (from the other side)
Z */
Z if (first_time) {
Z if (strncmp(buf, "nobody", 6) != 0) {
Z printf(" username points \n");
Z first_time = 0;
Z } else
Z puts(buf);
Z } else
Z puts(buf);
Z fflush(stdout);
Z } else
Z reset(0);
Z alarm(0);
Z }
Z}
Z
Z/*
Z * reset disconnects us from any sockets we've connected to,
Z * and shuts everything down nicely.
Z */
Zvoid reset(signal)
Zint signal;
Z{
Z char buf[1024];
Z struct timeval delay;
Z int mask;
Z int i;
Z
Z /*
Z * disconnect from our socket (getting rid of the
Z * gunk possibly leftover)
Z */
Z mask = 1 << sock;
Z delay.tv_sec = 0L;
Z delay.tv_usec = 500L;
Z shutdown(sock, 1);
Z i = select(dtabsiz, &mask, 0, 0, &delay);
Z if (i > 0) {
Z i = read(sock, buf, sizeof(buf));
Z write(1, buf, i);
Z }
Z shutdown(sock, 2);
Z (void) close(sock);
Z putchar('\n');
Z exit(0);
Z}
STUNKYFLUFF
set `sum < searchwho.c`
if test 2102 != $1
then
echo searchwho.c: Error. number of characters is: $1, should be: 2102.
fi
#
#
echo x - signal.c
sed 's/^Z//' >signal.c <<\STUNKYFLUFF
Z#ifndef lint
Zstatic char rcsid[] = "$Header: signal.c,v 2.1 85/04/10 17:32:00 matt Stab $";
Z#endif
Z/*
Z *
Z * search
Z *
Z * multi-player and multi-system search and destroy.
Z *
Z * Original code by Dave Pare 1984
Z * Ported & improved
Z * by Matt Crawford 1985
Z *
Z * signal handlers for the daemon
Z *
Z * Copyright (c) 1984
Z *
Z * $Log: signal.c,v $
Z * Revision 2.1 85/04/10 17:32:00 matt
Z * Major de-linting and minor restructuring.
Z *
Z */
Z
Z#include <stdio.h>
Z#include <sys/types.h>
Z#include <time.h>
Z#include <sys/file.h>
Z#include <signal.h>
Z#include <nlist.h>
Z#include "defines.h"
Z#include "structs.h"
Z
Z
Ztrap(sig)
Zint sig;
Z{
Z extern void done();
Z extern t_player player[NPLAYER];
Z extern int pfd;
Z extern int errfile;
Z t_player *p;
Z char buf[80];
Z
Z
Z for (p = player; p < &player[NPLAYER]; p++)
Z if (p->status.alive == TRUE)
Z done(p);
Z close(pfd);
Z sprintf(buf, "trapped interrupt %d\n", sig);
Z errlog(buf);
Z close(errfile);
Z exit(sig);
Z /*NOTREACHED*/
Z}
Z
Zcore_dump()
Z{
Z extern void done();
Z extern t_player player[NPLAYER];
Z t_player *p;
Z
Z errlog("dumping core...\n");
Z signal(SIGQUIT, SIG_IGN);
Z for (p = player; p < &player[NPLAYER]; p++)
Z if (p->status.alive == TRUE)
Z done(p);
Z signal(SIGQUIT, SIG_DFL);
Z kill(getpid(), SIGQUIT);
Z /*NOTREACHED*/
Z}
Z
Z
Z/*
Z * Put the delay in the game. tune to taste.
Z * There is not much one can do here, because SVR2 doesn't make
Z *
Z */
Zvoid
Zset_delay() {
Z static long lasttime = 0;
Z
Z if (time (0L) == lasttime)
Z sleep (1);
Z lasttime = time (0L);
Z/*
Z extern int nplayer;
Z long usecs;
Z usecs = 100000L - (nplayer * 15000L);
Z if (usecs < 10000L)
Z return;
Z*/
Z}
STUNKYFLUFF
set `sum < signal.c`
if test 58360 != $1
then
echo signal.c: Error. number of characters is: $1, should be: 58360.
fi
#
#
echo x - sscore.c
sed 's/^Z//' >sscore.c <<\STUNKYFLUFF
Z#ifndef lint
Zstatic char rcsid[] = "$Header: sscore.c,v 1.4 85/07/08 17:22:57 matt Exp $";
Z#endif
Z/*
Z *
Z * Original by Dave Pare 1983
Z * Ported & improved
Z * by Matt Crawford 1985
Z *
Z * program to sort and print the player scoreboard.
Z */
Z
Z
Z#include <stdio.h>
Z#include <ctype.h>
Z#include <sys/types.h>
Z#include <sys/file.h>
Z#include "defines.h"
Z#include "structs.h"
Z
Z
Zstruct totals {
Z char ptname[20]; /* player name */
Z int ptpoints; /* total points */
Z int pthits; /* total player hits */
Z int ptahits; /* total alien hits */
Z int ptkills; /* total player kills */
Z int ptkilled; /* total times killed */
Z int ptlast; /* last game's score */
Z int ptbest; /* best score */
Z int ptgames; /* # games played */
Z int average; /* average score */
Z} ;
Z
Zstruct totals *malloc();
Z
Zmain() {
Z register int i,
Z j,
Z found,
Z next;
Z register struct totals *lp;
Z int pointfd;
Z struct totals *list[2000];
Z long number;
Z
Z for (i=0; i<2000; i++)
Z list[i] = NULL;
Z if ((pointfd = open(POINTFILE, 0)) < 0)
Z fatal("can't open points file %s", POINTFILE);
Z printf("%-17s %-5s %-8s %-7s %-7s %-5s %-6s %-5s %-5s %-4s\n",
Z "Player", "Games", "Total", "Hits(p)", "Hits(a)",
Z "Kills", "Killed", "Best", "Last", "Avg");
Z for (number=0; number<2000; number++) {
Z lp = malloc(sizeof(struct totals));
Z if (lp == NULL)
Z fatal("out of memory\n");
Z if (read(pointfd, lp, sizeof(t_totals)) <= 0) {
Z free(lp);
Z break;
Z }
Z if (lp->ptgames > 0)
Z lp->average = lp->ptpoints/lp->ptgames;
Z else
Z lp->average = 0;
Z list[number] = lp;
Z }
Z if ( number == 0 )
Z exit(0);
Z found = 1;
Z for (i=number-1; i && found; i--) {
Z found = 0;
Z for (j=0, next=1; j<i; j++, next++) {
Z if (list[j]->ptbest < list[next]->ptbest) {
Z lp = list[j];
Z list[j] = list[next];
Z list[next] = lp;
Z found++;
Z }
Z }
Z }
Z for (i=0; i<2000; i++) {
Z lp = list[i];
Z if (lp == NULL || lp->ptpoints == 0)
Z continue;
Z printf("%-17s %-5d %-8d %-7d %-7d %-5d %-6d %-5d %-5d %-4d\n",
Z lp->ptname, lp->ptgames, lp->ptpoints, lp->pthits,
Z lp->ptahits, lp->ptkills, lp->ptkilled, lp->ptbest,
Z lp->ptlast, lp->average);
Z }
Z}
Z
Zfatal(fmt, arg)
Zchar *fmt;
Z{
Z fprintf(stderr, "sscore:");
Z fprintf(stderr, fmt, arg);
Z fputc('\n', stderr);
Z exit(1);
Z}
STUNKYFLUFF
set `sum < sscore.c`
if test 36604 != $1
then
echo sscore.c: Error. number of characters is: $1, should be: 36604.
fi
echo All done
exit 0
--
______________________________________________________
Lars Pensjo
{decvax,philabs}!mcvax!enea!chalmers!myab!lars