sail/sync.c

   1 /*      $NetBSD: sync.c,v 1.14 2000/02/09 22:27:56 jsm 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.14 2000/02/09 22:27:56 jsm 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 <time.h>
  57 #include "extern.h"
  58 #include "pathnames.h"
  59
  60 #define BUFSIZE 4096
  61
  62 static const char SF[] = _PATH_SYNC;
  63 static const char LF[] = _PATH_LOCK;
  64 static char sync_buf[BUFSIZE];
  65 static char *sync_bp = sync_buf;
  66 static char sync_lock[sizeof SF];
  67 static char sync_file[sizeof LF];
  68 static long sync_seek;
  69 static FILE *sync_fp;
  70
  71 void
  72 fmtship(buf, len, fmt, ship)
  73         char *buf;
  74         size_t len;
  75         const char *fmt;
  76         struct ship *ship;
  77 {
  78         while (*fmt) {
  79                 if (len-- == 0) {
  80                         *buf = '\0';
  81                         return;
  82                 }
  83                 if (*fmt == '$' && fmt[1] == '$') {
  84                         size_t l = snprintf(buf, len, "%s (%c%c)",
  85                             ship->shipname, colours(ship), sterncolour(ship));
  86                         buf += l;
  87                         len -= l - 1;
  88                         fmt += 2;
  89                 }
  90                 else
  91                         *buf++ = *fmt++;
  92         }
  93
  94         if (len > 0)
  95                 *buf = '\0';
  96 }
  97
  98
  99 /*VARARGS3*/
 100 void
 101 #ifdef __STDC__
 102 makesignal(struct ship *from, const char *fmt, struct ship *ship, ...)
 103 #else
 104 makesignal(va_alias)
 105         va_dcl
 106 #endif
 107 {
 108         char message[BUFSIZ];
 109         char format[BUFSIZ];
 110         va_list ap;
 111 #ifndef __STDC__
 112         struct ship *from;
 113         const char *fmt;
 114         struct ship *ship;
 115
 116         va_start(ap);
 117         from = va_arg(ap, struct ship *);
 118         fmt = va_arg(ap, const char *);
 119         ship = va_arg(ap, struct ship *);
 120 #else
 121         va_start(ap, ship);
 122 #endif
 123         fmtship(format, sizeof(format), fmt, ship);
 124         (void) vsprintf(message, format, ap);
 125         va_end(ap);
 126         Writestr(W_SIGNAL, from, message);
 127 }
 128
 129 void
 130 #ifdef __STDC__
 131 makemsg(struct ship *from, const char *fmt, ...)
 132 #else
 133 makemsg(va_alias)
 134         va_dcl
 135 #endif
 136 {
 137         char message[BUFSIZ];
 138         va_list ap;
 139 #ifndef __STDC__
 140         struct ship *from;
 141         const char *fmt;
 142
 143         va_start(ap);
 144         from = va_arg(ap, struct ship *);
 145         fmt = va_arg(ap, const char *);
 146 #else
 147         va_start(ap, fmt);
 148 #endif
 149         (void) vsprintf(message, fmt, ap);
 150         va_end(ap);
 151         Writestr(W_SIGNAL, from, message);
 152 }
 153
 154 int
 155 sync_exists(game)
 156         int game;
 157 {
 158         char buf[sizeof sync_file];
 159         struct stat s;
 160         time_t t;
 161
 162         (void) sprintf(buf, SF, game);
 163         (void) time(&t);
 164         setegid(egid);
 165         if (stat(buf, &s) < 0) {
 166                 setegid(gid);
 167                 return 0;
 168         }
 169         if (s.st_mtime < t - 60*60*2) {         /* 2 hours */
 170                 (void) unlink(buf);
 171                 (void) sprintf(buf, LF, game);
 172                 (void) unlink(buf);
 173                 setegid(gid);
 174                 return 0;
 175         } else {
 176                 setegid(gid);
 177                 return 1;
 178         }
 179 }
 180
 181 int
 182 sync_open()
 183 {
 184         struct stat tmp;
 185         if (sync_fp != NULL)
 186                 (void) fclose(sync_fp);
 187         (void) sprintf(sync_lock, LF, game);
 188         (void) sprintf(sync_file, SF, game);
 189         setegid(egid);
 190         if (stat(sync_file, &tmp) < 0) {
 191                 mode_t omask = umask(002);
 192                 sync_fp = fopen(sync_file, "w+");
 193                 (void) umask(omask);
 194         } else
 195                 sync_fp = fopen(sync_file, "r+");
 196         setegid(gid);
 197         if (sync_fp == NULL)
 198                 return -1;
 199         sync_seek = 0;
 200         return 0;
 201 }
 202
 203 void
 204 sync_close(remove)
 205         char remove;
 206 {
 207         if (sync_fp != 0)
 208                 (void) fclose(sync_fp);
 209         if (remove) {
 210                 setegid(egid);
 211                 (void) unlink(sync_file);
 212                 setegid(gid);
 213         }
 214 }
 215
 216 void
 217 Write(type, ship, a, b, c, d)
 218         int type;
 219         struct ship *ship;
 220         long a, b, c, d;
 221 {
 222
 223         (void) sprintf(sync_bp, "%d %d 0 %ld %ld %ld %ld\n",
 224                        type, ship->file->index, a, b, c, d);
 225         while (*sync_bp++)
 226                 ;
 227         sync_bp--;
 228         if (sync_bp >= &sync_buf[sizeof sync_buf])
 229                 abort();
 230         (void) sync_update(type, ship, NULL, a, b, c, d);
 231 }
 232
 233 void
 234 Writestr(type, ship, a)
 235         int type;
 236         struct ship *ship;
 237         const char *a;
 238 {
 239
 240         (void) sprintf(sync_bp, "%d %d 1 %s\n",
 241                        type, ship->file->index, a);
 242         while (*sync_bp++)
 243                 ;
 244         sync_bp--;
 245         if (sync_bp >= &sync_buf[sizeof sync_buf])
 246                 abort();
 247         (void) sync_update(type, ship, a, 0, 0, 0, 0);
 248 }
 249
 250 int
 251 Sync()
 252 {
 253         sig_t sighup, sigint;
 254         int n;
 255         int type, shipnum, isstr;
 256         char *astr;
 257         long a, b, c, d;
 258         char buf[80];
 259         char erred = 0;
 260
 261         sighup = signal(SIGHUP, SIG_IGN);
 262         sigint = signal(SIGINT, SIG_IGN);
 263         for (n = TIMEOUT; --n >= 0;) {
 264 #ifdef LOCK_EX
 265                 if (flock(fileno(sync_fp), LOCK_EX|LOCK_NB) >= 0)
 266                         break;
 267                 if (errno != EWOULDBLOCK)
 268                         return -1;
 269 #else
 270                 setegid(egid);
 271                 if (link(sync_file, sync_lock) >= 0) {
 272                         setegid(gid);
 273                         break;
 274                 }
 275                 setegid(gid);
 276                 if (errno != EEXIST)
 277                         return -1;
 278 #endif
 279                 sleep(1);
 280         }
 281         if (n <= 0)
 282                 return -1;
 283         (void) fseek(sync_fp, sync_seek, SEEK_SET);
 284         for (;;) {
 285                 switch (fscanf(sync_fp, "%d%d%d", &type, &shipnum, &isstr)) {
 286                 case 3:
 287                         break;
 288                 case EOF:
 289                         goto out;
 290                 default:
 291                         goto bad;
 292                 }
 293                 if (shipnum < 0 || shipnum >= cc->vessels)
 294                         goto bad;
 295                 if (isstr != 0 && isstr != 1)
 296                         goto bad;
 297                 if (isstr) {
 298                         char *p;
 299                         for (p = buf;;) {
 300                                 switch (*p++ = getc(sync_fp)) {
 301                                 case '\n':
 302                                         p--;
 303                                 case EOF:
 304                                         break;
 305                                 default:
 306                                         if (p >= buf + sizeof buf)
 307                                                 p--;
 308                                         continue;
 309                                 }
 310                                 break;
 311                         }
 312                         *p = 0;
 313                         for (p = buf; *p == ' '; p++)
 314                                 ;
 315                         astr = p;
 316                         a = b = c = d = 0;
 317                 } else {
 318                         if (fscanf(sync_fp, "%ld%ld%ld%ld", &a, &b, &c, &d) != 4)
 319                                 goto bad;
 320                         astr = NULL;
 321                 }
 322                 if (sync_update(type, SHIP(shipnum), astr, a, b, c, d) < 0)
 323                         goto bad;
 324         }
 325 bad:
 326         erred++;
 327 out:
 328         if (!erred && sync_bp != sync_buf) {
 329                 (void) fseek(sync_fp, 0L, SEEK_END);
 330                 (void) fwrite(sync_buf, sizeof *sync_buf, sync_bp - sync_buf,
 331                         sync_fp);
 332                 (void) fflush(sync_fp);
 333                 sync_bp = sync_buf;
 334         }
 335         sync_seek = ftell(sync_fp);
 336 #ifdef LOCK_EX
 337         (void) flock(fileno(sync_fp), LOCK_UN);
 338 #else
 339         setegid(egid);
 340         (void) unlink(sync_lock);
 341         setegid(gid);
 342 #endif
 343         (void) signal(SIGHUP, sighup);
 344         (void) signal(SIGINT, sigint);
 345         return erred ? -1 : 0;
 346 }
 347
 348 int
 349 sync_update(type, ship, astr, a, b, c, d)
 350         int type;
 351         struct ship *ship;
 352         const char *astr;
 353         long a, b, c, d;
 354 {
 355         switch (type) {
 356         case W_DBP: {
 357                 struct BP *p = &ship->file->DBP[a];
 358                 p->turnsent = b;
 359                 p->toship = SHIP(c);
 360                 p->mensent = d;
 361                 break;
 362                 }
 363         case W_OBP: {
 364                 struct BP *p = &ship->file->OBP[a];
 365                 p->turnsent = b;
 366                 p->toship = SHIP(c);
 367                 p->mensent = d;
 368                 break;
 369                 }
 370         case W_FOUL: {
 371                 struct snag *p = &ship->file->foul[a];
 372                 if (SHIP(a)->file->dir == 0)
 373                         break;
 374                 if (p->sn_count++ == 0)
 375                         p->sn_turn = turn;
 376                 ship->file->nfoul++;
 377                 break;
 378                 }
 379         case W_GRAP: {
 380                 struct snag *p = &ship->file->grap[a];
 381                 if (SHIP(a)->file->dir == 0)
 382                         break;
 383                 if (p->sn_count++ == 0)
 384                         p->sn_turn = turn;
 385                 ship->file->ngrap++;
 386                 break;
 387                 }
 388         case W_UNFOUL: {
 389                 struct snag *p = &ship->file->foul[a];
 390                 if (p->sn_count > 0) {
 391                         if (b) {
 392                                 ship->file->nfoul -= p->sn_count;
 393                                 p->sn_count = 0;
 394                         } else {
 395                                 ship->file->nfoul--;
 396                                 p->sn_count--;
 397                         }
 398                 }
 399                 break;
 400                 }
 401         case W_UNGRAP: {
 402                 struct snag *p = &ship->file->grap[a];
 403                 if (p->sn_count > 0) {
 404                         if (b) {
 405                                 ship->file->ngrap -= p->sn_count;
 406                                 p->sn_count = 0;
 407                         } else {
 408                                 ship->file->ngrap--;
 409                                 p->sn_count--;
 410                         }
 411                 }
 412                 break;
 413                 }
 414         case W_SIGNAL:
 415                 if (mode == MODE_PLAYER) {
 416                         if (nobells)
 417                                 Signal("$$: %s", ship, astr);
 418                         else
 419                                 Signal("\7$$: %s", ship, astr);
 420                 }
 421                 break;
 422         case W_CREW: {
 423                 struct shipspecs *s = ship->specs;
 424                 s->crew1 = a;
 425                 s->crew2 = b;
 426                 s->crew3 = c;
 427                 break;
 428                 }
 429         case W_CAPTAIN:
 430                 (void) strncpy(ship->file->captain, astr,
 431                         sizeof ship->file->captain - 1);
 432                 ship->file->captain[sizeof ship->file->captain - 1] = 0;
 433                 break;
 434         case W_CAPTURED:
 435                 if (a < 0)
 436                         ship->file->captured = 0;
 437                 else
 438                         ship->file->captured = SHIP(a);
 439                 break;
 440         case W_CLASS:
 441                 ship->specs->class = a;
 442                 break;
 443         case W_DRIFT:
 444                 ship->file->drift = a;
 445                 break;
 446         case W_EXPLODE:
 447                 if ((ship->file->explode = a) == 2)
 448                         ship->file->dir = 0;
 449                 break;
 450         case W_FS:
 451                 ship->file->FS = a;
 452                 break;
 453         case W_GUNL: {
 454                 struct shipspecs *s = ship->specs;
 455                 s->gunL = a;
 456                 s->carL = b;
 457                 break;
 458                 }
 459         case W_GUNR: {
 460                 struct shipspecs *s = ship->specs;
 461                 s->gunR = a;
 462                 s->carR = b;
 463                 break;
 464                 }
 465         case W_HULL:
 466                 ship->specs->hull = a;
 467                 break;
 468         case W_MOVE:
 469                 (void) strncpy(ship->file->movebuf, astr,
 470                         sizeof ship->file->movebuf - 1);
 471                 ship->file->movebuf[sizeof ship->file->movebuf - 1] = 0;
 472                 break;
 473         case W_PCREW:
 474                 ship->file->pcrew = a;
 475                 break;
 476         case W_POINTS:
 477                 ship->file->points = a;
 478                 break;
 479         case W_QUAL:
 480                 ship->specs->qual = a;
 481                 break;
 482         case W_RIGG: {
 483                 struct shipspecs *s = ship->specs;
 484                 s->rig1 = a;
 485                 s->rig2 = b;
 486                 s->rig3 = c;
 487                 s->rig4 = d;
 488                 break;
 489                 }
 490         case W_RIG1:
 491                 ship->specs->rig1 = a;
 492                 break;
 493         case W_RIG2:
 494                 ship->specs->rig2 = a;
 495                 break;
 496         case W_RIG3:
 497                 ship->specs->rig3 = a;
 498                 break;
 499         case W_RIG4:
 500                 ship->specs->rig4 = a;
 501                 break;
 502         case W_COL:
 503                 ship->file->col = a;
 504                 break;
 505         case W_DIR:
 506                 ship->file->dir = a;
 507                 break;
 508         case W_ROW:
 509                 ship->file->row = a;
 510                 break;
 511         case W_SINK:
 512                 if ((ship->file->sink = a) == 2)
 513                         ship->file->dir = 0;
 514                 break;
 515         case W_STRUCK:
 516                 ship->file->struck = a;
 517                 break;
 518         case W_TA:
 519                 ship->specs->ta = a;
 520                 break;
 521         case W_ALIVE:
 522                 alive = 1;
 523                 break;
 524         case W_TURN:
 525                 turn = a;
 526                 break;
 527         case W_WIND:
 528                 winddir = a;
 529                 windspeed = b;
 530                 break;
 531         case W_BEGIN:
 532                 (void) strcpy(ship->file->captain, "begin");
 533                 people++;
 534                 break;
 535         case W_END:
 536                 *ship->file->captain = 0;
 537                 ship->file->points = 0;
 538                 people--;
 539                 break;
 540         case W_DDEAD:
 541                 hasdriver = 0;
 542                 break;
 543         default:
 544                 fprintf(stderr, "sync_update: unknown type %d\r\n", type);
 545                 return -1;
 546         }
 547         return 0;
 548 }