sync.c revision 1.7
1 /* $NetBSD: sync.c,v 1.7 1997/10/13 21:04:40 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 #ifndef lint 38 #if 0 39 static char sccsid[] = "@(#)sync.c 8.2 (Berkeley) 4/28/95"; 40 #else 41 __RCSID("$NetBSD: sync.c,v 1.7 1997/10/13 21:04:40 christos Exp $"); 42 #endif 43 #endif /* not lint */ 44 45 #include <fcntl.h> 46 #include <errno.h> 47 #ifdef __STDC__ 48 #include <stdarg.h> 49 #else 50 #include <varargs.h> 51 #endif 52 #include <stdlib.h> 53 #include <unistd.h> 54 #include <sys/types.h> 55 #include <sys/stat.h> 56 #include "extern.h" 57 58 #define BUFSIZE 4096 59 60 static char sync_buf[BUFSIZE]; 61 static char *sync_bp = sync_buf; 62 static char sync_lock[25]; 63 static char sync_file[25]; 64 static long sync_seek; 65 static FILE *sync_fp; 66 #define SF "/tmp/#sailsink.%d" 67 #define LF "/tmp/#saillock.%d" 68 69 void 70 fmtship(buf, len, fmt, ship) 71 char *buf; 72 size_t len; 73 const char *fmt; 74 struct ship *ship; 75 { 76 while (*fmt) { 77 if (len-- == 0) { 78 *buf = '\0'; 79 return; 80 } 81 if (*fmt == '$' && fmt[1] == '$') { 82 size_t l = snprintf(buf, len, "%s (%c%c)", 83 ship->shipname, colours(ship), sterncolour(ship)); 84 buf += l; 85 len -= l - 1; 86 fmt += 2; 87 } 88 else 89 *buf++ = *fmt++; 90 } 91 92 if (len > 0) 93 *buf = '\0'; 94 } 95 96 97 /*VARARGS3*/ 98 void 99 #ifdef __STDC__ 100 makesignal(struct ship *from, const char *fmt, struct ship *ship, ...) 101 #else 102 makesignal(va_alias) 103 va_dcl 104 #endif 105 { 106 char message[BUFSIZ]; 107 char format[BUFSIZ]; 108 va_list ap; 109 #ifndef __STDC__ 110 struct ship *from; 111 const char *fmt; 112 struct ship *ship; 113 114 va_start(ap); 115 from = va_arg(ap, struct ship *); 116 fmt = va_arg(ap, const char *); 117 ship = va_arg(ap, struct ship *); 118 #else 119 va_start(ap, ship); 120 #endif 121 fmtship(format, sizeof(format), fmt, ship); 122 (void) vsprintf(message, format, ap); 123 va_end(ap); 124 Write(W_SIGNAL, from, 1, (long)message, 0, 0, 0); 125 } 126 127 void 128 #ifdef __STDC__ 129 makemsg(struct ship *from, const char *fmt, ...) 130 #else 131 makemsg(va_alias) 132 va_dcl 133 #endif 134 { 135 char message[BUFSIZ]; 136 va_list ap; 137 #ifndef __STDC__ 138 struct ship *from; 139 const char *fmt; 140 141 va_start(ap); 142 from = va_arg(ap, struct ship *); 143 fmt = va_arg(ap, const char *); 144 #else 145 va_start(ap, fmt); 146 #endif 147 (void) vsprintf(message, fmt, ap); 148 va_end(ap); 149 Write(W_SIGNAL, from, 1, (long)message, 0, 0, 0); 150 } 151 int 152 sync_exists(game) 153 { 154 char buf[sizeof sync_file]; 155 struct stat s; 156 time_t t; 157 158 (void) sprintf(buf, SF, game); 159 (void) time(&t); 160 if (stat(buf, &s) < 0) 161 return 0; 162 if (s.st_mtime < t - 60*60*2) { /* 2 hours */ 163 (void) unlink(buf); 164 (void) sprintf(buf, LF, game); 165 (void) unlink(buf); 166 return 0; 167 } else 168 return 1; 169 } 170 171 int 172 sync_open() 173 { 174 if (sync_fp != NULL) 175 (void) fclose(sync_fp); 176 (void) sprintf(sync_lock, LF, game); 177 (void) sprintf(sync_file, SF, game); 178 if (access(sync_file, 0) < 0) { 179 int omask = umask(issetuid ? 077 : 011); 180 sync_fp = fopen(sync_file, "w+"); 181 (void) umask(omask); 182 } else 183 sync_fp = fopen(sync_file, "r+"); 184 if (sync_fp == NULL) 185 return -1; 186 sync_seek = 0; 187 return 0; 188 } 189 190 void 191 sync_close(remove) 192 char remove; 193 { 194 if (sync_fp != 0) 195 (void) fclose(sync_fp); 196 if (remove) 197 (void) unlink(sync_file); 198 } 199 200 void 201 Write(type, ship, isstr, a, b, c, d) 202 int type; 203 struct ship *ship; 204 int isstr; 205 long a, b, c, d; 206 { 207 208 if (isstr) 209 (void) sprintf(sync_bp, "%d %d %d %s\n", 210 type, ship->file->index, isstr, (char *) a); 211 else 212 (void) sprintf(sync_bp, "%d %d %d %ld %ld %ld %ld\n", 213 type, ship->file->index, isstr, a, b, c, d); 214 while (*sync_bp++) 215 ; 216 sync_bp--; 217 if (sync_bp >= &sync_buf[sizeof sync_buf]) 218 abort(); 219 (void) sync_update(type, ship, a, b, c, d); 220 } 221 222 int 223 Sync() 224 { 225 sig_t sighup, sigint; 226 int n; 227 int type, shipnum, isstr; 228 long a, b, c, d; 229 char buf[80]; 230 char erred = 0; 231 extern errno; 232 233 sighup = signal(SIGHUP, SIG_IGN); 234 sigint = signal(SIGINT, SIG_IGN); 235 for (n = TIMEOUT; --n >= 0;) { 236 #ifdef LOCK_EX 237 if (flock(fileno(sync_fp), LOCK_EX|LOCK_NB) >= 0) 238 break; 239 if (errno != EWOULDBLOCK) 240 return -1; 241 #else 242 if (link(sync_file, sync_lock) >= 0) 243 break; 244 if (errno != EEXIST) 245 return -1; 246 #endif 247 sleep(1); 248 } 249 if (n <= 0) 250 return -1; 251 (void) fseek(sync_fp, sync_seek, 0); 252 for (;;) { 253 switch (fscanf(sync_fp, "%d%d%d", &type, &shipnum, &isstr)) { 254 case 3: 255 break; 256 case EOF: 257 goto out; 258 default: 259 goto bad; 260 } 261 if (shipnum < 0 || shipnum >= cc->vessels) 262 goto bad; 263 if (isstr != 0 && isstr != 1) 264 goto bad; 265 if (isstr) { 266 char *p; 267 for (p = buf;;) { 268 switch (*p++ = getc(sync_fp)) { 269 case '\n': 270 p--; 271 case EOF: 272 break; 273 default: 274 if (p >= buf + sizeof buf) 275 p--; 276 continue; 277 } 278 break; 279 } 280 *p = 0; 281 for (p = buf; *p == ' '; p++) 282 ; 283 a = (long)p; 284 b = c = d = 0; 285 } else 286 if (fscanf(sync_fp, "%ld%ld%ld%ld", &a, &b, &c, &d) != 4) 287 goto bad; 288 if (sync_update(type, SHIP(shipnum), a, b, c, d) < 0) 289 goto bad; 290 } 291 bad: 292 erred++; 293 out: 294 if (!erred && sync_bp != sync_buf) { 295 (void) fseek(sync_fp, 0L, 2); 296 (void) fwrite(sync_buf, sizeof *sync_buf, sync_bp - sync_buf, 297 sync_fp); 298 (void) fflush(sync_fp); 299 sync_bp = sync_buf; 300 } 301 sync_seek = ftell(sync_fp); 302 #ifdef LOCK_EX 303 (void) flock(fileno(sync_fp), LOCK_UN); 304 #else 305 (void) unlink(sync_lock); 306 #endif 307 (void) signal(SIGHUP, sighup); 308 (void) signal(SIGINT, sigint); 309 return erred ? -1 : 0; 310 } 311 312 int 313 sync_update(type, ship, a, b, c, d) 314 int type; 315 struct ship *ship; 316 long a, b, c, d; 317 { 318 switch (type) { 319 case W_DBP: { 320 struct BP *p = &ship->file->DBP[a]; 321 p->turnsent = b; 322 p->toship = SHIP(c); 323 p->mensent = d; 324 break; 325 } 326 case W_OBP: { 327 struct BP *p = &ship->file->OBP[a]; 328 p->turnsent = b; 329 p->toship = SHIP(c); 330 p->mensent = d; 331 break; 332 } 333 case W_FOUL: { 334 struct snag *p = &ship->file->foul[a]; 335 if (SHIP(a)->file->dir == 0) 336 break; 337 if (p->sn_count++ == 0) 338 p->sn_turn = turn; 339 ship->file->nfoul++; 340 break; 341 } 342 case W_GRAP: { 343 struct snag *p = &ship->file->grap[a]; 344 if (SHIP(a)->file->dir == 0) 345 break; 346 if (p->sn_count++ == 0) 347 p->sn_turn = turn; 348 ship->file->ngrap++; 349 break; 350 } 351 case W_UNFOUL: { 352 struct snag *p = &ship->file->foul[a]; 353 if (p->sn_count > 0) 354 if (b) { 355 ship->file->nfoul -= p->sn_count; 356 p->sn_count = 0; 357 } else { 358 ship->file->nfoul--; 359 p->sn_count--; 360 } 361 break; 362 } 363 case W_UNGRAP: { 364 struct snag *p = &ship->file->grap[a]; 365 if (p->sn_count > 0) 366 if (b) { 367 ship->file->ngrap -= p->sn_count; 368 p->sn_count = 0; 369 } else { 370 ship->file->ngrap--; 371 p->sn_count--; 372 } 373 break; 374 } 375 case W_SIGNAL: 376 if (mode == MODE_PLAYER) 377 if (nobells) 378 Signal("$$: %s", ship, (char *) a); 379 else 380 Signal("\7$$: %s", ship, (char *) a); 381 break; 382 case W_CREW: { 383 struct shipspecs *s = ship->specs; 384 s->crew1 = a; 385 s->crew2 = b; 386 s->crew3 = c; 387 break; 388 } 389 case W_CAPTAIN: 390 (void) strncpy(ship->file->captain, (char *)a, 391 sizeof ship->file->captain - 1); 392 ship->file->captain[sizeof ship->file->captain - 1] = 0; 393 break; 394 case W_CAPTURED: 395 if (a < 0) 396 ship->file->captured = 0; 397 else 398 ship->file->captured = SHIP(a); 399 break; 400 case W_CLASS: 401 ship->specs->class = a; 402 break; 403 case W_DRIFT: 404 ship->file->drift = a; 405 break; 406 case W_EXPLODE: 407 if ((ship->file->explode = a) == 2) 408 ship->file->dir = 0; 409 break; 410 case W_FS: 411 ship->file->FS = a; 412 break; 413 case W_GUNL: { 414 struct shipspecs *s = ship->specs; 415 s->gunL = a; 416 s->carL = b; 417 break; 418 } 419 case W_GUNR: { 420 struct shipspecs *s = ship->specs; 421 s->gunR = a; 422 s->carR = b; 423 break; 424 } 425 case W_HULL: 426 ship->specs->hull = a; 427 break; 428 case W_MOVE: 429 (void) strncpy(ship->file->movebuf, (char *)a, 430 sizeof ship->file->movebuf - 1); 431 ship->file->movebuf[sizeof ship->file->movebuf - 1] = 0; 432 break; 433 case W_PCREW: 434 ship->file->pcrew = a; 435 break; 436 case W_POINTS: 437 ship->file->points = a; 438 break; 439 case W_QUAL: 440 ship->specs->qual = a; 441 break; 442 case W_RIGG: { 443 struct shipspecs *s = ship->specs; 444 s->rig1 = a; 445 s->rig2 = b; 446 s->rig3 = c; 447 s->rig4 = d; 448 break; 449 } 450 case W_RIG1: 451 ship->specs->rig1 = a; 452 break; 453 case W_RIG2: 454 ship->specs->rig2 = a; 455 break; 456 case W_RIG3: 457 ship->specs->rig3 = a; 458 break; 459 case W_RIG4: 460 ship->specs->rig4 = a; 461 break; 462 case W_COL: 463 ship->file->col = a; 464 break; 465 case W_DIR: 466 ship->file->dir = a; 467 break; 468 case W_ROW: 469 ship->file->row = a; 470 break; 471 case W_SINK: 472 if ((ship->file->sink = a) == 2) 473 ship->file->dir = 0; 474 break; 475 case W_STRUCK: 476 ship->file->struck = a; 477 break; 478 case W_TA: 479 ship->specs->ta = a; 480 break; 481 case W_ALIVE: 482 alive = 1; 483 break; 484 case W_TURN: 485 turn = a; 486 break; 487 case W_WIND: 488 winddir = a; 489 windspeed = b; 490 break; 491 case W_BEGIN: 492 (void) strcpy(ship->file->captain, "begin"); 493 people++; 494 break; 495 case W_END: 496 *ship->file->captain = 0; 497 ship->file->points = 0; 498 people--; 499 break; 500 case W_DDEAD: 501 hasdriver = 0; 502 break; 503 default: 504 fprintf(stderr, "sync_update: unknown type %d\r\n", type); 505 return -1; 506 } 507 return 0; 508 } 509
Indexes created Tue Sep 30 17:09:57 GMT 2025