Expunge revision histories in files.

[sw-tools] / src / sw_info.c

/* -*-c-*-
 *
 * $Id: sw_info.c,v 1.6 2004/04/08 01:52:19 mdw Exp $
 *
 * Maintenance of `.sw-info' files
 *
 * (c) 1999 EBI
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of sw-tools.
 *
 * sw-tools 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 2 of the License, or
 * (at your option) any later version.
 * 
 * sw-tools 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 sw-tools; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <sys/types.h>
#include <sys/wait.h>
#include <pwd.h>
#include <unistd.h>

#ifndef DECL_ENVIRON
  extern char **environ;
#endif

#include <mLib/alloc.h>
#include <mLib/dstr.h>
#include <mLib/lock.h>
#include <mLib/quis.h>
#include <mLib/report.h>

#include "sw_arch.h"
#include "sw_env.h"
#include "sw_info.h"

/*----- Static variables --------------------------------------------------*/

static struct swfield {
  char *name;
  size_t off;
  char *desc;
} swfields[] = {
  { "package", offsetof(swinfo, package), "Package" },
  { "version", offsetof(swinfo, version), "Version" },
  { "maintainer", offsetof(swinfo, maintainer), "Maintained by" },
  { "date", offsetof(swinfo, date), "Last modified" },
  { "only-arch", offsetof(swinfo, only_arch), "Only build for" },
  { "arch", offsetof(swinfo, arch), "Successfully built" },
  { 0, 0 }
};
typedef struct swfield swfield;

#define SWINFO(sw, off) (*(char **)((char *)sw + off))

/*----- Main code ---------------------------------------------------------*/

/* --- @swinfo_clear@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointe to info block
 *
 * Returns:	---
 *
 * Use:		Clears an info block so that it doesn't contain anything.
 *		This is mainly useful when building skeletons to apply using
 *		@swinfo_update@.
 */

void swinfo_clear(swinfo *sw)
{
  swfield *f;
  for (f = swfields; f->name; f++)
    SWINFO(sw, f->off) = 0;
} 

/* --- @swinfo_fetch@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointer to info block to fill in
 *
 * Returns:	Zero if OK, else nonzero.
 *
 * Use:		Fills in the info block if it can.
 */

int swinfo_fetch(swinfo *sw)
{
  FILE *fp;
  dstr d = DSTR_INIT;
  swfield *f;
  int line = 0;

  /* --- Initialize the various fields --- */

  swinfo_clear(sw);

  /* --- Open the data file --- */

  if ((fp = fopen(".sw-info", "r")) == 0)
    return (-1);

  /* --- Read the lines from the file --- */

  for (; dstr_putline(&d, fp) != EOF; DRESET(&d)) {
    char *p = d.buf;
    char *key, *value;
    line++;

    /* --- Find the field name --- */

    while (isspace((unsigned char)*p))
      p++;
    if (*p == 0 || *p == '#')
      continue;

    /* --- Find the end of the field name --- */

    key = p;
    while (*p && *p != '=' && !isspace((unsigned char)*p))
      p++;
    
    /* --- Skip an optional `=' sign --- */

    {
      char ch = *p;
      if (ch)
	*p++ = 0;
      while (isspace((unsigned char)*p))
	p++;
      if (*p == '=' && ch != '=') {
	p++;
	while (isspace((unsigned char)*p))
	  p++;
      }	
    }

    value = p;
    
    /* --- Look up the key in the table --- */

    for (f = swfields; f->name; f++) {
      if (strcmp(key, f->name) == 0)
	goto found;
    }
    moan("unknown key `%s' at line %i in `.sw-info'", key, line);
    continue;

    /* --- Put the value in --- */

  found:
    SWINFO(sw, f->off) = xstrdup(value);
  }

  fclose(fp);
  dstr_destroy(&d);
  return (0);
}

/* --- @swinfo_sanity@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointer to an info block
 *
 * Returns:	Yes, if the block is OK.
 *
 * Use:		Objects if the information in the info block is bad.
 */

void swinfo_sanity(swinfo *sw)
{
  if (!sw->package)
    die(1, "unknown package name.  Try `%s setup PACKAGE VERSION'.", QUIS);
  if (!sw->version)
    die(1, "unknown package version.  Try `%s setup PACKAGE VERSION'.",
	QUIS);
  if (!sw->maintainer)
    die(1, "unknown maintainer.  Try `%s setup PACKAGE VERSION'.", QUIS);
  if (!sw->date)
    die(1, "unknown date.  Try `%s setup PACKAGE VERSION'.", QUIS);
}

/* --- @swinfo_put@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointer to an info block
 *
 * Returns:	Zero if it worked, nonzero if not.
 *
 * Use:		Writes an info block to the appropriate file.
 */

int swinfo_put(swinfo *sw)
{
  FILE *fp;
  swfield *f;
  int e;

  /* --- Quick sanity check --- */

  swinfo_sanity(sw);

  /* --- Write the new data out --- */

  if ((fp = fopen(".sw-info.new", "w")) == 0)
    return (-1);
  for (f = swfields; f->name; f++) {
    if (!SWINFO(sw, f->off))
      continue;
    if (fprintf(fp, "%s = %s\n", f->name, SWINFO(sw, f->off)) == EOF) {
      e = errno;
      fclose(fp);
      goto tidy_0;
    }
  }
  if (fclose(fp) == EOF) {
    e = errno;
    goto tidy_0;
  }

  /* --- Carefully! replace the old one --- *
   *
   * Keep an old one around just in case, unless the renames fail because
   * files don't exist.
   */

  remove(".sw-info.older");		/* Don't care if this fails */
  if (rename(".sw-info.old", ".sw-info.older") && errno != ENOENT)
    { e = errno; goto tidy_0; }
  if (rename(".sw-info", ".sw-info.old") && errno != ENOENT)
    { e = errno; goto tidy_1; }
  if (rename(".sw-info.new", ".sw-info"))
    { e = errno; goto tidy_2; }
  remove(".sw-info.older");		/* Don't care if this fails */
  return (0);

  /* --- Tidy up if anything went tits-up --- */

tidy_2:
  rename(".sw-info.old", ".sw-info");
tidy_1:
  rename(".sw-info.older", ".sw-info.old");
tidy_0:
  remove(".sw-info.new");
  errno = e;
  return (-1);
}

/* --- @swinfo_destroy@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointer to info block
 *
 * Returns:	---
 *
 * Use:		Destroys an info block when it's not useful any more.
 */

void swinfo_destroy(swinfo *sw)
{
  swfield *f;

  for (f = swfields; f->name; f++) {
    if (SWINFO(sw, f->off))
      free(SWINFO(sw, f->off));
  }
}

/* --- @swinfo_update@ --- *
 *
 * Arguments:	@swinfo *sw@ = pointer to info block
 *		@swinfo *skel@ = pointer to skeleton values
 *
 * Returns:	---
 *
 * Use:		Updates the fields in an information block, except for the
 *		architecture names stuff.  (I'll leave that for later,
 *		because it's rather more involved.
 */

void swinfo_update(swinfo *sw, swinfo *skel)
{
  char ubuf[20];
  char dbuf[20];
  swfield *f;

  /* --- Set up a default maintainer --- */

  if (!skel->maintainer && !sw->maintainer) {
    char *u = getenv("USER");

    if (!u)
      u = getenv("LOGNAME");
    if (!u) {
      struct passwd *pw = getpwuid(getuid());
      if (!pw) {
	moan("you don't seem to exist");
	sprintf(ubuf, "uid %i", (int)getuid());
	u = ubuf;
      } else
	u = pw->pw_name;
    }
    skel->maintainer = u;
  }

  /* --- Set up a default date --- */

  {
    time_t t = time(0);
    struct tm *tm = localtime(&t);
    strftime(dbuf, sizeof(dbuf), "%Y-%m-%d", tm);
    skel->date = dbuf;
  }

  /* --- Set a default architecture list --- */

  if (!skel->arch && !sw->arch)
    skel->arch = "";

  /* --- Grind through all the fields --- */

  for (f = swfields; f->name; f++) {
    if (!SWINFO(skel, f->off) || strcmp(SWINFO(skel, f->off), "-") == 0)
      continue;
    if (SWINFO(sw, f->off))
      free(SWINFO(sw, f->off));
    SWINFO(sw, f->off) = xstrdup(SWINFO(skel, f->off));
  }
}

/*----- Subcommands -------------------------------------------------------*/

/* --- @sw_setup@ --- */

int sw_setup(int argc, char *argv[])
{
  swinfo sw, skel;
  if (argc < 3 || argc > 4)
    die(1, "Usage: setup PACKAGE VERSION [MAINTAINER]");
  swinfo_fetch(&sw);
  swinfo_clear(&skel);
  skel.package = argv[1];
  skel.version = argv[2];
  if (argv[3])
    skel.maintainer = argv[3];
  swinfo_update(&sw, &skel);
  swinfo_put(&sw);
  return (0);
}

/* --- @sw_status@ --- */

int sw_status(int argc, char *argv[])
{
  swinfo sw;
  swfield *f;
  if (swinfo_fetch(&sw)) {
    die(1, "couldn't read build status: %s (try running setup)",
	strerror(errno));
  }
  for (f = swfields; f->name; f++) {
    if (SWINFO(&sw, f->off))
      printf("%s: %s\n", f->desc, SWINFO(&sw, f->off));
  }
  return (0);
}

/* --- @sw_commit@ --- */

int sw_commit(int argc, char *argv[])
{
  swinfo sw;

  if (argc != 1)
    die(1, "Usage: commit");
  if (swinfo_fetch(&sw)) {
    die(1, "couldn't read build status: %s (try running setup)",
	strerror(errno));
  }

  /* --- Make sure everything has been built properly --- */

  {
    archcons *a, *aa;
    archcons *all = arch_readtab();

    if (sw.arch) {
      for (a = aa = arch_filter(all, sw.arch, 0, 0); a; a = a->cdr)
	a->car->flags |= archFlag_built;
      arch_free(aa);
    }

    aa = arch_filter(all, sw.only_arch, archFlag_built, 0);
    if (aa) {
      const char *sep = "";
      fprintf(stderr, "%s: not built for ", QUIS);
      for (a = aa; a; a = a->cdr) {
	fprintf(stderr, "%s%s", sep, a->car->arch);
	sep = ", ";
      }
      fputc('\n', stderr);
      exit(1);
    }
    arch_free(aa);
  }

  /* --- Run the local precommit check script --- */

  {
    pid_t kid;
    struct sigaction sa, sa_int, sa_quit;
    int status;

    /* --- Make sure I can trap the child's death --- */

    sa.sa_handler = SIG_IGN;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if (sigaction(SIGINT, &sa, &sa_int) || sigaction(SIGQUIT, &sa, &sa_quit))
      die(1, "couldn't set signal dispositions: %s", strerror(errno));

    /* --- Spawn off a child process --- */

    fflush(0);
    kid = fork();
    if (kid < 0)
      die(1, "error from fork: %s", strerror(errno));
    if (kid == 0) {
      sym_table t;

      /* --- Re-enable signals --- */

      sigaction(SIGINT, &sa_int, 0);
      sigaction(SIGQUIT, &sa_quit, 0);

      /* --- Set up the environment --- */

      sym_create(&t);
      env_import(&t, environ);
      env_put(&t, "SW_PACKAGE", sw.package);
      env_put(&t, "SW_VERSION", sw.version);
      env_put(&t, "SW_MAINTAINER", sw.maintainer);
      env_put(&t, "SW_DATE", sw.date);
      env_put(&t, "SW_ARCHLIST", sw.arch);
      env_put(&t, "SW_PREFIX", PREFIX);
      environ = env_export(&t);

      /* --- Run the commit check script --- */

      execl(PREFIX "/share/sw-precommit", "sw-precommit",
	    sw.package, (char *)0);
      if (errno == ENOENT)
	_exit(0);
      die(1, "couldn't run " PREFIX "/share/sw-precommit: %s",
	  strerror(errno));
    }

    /* --- Wait for the child to finish --- */

    if (waitpid(kid, &status, 0) < 0)
      die(1, "error waiting for child: %s", strerror(errno));
    if (!(WIFEXITED(status) && WEXITSTATUS(status) == 0))
      die(1, "sw-precommit failed");
    sigaction(SIGINT, &sa_int, 0);
    sigaction(SIGQUIT, &sa_quit, 0);
  }

  /* --- Write to the index file --- */

  {
    FILE *fp = fopen(PREFIX "/sw-index", "a");
    swfield *f;
    const char *sep = "";

    if (!fp)
      die(1, "couldn't open index file: %s", strerror(errno));
    if (lock_file(fileno(fp), LOCK_EXCL))
      die(1, "couldn't obtain lock on index file: %s", strerror(errno));

    for (f = swfields; f->name; f++) {
      if (SWINFO(&sw, f->off)) {
	fprintf(fp, "%s%s = %s", sep, f->name, SWINFO(&sw, f->off));
	sep = "; ";
      }
    }
    fputc('\n', fp);
    fclose(fp);
  }

  return (0);
}

/*----- That's all, folks -------------------------------------------------*/