sail/sync.c

   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 }