scorefile.c

/*
 * Rog-O-Matic
 * Automatically exploring the dungeons of doom.
 *
 * Copyright (C) 2008 by Anthony Molinaro
 * Copyright (C) 1985 by Appel, Jacobson, Hamey, and Mauldin.
 *
 * This file is part of Rog-O-Matic.
 *
 * Rog-O-Matic is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Rog-O-Matic is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Rog-O-Matic.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * scorefile.c:
 *
 * This file contains the functions which update the rogomatic scorefile,
 * which lives in <RGMDIR>/rgmscore<versionstr>. LOCKFILE is used to
 * prevent simultaneous accesses to the file. rgmdelta<versionstr>
 * contains new scores, and whenever the score file is printed the delta
 * file is sorted and merged into the rgmscore file.
 */

# include <stdio.h>
# include <stdlib.h>
# include <unistd.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <signal.h>
# include <string.h>
# include <errno.h>

# include "types.h"
# include "config.h"
# include "globals.h"
# include "install.h"

# define LINESIZE	2048
# define SCORE(s,p)     (atoi (s+p))

/* static declarations */

static void intrupscore (int sig __attribute__ ((__unused__)));

/*
 * add_score: Write a new score line out to the correct rogomatic score
 * file by creating a temporary copy and inserting the new line in the
 * proper place. Be tense about preventing simultaneous access to the
 * score file and catching interrupts and things.
 */

void
add_score (char *new_line, char *vers, int ntrm)
{
  char *newfil = NULL;	    /* rogomatic delta filename */
  FILE *newlog;
  int lock_fd;

  /* form paths */
  newfil = form_prefix_path ( rgmdir, "rgmdelta", vers);

  /* Defer interrupts while mucking with the score file */
  critical ();

  /* lock */
  lock_fd = lock_file (__func__, NULL, lock_path);

  /* Now create a temporary to copy into */
  if ((newlog = wopen (newfil, "a")) == NULL) {
    quit (1, "ERROR: %s: file: %s line: %d dungeon: %u Unable to write: %s: %s\n",
	     __func__, __FILE__, __LINE__, dnum, newfil, strerror (errno));
    not_reached ();
  } else {
    fprintf (newlog, "%s\n", new_line);
    fflush (newlog);
    fclose (newlog);
  }

  /* unlock */
  unlock_file (__func__, lock_fd);
  if (newfil != NULL) {
      free (newfil);
      newfil = NULL;
  }

  /* free path */
  if (newfil != NULL) {
      free (newfil);
      newfil = NULL;
  }

  uncritical ();
}

/*
 * dumpscore: Print out the scoreboard.
 */

void
dumpscore (char *vers)
{
  char  *scrfil = NULL;	    /* rogomatic score file path */
  char  *delfil = NULL;	    /* rogomatic delta file path */
  char  *newfil = NULL;	    /* rogomatic new file path */
  char  *allfil = NULL;	    /* rogomatic all scores file path */
  char  cmd[BIGBUF + 1];    /* shell command buffer, +1 for paranoia */
  FILE *scoref;		    /* score file stream */
  FILE *deltaf;		    /* delta file stream */
  int   oldmask;	    /* original umask */
  int   lock_fd;	    /* lock file descriptor */
  int   code = 0;	    /* command exit code */
  char  ch;

  /* zeroize arrays */
  memset (cmd, 0, sizeof(cmd)); /* paranoia */

  /* form paths */
  scrfil = form_prefix_path (rgmdir, "rgmscore", vers);
  delfil = form_prefix_path (rgmdir, "rgmdelta", vers);
  newfil = form_prefix_path (rgmdir, "NewScore", vers);
  allfil = form_prefix_path (rgmdir, "AllScore", vers);

  /* On interrupts we must relinquish control of the score file */
  int_exit (intrupscore);

  /* lock */
  lock_fd = lock_file (__func__, NULL, lock_path);

  deltaf = fopen (delfil, "r");
  if (deltaf == NULL) {
    quit (1, "ERROR: %s: file: %s line: %d dungeon: %u failed to open rogomatic delta file: %s error: %s\n",
	     __func__, __FILE__, __LINE__, dnum, delfil, strerror (errno));
    not_reached ();
  }
  scoref = fopen (scrfil, "r");
  if (scoref == NULL) {
    quit (1, "ERROR: %s: file: %s line: %d dungeon: %u failed to open rogomatic score file: %s error: %s\n",
	     __func__, __FILE__, __LINE__, dnum, scrfil, strerror (errno));
    not_reached ();
  }

  /* If there are new scores, sort and merge them into the score file */
  if (deltaf != NULL) {

    fclose (deltaf);

    /* Defer interrupts while mucking with the score file */
    critical ();

    /* Make certain any new files are world writable */
    oldmask = umask (0);

    /* If we have an old file and a delta file, merge them */
    if (scoref != NULL) {

      /* first sort command and args */
      char *args_0[] = {
	"sort", "+4nr", "-o", newfil, delfil, NULL
      };

      /* second sort command and args */
      char *args_1[] = {
	"sort", "+4nr", "-o", allfil, newfil, scrfil, NULL
      };


      /* close out the score file */
      fclose (scoref);

      /*
       * sort delta score file into a new rogomatic score file
       */
      code = fork_exec ("sort", args_0);
      if (code != 0) {
	quit (1, "ERROR: %s: file: %s line: %d dungeon: %u sort +4nr -o %s %s failed, exit code: %d\n",
		 __func__, __FILE__, __LINE__, dnum, newfil, delfil, code);
	not_reached ();
      }

      /*
       * sort merge the new rogomatic score file, and existing rogomatic score file into rogomatic all score file
       */
      code = fork_exec ("sort", args_1);
      if (code != 0) {
	quit (1, "ERROR: %s: file: %s line: %d dungeon: %u sort +4nr -o %s %s %s failed, exit code: %d\n",
		 __func__, __FILE__, __LINE__, dnum, allfil, newfil, scrfil, code);
	not_reached ();
      }

      if (filelength (allfil) != filelength (delfil) + filelength (scrfil)) {
	/* unlink */
	unlink (newfil);
	unlink (allfil);

	/* unlock */
	unlock_file (__func__, lock_fd);
	quit (1, "ERROR: %s: file: %s line: %d dungeon: %u new file is wrong length!\n",
		 __func__, __FILE__, __LINE__, dnum);
	not_reached ();
      }
      else {
        /* New file is okay, unlink old files and pointer swap score file */
        unlink (delfil);
	unlink (newfil);
        unlink (scrfil);
	link (allfil, scrfil);
	unlink (allfil);
      }

      scoref = fopen (scrfil, "r");
    }
    else
      /* Only have delta file, sort into scorefile and unlink delta */
    {

      /* first sort command and args */
      char *args[] = {
	"sort", "+4nr", "-o", scrfil, delfil, NULL
      };

      /*
       * sort delta score file into a rogomatic score file
       */
      code = fork_exec ("sort", args);
      if (code != 0) {
	quit (1, "ERROR: %s: file: %s line: %d dungeon: %u sort +4nr -o %s %s failed, exit code: %d\n",
		 __func__, __FILE__, __LINE__, dnum, scrfil, delfil, code);
	not_reached ();
      }

      unlink (delfil);
      scoref = fopen (scrfil, "r");
    }

    /* Restore umask */
    umask (oldmask);

    /* Restore interrupt status after score file stable */
    uncritical ();
  }

  /* Now any new scores have been put into scrfil, read it */
  if (scoref == NULL) {

    /* unlock */
    unlock_file (__func__, lock_fd);
    quit (1, "ERROR: %s: file: %s line: %d dungeon: %u Can't find: %s\n",
	      __func__, __FILE__, __LINE__, dnum, scrfil);
    not_reached ();
  }

  printf ("Rog-O-Matic Scores against version %s:\n\n", vers);
  printf ("%s%s", "Date        Time     User           Gold Killed by",
	  "         Lvl  Hp  Str  Ac  Exp        Game Dungeon\n");

  while ((int) (ch = fgetc (scoref)) != EOF)
    putchar (ch);

  fclose (scoref);

  /* unlock */
  unlock_file (__func__, lock_fd);

  /* free paths */
  if (scrfil != NULL) {
      free (scrfil);
      scrfil = NULL;
  }
  if (delfil != NULL) {
      free (delfil);
      scrfil = NULL;
  }
  if (newfil != NULL) {
      free (newfil);
      scrfil = NULL;
  }
  if (allfil != NULL) {
      free (allfil);
      scrfil = NULL;
  }

  exit (0);
}

/*
 * intrupscore: We have an interrupt, clean up and unlock the score file.
 */

static void
intrupscore (int sig __attribute__ ((__unused__)))
{
  exit (1);
}