/*      $NetBSD: sync.c,v 1.34 2013/10/19 17:23:08 christos Exp $       */

/*
* Copyright (c) 1983, 1993
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)sync.c      8.2 (Berkeley) 4/28/95";
#else
__RCSID("$NetBSD: sync.c,v 1.34 2013/10/19 17:23:08 christos Exp $");
#endif
#endif /* not lint */

#include <sys/stat.h>

#include <fcntl.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "extern.h"
#include "pathnames.h"

#define BUFSIZE 4096

/* Message types */
#define W_CAPTAIN       1
#define W_CAPTURED      2
#define W_CLASS         3
#define W_CREW          4
#define W_DBP           5
#define W_DRIFT         6
#define W_EXPLODE       7
/*      W_FILE          8   not used */
#define W_FOUL          9
#define W_GUNL          10
#define W_GUNR          11
#define W_HULL          12
#define W_MOVE          13
#define W_OBP           14
#define W_PCREW         15
#define W_UNFOUL        16
#define W_POINTS        17
#define W_QUAL          18
#define W_UNGRAP        19
#define W_RIGG          20
#define W_COL           21
#define W_DIR           22
#define W_ROW           23
#define W_SIGNAL        24
#define W_SINK          25
#define W_STRUCK        26
#define W_TA            27
#define W_ALIVE         28
#define W_TURN          29
#define W_WIND          30
#define W_FS            31
#define W_GRAP          32
#define W_RIG1          33
#define W_RIG2          34
#define W_RIG3          35
#define W_RIG4          36
#define W_BEGIN         37
#define W_END           38
#define W_DDEAD         39


static void recv_captain(struct ship *ship, const char *astr);
static void recv_captured(struct ship *ship, long a);
static void recv_class(struct ship *ship, long a);
static void recv_crew(struct ship *ship, long a, long b, long c);
static void recv_dbp(struct ship *ship, long a, long b, long c, long d);
static void recv_drift(struct ship *ship, long a);
static void recv_explode(struct ship *ship, long a);
static void recv_foul(struct ship *ship, long a);
static void recv_gunl(struct ship *ship, long a, long b);
static void recv_gunr(struct ship *ship, long a, long b);
static void recv_hull(struct ship *ship, long a);
static void recv_move(struct ship *ship, const char *astr);
static void recv_obp(struct ship *ship, long a, long b, long c, long d);
static void recv_pcrew(struct ship *ship, long a);
static void recv_unfoul(struct ship *ship, long a, long b);
static void recv_points(struct ship *ship, long a);
static void recv_qual(struct ship *ship, long a);
static void recv_ungrap(struct ship *ship, long a, long b);
static void recv_rigg(struct ship *ship, long a, long b, long c, long d);
static void recv_col(struct ship *ship, long a);
static void recv_dir(struct ship *ship, long a);
static void recv_row(struct ship *ship, long a);
static void recv_signal(struct ship *ship, const char *astr);
static void recv_sink(struct ship *ship, long a);
static void recv_struck(struct ship *ship, long a);
static void recv_ta(struct ship *ship, long a);
static void recv_alive(void);
static void recv_turn(long a);
static void recv_wind(long a, long b);
static void recv_fs(struct ship *ship, long a);
static void recv_grap(struct ship *ship, long a);
static void recv_rig1(struct ship *ship, long a);
static void recv_rig2(struct ship *ship, long a);
static void recv_rig3(struct ship *ship, long a);
static void recv_rig4(struct ship *ship, long a);
static void recv_begin(struct ship *ship);
static void recv_end(struct ship *ship);
static void recv_ddead(void);

static void Write(int, struct ship *, long, long, long, long);
static void Writestr(int, struct ship *, const char *);

static int sync_update(int, struct ship *, const char *,
                      long, long, long, long);

static char sync_buf[BUFSIZE];
static char *sync_bp = sync_buf;
static long sync_seek;
static FILE *sync_fp;

static const char *
get_sync_file(int scenario_number)
{
       static char sync_file[NAME_MAX];

       snprintf(sync_file, sizeof(sync_file), _FILE_SYNC, scenario_number);
       return sync_file;
}

static const char *
get_lock_file(int scenario_number)
{
       static char sync_lock[NAME_MAX];

       snprintf(sync_lock, sizeof(sync_lock), _FILE_LOCK, scenario_number);
       return sync_lock;
}

void
fmtship(char *buf, size_t len, const char *fmt, struct ship *ship)
{
       while (*fmt) {
               if (len-- == 0) {
                       *buf = '\0';
                       return;
               }
               if (*fmt == '$' && fmt[1] == '$') {
                       size_t l = snprintf(buf, len, "%s (%c%c)",
                           ship->shipname, colours(ship), sterncolour(ship));
                       buf += l;
                       len -= l - 1;
                       fmt += 2;
               }
               else
                       *buf++ = *fmt++;
       }

       if (len > 0)
               *buf = '\0';
}


/*VARARGS3*/
void
makesignal(struct ship *from, const char *fmt, struct ship *ship, ...)
{
       char message[BUFSIZ];
       char format[BUFSIZ];
       va_list ap;

       va_start(ap, ship);
       fmtship(format, sizeof(format), fmt, ship);
       vsnprintf(message, sizeof(message), format, ap);
       va_end(ap);
       send_signal(from, message);
}

/*VARARGS2*/
void
makemsg(struct ship *from, const char *fmt, ...)
{
       char message[BUFSIZ];
       va_list ap;

       va_start(ap, fmt);
       vsnprintf(message, sizeof(message), fmt, ap);
       va_end(ap);
       send_signal(from, message);
}

int
sync_exists(int gamenum)
{
       const char *path;
       struct stat s;
       time_t t;

       path = get_sync_file(gamenum);
       time(&t);
       setegid(egid);
       if (stat(path, &s) < 0) {
               setegid(gid);
               return 0;
       }
       if (s.st_mtime < t - 60*60*2) {         /* 2 hours */
               unlink(path);
               path = get_lock_file(gamenum);
               unlink(path);
               setegid(gid);
               return 0;
       } else {
               setegid(gid);
               return 1;
       }
}

int
sync_open(void)
{
       const char *sync_file;
       struct stat tmp;

       if (sync_fp != NULL)
               fclose(sync_fp);
       sync_file = get_sync_file(game);
       (void)get_lock_file(game);
       setegid(egid);
       if (stat(sync_file, &tmp) < 0) {
               mode_t omask = umask(002);
               sync_fp = fopen(sync_file, "w+");
               umask(omask);
       } else
               sync_fp = fopen(sync_file, "r+");
       setegid(gid);
       if (sync_fp == NULL)
               return -1;
       sync_seek = 0;
       return 0;
}

void
sync_close(int doremove)
{
       const char *sync_file;

       if (sync_fp != 0)
               fclose(sync_fp);
       if (doremove) {
               sync_file = get_sync_file(game);
               setegid(egid);
               unlink(sync_file);
               setegid(gid);
       }
}

static void
Write(int type, struct ship *ship, long a, long b, long c, long d)
{
       size_t max = sizeof(sync_buf) - (sync_bp - sync_buf);
       int shipindex = (ship == NULL) ? 0 : ship->file->index;

       snprintf(sync_bp, max, "%d %d 0 %ld %ld %ld %ld\n",
                      type, shipindex, a, b, c, d);
       while (*sync_bp++)
               ;
       sync_bp--;
       if (sync_bp >= &sync_buf[sizeof sync_buf])
               abort();
       sync_update(type, ship, NULL, a, b, c, d);
}

static void
Writestr(int type, struct ship *ship, const char *a)
{
       size_t max = sizeof(sync_buf) - (sync_bp - sync_buf);
       int shipindex = (ship == NULL) ? 0 : ship->file->index;

       snprintf(sync_bp, max, "%d %d 1 %s\n", type, shipindex, a);
       while (*sync_bp++)
               ;
       sync_bp--;
       if (sync_bp >= &sync_buf[sizeof sync_buf])
               abort();
       sync_update(type, ship, a, 0, 0, 0, 0);
}

int
Sync(void)
{
       sig_t sighup, sigint;
       int n;
       int type, shipnum, isstr;
       char *astr;
       long a, b, c, d;
       char buf[80];
       char erred = 0;
#ifndef LOCK_EX
       const char *sync_file;
       const char *sync_lock;
#endif

       sighup = signal(SIGHUP, SIG_IGN);
       sigint = signal(SIGINT, SIG_IGN);
       for (n = TIMEOUT; --n >= 0;) {
#ifdef LOCK_EX
               if (flock(fileno(sync_fp), LOCK_EX|LOCK_NB) >= 0)
                       break;
               if (errno != EWOULDBLOCK)
                       return -1;
#else
               sync_file = get_sync_file(game);
               sync_lock = get_lock_file(game);
               setegid(egid);
               if (link(sync_file, sync_lock) >= 0) {
                       setegid(gid);
                       break;
               }
               setegid(gid);
               if (errno != EEXIST)
                       return -1;
#endif
               sleep(1);
       }
       if (n <= 0)
               return -1;
       fseek(sync_fp, sync_seek, SEEK_SET);
       for (;;) {
               switch (fscanf(sync_fp, "%d%d%d", &type, &shipnum, &isstr)) {
               case 3:
                       break;
               case EOF:
                       goto out;
               default:
                       goto bad;
               }
               if (shipnum < 0 || shipnum >= cc->vessels)
                       goto bad;
               if (isstr != 0 && isstr != 1)
                       goto bad;
               if (isstr) {
                       int ch;
                       char *p;

                       for (p = buf;;) {
                               ch = getc(sync_fp);
                               *p++ = ch;
                               switch (ch) {
                               case '\n':
                                       p--;
                               case EOF:
                                       break;
                               default:
                                       if (p >= buf + sizeof buf)
                                               p--;
                                       continue;
                               }
                               break;
                       }
                       *p = 0;
                       for (p = buf; *p == ' '; p++)
                               ;
                       astr = p;
                       a = b = c = d = 0;
               } else {
                       if (fscanf(sync_fp, "%ld%ld%ld%ld", &a, &b, &c, &d)
                           != 4)
                               goto bad;
                       astr = NULL;
               }
               if (sync_update(type, SHIP(shipnum), astr, a, b, c, d) < 0)
                       goto bad;
       }
bad:
       erred++;
out:
       if (!erred && sync_bp != sync_buf) {
               fseek(sync_fp, 0L, SEEK_END);
               fwrite(sync_buf, sizeof *sync_buf, sync_bp - sync_buf,
                       sync_fp);
               fflush(sync_fp);
               sync_bp = sync_buf;
       }
       sync_seek = ftell(sync_fp);
#ifdef LOCK_EX
       flock(fileno(sync_fp), LOCK_UN);
#else
       setegid(egid);
       unlink(sync_lock);
       setegid(gid);
#endif
       signal(SIGHUP, sighup);
       signal(SIGINT, sigint);
       return erred ? -1 : 0;
}

static int
sync_update(int type, struct ship *ship, const char *astr,
           long a, long b, long c, long d)
{
       switch (type) {
       case W_CAPTAIN:  recv_captain(ship, astr);    break;
       case W_CAPTURED: recv_captured(ship, a);      break;
       case W_CLASS:    recv_class(ship, a);         break;
       case W_CREW:     recv_crew(ship, a, b, c);    break;
       case W_DBP:      recv_dbp(ship, a, b, c, d);  break;
       case W_DRIFT:    recv_drift(ship, a);         break;
       case W_EXPLODE:  recv_explode(ship, a);       break;
       case W_FOUL:     recv_foul(ship, a);          break;
       case W_GUNL:     recv_gunl(ship, a, b);       break;
       case W_GUNR:     recv_gunr(ship, a, b);       break;
       case W_HULL:     recv_hull(ship, a);          break;
       case W_MOVE:     recv_move(ship, astr);       break;
       case W_OBP:      recv_obp(ship, a, b, c, d);  break;
       case W_PCREW:    recv_pcrew(ship, a);         break;
       case W_UNFOUL:   recv_unfoul(ship, a, b);     break;
       case W_POINTS:   recv_points(ship, a);        break;
       case W_QUAL:     recv_qual(ship, a);          break;
       case W_UNGRAP:   recv_ungrap(ship, a, b);     break;
       case W_RIGG:     recv_rigg(ship, a, b, c, d); break;
       case W_COL:      recv_col(ship, a);           break;
       case W_DIR:      recv_dir(ship, a);           break;
       case W_ROW:      recv_row(ship, a);           break;
       case W_SIGNAL:   recv_signal(ship, astr);     break;
       case W_SINK:     recv_sink(ship, a);          break;
       case W_STRUCK:   recv_struck(ship, a);        break;
       case W_TA:       recv_ta(ship, a);            break;
       case W_ALIVE:    recv_alive();                break;
       case W_TURN:     recv_turn(a);                break;
       case W_WIND:     recv_wind(a, b);             break;
       case W_FS:       recv_fs(ship, a);            break;
       case W_GRAP:     recv_grap(ship, a);          break;
       case W_RIG1:     recv_rig1(ship, a);          break;
       case W_RIG2:     recv_rig2(ship, a);          break;
       case W_RIG3:     recv_rig3(ship, a);          break;
       case W_RIG4:     recv_rig4(ship, a);          break;
       case W_BEGIN:    recv_begin(ship);            break;
       case W_END:      recv_end(ship);              break;
       case W_DDEAD:    recv_ddead();                break;
       default:
               fprintf(stderr, "sync_update: unknown type %d\r\n", type);
               return -1;
       }
       return 0;
}

/*
* Messages to send
*/

void
send_captain(struct ship *ship, const char *astr)
{
       Writestr(W_CAPTAIN, ship, astr);
}

void
send_captured(struct ship *ship, long a)
{
       Write(W_CAPTURED, ship, a, 0, 0, 0);
}

void
send_class(struct ship *ship, long a)
{
       Write(W_CLASS, ship, a, 0, 0, 0);
}

void
send_crew(struct ship *ship, long a, long b, long c)
{
       Write(W_CREW, ship, a, b, c, 0);
}

void
send_dbp(struct ship *ship, long a, long b, long c, long d)
{
       Write(W_DBP, ship, a, b, c, d);
}

void
send_drift(struct ship *ship, long a)
{
       Write(W_DRIFT, ship, a, 0, 0, 0);
}

void
send_explode(struct ship *ship, long a)
{
       Write(W_EXPLODE, ship, a, 0, 0, 0);
}

void
send_foul(struct ship *ship, long a)
{
       Write(W_FOUL, ship, a, 0, 0, 0);
}

void
send_gunl(struct ship *ship, long a, long b)
{
       Write(W_GUNL, ship, a, b, 0, 0);
}

void
send_gunr(struct ship *ship, long a, long b)
{
       Write(W_GUNR, ship, a, b, 0, 0);
}

void
send_hull(struct ship *ship, long a)
{
       Write(W_HULL, ship, a, 0, 0, 0);
}

void
send_move(struct ship *ship, const char *astr)
{
       Writestr(W_MOVE, ship, astr);
}

void
send_obp(struct ship *ship, long a, long b, long c, long d)
{
       Write(W_OBP, ship, a, b, c, d);
}

void
send_pcrew(struct ship *ship, long a)
{
       Write(W_PCREW, ship, a, 0, 0, 0);
}

void
send_unfoul(struct ship *ship, long a, long b)
{
       Write(W_UNFOUL, ship, a, b, 0, 0);
}

void
send_points(struct ship *ship, long a)
{
       Write(W_POINTS, ship, a, 0, 0, 0);
}

void
send_qual(struct ship *ship, long a)
{
       Write(W_QUAL, ship, a, 0, 0, 0);
}

void
send_ungrap(struct ship *ship, long a, long b)
{
       Write(W_UNGRAP, ship, a, b, 0, 0);
}

void
send_rigg(struct ship *ship, long a, long b, long c, long d)
{
       Write(W_RIGG, ship, a, b, c, d);
}

void
send_col(struct ship *ship, long a)
{
       Write(W_COL, ship, a, 0, 0, 0);
}

void
send_dir(struct ship *ship, long a)
{
       Write(W_DIR, ship, a, 0, 0, 0);
}

void
send_row(struct ship *ship, long a)
{
       Write(W_ROW, ship, a, 0, 0, 0);
}

void
send_signal(struct ship *ship, const char *astr)
{
       Writestr(W_SIGNAL, ship, astr);
}

void
send_sink(struct ship *ship, long a)
{
       Write(W_SINK, ship, a, 0, 0, 0);
}

void
send_struck(struct ship *ship, long a)
{
       Write(W_STRUCK, ship, a, 0, 0, 0);
}

void
send_ta(struct ship *ship, long a)
{
       Write(W_TA, ship, a, 0, 0, 0);
}

void
send_alive(void)
{
       Write(W_ALIVE, NULL, 0, 0, 0, 0);
}

void
send_turn(long a)
{
       Write(W_TURN, NULL, a, 0, 0, 0);
}

void
send_wind(long a, long b)
{
       Write(W_WIND, NULL, a, b, 0, 0);
}

void
send_fs(struct ship *ship, long a)
{
       Write(W_FS, ship, a, 0, 0, 0);
}

void
send_grap(struct ship *ship, long a)
{
       Write(W_GRAP, ship, a, 0, 0, 0);
}

void
send_rig1(struct ship *ship, long a)
{
       Write(W_RIG1, ship, a, 0, 0, 0);
}

void
send_rig2(struct ship *ship, long a)
{
       Write(W_RIG2, ship, a, 0, 0, 0);
}

void
send_rig3(struct ship *ship, long a)
{
       Write(W_RIG3, ship, a, 0, 0, 0);
}

void
send_rig4(struct ship *ship, long a)
{
       Write(W_RIG4, ship, a, 0, 0, 0);
}

void
send_begin(struct ship *ship)
{
       Write(W_BEGIN, ship, 0, 0, 0, 0);
}

void
send_end(struct ship *ship)
{
       Write(W_END, ship, 0, 0, 0, 0);
}

void
send_ddead(void)
{
       Write(W_DDEAD, NULL, 0, 0, 0, 0);
}


/*
* Actions upon message receipt
*/

static void
recv_captain(struct ship *ship, const char *astr)
{
       strlcpy(ship->file->captain, astr, sizeof ship->file->captain);
}

static void
recv_captured(struct ship *ship, long a)
{
       if (a < 0)
               ship->file->captured = 0;
       else
               ship->file->captured = SHIP(a);
}

static void
recv_class(struct ship *ship, long a)
{
       ship->specs->class = a;
}

static void
recv_crew(struct ship *ship, long a, long b, long c)
{
       struct shipspecs *s = ship->specs;

       s->crew1 = a;
       s->crew2 = b;
       s->crew3 = c;
}

static void
recv_dbp(struct ship *ship, long a, long b, long c, long d)
{
       struct BP *p = &ship->file->DBP[a];

       p->turnsent = b;
       p->toship = SHIP(c);
       p->mensent = d;
}

static void
recv_drift(struct ship *ship, long a)
{
       ship->file->drift = a;
}

static void
recv_explode(struct ship *ship, long a)
{
       if ((ship->file->explode = a) == 2)
               ship->file->dir = 0;
}

static void
recv_foul(struct ship *ship, long a)
{
       struct snag *p = &ship->file->foul[a];

       if (SHIP(a)->file->dir == 0)
               return;
       if (p->sn_count++ == 0)
               p->sn_turn = turn;
       ship->file->nfoul++;
}

static void
recv_gunl(struct ship *ship, long a, long b)
{
       struct shipspecs *s = ship->specs;

       s->gunL = a;
       s->carL = b;
}

static void
recv_gunr(struct ship *ship, long a, long b)
{
       struct shipspecs *s = ship->specs;

       s->gunR = a;
       s->carR = b;
}

static void
recv_hull(struct ship *ship, long a)
{
       ship->specs->hull = a;
}

static void
recv_move(struct ship *ship, const char *astr)
{
       strlcpy(ship->file->movebuf, astr, sizeof ship->file->movebuf);
}

static void
recv_obp(struct ship *ship, long a, long b, long c, long d)
{
       struct BP *p = &ship->file->OBP[a];

       p->turnsent = b;
       p->toship = SHIP(c);
       p->mensent = d;
}

static void
recv_pcrew(struct ship *ship, long a)
{
       ship->file->pcrew = a;
}

static void
recv_unfoul(struct ship *ship, long a, long b)
{
       struct snag *p = &ship->file->foul[a];

       if (p->sn_count > 0) {
               if (b) {
                       ship->file->nfoul -= p->sn_count;
                       p->sn_count = 0;
               } else {
                       ship->file->nfoul--;
                       p->sn_count--;
               }
       }
}

static void
recv_points(struct ship *ship, long a)
{
       ship->file->points = a;
}

static void
recv_qual(struct ship *ship, long a)
{
       ship->specs->qual = a;
}

static void
recv_ungrap(struct ship *ship, long a, long b)
{
       struct snag *p = &ship->file->grap[a];

       if (p->sn_count > 0) {
               if (b) {
                       ship->file->ngrap -= p->sn_count;
                       p->sn_count = 0;
               } else {
                       ship->file->ngrap--;
                       p->sn_count--;
               }
       }
}

static void
recv_rigg(struct ship *ship, long a, long b, long c, long d)
{
       struct shipspecs *s = ship->specs;

       s->rig1 = a;
       s->rig2 = b;
       s->rig3 = c;
       s->rig4 = d;
}

static void
recv_col(struct ship *ship, long a)
{
       ship->file->col = a;
}

static void
recv_dir(struct ship *ship, long a)
{
       ship->file->dir = a;
}

static void
recv_row(struct ship *ship, long a)
{
       ship->file->row = a;
}

static void
recv_signal(struct ship *ship, const char *astr)
{
       if (mode == MODE_PLAYER) {
               if (nobells)
                       Signal("$$: %s", ship, astr);
               else
                       Signal("\a$$: %s", ship, astr);
       }
}

static void
recv_sink(struct ship *ship, long a)
{
       if ((ship->file->sink = a) == 2)
               ship->file->dir = 0;
}

static void
recv_struck(struct ship *ship, long a)
{
       ship->file->struck = a;
}

static void
recv_ta(struct ship *ship, long a)
{
       ship->specs->ta = a;
}

static void
recv_alive(void)
{
       alive = 1;
}

static void
recv_turn(long a)
{
       turn = a;
}

static void
recv_wind(long a, long b)
{
       winddir = a;
       windspeed = b;
}

static void
recv_fs(struct ship *ship, long a)
{
       ship->file->FS = a;
}

static void
recv_grap(struct ship *ship, long a)
{
       struct snag *p = &ship->file->grap[a];

       if (SHIP(a)->file->dir == 0)
               return;
       if (p->sn_count++ == 0)
               p->sn_turn = turn;
       ship->file->ngrap++;
}

static void
recv_rig1(struct ship *ship, long a)
{
       ship->specs->rig1 = a;
}

static void
recv_rig2(struct ship *ship, long a)
{
       ship->specs->rig2 = a;
}

static void
recv_rig3(struct ship *ship, long a)
{
       ship->specs->rig3 = a;
}

static void
recv_rig4(struct ship *ship, long a)
{
       ship->specs->rig4 = a;
}

static void
recv_begin(struct ship *ship)
{
       strcpy(ship->file->captain, "begin");
       people++;
}

static void
recv_end(struct ship *ship)
{
       *ship->file->captain = 0;
       ship->file->points = 0;
       people--;
}

static void
recv_ddead(void)
{
       hasdriver = 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.