Build separately from mLib.

[sw-tools] / src / sw_links.c

/* -*-c-*-
 *
 * $Id: sw_links.c,v 1.1 1999/06/02 16:53:36 mdw Exp $
 *
 * Messing with symlink trees
 *
 * (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.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: sw_links.c,v $
 * Revision 1.1  1999/06/02 16:53:36  mdw
 * Initial revision
 *
 */

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

#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <utime.h>
#include <fcntl.h>

#include <mLib/alloc.h>
#include <mLib/dspool.h>
#include <mLib/dstr.h>
#include <mLib/report.h>
#include <mLib/sub.h>

#include "sw_arch.h"
#include "sw_build.h"
#include "sw_links.h"

/*----- Data structures ---------------------------------------------------*/

typedef struct fent {
  struct fent *next;
  dstr *name;
  dstr *link;
  struct stat st;
} fent;

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

static dstr down;
static dstr up;
static archcons *alist;
static archcons *all;
static dspool pool;

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

/* --- @canon@ --- *
 *
 * Arguments:	@dstr *d@ = path string to canonify
 *
 * Returns:	---
 *
 * Use:		Strips out all `dir/..' pairs in a path string.  Also removes
 *		any `.' and empty components.
 */

static void canon(dstr *d)
{
#define MAXBUF 16
  char *b[MAXBUF];
  int bp;
  int v, n;
  int retry;
  char *path;
  char *p, *q;
  int r;

  /* --- Initial stuff --- *
   *
   * If @path@ starts with `/' then initial `..' and `.' sequences can be
   * discarded immediately.  Remember this by remembering where the start of
   * the string is.
   */

  DPUTZ(d);
  p = q = path = d->buf;
  if (*p == '/') {
    p++; q++; path++;
    r = 1;
  } else
    r = 0;

  /* --- Now for the main job --- *
   *
   * Scan each path component.  If it's a normal name, store @q@ in my
   * circular buffer, and copy its text from @p@ to @q@.  If it's blank,
   * or `.' then skip @p@ past it.  If it's `..', and there's an entry in my
   * buffer, then reset @q@ back to that position and skip @p@ on past;
   * otherwise, copy it to @q@.
   *
   * Complications arise when the buffer gets full.  Old entries are
   * discarded off the bottom.  If it turns out they were useful (because
   * @n@ is zero, but @v@ isn't) then @retry@ is set and we go round again
   * when we're finished.
   */

again:
  bp = n = v = 0;
  retry = 0;

  while (*p) {

    /* --- Skip empty items --- */

    while (*p == '/')
      p++;

    /* --- Things with `.' in front of them --- */

    if (*p == '.') {
      if (p[1] == 0)
	break;
      else if (p[1] == '/') {
	p += 2;
	continue;
      } else if (p[1] == '.' && (p[2] == '/' || p[2] == 0)) {
	if (n) {
	  bp = bp ? bp - 1 : MAXBUF - 1;
	  q = b[bp];
	  n--; v--;
	  p += 2;
	  continue;
	} else {
	  if (v)
	    retry = 1;
	  else if (r) {
	    p += 2;
	    continue;
	  }
	  goto out;
	}
      }
    }
	  
    /* --- Normal things --- */

    b[bp++] = q;
    if (bp >= MAXBUF) bp = 0;
    v++;
    if (n < MAXBUF) n++;
  out:
    while (*p && *p != '/')
      *q++ = *p++;
    if (*p == '/')
      *q++ = *p++;
  }
  *q = 0;

  /* --- Tidying up --- */

  if (retry) {
    p = q = path;
    goto again;
  }
  if (q > path && q[-1] == '/')
    q[-1] = 0;
  d->len = q - d->buf;
}

/* --- @linktree@ --- *
 *
 * Arguments:	@int top@ = nonzero if this is toplevel
 *		@dstr *cont@ = continuation directory
 *
 * Returns:	Zero if things are working well, nonzero otherwise.
 *
 * Use:		Main recursive tree-linking algorithm.  This makes extensive
 *		use of the dynamic strings @up@ and @down@ as stacks to
 *		maintain state.
 *
 *		On entry, @down@ contains the name of the path to scan,
 *		relative to the common root; @up@ is the inverse path, from
 *		the directory @down@ back up to the root.  As a special
 *		wrinkle, @up@ has an additional `../' on the front.  The
 *		current directory is @down@.  On exit, the current directory
 *		is set to @cont@.
 *
 *		See the `description of the algorithm' below to really
 *		understand what's going on here.  It's not completely
 *		trivial.
 */

static int linktree(int top, dstr *cont)
{
  int rc = 0;
  fent *fs;
  dstr *dd;

  if (!alist)
    return (0);

  DSGET(&pool, dd);

  /* --- Description of the algorithm ---
   *
   * This is the sort of thing which is easy to do badly and hard to do
   * well.  The current algorithm seeks to minimize the amount of searching
   * that the operating system has to do around the filesystem, by changing
   * the current directory fairly often.  But it also tries to avoid using
   * too much memory, and never visits the same directory twice.
   *
   * I start off in the `common root'.  This is the directory that the user
   * actually wanted to make link trees of, and is the parent of all the link
   * trees.  The algorithm keeps track of where it's meant to be using two
   * (static) variables, @down@ and @up@.  The @down@ variable tracks the
   * current directory relative to the common root, and the @up@ variable
   * contains enough `../'s to get back to the common root from the current
   * directory, and one more (for getting back into the main tree from one of
   * the architecture link trees, which has an extra level of depth).  When a
   * recursion stage is entered, the current directory is already set
   * correctly.
   *
   * At any stage in the recursion, there is a `continuation' directory.
   * This is where my caller wants you to go when I've finished my job.  If I
   * have no subdirectories to cope with, then I just change into the
   * continuation when I've finished making all my links.  The trick with
   * continations really works with subdirectories.  I change into the first
   * subdirectory in my list myself, passing it a continuation for the next
   * subdirectory in sequence.  The last subdirectory gets given a modified
   * version of my own contination which keeps my caller happy without me
   * actually having to do anything.
   *
   * The actual work is done by a postorder traversal.  A directory is
   * processed in four phases, with an interlude between phases three and
   * four.
   *
   *   * Phase one scans the current directory, and stores the names of
   *	 everything in a list.  Uninteresting things like `.' and `..', and
   *	 the architecture trees at toplevel, are filtered out at this stage.
   *	 When this scan is complete, I no longer need a file descriptor open
   *	 on the directory, and I can close it.
   *
   *   * Phase two examines each item scanned in phase one, and determines
   *	 how to deal with it.  Directory objects turn into real hard
   *	 directories; symlinks turn into adjusted symlinks to the same
   *	 destination; and files turn into relative symlinks of the right
   *	 kind.
   *
   *   * Phase three moves into the corresponding link directory for each
   *	 architecture, and makes the links and directories decided upon in
   *	 phase two.  When phase three is complete, the current directory is
   *	 still the link directory for the last architecture.
   *
   *   * The interlude tidies up some internal structures a little, and
   *	 handles early exit.  Firstly, the list of objects is filtered, and
   *	 everything which isn't a directory is removed.  Secondly, if the
   *	 list is now empty, the algorithm does its `early exit': it works out
   *	 how to get to the continuation directory from where it is now, does
   *	 that, and then returns.
   *
   *   * Phase four does the recursion step.  There is at least one
   *	 subdirectory to deal with.  Change out of the link tree, and into
   *	 the first subdirectory of my main directory.  Now, for each
   *	 subdirectory, recursively build trees, setting @down@, @up@ and the
   *	 continuation according to the description above.
   *
   * That completes the algorithm.
   */

  {
    /* --- Phase one: directory scan --- */

    DIR *dp;
    struct dirent *d;
    fent **ff, *f;
    dstr *ds;

    /* --- Open a directory stream --- */

    if ((dp = opendir(".")) == 0) {
      moan("couldn't read directory `%s': %s", down.buf, strerror(errno));
      chdir(cont->buf);
      return (-1);
    }

    /* --- Read the entries out one by one --- */

    ff = &fs;
    while ((d = readdir(dp)) != 0) {

      /* --- Skip `.' and `..' directories --- */

      {
	char *p = d->d_name;
	if (p[0] == '.' && ((p[1] == '.' && p[2] == 0) || p[1] == 0))
	  goto skip;
      }

      /* --- If this is toplevel, skip over the symlink trees --- */

      if (top) {
	archcons *a;
	for (a = all; a; a = a->cdr) {
	  if (strcmp(d->d_name, a->car->arch) == 0)
	    goto skip;
	}
      }

      /* --- Make a little structure with the entries in --- */

      DSGET(&pool, ds);
      DPUTS(ds, d->d_name);
      f = CREATE(fent);
      f->name = ds;
      *ff = f;
      ff = &f->next;
    skip:;
    }

    closedir(dp);
    *ff = 0;
  }

  {
    /* -- Phase two: read attributes --- */

    fent *f;

    for (f = fs; f; f = f->next) {

      /* --- Read the file information --- */

      if (lstat(f->name->buf, &f->st)) {
	moan("couldn't stat file `%s%s': %s",
	     down.buf, f->name->buf, strerror(errno));
	DSPUT(&pool, f->name);
	f->name = 0;
	rc = -1;
      }

      /* --- Handle symbolic links --- *
       *
       * I need to canonify relative symbolic links.  (And there shouldn't be
       * any absolute links in a source distribution!)
       */

      else if (S_ISLNK(f->st.st_mode)) {
	dstr *ds;
	int i;
	DSGET(&pool, ds);
	DENSURE(ds, f->st.st_size + 1);
	if ((i = readlink(f->name->buf, ds->buf, ds->sz)) < 0) {
	  moan("couldn't read symbolic link `%s%s': %s",
	       down.buf, f->name->buf, strerror(errno));
	} else {
	  ds->buf[i] = 0;
	  ds->len = i;
	  if (ds->buf[0] == '/')
	    f->link = ds;
	  else {
	    dstr *d;
	    DSGET(&pool, d);
	    f->link = d;
	    DPUTD(d, &up);
	    DPUTD(d, &down);
	    DPUTD(d, ds);
	    canon(d);
	    DSPUT(&pool, ds);
	  }
	}
      }

      /* --- Directories are easy: they get created the hard way --- */

      else if (S_ISDIR(f->st.st_mode))
	f->link = 0;

      /* --- Everything else is just a link --- */

      else {
	dstr *d;
	DSGET(&pool, d);
	f->link = d;
	DPUTD(d, &up);
	DPUTD(d, &down);
	DPUTD(d, f->name);
      }
    }
  }

  {
    /* --- Phase three: output links --- */

    archcons *a;

    /* --- Step 1: change directory --- */

    dd->len = 0;
    DPUTD(dd, &up);
    DPUTS(dd, alist->car->arch);
    DPUTC(dd, '/');
    DPUTD(dd, &down);
    if (chdir(dd->buf + 3)) {
      die(1, "fatal error: couldn't change directory to `%s': %s",
	  dd->buf + 3, strerror(errno));
    }

    a = alist;
    for (;;) {

      /* --- Step 2: populate with links --- */

      archent *e = a->car;
      fent *f;

      for (f = fs; f; f = f->next) {
	if (f->link) {
	  {
	    struct stat st;
	    if (lstat(f->name->buf, &st) == 0 && S_ISLNK(st.st_mode))
	      unlink(f->name->buf);
	  }
	  if (symlink(f->link->buf, f->name->buf)) {
	    moan("couldn't create link `%s%s/%s': %s",
		 e->arch, down.buf, f->name->buf, strerror(errno));
	    rc = -1;
	  }
	} else if (f->name) {
	  if (mkdir(f->name->buf, f->st.st_mode & 07777) &&
	      errno != EEXIST) {
	    moan("couldn't create directory `%s%s/%s: %s",
		 e->arch, down.buf, f->name->buf, strerror(errno));
	    rc = -1;
	  }
	}
      }

      /* --- Step 3: move along --- */

      a = a->cdr;
      if (!a)
	break;

      dd->len = 0;
      DPUTD(dd, &up);
      DPUTS(dd, a->car->arch);
      DPUTC(dd, '/');
      DPUTD(dd, &down);
      if (chdir(dd->buf)) {
	die(1, "fatal error: couldn't change directory to `%s': %s",
	    dd->buf, strerror(errno));
      }
    }
  }

  /* --- Interlude: filter out nondirectories from the file list --- *
   *
   * This is a memory-saving exercise, and it makes the subdirectory handling
   * simpler.
   */

  {
    fent **ff = &fs;
    while (*ff) {
      fent *f = *ff;
      if (f->name && !f->link)
	ff = &f->next;
      else {
	if (f->name)
	  DSPUT(&pool, f->name);
	if (f->link)
	  DSPUT(&pool, f->link);
	*ff = f->next;
	DESTROY(f);
      }
    }
  }

  /* --- Interlude: early exit if no directories --- *
   *
   * Presumably, a call to @canon@ is cheaper than traversing too many
   * directories in the kernel.
   */

  if (!fs) {
    dd->len = 0;
    DPUTD(dd, &up);
    DPUTD(dd, &down);
    DPUTD(dd, cont);
    canon(dd);
    if (chdir(dd->buf)) {
      die(1, "fatal error: couldn't change directory to `%s': %s",
	  dd->buf, strerror(errno));
    }
    DSPUT(&pool, dd);
    return (rc);
  }

  {
    /* --- Phase four: process subdirectories --- */

    fent *f;
    size_t ulen = up.len, dlen = down.len;

    /* --- Set current directory for first directory --- *
     *
     * Subsequent directories do the right thing with the @cont@ argument.
     * Then just leave this one queued up for the next time around.
     */

    dd->len = 0;
    DPUTD(dd, &up);
    DPUTD(dd, &down);
    DPUTD(dd, fs->name);
    if (chdir(dd->buf)) {
      die(1, "fatal error: couldn't change directory to `%s': %s",
	  dd->buf, strerror(errno));
    }

    /* --- Now just process all the directories in turn --- */

    f = fs;
    while (f) {

      /* --- Sort out the new `up' and `down' --- */

      up.len = ulen;
      down.len = dlen;
      DPUTS(&up, "../");
      DPUTD(&down, f->name);
      DPUTS(&down, "/");

      /* --- Set up the continuation directory --- */

      dd->len = 0;
      DPUTS(dd, "../");
      if (f->next)
	DPUTD(dd, f->next->name);
      else
	DPUTD(dd, cont);

      /* --- Clean up this node --- */

      {
	fent *fnext = f->next;
	DSPUT(&pool, f->name);
	DESTROY(f);
	f = fnext;
      }

      /* --- Go for it --- */

      linktree(0, dd);
    }
  }

  DSPUT(&pool, dd);
  return (rc);
}

/* --- @snap@ --- *
 *
 * Arguments:	@const char *f@ = filename to snap
 *
 * Returns:	Zero if ok, nonzero otherwise.
 *
 * Use:		Snaps a symlink in one of the symlink trees into a real file.
 *		Also (by design) happens to work even if there wasn't a
 *		symlink there to begin with, in which case any necessary
 *		directories are created beforehand.
 */

static int snap(const char *f)
{
  int narch;
  int *fd;
  int ifd;
  struct stat st;
  dstr *d;
  int rc = 0;

  /* --- Open the input file --- */

  if ((ifd = open(f, O_RDONLY)) < 0) {
    moan("couldn't open `%s' for reading: %s", f, strerror(errno));
    return (-1);
  }

  if (fstat(ifd, &st)) {
    moan("couldn't read information about `%s': %s", f, strerror(errno));
    return (-1);
  }  

  /* --- Count the architectures --- */

  { archcons *a; for (a = alist, narch = 0; a; a = a->cdr, narch++) ; }
  d = xmalloc(narch * sizeof(dstr));
  fd = xmalloc(narch * sizeof(int));

  /* --- Make the directories needed, remove the old files, and so on --- */

  {
    int i;
    archcons *a;
    char *p = xstrdup(f);
    char *q;

    for (i = 0; i < narch; i++)
      DCREATE(&d[i]);
    for (i = 0, a = alist; a; i++, a = a->cdr)
      DPUTS(&d[i], a->car->arch);
    for (q = strtok(p, "/"); q; q = strtok(0, "/")) {
      for (i = 0; i < narch; i++) {
	mkdir(d[i].buf, 0775);
	DPUTC(&d[i], '/');
	DPUTS(&d[i], q);
      }
    }
    for (i = 0; i < narch; i++) {
      unlink(d[i].buf);
      if ((fd[i] = open(d[i].buf, O_WRONLY | O_TRUNC | O_CREAT,
			st.st_mode & 07777)) < 0) {
	moan("couldn't open `%s' for writing: %s",
	     d[i].buf, strerror(errno));
	rc = -1;
      }
    }
    free(p);
  }

  /* --- Main data copy loop --- */

  {
    int i;
    char buf[BUFSIZ];
    ssize_t n;

    for (;;) {
      n = read(ifd, buf, sizeof(buf));
      if (n < 0) {
	moan("error reading `%s': %s", f, strerror(errno));
	rc = -1;
	for (i = 0; i < narch; i++) {
	  close(fd[i]);
	  fd[i] = -1;
	  unlink(d[i].buf);
	}
	break;
      }
      if (!n)
	break;
      for (i = 0; i < narch; i++) {
	if (fd[i] < 0)
	  continue;
	if (write(fd[i], buf, n) < 0) {
	  moan("error writing `%s', %s", d[i].buf, strerror(errno));
	  close(fd[i]);
	  fd[i] = -1;
	  unlink(d[i].buf);
	  rc = -1;
	}
      }
    }
  }

  /* --- Set the state on the finished files --- */

  {
    int i;
    struct utimbuf u;

    u.actime = st.st_atime;
    u.modtime = st.st_mtime;

    for (i = 0; i < narch; i++) {
      if (fd[i] >= 0) {
	close(fd[i]);
	chmod(d[i].buf, st.st_mode & 07777);
	utime(d[i].buf, &u);
      }
      DDESTROY(&d[i]);
    }
  }

  free(d);
  free(fd);
  return (rc);
}

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

/* --- @sw_link@ --- */

int sw_link(int argc, char *argv[])
{
  int rc = 0;
  swinfo sw;

  if (argc != 1)
    die(1, "Usage: linktree");

  /* --- Initialize the dynamic strings --- */

  dstr_create(&up);
  dstr_puts(&up, "../");
  dstr_create(&down);
  dstr_putz(&down);
  dspool_create(&pool, 32);

  /* --- Set up the architecture lists --- */

  if (swinfo_fetch(&sw)) {
    die(1, "couldn't read build status: %s (try running setup)",
	strerror(errno));
  }
  swinfo_sanity(&sw);
  all = arch_readtab();
  alist = swbuild_archlist(&sw);

  if (!alist) {
    moan("All desired architectures already built!");
    return (0);
  }

  {
    archcons *a;
    for (a = alist; a; a = a->cdr) {
      if (mkdir(a->car->arch, 0775) && errno != EEXIST) {
	moan("couldn't create architecture tree `%s': %s",
	     a->car->arch, strerror(errno));
	rc = -1;
      }
    }
  }

  /* --- Go --- */

  if (rc == 0) {
    dstr d = DSTR_INIT;
    rc = linktree(1, &d);
    DDESTROY(&d);
  }

  /* --- Clean up the mess --- */

  dspool_destroy(&pool);
  return (!!rc);
}

/* --- @sw_snap@ --- */

int sw_snap(int argc, char *argv[])
{
  int rc = 0;
  swinfo sw;
  int i;

  if (argc < 2)
    die(1, "Usage: snaplink FILE...");

  /* --- Set up the architecture lists --- */

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

  if (!alist) {
    moan("All desired architectures already built!");
    return (0);
  }

  for (i = 1; i < argc; i++) {
    if (snap(argv[i]))
      rc = 1;
  }

  return (rc);
}

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