[unix-history] / usr / src / games / sail / sync.c

#ifndef lint
static	char *sccsid = "@(#)sync.c	2.2 83/11/01";
#endif

#include "externs.h"

static char sync_buf[BUFSIZE];
static char *sync_bufp = sync_buf;
static char sync_lock[25];
static char sync_file[25];
static long sync_seek;
static FILE *sync_fp;
#define SF "/tmp/#sailsink.%d"
#define LF "/tmp/#saillock.%d"

/*VARARGS3*/
makesignal(from, fmt, ship, a, b, c)
struct ship *from;
char *fmt;
register struct ship *ship;
{
	char message[80];

	if (ship == 0)
		(void) sprintf(message, fmt, a, b, c);
	else
		(void) sprintf(message, fmt,
			ship->shipname, colours(ship),
			sterncolour(ship), a, b, c);
	Write(W_SIGNAL, from, 1, (int)message, 0, 0, 0);
}

#include <sys/types.h>
#include <sys/stat.h>
sync_exists(game)
{
	char buf[sizeof sync_file];
	struct stat s;
	time_t t;

	(void) sprintf(buf, SF, game);
	time(&t);
	if (stat(buf, &s) < 0)
		return 0;
	if (s.st_mtime < t - 60*60*2) {		/* 2 hours */
		unlink(buf);
		return 0;
	} else
		return 1;
}

sync_open()
{
	(void) sprintf(sync_lock, LF, game);
	(void) sprintf(sync_file, SF, game);
	if (access(sync_file, 0) < 0) {
		int omask;
#ifdef SETUID
		omask = umask(077);
#else
		omask = umask(011);
#endif
		sync_fp = fopen(sync_file, "w+");
		(void) umask(omask);
	} else
		sync_fp = fopen(sync_file, "r+");
	if (sync_fp == 0)
		return -1;
	sync_seek == 0;
	return 0;
}

sync_close(remove)
char remove;
{
	if (sync_fp != 0)
		(void) fclose(sync_fp);
	if (remove)
		(void) unlink(sync_file);
}

Write(type, ship, isstr, a, b, c, d)
int type;
struct ship *ship;
char isstr;
int a, b, c, d;
{
	if (isstr)
		(void) sprintf(sync_bufp, "%d %d %d %s\n",
			type, ship-SHIP(0), isstr, a);
	else
		(void) sprintf(sync_bufp, "%d %d %d %d %d %d %d\n",
			type, ship-SHIP(0), isstr, a, b, c, d);
	while (*sync_bufp++)
		;
	sync_bufp--;
	if (sync_bufp >= &sync_buf[sizeof sync_buf])
		abort();
	sync_update(type, ship, a, b, c, d);
}

Sync()
{
	int (*sig1)(), (*sig2)();
	int type, shipnum, isstr, a, b, c, d;
	char buf[60];
	register char *p = buf;
	int n;

	sig1 = signal(SIGHUP, SIG_IGN);
	sig2 = signal(SIGINT, SIG_IGN);
	for (n = 0; link(sync_file, sync_lock) < 0 && n < 30; n++)
		sleep(2);
	(void) fseek(sync_fp, sync_seek, 0);
	while (fscanf(sync_fp, "%d%d%d", &type, &shipnum, &isstr) != EOF) {
		if (isstr) {
			for (p = buf;;) {
				switch (*p++ = getc(sync_fp)) {
				case '\n':
					p--;
				case EOF:
					break;
				default:
					continue;
				}
				break;
			}
			*p = 0;
			for (p = buf; *p == ' '; p++)
				;
			a = (int)p;
			b = c = d = 0;
		} else
			(void) fscanf(sync_fp, "%d%d%d%d", &a, &b, &c, &d);
		sync_update(type, SHIP(shipnum), a, b, c, d);
	}
	if (sync_bufp != sync_buf) {
		(void) fseek(sync_fp, 0L, 2);
		(void) fputs(sync_buf, sync_fp);
		(void) fflush(sync_fp);
		sync_bufp = sync_buf;
	}
	sync_seek = ftell(sync_fp);
	(void) unlink(sync_lock);
	(void) signal(SIGHUP, sig1);
	(void) signal(SIGINT, sig2);
}

sync_update(type, ship, a, b, c, d)
int type;
register struct ship *ship;
int a, b, c, d;
{
	switch (type) {
	case W_DBP: {
		register struct BP *p = &ship->file->DBP[a];
		p->turnsent = b;
		p->toship = SHIP(c);
		p->mensent = d;
		break;
		}
	case W_OBP: {
		register struct BP *p = &ship->file->OBP[a];
		p->turnsent = b;
		p->toship = SHIP(c);
		p->mensent = d;
		break;
		}
	case W_FOUL: {
		register struct snag *p = &ship->file->fouls[a];
		p->turnfoul = b;
		p->toship = SHIP(c);
		break;
		}
	case W_GRAP: {
		register struct snag *p = &ship->file->grapples[a];
		p->turnfoul = b;
		p->toship = SHIP(c);
		break;
		}
	case W_SIGNAL:
		if (isplayer) {
			Signal("\7%s (%c%c): %s", ship, a);
		}
		break;
	case W_CREW: {
		register struct shipspecs *s = ship->specs;
		s->crew1 = a;
		s->crew2 = b;
		s->crew3 = c;
		break;
		}
	case W_CAPTAIN:
		(void) strncpy(ship->file->captain, (char *)a,
			sizeof ship->file->captain - 1);
		ship->file->captain[sizeof ship->file->captain - 1] = 0;
		break;
	case W_CAPTURED:
		if (a < 0)
			ship->file->captured = 0;
		else
			ship->file->captured = SHIP(a);
		break;
	case W_CLASS:
		ship->specs->class = a;
		break;
	case W_DRIFT:
		ship->file->drift = a;
		break;
	case W_EXPLODE:
		if ((ship->file->explode = a) == 2)
			ship->file->dir = 0;
		break;
	case W_FS:
		ship->file->FS = a;
		break;
	case W_GUNL: {
		register struct shipspecs *s = ship->specs;
		s->gunL = a;
		s->carL = b;
		break;
		}
	case W_GUNR: {
		register struct shipspecs *s = ship->specs;
		s->gunR = a;
		s->carR = b;
		break;
		}
	case W_HULL:
		ship->specs->hull = a;
		break;
	case W_LAST:
		(void) strncpy(ship->file->last, (char *)a,
			sizeof ship->file->last - 1);
		ship->file->last[sizeof ship->file->last - 1] = 0;
		break;
	case W_PCREW:
		ship->file->pcrew = a;
		break;
	case W_POINTS:
		ship->file->points = a;
		break;
	case W_QUAL:
		ship->specs->qual = a;
		break;
	case W_RIGG: {
		register struct shipspecs *s = ship->specs;
		s->rig1 = a;
		s->rig2 = b;
		s->rig3 = c;
		s->rig4 = d;
		break;
		}
	case W_RIG1:
		ship->specs->rig1 = a;
		break;
	case W_RIG2:
		ship->specs->rig2 = a;
		break;
	case W_RIG3:
		ship->specs->rig3 = a;
		break;
	case W_RIG4:
		ship->specs->rig4 = a;
		break;
	case W_SHIPCOL:
		ship->file->col = a;
		break;
	case W_SHIPDIR:
		ship->file->dir = a;
		break;
	case W_SHIPROW:
		ship->file->row = a;
		break;
	case W_SINK:
		if ((ship->file->sink = a) == 2)
			ship->file->dir = 0;
		break;
	case W_STRUCK:
		ship->file->struck = a;
		break;
	case W_TA:
		ship->specs->ta = a;
		break;
	case W_ALIVE:
		alive = 1;
		break;
	case W_TURN:
		turn = a;
		break;
	case W_WIND:
		winddir = a;
		windspeed = b;
		break;
	case W_BEGIN:
		(void) strcpy(ship->file->captain, "begin");
		people++;
		break;
	case W_END:
		(void) strcpy(ship->file->captain, "");
		people--;
		break;
	default:
		fprintf(stderr, "sync_update: unknown type %d\n", type);
		break;
	}
}
Commit	Line	Data
15e30c53	1	#ifndef lint
7cd3d9ac	2	static char *sccsid = "@(#)sync.c 2.2 83/11/01";
15e30c53 EW	3	#endif
	4
	5	#include "externs.h"
	6
	7	static char sync_buf[BUFSIZE];
	8	static char *sync_bufp = sync_buf;
	9	static char sync_lock[25];
	10	static char sync_file[25];
	11	static long sync_seek;
	12	static FILE *sync_fp;
	13	#define SF "/tmp/#sailsink.%d"
	14	#define LF "/tmp/#saillock.%d"
	15
	16	/VARARGS3/
	17	makesignal(from, fmt, ship, a, b, c)
	18	struct ship *from;
	19	char *fmt;
	20	register struct ship *ship;
	21	{
	22	char message[80];
	23
	24	if (ship == 0)
	25	(void) sprintf(message, fmt, a, b, c);
	26	else
	27	(void) sprintf(message, fmt,
	28	ship->shipname, colours(ship),
	29	sterncolour(ship), a, b, c);
	30	Write(W_SIGNAL, from, 1, (int)message, 0, 0, 0);
	31	}
	32
30d1a80b EW	33	#include <sys/types.h>
30d1a80b EW	34	#include <sys/stat.h>
15e30c53 EW	35	sync_exists(game)
	36	{
	37	char buf[sizeof sync_file];
30d1a80b EW	38	struct stat s;
30d1a80b EW	39	time_t t;
15e30c53 EW	40
15e30c53 EW	41	(void) sprintf(buf, SF, game);
30d1a80b EW	42	time(&t);
	43	if (stat(buf, &s) < 0)
	44	return 0;
	45	if (s.st_mtime < t - 60602) { /* 2 hours */
	46	unlink(buf);
	47	return 0;
	48	} else
	49	return 1;
15e30c53 EW	50	}
	51
	52	sync_open()
	53	{
	54	(void) sprintf(sync_lock, LF, game);
	55	(void) sprintf(sync_file, SF, game);
	56	if (access(sync_file, 0) < 0) {
	57	int omask;
	58	#ifdef SETUID
	59	omask = umask(077);
	60	#else
	61	omask = umask(011);
	62	#endif
	63	sync_fp = fopen(sync_file, "w+");
	64	(void) umask(omask);
	65	} else
	66	sync_fp = fopen(sync_file, "r+");
	67	if (sync_fp == 0)
	68	return -1;
	69	sync_seek == 0;
9224751f	70	return 0;
15e30c53 EW	71	}
	72
	73	sync_close(remove)
	74	char remove;
	75	{
7cd3d9ac EW	76	if (sync_fp != 0)
7cd3d9ac EW	77	(void) fclose(sync_fp);
15e30c53 EW	78	if (remove)
	79	(void) unlink(sync_file);
	80	}
	81
	82	Write(type, ship, isstr, a, b, c, d)
	83	int type;
	84	struct ship *ship;
	85	char isstr;
	86	int a, b, c, d;
	87	{
	88	if (isstr)
	89	(void) sprintf(sync_bufp, "%d %d %d %s\n",
	90	type, ship-SHIP(0), isstr, a);
	91	else
	92	(void) sprintf(sync_bufp, "%d %d %d %d %d %d %d\n",
	93	type, ship-SHIP(0), isstr, a, b, c, d);
	94	while (*sync_bufp++)
	95	;
	96	sync_bufp--;
	97	if (sync_bufp >= &sync_buf[sizeof sync_buf])
	98	abort();
	99	sync_update(type, ship, a, b, c, d);
	100	}
	101
	102	Sync()
	103	{
	104	int (sig1)(), (sig2)();
	105	int type, shipnum, isstr, a, b, c, d;
	106	char buf[60];
	107	register char *p = buf;
	108	int n;
	109
	110	sig1 = signal(SIGHUP, SIG_IGN);
	111	sig2 = signal(SIGINT, SIG_IGN);
	112	for (n = 0; link(sync_file, sync_lock) < 0 && n < 30; n++)
	113	sleep(2);
	114	(void) fseek(sync_fp, sync_seek, 0);
	115	while (fscanf(sync_fp, "%d%d%d", &type, &shipnum, &isstr) != EOF) {
	116	if (isstr) {
	117	for (p = buf;;) {
	118	switch (*p++ = getc(sync_fp)) {
	119	case '\n':
	120	p--;
	121	case EOF:
	122	break;
	123	default:
	124	continue;
	125	}
	126	break;
	127	}
	128	*p = 0;
	129	for (p = buf; *p == ' '; p++)
	130	;
	131	a = (int)p;
	132	b = c = d = 0;
	133	} else
	134	(void) fscanf(sync_fp, "%d%d%d%d", &a, &b, &c, &d);
	135	sync_update(type, SHIP(shipnum), a, b, c, d);
	136	}
	137	if (sync_bufp != sync_buf) {
	138	(void) fseek(sync_fp, 0L, 2);
	139	(void) fputs(sync_buf, sync_fp);
	140	(void) fflush(sync_fp);
	141	sync_bufp = sync_buf;
142	}
143	sync_seek = ftell(sync_fp);
144	(void) unlink(sync_lock);
145	(void) signal(SIGHUP, sig1);
146	(void) signal(SIGINT, sig2);
147	}
148
149	sync_update(type, ship, a, b, c, d)
150	int type;
151	register struct ship *ship;
152	int a, b, c, d;
153	{
154	switch (type) {
155	case W_DBP: {
156	register struct BP *p = &ship->file->DBP[a];
157	p->turnsent = b;
158	p->toship = SHIP(c);
159	p->mensent = d;
160	break;
161	}
162	case W_OBP: {
163	register struct BP *p = &ship->file->OBP[a];
164	p->turnsent = b;
165	p->toship = SHIP(c);
166	p->mensent = d;
167	break;
168	}
169	case W_FOUL: {
170	register struct snag *p = &ship->file->fouls[a];
171	p->turnfoul = b;
172	p->toship = SHIP(c);
173	break;
174	}
175	case W_GRAP: {
176	register struct snag *p = &ship->file->grapples[a];
177	p->turnfoul = b;
178	p->toship = SHIP(c);
179	break;
180	}
181	case W_SIGNAL:
0f5fabce	182	if (isplayer) {
fe0cae24	183	Signal("\7%s (%c%c): %s", ship, a);
0f5fabce	184	}
15e30c53 EW	185	break;
	186	case W_CREW: {
	187	register struct shipspecs *s = ship->specs;
	188	s->crew1 = a;
	189	s->crew2 = b;
	190	s->crew3 = c;
	191	break;
	192	}
	193	case W_CAPTAIN:
	194	(void) strncpy(ship->file->captain, (char *)a,
	195	sizeof ship->file->captain - 1);
	196	ship->file->captain[sizeof ship->file->captain - 1] = 0;
	197	break;
	198	case W_CAPTURED:
66e5ed8a EW	199	if (a < 0)
	200	ship->file->captured = 0;
	201	else
	202	ship->file->captured = SHIP(a);
15e30c53 EW	203	break;
	204	case W_CLASS:
	205	ship->specs->class = a;
	206	break;
	207	case W_DRIFT:
	208	ship->file->drift = a;
	209	break;
	210	case W_EXPLODE:
	211	if ((ship->file->explode = a) == 2)
	212	ship->file->dir = 0;
	213	break;
	214	case W_FS:
	215	ship->file->FS = a;
	216	break;
	217	case W_GUNL: {
	218	register struct shipspecs *s = ship->specs;
	219	s->gunL = a;
	220	s->carL = b;
	221	break;
	222	}
	223	case W_GUNR: {
	224	register struct shipspecs *s = ship->specs;
	225	s->gunR = a;
	226	s->carR = b;
	227	break;
	228	}
	229	case W_HULL:
	230	ship->specs->hull = a;
	231	break;
	232	case W_LAST:
	233	(void) strncpy(ship->file->last, (char *)a,
	234	sizeof ship->file->last - 1);
	235	ship->file->last[sizeof ship->file->last - 1] = 0;
	236	break;
	237	case W_PCREW:
	238	ship->file->pcrew = a;
	239	break;
	240	case W_POINTS:
	241	ship->file->points = a;
	242	break;
	243	case W_QUAL:
	244	ship->specs->qual = a;
	245	break;
	246	case W_RIGG: {
	247	register struct shipspecs *s = ship->specs;
	248	s->rig1 = a;
	249	s->rig2 = b;
	250	s->rig3 = c;
	251	s->rig4 = d;
	252	break;
	253	}
	254	case W_RIG1:
	255	ship->specs->rig1 = a;
	256	break;
	257	case W_RIG2:
	258	ship->specs->rig2 = a;
	259	break;
	260	case W_RIG3:
	261	ship->specs->rig3 = a;
	262	break;
	263	case W_RIG4:
	264	ship->specs->rig4 = a;
	265	break;
	266	case W_SHIPCOL:
267	ship->file->col = a;
268	break;
269	case W_SHIPDIR:
270	ship->file->dir = a;
271	break;
272	case W_SHIPROW:
273	ship->file->row = a;
274	break;
275	case W_SINK:
276	if ((ship->file->sink = a) == 2)
277	ship->file->dir = 0;
278	break;
279	case W_STRUCK:
280	ship->file->struck = a;
281	break;
282	case W_TA:
283	ship->specs->ta = a;
284	break;
285	case W_ALIVE:
286	alive = 1;
287	break;
288	case W_TURN:
289	turn = a;
290	break;
291	case W_WIND:
292	winddir = a;
293	windspeed = b;
294	break;
295	case W_BEGIN:
296	(void) strcpy(ship->file->captain, "begin");
297	people++;
298	break;
299	case W_END:
300	(void) strcpy(ship->file->captain, "");
301	people--;
302	break;
303	default:
304	fprintf(stderr, "sync_update: unknown type %d\n", type);
305	break;
306	}
307	}