1: /*      $NetBSD: dumpgame.c,v 1.9 2004/01/27 20:30:31 jsm Exp $      */
    2: 
    3: /*
    4:  * Copyright (c) 1980, 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. Neither the name of the University nor the names of its contributors
   16:  *    may be used to endorse or promote products derived from this software
   17:  *    without specific prior written permission.
   18:  *
   19:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29:  * SUCH DAMAGE.
   30:  */
   31: 
   32: #include <sys/cdefs.h>
   33: #ifndef lint
   34: #if 0
   35: static char sccsid[] = "@(#)dumpgame.c  8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: dumpgame.c,v 1.9 2004/01/27 20:30:31 jsm Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <stdio.h>
   42: #include <err.h>
   43: #include <unistd.h>
   44: #include <fcntl.h>
   45: #include "trek.h"
   46: 
   47: /***  THIS CONSTANT MUST CHANGE AS THE DATA SPACES CHANGE ***/
   48: # define        VERSION                2
   49: 
   50: struct dump
   51: {
   52:         char   *area;
   53:         int    count;
   54: };
   55: 
   56: static int readdump(int);
   57: 
   58: 
   59: struct dump     Dump_template[] =
   60: {
   61:         { (char *)&Ship,       sizeof (Ship) },
   62:         { (char *)&Now,                sizeof (Now) },
   63:         { (char *)&Param,      sizeof (Param) },
   64:         { (char *)&Etc,                sizeof (Etc) },
   65:         { (char *)&Game,       sizeof (Game) },
   66:         { (char *)Sect,                sizeof (Sect) },
   67:         { (char *)Quad,                sizeof (Quad) },
   68:         { (char *)&Move,       sizeof (Move) },
   69:         { (char *)Event,       sizeof (Event) },
   70:         { NULL,                        0 }
   71: };
   72: 
   73: /*
   74: **  DUMP GAME
   75: **
   76: **      This routine dumps the game onto the file "trek.dump".  The
   77: **      first two bytes of the file are a version number, which
   78: **      reflects whether this image may be used.  Obviously, it must
   79: **      change as the size, content, or order of the data structures
   80: **      output change.
   81: */
   82: 
   83: /*ARGSUSED*/
   84: void
   85: dumpgame(v)
   86:         int v __attribute__((__unused__));
   87: {
   88:         int            version;
   89:         int            fd;
   90:         struct dump    *d;
   91:         int            i;
   92: 
   93:         if ((fd = creat("trek.dump", 0644)) < 0) {
   94:                 warn("cannot open `trek.dump'");
   95:                 return;
   96:         }
   97:         version = VERSION;
   98:         write(fd, &version, sizeof version);
   99: 
  100:         /* output the main data areas */
  101:         for (d = Dump_template; d->area; d++)
  102:         {
  103:                 write(fd, &d->area, sizeof d->area);
  104:                 i = d->count;
  105:                 write(fd, d->area, i);
  106:         }
  107: 
  108:         close(fd);
  109: }
  110: 
  111: 
  112: /*
  113: **  RESTORE GAME
  114: **
  115: **      The game is restored from the file "trek.dump".  In order for
  116: **      this to succeed, the file must exist and be readable, must
  117: **      have the correct version number, and must have all the appro-
  118: **      priate data areas.
  119: **
  120: **      Return value is zero for success, one for failure.
  121: */
  122: 
  123: int
  124: restartgame()
  125: {
  126:         int    fd;
  127:         int            version;
  128: 
  129:         if ((fd = open("trek.dump", O_RDONLY)) < 0 ||
  130:             read(fd, &version, sizeof version) != sizeof version ||
  131:             version != VERSION ||
  132:             readdump(fd))
  133:         {
  134:                 printf("cannot restart\n");
  135:                 close(fd);
  136:                 return (1);
  137:         }
  138: 
  139:         close(fd);
  140:         return (0);
  141: }
  142: 
  143: 
  144: /*
  145: **  READ DUMP
  146: **
  147: **      This is the business end of restartgame().  It reads in the
  148: **      areas.
  149: **
  150: **      Returns zero for success, one for failure.
  151: */
  152: 
  153: static int
  154: readdump(fd1)
  155: int     fd1;
  156: {
  157:         int            fd;
  158:         struct dump    *d;
  159:         int            i;
  160:         long                   junk;
  161: 
  162:         fd = fd1;
  163: 
  164:         for (d = Dump_template; d->area; d++)
  165:         {
  166:                 if (read(fd, &junk, sizeof junk) != (sizeof junk))
  167:                         return (1);
  168:                 if ((char *)junk != d->area)
  169:                         return (1);
  170:                 i = d->count;
  171:                 if (read(fd, d->area, i) != i)
  172:                         return (1);
  173:         }
  174: 
  175:         /* make quite certain we are at EOF */
  176:         return (read(fd, &junk, 1));
  177: }