sync.c revision 1.10
1 /* $NetBSD: sync.c,v 1.10 1998/09/11 14:15:46 hubertf 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.10 1998/09/11 14:15:46 hubertf 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 int game; 154 { 155 char buf[sizeof sync_file]; 156 struct stat s; 157 time_t t; 158 159 (void) sprintf(buf, SF, game); 160 (void) time(&t); 161 if (stat(buf, &s) < 0) 162 return 0; 163 if (s.st_mtime < t - 60*60*2) { /* 2 hours */ 164 (void) unlink(buf); 165 (void) sprintf(buf, LF, game); 166 (void) unlink(buf); 167 return 0; 168 } else 169 return 1; 170 } 171 172 int 173 sync_open() 174 { 175 if (sync_fp != NULL) 176 (void) fclose(sync_fp); 177 (void) sprintf(sync_lock, LF, game); 178 (void) sprintf(sync_file, SF, game); 179 if (access(sync_file, 0) < 0) { 180 int omask = umask(issetuid ? 077 : 011); 181 sync_fp = fopen(sync_file, "w+"); 182 (void) umask(omask); 183 } else 184 sync_fp = fopen(sync_file, "r+"); 185 if (sync_fp == NULL) 186 return -1; 187 sync_seek = 0; 188 return 0; 189 } 190 191 void 192 sync_close(remove) 193 char remove; 194 { 195 if (sync_fp != 0) 196 (void) fclose(sync_fp); 197 if (remove) 198 (void) unlink(sync_file); 199 } 200 201 void 202 Write(type, ship, isstr, a, b, c, d) 203 int type; 204 struct ship *ship; 205 int isstr; 206 long a, b, c, d; 207 { 208 209 if (isstr) 210 (void) sprintf(sync_bp, "%d %d %d %s\n", 211 type, ship->file->index, isstr, (char *) a); 212 else 213 (void) sprintf(sync_bp, "%d %d %d %ld %ld %ld %ld\n", 214 type, ship->file->index, isstr, a, b, c, d); 215 while (*sync_bp++) 216 ; 217 sync_bp--; 218 if (sync_bp >= &sync_buf[sizeof sync_buf]) 219 abort(); 220 (void) sync_update(type, ship, a, b, c, d); 221 } 222 223 int 224 Sync() 225 { 226 sig_t sighup, sigint; 227 int n; 228 int type, shipnum, isstr; 229 long a, b, c, d; 230 char buf[80]; 231 char erred = 0; 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 } 362 break; 363 } 364 case W_UNGRAP: { 365 struct snag *p = &ship->file->grap[a]; 366 if (p->sn_count > 0) { 367 if (b) { 368 ship->file->ngrap -= p->sn_count; 369 p->sn_count = 0; 370 } else { 371 ship->file->ngrap--; 372 p->sn_count--; 373 } 374 } 375 break; 376 } 377 case W_SIGNAL: 378 if (mode == MODE_PLAYER) { 379 if (nobells) 380 Signal("$$: %s", ship, (char *) a); 381 else 382 Signal("\7$$: %s", ship, (char *) a); 383 } 384 break; 385 case W_CREW: { 386 struct shipspecs *s = ship->specs; 387 s->crew1 = a; 388 s->crew2 = b; 389 s->crew3 = c; 390 break; 391 } 392 case W_CAPTAIN: 393 (void) strncpy(ship->file->captain, (char *)a, 394 sizeof ship->file->captain - 1); 395 ship->file->captain[sizeof ship->file->captain - 1] = 0; 396 break; 397 case W_CAPTURED: 398 if (a < 0) 399 ship->file->captured = 0; 400 else 401 ship->file->captured = SHIP(a); 402 break; 403 case W_CLASS: 404 ship->specs->class = a; 405 break; 406 case W_DRIFT: 407 ship->file->drift = a; 408 break; 409 case W_EXPLODE: 410 if ((ship->file->explode = a) == 2) 411 ship->file->dir = 0; 412 break; 413 case W_FS: 414 ship->file->FS = a; 415 break; 416 case W_GUNL: { 417 struct shipspecs *s = ship->specs; 418 s->gunL = a; 419 s->carL = b; 420 break; 421 } 422 case W_GUNR: { 423 struct shipspecs *s = ship->specs; 424 s->gunR = a; 425 s->carR = b; 426 break; 427 } 428 case W_HULL: 429 ship->specs->hull = a; 430 break; 431 case W_MOVE: 432 (void) strncpy(ship->file->movebuf, (char *)a, 433 sizeof ship->file->movebuf - 1); 434 ship->file->movebuf[sizeof ship->file->movebuf - 1] = 0; 435 break; 436 case W_PCREW: 437 ship->file->pcrew = a; 438 break; 439 case W_POINTS: 440 ship->file->points = a; 441 break; 442 case W_QUAL: 443 ship->specs->qual = a; 444 break; 445 case W_RIGG: { 446 struct shipspecs *s = ship->specs; 447 s->rig1 = a; 448 s->rig2 = b; 449 s->rig3 = c; 450 s->rig4 = d; 451 break; 452 } 453 case W_RIG1: 454 ship->specs->rig1 = a; 455 break; 456 case W_RIG2: 457 ship->specs->rig2 = a; 458 break; 459 case W_RIG3: 460 ship->specs->rig3 = a; 461 break; 462 case W_RIG4: 463 ship->specs->rig4 = a; 464 break; 465 case W_COL: 466 ship->file->col = a; 467 break; 468 case W_DIR: 469 ship->file->dir = a; 470 break; 471 case W_ROW: 472 ship->file->row = a; 473 break; 474 case W_SINK: 475 if ((ship->file->sink = a) == 2) 476 ship->file->dir = 0; 477 break; 478 case W_STRUCK: 479 ship->file->struck = a; 480 break; 481 case W_TA: 482 ship->specs->ta = a; 483 break; 484 case W_ALIVE: 485 alive = 1; 486 break; 487 case W_TURN: 488 turn = a; 489 break; 490 case W_WIND: 491 winddir = a; 492 windspeed = b; 493 break; 494 case W_BEGIN: 495 (void) strcpy(ship->file->captain, "begin"); 496 people++; 497 break; 498 case W_END: 499 *ship->file->captain = 0; 500 ship->file->points = 0; 501 people--; 502 break; 503 case W_DDEAD: 504 hasdriver = 0; 505 break; 506 default: 507 fprintf(stderr, "sync_update: unknown type %d\r\n", type); 508 return -1; 509 } 510 return 0; 511 } 512
Indexes created Wed Oct 01 15:09:59 GMT 2025