1: /*      $NetBSD: save.c,v 1.11 2003/08/07 09:37:26 agc 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. 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[] = "@(#)save.c      8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: save.c,v 1.11 2003/08/07 09:37:26 agc Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <time.h>
   42: 
   43: #include "mille.h"
   44: 
   45: #ifndef unctrl
   46: #include "unctrl.h"
   47: #endif
   48: 
   49: /*
   50:  * @(#)save.c   1.2 (Berkeley) 3/28/83
   51:  */
   52: 
   53: typedef struct stat     STAT;
   54: 
   55: /*
   56:  *      This routine saves the current game for use at a later date
   57:  *      Returns FALSE if it couldn't be done.
   58:  */
   59: bool
   60: save()
   61: {
   62:         char   *sp;
   63:         int    outf;
   64:         time_t *tp;
   65:         char   buf[80];
   66:         time_t tme;
   67:         STAT   junk;
   68:         bool   rv;
   69: 
   70:         sp = NULL;
   71:         tp = &tme;
   72:         if (Fromfile && getyn(SAMEFILEPROMPT))
   73:                 strcpy(buf, Fromfile);
   74:         else {
   75: over:
   76:                 prompt(FILEPROMPT);
   77:                 leaveok(Board, FALSE);
   78:                 refresh();
   79:                 sp = buf;
   80:                 while ((*sp = readch()) != '\n' && *sp != '\r') {
   81:                         if (*sp == killchar())
   82:                                 goto over;
   83:                         else if (*sp == erasechar()) {
   84:                                 if (--sp < buf)
   85:                                         sp = buf;
   86:                                 else {
   87:                                         addch('\b');
   88:                                         /*
   89:                                          * if the previous char was a control
   90:                                          * char, cover up two characters.
   91:                                          */
   92:                                         if (*sp < ' ')
   93:                                                 addch('\b');
   94:                                         clrtoeol();
   95:                                 }
   96:                         }
   97:                         else {
   98:                                 addstr(unctrl(*sp));
   99:                                 ++sp;
  100:                         }
  101:                         refresh();
  102:                 }
  103:                 *sp = '\0';
  104:                 leaveok(Board, TRUE);
  105:         }
  106: 
  107:         /*
  108:          * check for existing files, and confirm overwrite if needed
  109:          */
  110: 
  111:         if (sp == buf || (!Fromfile && stat(buf, &junk) > -1
  112:             && getyn(OVERWRITEFILEPROMPT) == FALSE))
  113:                 return FALSE;
  114: 
  115:         if ((outf = creat(buf, 0644)) < 0) {
  116:                 error(strerror(errno));
  117:                 return FALSE;
  118:         }
  119:         mvwaddstr(Score, ERR_Y, ERR_X, buf);
  120:         wrefresh(Score);
  121:         time(tp);                      /* get current time                */
  122:         rv = varpush(outf, writev);
  123:         close(outf);
  124:         if (rv == FALSE) {
  125:                 unlink(buf);
  126:         } else {
  127:                 strcpy(buf, ctime(tp));
  128:                 for (sp = buf; *sp != '\n'; sp++)
  129:                         continue;
  130:                 *sp = '\0';
  131:                 wprintw(Score, " [%s]", buf);
  132:         }
  133:         wclrtoeol(Score);
  134:         wrefresh(Score);
  135:         return rv;
  136: }
  137: 
  138: /*
  139:  *      This does the actual restoring.  It returns TRUE if the
  140:  * backup was made on exiting, in which case certain things must
  141:  * be cleaned up before the game starts.
  142:  */
  143: bool
  144: rest_f(file)
  145:         const char     *file;
  146: {
  147: 
  148:         char   *sp;
  149:         int    inf;
  150:         char   buf[80];
  151:         STAT   sbuf;
  152: 
  153:         if ((inf = open(file, O_RDONLY)) < 0) {
  154:                 warn("%s", file);
  155:                 exit(1);
  156:         }
  157:         if (fstat(inf, &sbuf) < 0) {           /* get file stats        */
  158:                 warn("%s", file);
  159:                 exit(1);
  160:         }
  161:         varpush(inf, readv);
  162:         close(inf);
  163:         strcpy(buf, ctime(&sbuf.st_mtime));
  164:         for (sp = buf; *sp != '\n'; sp++)
  165:                 continue;
  166:         *sp = '\0';
  167:         /*
  168:          * initialize some necessary values
  169:          */
  170:         (void)sprintf(Initstr, "%s [%s]\n", file, buf);
  171:         Fromfile = file;
  172:         return !On_exit;
  173: }