Import CVS-1.6.3-951211.. Basically, this is the cvs-1.6.2 release

plus a couple of minor changes..  

Some highlights of the new stuff that was not in the old version:
 - remote access support.. full checkout/commit/log/etc..
 - much improved dead file support..
 - speed improvements
 - better $CVSROOT handling
 - $Name$ support
 - support for a "cvsadmin" group to cut down rampant use of "cvs admin -o"
 - safer setuid/setgid support
 - many bugs fixed.. :-)
 - probably some new ones.. :-(
 - more that I cannot remember offhand..

10 files changed, 1909 insertions, 0 deletions

diff --git a/gnu/usr.bin/cvs/lib/error.h b/gnu/usr.bin/cvs/lib/error.h
new file mode 100644
index 0000000..7d4f535
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/error.h
@@ -0,0 +1,47 @@
+/* error.h -- declaration for error-reporting function
+   Copyright (C) 1995 Software Foundation, Inc.
+
+   This program 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, or (at your option)
+   any later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _error_h_
+#define _error_h_
+
+#ifndef __attribute__
+/* This feature is available in gcc versions 2.5 and later.  */
+# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
+#  define __attribute__(Spec) /* empty */
+# endif
+/* The __-protected variants of `format' and `printf' attributes
+   are accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
+# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
+#  define __format__ format
+#  define __printf__ printf
+# endif
+#endif
+
+#if __STDC__
+void error (int, int, const char *, ...) \
+  __attribute__ ((__format__ (__printf__, 3, 4)));
+#else
+void error ();
+#endif
+
+/* If non-zero, error will use the CVS protocol to report error
+   messages.  This will only be set in the CVS server parent process;
+   most other code is run via do_cvs_command, which forks off a child
+   process and packages up its stderr in the protocol.  */
+extern int error_use_protocol;
+
+#endif /* _error_h_ */
diff --git a/gnu/usr.bin/cvs/lib/filesubr.c b/gnu/usr.bin/cvs/lib/filesubr.c
new file mode 100644
index 0000000..3a52691
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/filesubr.c
@@ -0,0 +1,640 @@
+/* filesubr.c --- subroutines for dealing with files
+   Jim Blandy <jimb@cyclic.com>
+
+   This file is part of GNU CVS.
+
+   GNU CVS 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, or (at your option) any
+   later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* These functions were moved out of subr.c because they need different
+   definitions under operating systems (like, say, Windows NT) with different
+   file system semantics.  */
+
+#include "cvs.h"
+
+#ifndef lint
+static const char rcsid[] = "$CVSid:$";
+USE(rcsid);
+#endif
+
+/*
+ * I don't know of a convenient way to test this at configure time, or else
+ * I'd certainly do it there.
+ */
+#if defined(NeXT)
+#define LOSING_TMPNAM_FUNCTION
+#endif
+
+static int deep_remove_dir PROTO((const char *path));
+
+/*
+ * Copies "from" to "to".
+ */
+void
+copy_file (from, to)
+    const char *from;
+    const char *to;
+{
+    struct stat sb;
+    struct utimbuf t;
+    int fdin, fdout;
+
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> copy(%s,%s)\n",
+			(server_active) ? 'S' : ' ', from, to);
+#else
+	(void) fprintf (stderr, "-> copy(%s,%s)\n", from, to);
+#endif
+    if (noexec)
+	return;
+
+    if ((fdin = open (from, O_RDONLY)) < 0)
+	error (1, errno, "cannot open %s for copying", from);
+    if (fstat (fdin, &sb) < 0)
+	error (1, errno, "cannot fstat %s", from);
+    if ((fdout = creat (to, (int) sb.st_mode & 07777)) < 0)
+	error (1, errno, "cannot create %s for copying", to);
+    if (sb.st_size > 0)
+    {
+	char buf[BUFSIZ];
+	int n;
+
+	for (;;) 
+	{
+	    n = read (fdin, buf, sizeof(buf));
+	    if (n == -1)
+	    {
+#ifdef EINTR
+		if (errno == EINTR)
+		    continue;
+#endif
+		error (1, errno, "cannot read file %s for copying", from);
+	    }
+            else if (n == 0) 
+		break;
+  
+	    if (write(fdout, buf, n) != n) {
+		error (1, errno, "cannot write file %s for copying", to);
+	    }
+	}
+
+#ifdef HAVE_FSYNC
+	if (fsync (fdout)) 
+	    error (1, errno, "cannot fsync file %s after copying", to);
+#endif
+    }
+
+    if (close (fdin) < 0) 
+	error (0, errno, "cannot close %s", from);
+    if (close (fdout) < 0)
+	error (1, errno, "cannot close %s", to);
+
+    /* now, set the times for the copied file to match those of the original */
+    memset ((char *) &t, 0, sizeof (t));
+    t.actime = sb.st_atime;
+    t.modtime = sb.st_mtime;
+    (void) utime (to, &t);
+}
+
+/* FIXME-krp: these functions would benefit from caching the char * &
+   stat buf.  */
+
+/*
+ * Returns non-zero if the argument file is a directory, or is a symbolic
+ * link which points to a directory.
+ */
+int
+isdir (file)
+    const char *file;
+{
+    struct stat sb;
+
+    if (stat (file, &sb) < 0)
+	return (0);
+    return (S_ISDIR (sb.st_mode));
+}
+
+/*
+ * Returns non-zero if the argument file is a symbolic link.
+ */
+int
+islink (file)
+    const char *file;
+{
+#ifdef S_ISLNK
+    struct stat sb;
+
+    if (lstat (file, &sb) < 0)
+	return (0);
+    return (S_ISLNK (sb.st_mode));
+#else
+    return (0);
+#endif
+}
+
+/*
+ * Returns non-zero if the argument file exists.
+ */
+int
+isfile (file)
+    const char *file;
+{
+    return isaccessible(file, F_OK);
+}
+
+/*
+ * Returns non-zero if the argument file is readable.
+ */
+int
+isreadable (file)
+    const char *file;
+{
+    return isaccessible(file, R_OK);
+}
+
+/*
+ * Returns non-zero if the argument file is writable.
+ */
+int
+iswritable (file)
+    const char *file;
+{
+    return isaccessible(file, W_OK);
+}
+
+/*
+ * Returns non-zero if the argument file is accessable according to
+ * mode.  If compiled with SETXID_SUPPORT also works if cvs has setxid
+ * bits set.
+ */
+int
+isaccessible (file, mode)
+    const char *file;
+    const int mode;
+{
+#ifdef SETXID_SUPPORT
+    struct stat sb;
+    int umask = 0;
+    int gmask = 0;
+    int omask = 0;
+    int uid;
+    
+    if (stat(file, &sb) == -1)
+	return 0;
+    if (mode == F_OK)
+	return 1;
+
+    uid = geteuid();
+    if (uid == 0)		/* superuser */
+    {
+	if (mode & X_OK)
+	    return sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH);
+	else
+	    return 1;
+    }
+	
+    if (mode & R_OK)
+    {
+	umask |= S_IRUSR;
+	gmask |= S_IRGRP;
+	omask |= S_IROTH;
+    }
+    if (mode & W_OK)
+    {
+	umask |= S_IWUSR;
+	gmask |= S_IWGRP;
+	omask |= S_IWOTH;
+    }
+    if (mode & X_OK)
+    {
+	umask |= S_IXUSR;
+	gmask |= S_IXGRP;
+	omask |= S_IXOTH;
+    }
+
+    if (sb.st_uid == uid)
+	return (sb.st_mode & umask) == umask;
+    else if (sb.st_gid == getegid())
+	return (sb.st_mode & gmask) == gmask;
+    else
+	return (sb.st_mode & omask) == omask;
+#else
+    return access(file, mode) == 0;
+#endif
+}
+
+/*
+ * Open a file and die if it fails
+ */
+FILE *
+open_file (name, mode)
+    const char *name;
+    const char *mode;
+{
+    FILE *fp;
+
+    if ((fp = fopen (name, mode)) == NULL)
+	error (1, errno, "cannot open %s", name);
+    return (fp);
+}
+
+/*
+ * Make a directory and die if it fails
+ */
+void
+make_directory (name)
+    const char *name;
+{
+    struct stat sb;
+
+    if (stat (name, &sb) == 0 && (!S_ISDIR (sb.st_mode)))
+	    error (0, 0, "%s already exists but is not a directory", name);
+    if (!noexec && mkdir (name, 0777) < 0)
+	error (1, errno, "cannot make directory %s", name);
+}
+
+/*
+ * Make a path to the argument directory, printing a message if something
+ * goes wrong.
+ */
+void
+make_directories (name)
+    const char *name;
+{
+    char *cp;
+
+    if (noexec)
+	return;
+
+    if (mkdir (name, 0777) == 0 || errno == EEXIST)
+	return;
+    if (! existence_error (errno))
+    {
+	error (0, errno, "cannot make path to %s", name);
+	return;
+    }
+    if ((cp = strrchr (name, '/')) == NULL)
+	return;
+    *cp = '\0';
+    make_directories (name);
+    *cp++ = '/';
+    if (*cp == '\0')
+	return;
+    (void) mkdir (name, 0777);
+}
+
+/*
+ * Change the mode of a file, either adding write permissions, or removing
+ * all write permissions.  Either change honors the current umask setting.
+ */
+void
+xchmod (fname, writable)
+    char *fname;
+    int writable;
+{
+    struct stat sb;
+    mode_t mode, oumask;
+
+    if (stat (fname, &sb) < 0)
+    {
+	if (!noexec)
+	    error (0, errno, "cannot stat %s", fname);
+	return;
+    }
+    oumask = umask (0);
+    (void) umask (oumask);
+    if (writable)
+    {
+	mode = sb.st_mode | (~oumask
+			     & (((sb.st_mode & S_IRUSR) ? S_IWUSR : 0)
+				| ((sb.st_mode & S_IRGRP) ? S_IWGRP : 0)
+				| ((sb.st_mode & S_IROTH) ? S_IWOTH : 0)));
+    }
+    else
+    {
+	mode = sb.st_mode & ~(S_IWRITE | S_IWGRP | S_IWOTH) & ~oumask;
+    }
+
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> chmod(%s,%o)\n",
+			(server_active) ? 'S' : ' ', fname, mode);
+#else
+	(void) fprintf (stderr, "-> chmod(%s,%o)\n", fname, mode);
+#endif
+    if (noexec)
+	return;
+
+    if (chmod (fname, mode) < 0)
+	error (0, errno, "cannot change mode of file %s", fname);
+}
+
+/*
+ * Rename a file and die if it fails
+ */
+void
+rename_file (from, to)
+    const char *from;
+    const char *to;
+{
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> rename(%s,%s)\n",
+			(server_active) ? 'S' : ' ', from, to);
+#else
+	(void) fprintf (stderr, "-> rename(%s,%s)\n", from, to);
+#endif
+    if (noexec)
+	return;
+
+    if (rename (from, to) < 0)
+	error (1, errno, "cannot rename file %s to %s", from, to);
+}
+
+/*
+ * link a file, if possible.
+ */
+int
+link_file (from, to)
+    const char *from;
+    const char *to;
+{
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> link(%s,%s)\n",
+			(server_active) ? 'S' : ' ', from, to);
+#else
+	(void) fprintf (stderr, "-> link(%s,%s)\n", from, to);
+#endif
+    if (noexec)
+	return (0);
+
+    return (link (from, to));
+}
+
+/*
+ * unlink a file, if possible.
+ */
+int
+unlink_file (f)
+    const char *f;
+{
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> unlink(%s)\n",
+			(server_active) ? 'S' : ' ', f);
+#else
+	(void) fprintf (stderr, "-> unlink(%s)\n", f);
+#endif
+    if (noexec)
+	return (0);
+
+    return (unlink (f));
+}
+
+/*
+ * Unlink a file or dir, if possible.  If it is a directory do a deep
+ * removal of all of the files in the directory.  Return -1 on error
+ * (in which case errno is set).
+ */
+int
+unlink_file_dir (f)
+    const char *f;
+{
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> unlink_file_dir(%s)\n",
+			(server_active) ? 'S' : ' ', f);
+#else
+	(void) fprintf (stderr, "-> unlink_file_dir(%s)\n", f);
+#endif
+    if (noexec)
+	return (0);
+
+    if (unlink (f) != 0)
+    {
+	/* under NEXTSTEP errno is set to return EPERM if
+	 * the file is a directory,or if the user is not
+	 * allowed to read or write to the file.
+	 * [This is probably a bug in the O/S]
+	 * other systems will return EISDIR to indicate
+	 * that the path is a directory.
+	 */
+        if (errno == EISDIR || errno == EPERM)
+                return deep_remove_dir (f);
+        else
+		/* The file wasn't a directory and some other
+		 * error occured
+		 */
+                return -1;
+    }
+    /* We were able to remove the file from the disk */
+    return 0;
+}
+
+/* Remove a directory and everything it contains.  Returns 0 for
+ * success, -1 for failure (in which case errno is set).
+ */
+
+static int
+deep_remove_dir (path)
+    const char *path;
+{
+    DIR		  *dirp;
+    struct dirent *dp;
+    char	   buf[PATH_MAX];
+
+    if ( rmdir (path) != 0 && errno == ENOTEMPTY )
+    {
+	if ((dirp = opendir (path)) == NULL)
+	    /* If unable to open the directory return
+	     * an error
+	     */
+	    return -1;
+
+	while ((dp = readdir (dirp)) != NULL)
+	{
+	    if (strcmp (dp->d_name, ".") == 0 ||
+			strcmp (dp->d_name, "..") == 0)
+		continue;
+
+	    sprintf (buf, "%s/%s", path, dp->d_name);
+
+	    if (unlink (buf) != 0 )
+	    {
+		if (errno == EISDIR || errno == EPERM)
+		{
+		    if (deep_remove_dir (buf))
+		    {
+			closedir (dirp);
+			return -1;
+		    }
+		}
+		else
+		{
+		    /* buf isn't a directory, or there are
+		     * some sort of permision problems
+		     */
+		    closedir (dirp);
+		    return -1;
+		}
+	    }
+	}
+	closedir (dirp);
+	return rmdir (path);
+    }
+    /* Was able to remove the directory return 0 */
+    return 0;
+}
+
+/* Read NCHARS bytes from descriptor FD into BUF.
+   Return the number of characters successfully read.
+   The number returned is always NCHARS unless end-of-file or error.  */
+static size_t
+block_read (fd, buf, nchars)
+    int fd;
+    char *buf;
+    size_t nchars;
+{
+    char *bp = buf;
+    size_t nread;
+
+    do 
+    {
+	nread = read (fd, bp, nchars);
+	if (nread == (size_t)-1)
+	{
+#ifdef EINTR
+	    if (errno == EINTR)
+		continue;
+#endif
+	    return (size_t)-1;
+	}
+
+	if (nread == 0)
+	    break; 
+
+	bp += nread;
+	nchars -= nread;
+    } while (nchars != 0);
+
+    return bp - buf;
+} 
+
+    
+/*
+ * Compare "file1" to "file2". Return non-zero if they don't compare exactly.
+ */
+int
+xcmp (file1, file2)
+    const char *file1;
+    const char *file2;
+{
+    char *buf1, *buf2;
+    struct stat sb1, sb2;
+    int fd1, fd2;
+    int ret;
+
+    if ((fd1 = open (file1, O_RDONLY)) < 0)
+	error (1, errno, "cannot open file %s for comparing", file1);
+    if ((fd2 = open (file2, O_RDONLY)) < 0)
+	error (1, errno, "cannot open file %s for comparing", file2);
+    if (fstat (fd1, &sb1) < 0)
+	error (1, errno, "cannot fstat %s", file1);
+    if (fstat (fd2, &sb2) < 0)
+	error (1, errno, "cannot fstat %s", file2);
+
+    /* A generic file compare routine might compare st_dev & st_ino here 
+       to see if the two files being compared are actually the same file.
+       But that won't happen in CVS, so we won't bother. */
+
+    if (sb1.st_size != sb2.st_size)
+	ret = 1;
+    else if (sb1.st_size == 0)
+	ret = 0;
+    else
+    {
+	/* FIXME: compute the optimal buffer size by computing the least
+	   common multiple of the files st_blocks field */
+	size_t buf_size = 8 * 1024;
+	size_t read1;
+	size_t read2;
+
+	buf1 = xmalloc (buf_size);
+	buf2 = xmalloc (buf_size);
+
+	do 
+	{
+	    read1 = block_read (fd1, buf1, buf_size);
+	    if (read1 == (size_t)-1)
+		error (1, errno, "cannot read file %s for comparing", file1);
+
+	    read2 = block_read (fd2, buf2, buf_size);
+	    if (read2 == (size_t)-1)
+		error (1, errno, "cannot read file %s for comparing", file2);
+
+	    /* assert (read1 == read2); */
+
+	    ret = memcmp(buf1, buf2, read1);
+	} while (ret == 0 && read1 == buf_size);
+
+	free (buf1);
+	free (buf2);
+    }
+	
+    (void) close (fd1);
+    (void) close (fd2);
+    return (ret);
+}
+
+#ifdef LOSING_TMPNAM_FUNCTION
+char *tmpnam(char *s)
+{
+    static char value[L_tmpnam+1];
+
+    if (s){
+       strcpy(s,"/tmp/cvsXXXXXX");
+       mktemp(s);
+       return s;
+    }else{
+       strcpy(value,"/tmp/cvsXXXXXX");
+       mktemp(s);
+       return value;
+    }
+}
+#endif
+
+/* Return non-zero iff FILENAME is absolute.
+   Trivial under Unix, but more complicated under other systems.  */
+int
+isabsolute (filename)
+    const char *filename;
+{
+    return filename[0] == '/';
+}
+
+
+/* Return a pointer into PATH's last component.  */
+char *
+last_component (path)
+    char *path;
+{
+    char *last = strrchr (path, '/');
+
+    if (last)
+        return last + 1;
+    else
+        return path;
+}
diff --git a/gnu/usr.bin/cvs/lib/getline.c b/gnu/usr.bin/cvs/lib/getline.c
new file mode 100644
index 0000000..c699461
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/getline.c
@@ -0,0 +1,126 @@
+/* getline.c -- Replacement for GNU C library function getline
+
+Copyright (C) 1993 Free Software Foundation, Inc.
+
+This program 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.
+
+This program 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 this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* Written by Jan Brittenson, bson@gnu.ai.mit.edu.  */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <stdio.h>
+#define NDEBUG
+#include <assert.h>
+
+#if STDC_HEADERS
+#include <stdlib.h>
+#else
+char *malloc (), *realloc ();
+#endif
+
+/* Always add at least this many bytes when extending the buffer.  */
+#define MIN_CHUNK 64
+
+/* Read up to (and including) a TERMINATOR from STREAM into *LINEPTR
+   + OFFSET (and null-terminate it). *LINEPTR is a pointer returned from
+   malloc (or NULL), pointing to *N characters of space.  It is realloc'd
+   as necessary.  Return the number of characters read (not including the
+   null terminator), or -1 on error or EOF.  */
+
+int
+getstr (lineptr, n, stream, terminator, offset)
+     char **lineptr;
+     size_t *n;
+     FILE *stream;
+     char terminator;
+     int offset;
+{
+  int nchars_avail;		/* Allocated but unused chars in *LINEPTR.  */
+  char *read_pos;		/* Where we're reading into *LINEPTR. */
+  int ret;
+
+  if (!lineptr || !n || !stream)
+    return -1;
+
+  if (!*lineptr)
+    {
+      *n = MIN_CHUNK;
+      *lineptr = malloc (*n);
+      if (!*lineptr)
+	return -1;
+    }
+
+  nchars_avail = *n - offset;
+  read_pos = *lineptr + offset;
+
+  for (;;)
+    {
+      register int c = getc (stream);
+
+      /* We always want at least one char left in the buffer, since we
+	 always (unless we get an error while reading the first char)
+	 NUL-terminate the line buffer.  */
+
+      assert(*n - nchars_avail == read_pos - *lineptr);
+      if (nchars_avail < 2)
+	{
+	  if (*n > MIN_CHUNK)
+	    *n *= 2;
+	  else
+	    *n += MIN_CHUNK;
+
+	  nchars_avail = *n + *lineptr - read_pos;
+	  *lineptr = realloc (*lineptr, *n);
+	  if (!*lineptr)
+	    return -1;
+	  read_pos = *n - nchars_avail + *lineptr;
+	  assert(*n - nchars_avail == read_pos - *lineptr);
+	}
+
+      if (c == EOF || ferror (stream))
+	{
+	  /* Return partial line, if any.  */
+	  if (read_pos == *lineptr)
+	    return -1;
+	  else
+	    break;
+	}
+
+      *read_pos++ = c;
+      nchars_avail--;
+
+      if (c == terminator)
+	/* Return the line.  */
+	break;
+    }
+
+  /* Done - NUL terminate and return the number of chars read.  */
+  *read_pos = '\0';
+
+  ret = read_pos - (*lineptr + offset);
+  return ret;
+}
+
+int
+getline (lineptr, n, stream)
+     char **lineptr;
+     size_t *n;
+     FILE *stream;
+{
+  return getstr (lineptr, n, stream, '\n', 0);
+}
diff --git a/gnu/usr.bin/cvs/lib/getline.h b/gnu/usr.bin/cvs/lib/getline.h
new file mode 100644
index 0000000..30bcc25
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/getline.h
@@ -0,0 +1,15 @@
+#ifndef _getline_h_
+#define _getline_h_ 1
+
+#include <stdio.h>
+
+#if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
+#define __PROTO(args) args
+#else
+#define __PROTO(args) ()
+#endif  /* GCC.  */
+
+int
+  getline __PROTO ((char **_lineptr, size_t *_n, FILE *_stream));
+
+#endif /* _getline_h_ */
diff --git a/gnu/usr.bin/cvs/lib/md5.c b/gnu/usr.bin/cvs/lib/md5.c
new file mode 100644
index 0000000..4ad99cd
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/md5.c
@@ -0,0 +1,277 @@
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+#include "config.h"
+
+#if HAVE_STRING_H || STDC_HEADERS
+#include <string.h>	/* for memcpy() */
+#endif
+
+/* Add prototype support.  */
+#ifndef PROTO
+#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#define PROTO(ARGS) ARGS
+#else
+#define PROTO(ARGS) ()
+#endif
+#endif
+
+#include "md5.h"
+
+void byteReverse PROTO ((unsigned char *buf, unsigned longs));
+
+#ifndef ASM_MD5
+/*
+ * Note: this code is harmless on little-endian machines.
+ */
+void byteReverse (buf, longs)
+     unsigned char *buf;
+     unsigned longs;
+{
+	uint32 t;
+	do {
+		t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
+		            ((unsigned)buf[1]<<8 | buf[0]);
+		*(uint32 *)buf = t;
+		buf += 4;
+	} while (--longs);
+}
+#endif
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void
+MD5Init(ctx)
+     struct MD5Context *ctx;
+{
+	ctx->buf[0] = 0x67452301;
+	ctx->buf[1] = 0xefcdab89;
+	ctx->buf[2] = 0x98badcfe;
+	ctx->buf[3] = 0x10325476;
+
+	ctx->bits[0] = 0;
+	ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void
+MD5Update(ctx, buf, len)
+     struct MD5Context *ctx;
+     unsigned char const *buf;
+     unsigned len;
+{
+	uint32 t;
+
+	/* Update bitcount */
+
+	t = ctx->bits[0];
+	if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
+		ctx->bits[1]++;	/* Carry from low to high */
+	ctx->bits[1] += len >> 29;
+
+	t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
+
+	/* Handle any leading odd-sized chunks */
+
+	if ( t ) {
+		unsigned char *p = (unsigned char *)ctx->in + t;
+
+		t = 64-t;
+		if (len < t) {
+			memcpy(p, buf, len);
+			return;
+		}
+		memcpy(p, buf, t);
+		byteReverse(ctx->in, 16);
+		MD5Transform(ctx->buf, (uint32 *)ctx->in);
+		buf += t;
+		len -= t;
+	}
+
+	/* Process data in 64-byte chunks */
+
+	while (len >= 64) {
+		memcpy(ctx->in, buf, 64);
+		byteReverse(ctx->in, 16);
+		MD5Transform(ctx->buf, (uint32 *)ctx->in);
+		buf += 64;
+		len -= 64;
+	}
+
+	/* Handle any remaining bytes of data. */
+
+	memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void
+MD5Final(digest, ctx)
+     unsigned char digest[16];
+     struct MD5Context *ctx;
+{
+	unsigned count;
+	unsigned char *p;
+
+	/* Compute number of bytes mod 64 */
+	count = (ctx->bits[0] >> 3) & 0x3F;
+
+	/* Set the first char of padding to 0x80.  This is safe since there is
+	   always at least one byte free */
+	p = ctx->in + count;
+	*p++ = 0x80;
+
+	/* Bytes of padding needed to make 64 bytes */
+	count = 64 - 1 - count;
+
+	/* Pad out to 56 mod 64 */
+	if (count < 8) {
+		/* Two lots of padding:  Pad the first block to 64 bytes */
+		memset(p, 0, count);
+		byteReverse(ctx->in, 16);
+		MD5Transform(ctx->buf, (uint32 *)ctx->in);
+
+		/* Now fill the next block with 56 bytes */
+		memset(ctx->in, 0, 56);
+	} else {
+		/* Pad block to 56 bytes */
+		memset(p, 0, count-8);
+	}
+	byteReverse(ctx->in, 14);
+
+	/* Append length in bits and transform */
+	((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];
+	((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];
+
+	MD5Transform(ctx->buf, (uint32 *)ctx->in);
+	byteReverse((unsigned char *)ctx->buf, 4);
+	memcpy(digest, ctx->buf, 16);
+	memset(ctx, 0, sizeof(ctx));	/* In case it's sensitive */
+}
+
+#ifndef ASM_MD5
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void
+MD5Transform(buf, in)
+     uint32 buf[4];
+     uint32 const in[16];
+{
+	register uint32 a, b, c, d;
+
+	a = buf[0];
+	b = buf[1];
+	c = buf[2];
+	d = buf[3];
+
+	MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
+	MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
+	MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
+	MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
+	MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
+	MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
+	MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
+	MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
+	MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
+	MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
+	MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
+	MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
+	MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
+	MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
+	MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
+	MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
+
+	MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
+	MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
+	MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
+	MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
+	MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
+	MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
+	MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
+	MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
+	MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
+	MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
+	MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
+	MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
+	MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
+	MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
+	MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
+	MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
+
+	MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
+	MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
+	MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
+	MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
+	MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
+	MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
+	MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
+	MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
+	MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
+	MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
+	MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
+	MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
+	MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
+	MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
+	MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
+	MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
+
+	MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
+	MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
+	MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
+	MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
+	MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
+	MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
+	MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
+	MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
+	MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
+	MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
+	MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
+	MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
+	MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
+	MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
+	MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
+	MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
+
+	buf[0] += a;
+	buf[1] += b;
+	buf[2] += c;
+	buf[3] += d;
+}
+#endif
diff --git a/gnu/usr.bin/cvs/lib/md5.h b/gnu/usr.bin/cvs/lib/md5.h
new file mode 100644
index 0000000..bfe79cc
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/md5.h
@@ -0,0 +1,31 @@
+#ifndef MD5_H
+#define MD5_H
+
+#if SIZEOF_LONG == 4
+typedef unsigned long uint32;
+#else
+#if SIZEOF_INT == 4
+typedef unsigned int uint32;
+#else
+Congratulations!  You get to rewrite this code so that it does not require
+a 32-bit integer type!  (Or maybe you just need to reconfigure.)
+#endif
+#endif
+
+struct MD5Context {
+	uint32 buf[4];
+	uint32 bits[2];
+	unsigned char in[64];
+};
+
+void MD5Init PROTO((struct MD5Context *context));
+void MD5Update PROTO((struct MD5Context *context, unsigned char const *buf, unsigned len));
+void MD5Final PROTO((unsigned char digest[16], struct MD5Context *context));
+void MD5Transform PROTO((uint32 buf[4], uint32 const in[16]));
+
+/*
+ * This is needed to make RSAREF happy on some MS-DOS compilers.
+ */
+typedef struct MD5Context MD5_CTX;
+
+#endif /* !MD5_H */
diff --git a/gnu/usr.bin/cvs/lib/run.c b/gnu/usr.bin/cvs/lib/run.c
new file mode 100644
index 0000000..6a06a38
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/run.c
@@ -0,0 +1,533 @@
+/* run.c --- routines for executing subprocesses.
+   
+   This file is part of GNU CVS.
+
+   GNU CVS 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, or (at your option) any
+   later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "cvs.h"
+
+#ifdef HAVE_VPRINTF
+#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#include <stdarg.h>
+#define VA_START(args, lastarg) va_start(args, lastarg)
+#else
+#include <varargs.h>
+#define VA_START(args, lastarg) va_start(args)
+#endif
+#else
+#define va_alist a1, a2, a3, a4, a5, a6, a7, a8
+#define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
+#endif
+
+static void run_add_arg PROTO((const char *s));
+static void run_init_prog PROTO((void));
+
+extern char *strtok ();
+
+/*
+ * To exec a program under CVS, first call run_setup() to setup any initial
+ * arguments.  The options to run_setup are essentially like printf(). The
+ * arguments will be parsed into whitespace separated words and added to the
+ * global run_argv list.
+ * 
+ * Then, optionally call run_arg() for each additional argument that you'd like
+ * to pass to the executed program.
+ * 
+ * Finally, call run_exec() to execute the program with the specified arguments.
+ * The execvp() syscall will be used, so that the PATH is searched correctly.
+ * File redirections can be performed in the call to run_exec().
+ */
+static char *run_prog;
+static char **run_argv;
+static int run_argc;
+static int run_argc_allocated;
+
+/* VARARGS */
+#if defined (HAVE_VPRINTF) && (defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__))
+void 
+run_setup (const char *fmt,...)
+#else
+void 
+run_setup (fmt, va_alist)
+    char *fmt;
+    va_dcl
+#endif
+{
+#ifdef HAVE_VPRINTF
+    va_list args;
+#endif
+    char *cp;
+    int i;
+
+    run_init_prog ();
+
+    /* clean out any malloc'ed values from run_argv */
+    for (i = 0; i < run_argc; i++)
+    {
+	if (run_argv[i])
+	{
+	    free (run_argv[i]);
+	    run_argv[i] = (char *) 0;
+	}
+    }
+    run_argc = 0;
+
+    /* process the varargs into run_prog */
+#ifdef HAVE_VPRINTF
+    VA_START (args, fmt);
+    (void) vsprintf (run_prog, fmt, args);
+    va_end (args);
+#else
+    (void) sprintf (run_prog, fmt, a1, a2, a3, a4, a5, a6, a7, a8);
+#endif
+
+    /* put each word into run_argv, allocating it as we go */
+    for (cp = strtok (run_prog, " \t"); cp; cp = strtok ((char *) NULL, " \t"))
+	run_add_arg (cp);
+}
+
+void
+run_arg (s)
+    const char *s;
+{
+    run_add_arg (s);
+}
+
+/* VARARGS */
+#if defined (HAVE_VPRINTF) && (defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__))
+void 
+run_args (const char *fmt,...)
+#else
+void 
+run_args (fmt, va_alist)
+    char *fmt;
+    va_dcl
+#endif
+{
+#ifdef HAVE_VPRINTF
+    va_list args;
+#endif
+
+    run_init_prog ();
+
+    /* process the varargs into run_prog */
+#ifdef HAVE_VPRINTF
+    VA_START (args, fmt);
+    (void) vsprintf (run_prog, fmt, args);
+    va_end (args);
+#else
+    (void) sprintf (run_prog, fmt, a1, a2, a3, a4, a5, a6, a7, a8);
+#endif
+
+    /* and add the (single) argument to the run_argv list */
+    run_add_arg (run_prog);
+}
+
+static void
+run_add_arg (s)
+    const char *s;
+{
+    /* allocate more argv entries if we've run out */
+    if (run_argc >= run_argc_allocated)
+    {
+	run_argc_allocated += 50;
+	run_argv = (char **) xrealloc ((char *) run_argv,
+				     run_argc_allocated * sizeof (char **));
+    }
+
+    if (s)
+	run_argv[run_argc++] = xstrdup (s);
+    else
+	run_argv[run_argc] = (char *) 0;	/* not post-incremented on purpose! */
+}
+
+static void
+run_init_prog ()
+{
+    /* make sure that run_prog is allocated once */
+    if (run_prog == (char *) 0)
+	run_prog = xmalloc (10 * 1024);	/* 10K of args for _setup and _arg */
+}
+
+int
+run_exec (stin, stout, sterr, flags)
+    char *stin;
+    char *stout;
+    char *sterr;
+    int flags;
+{
+    int shin, shout, sherr;
+    int mode_out, mode_err;
+    int status;
+    int rc = -1;
+    int rerrno = 0;
+    int pid, w;
+
+#ifdef POSIX_SIGNALS
+    sigset_t sigset_mask, sigset_omask;
+    struct sigaction act, iact, qact;
+
+#else
+#ifdef BSD_SIGNALS
+    int mask;
+    struct sigvec vec, ivec, qvec;
+
+#else
+    RETSIGTYPE (*istat) (), (*qstat) ();
+#endif
+#endif
+
+    if (trace)
+    {
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> system(", (server_active) ? 'S' : ' ');
+#else
+	(void) fprintf (stderr, "-> system(");
+#endif
+	run_print (stderr);
+	(void) fprintf (stderr, ")\n");
+    }
+    if (noexec && (flags & RUN_REALLY) == 0)
+	return (0);
+
+    /* make sure that we are null terminated, since we didn't calloc */
+    run_add_arg ((char *) 0);
+
+    /* setup default file descriptor numbers */
+    shin = 0;
+    shout = 1;
+    sherr = 2;
+
+    /* set the file modes for stdout and stderr */
+    mode_out = mode_err = O_WRONLY | O_CREAT;
+    mode_out |= ((flags & RUN_STDOUT_APPEND) ? O_APPEND : O_TRUNC);
+    mode_err |= ((flags & RUN_STDERR_APPEND) ? O_APPEND : O_TRUNC);
+
+    if (stin && (shin = open (stin, O_RDONLY)) == -1)
+    {
+	rerrno = errno;
+	error (0, errno, "cannot open %s for reading (prog %s)",
+	       stin, run_argv[0]);
+	goto out0;
+    }
+    if (stout && (shout = open (stout, mode_out, 0666)) == -1)
+    {
+	rerrno = errno;
+	error (0, errno, "cannot open %s for writing (prog %s)",
+	       stout, run_argv[0]);
+	goto out1;
+    }
+    if (sterr && (flags & RUN_COMBINED) == 0)
+    {
+	if ((sherr = open (sterr, mode_err, 0666)) == -1)
+	{
+	    rerrno = errno;
+	    error (0, errno, "cannot open %s for writing (prog %s)",
+		   sterr, run_argv[0]);
+	    goto out2;
+	}
+    }
+
+    /* Make sure we don't flush this twice, once in the subprocess.  */
+    fflush (stdout);
+    fflush (stderr);
+
+    /* The output files, if any, are now created.  Do the fork and dups */
+#ifdef HAVE_VFORK
+    pid = vfork ();
+#else
+    pid = fork ();
+#endif
+    if (pid == 0)
+    {
+	if (shin != 0)
+	{
+	    (void) dup2 (shin, 0);
+	    (void) close (shin);
+	}
+	if (shout != 1)
+	{
+	    (void) dup2 (shout, 1);
+	    (void) close (shout);
+	}
+	if (flags & RUN_COMBINED)
+	    (void) dup2 (1, 2);
+	else if (sherr != 2)
+	{
+	    (void) dup2 (sherr, 2);
+	    (void) close (sherr);
+	}
+
+	/* dup'ing is done.  try to run it now */
+	(void) execvp (run_argv[0], run_argv);
+	error (0, errno, "cannot exec %s", run_argv[0]);
+	_exit (127);
+    }
+    else if (pid == -1)
+    {
+	rerrno = errno;
+	goto out;
+    }
+
+    /* the parent.  Ignore some signals for now */
+#ifdef POSIX_SIGNALS
+    if (flags & RUN_SIGIGNORE)
+    {
+	act.sa_handler = SIG_IGN;
+	(void) sigemptyset (&act.sa_mask);
+	act.sa_flags = 0;
+	(void) sigaction (SIGINT, &act, &iact);
+	(void) sigaction (SIGQUIT, &act, &qact);
+    }
+    else
+    {
+	(void) sigemptyset (&sigset_mask);
+	(void) sigaddset (&sigset_mask, SIGINT);
+	(void) sigaddset (&sigset_mask, SIGQUIT);
+	(void) sigprocmask (SIG_SETMASK, &sigset_mask, &sigset_omask);
+    }
+#else
+#ifdef BSD_SIGNALS
+    if (flags & RUN_SIGIGNORE)
+    {
+	memset ((char *) &vec, 0, sizeof (vec));
+	vec.sv_handler = SIG_IGN;
+	(void) sigvec (SIGINT, &vec, &ivec);
+	(void) sigvec (SIGQUIT, &vec, &qvec);
+    }
+    else
+	mask = sigblock (sigmask (SIGINT) | sigmask (SIGQUIT));
+#else
+    istat = signal (SIGINT, SIG_IGN);
+    qstat = signal (SIGQUIT, SIG_IGN);
+#endif
+#endif
+
+    /* wait for our process to die and munge return status */
+#ifdef POSIX_SIGNALS
+    while ((w = waitpid (pid, &status, 0)) == -1 && errno == EINTR)
+	;
+#else
+    while ((w = wait (&status)) != pid)
+    {
+	if (w == -1 && errno != EINTR)
+	    break;
+    }
+#endif
+    if (w == -1)
+    {
+	rc = -1;
+	rerrno = errno;
+    }
+    else if (WIFEXITED (status))
+	rc = WEXITSTATUS (status);
+    else if (WIFSIGNALED (status))
+    {
+	if (WTERMSIG (status) == SIGPIPE)
+	    error (1, 0, "broken pipe");
+	rc = 2;
+    }
+    else
+	rc = 1;
+
+    /* restore the signals */
+#ifdef POSIX_SIGNALS
+    if (flags & RUN_SIGIGNORE)
+    {
+	(void) sigaction (SIGINT, &iact, (struct sigaction *) NULL);
+	(void) sigaction (SIGQUIT, &qact, (struct sigaction *) NULL);
+    }
+    else
+	(void) sigprocmask (SIG_SETMASK, &sigset_omask, (sigset_t *) NULL);
+#else
+#ifdef BSD_SIGNALS
+    if (flags & RUN_SIGIGNORE)
+    {
+	(void) sigvec (SIGINT, &ivec, (struct sigvec *) NULL);
+	(void) sigvec (SIGQUIT, &qvec, (struct sigvec *) NULL);
+    }
+    else
+	(void) sigsetmask (mask);
+#else
+    (void) signal (SIGINT, istat);
+    (void) signal (SIGQUIT, qstat);
+#endif
+#endif
+
+    /* cleanup the open file descriptors */
+  out:
+    if (sterr)
+	(void) close (sherr);
+  out2:
+    if (stout)
+	(void) close (shout);
+  out1:
+    if (stin)
+	(void) close (shin);
+
+  out0:
+    if (rerrno)
+	errno = rerrno;
+    return (rc);
+}
+
+void
+run_print (fp)
+    FILE *fp;
+{
+    int i;
+
+    for (i = 0; i < run_argc; i++)
+    {
+	(void) fprintf (fp, "'%s'", run_argv[i]);
+	if (i != run_argc - 1)
+	    (void) fprintf (fp, " ");
+    }
+}
+
+FILE *
+Popen (cmd, mode)
+    const char *cmd;
+    const char *mode;
+{
+    if (trace)
+#ifdef SERVER_SUPPORT
+	(void) fprintf (stderr, "%c-> Popen(%s,%s)\n",
+			(server_active) ? 'S' : ' ', cmd, mode);
+#else
+	(void) fprintf (stderr, "-> Popen(%s,%s)\n", cmd, mode);
+#endif
+    if (noexec)
+	return (NULL);
+
+    return (popen (cmd, mode));
+}
+
+extern int evecvp PROTO((char *file, char **argv));
+
+int
+piped_child (command, tofdp, fromfdp)
+     char **command;
+     int *tofdp;
+     int *fromfdp;
+{
+    int pid;
+    int to_child_pipe[2];
+    int from_child_pipe[2];
+
+    if (pipe (to_child_pipe) < 0)
+	error (1, errno, "cannot create pipe");
+    if (pipe (from_child_pipe) < 0)
+	error (1, errno, "cannot create pipe");
+
+    pid = fork ();
+    if (pid < 0)
+	error (1, errno, "cannot fork");
+    if (pid == 0)
+    {
+	if (dup2 (to_child_pipe[0], STDIN_FILENO) < 0)
+	    error (1, errno, "cannot dup2");
+	if (close (to_child_pipe[1]) < 0)
+	    error (1, errno, "cannot close");
+	if (close (from_child_pipe[0]) < 0)
+	    error (1, errno, "cannot close");
+	if (dup2 (from_child_pipe[1], STDOUT_FILENO) < 0)
+	    error (1, errno, "cannot dup2");
+
+	execvp (command[0], command);
+	error (1, errno, "cannot exec");
+    }
+    if (close (to_child_pipe[0]) < 0)
+	error (1, errno, "cannot close");
+    if (close (from_child_pipe[1]) < 0)
+	error (1, errno, "cannot close");
+
+    *tofdp = to_child_pipe[1];
+    *fromfdp = from_child_pipe[0];
+    return pid;
+}
+
+
+void
+close_on_exec (fd)
+     int fd;
+{
+#if defined (FD_CLOEXEC) && defined (F_SETFD)
+  if (fcntl (fd, F_SETFD, 1))
+    error (1, errno, "can't set close-on-exec flag on %d", fd);
+#endif
+}
+
+/*
+ * dir = 0 : main proc writes to new proc, which writes to oldfd
+ * dir = 1 : main proc reads from new proc, which reads from oldfd
+ */
+
+int
+filter_stream_through_program (oldfd, dir, prog, pidp)
+     int oldfd, dir;
+     char **prog;
+     pid_t *pidp;
+{
+    int p[2], newfd;
+    pid_t newpid;
+
+    if (pipe (p))
+	error (1, errno, "cannot create pipe");
+    newpid = fork ();
+    if (pidp)
+	*pidp = newpid;
+    switch (newpid)
+    {
+      case -1:
+	error (1, errno, "cannot fork");
+      case 0:
+	/* child */
+	if (dir)
+	{
+	    /* write to new pipe */
+	    close (p[0]);
+	    dup2 (oldfd, 0);
+	    dup2 (p[1], 1);
+	}
+	else
+	{
+	    /* read from new pipe */
+	    close (p[1]);
+	    dup2 (p[0], 0);
+	    dup2 (oldfd, 1);
+	}
+	/* Should I be blocking some signals here?  */
+	execvp (prog[0], prog);
+	error (1, errno, "couldn't exec %s", prog[0]);
+      default:
+	/* parent */
+	close (oldfd);
+	if (dir)
+	{
+	    /* read from new pipe */
+	    close (p[1]);
+	    newfd = p[0];
+	}
+	else
+	{
+	    /* write to new pipe */
+	    close (p[0]);
+	    newfd = p[1];
+	}
+	close_on_exec (newfd);
+	return newfd;
+    }
+}
diff --git a/gnu/usr.bin/cvs/lib/save-cwd.c b/gnu/usr.bin/cvs/lib/save-cwd.c
new file mode 100644
index 0000000..1bdf791
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/save-cwd.c
@@ -0,0 +1,141 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#else
+# include <sys/file.h>
+#endif
+
+#ifdef HAVE_DIRECT_H
+# include <direct.h>
+#endif
+
+#ifdef HAVE_IO_H
+# include <io.h>
+#endif
+
+#include <errno.h>
+# ifndef errno
+extern int errno;
+#endif
+
+#include "save-cwd.h"
+#include "error.h"
+
+char *xgetwd __PROTO((void));
+
+/* Record the location of the current working directory in CWD so that
+   the program may change to other directories and later use restore_cwd
+   to return to the recorded location.  This function may allocate
+   space using malloc (via xgetwd) or leave a file descriptor open;
+   use free_cwd to perform the necessary free or close.  Upon failure,
+   no memory is allocated, any locally opened file descriptors are
+   closed;  return non-zero -- in that case, free_cwd need not be
+   called, but doing so is ok.  Otherwise, return zero.  */
+
+int
+save_cwd (cwd)
+     struct saved_cwd *cwd;
+{
+  static int have_working_fchdir = 1;
+
+  cwd->desc = -1;
+  cwd->name = NULL;
+
+  if (have_working_fchdir)
+    {
+#ifdef HAVE_FCHDIR
+      cwd->desc = open (".", O_RDONLY);
+      if (cwd->desc < 0)
+	{
+	  error (0, errno, "cannot open current directory");
+	  return 1;
+	}
+
+# if __sun__ || sun
+      /* On SunOS 4, fchdir returns EINVAL if accounting is enabled,
+	 so we have to fall back to chdir.  */
+      if (fchdir (cwd->desc))
+	{
+	  if (errno == EINVAL)
+	    {
+	      close (cwd->desc);
+	      cwd->desc = -1;
+	      have_working_fchdir = 0;
+	    }
+	  else
+	    {
+	      error (0, errno, "current directory");
+	      close (cwd->desc);
+	      cwd->desc = -1;
+	      return 1;
+	    }
+	}
+# endif /* __sun__ || sun */
+#else
+#define fchdir(x) (abort (), 0)
+      have_working_fchdir = 0;
+#endif
+    }
+
+  if (!have_working_fchdir)
+    {
+      cwd->name = xgetwd ();
+      if (cwd->name == NULL)
+	{
+	  error (0, errno, "cannot get current directory");
+	  return 1;
+	}
+    }
+  return 0;
+}
+
+/* Change to recorded location, CWD, in directory hierarchy.
+   If "saved working directory", NULL))
+   */
+
+int
+restore_cwd (cwd, dest)
+     const struct saved_cwd *cwd;
+     const char *dest;
+{
+  int fail = 0;
+  if (cwd->desc >= 0)
+    {
+      if (fchdir (cwd->desc))
+	{
+	  error (0, errno, "cannot return to %s",
+		 (dest ? dest : "saved working directory"));
+	  fail = 1;
+	}
+    }
+  else if (chdir (cwd->name) < 0)
+    {
+      error (0, errno, "%s", cwd->name);
+      fail = 1;
+    }
+  return fail;
+}
+
+void
+free_cwd (cwd)
+     struct saved_cwd *cwd;
+{
+  if (cwd->desc >= 0)
+    close (cwd->desc);
+  if (cwd->name)
+    free (cwd->name);
+}
+
diff --git a/gnu/usr.bin/cvs/lib/save-cwd.h b/gnu/usr.bin/cvs/lib/save-cwd.h
new file mode 100644
index 0000000..f9802f8
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/save-cwd.h
@@ -0,0 +1,20 @@
+#ifndef SAVE_CWD_H
+#define SAVE_CWD_H 1
+
+struct saved_cwd
+  {
+    int desc;
+    char *name;
+  };
+
+#if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
+#define __PROTO(args) args
+#else
+#define __PROTO(args) ()
+#endif  /* GCC.  */
+
+int save_cwd __PROTO((struct saved_cwd *cwd));
+int restore_cwd __PROTO((const struct saved_cwd *cwd, const char *dest));
+void free_cwd __PROTO((struct saved_cwd *cwd));
+
+#endif /* SAVE_CWD_H */
diff --git a/gnu/usr.bin/cvs/lib/xgetwd.c b/gnu/usr.bin/cvs/lib/xgetwd.c
new file mode 100644
index 0000000..8fe4ec1
--- /dev/null
+++ b/gnu/usr.bin/cvs/lib/xgetwd.c
@@ -0,0 +1,79 @@
+/* xgetwd.c -- return current directory with unlimited length
+   Copyright (C) 1992 Free Software Foundation, Inc.
+
+   This program 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, or (at your option)
+   any later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* Derived from xgetcwd.c in e.g. the GNU sh-utils.  */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "system.h"
+
+#include <stdio.h>
+#include <errno.h>
+#ifndef errno
+extern int errno;
+#endif
+#include <sys/types.h>
+
+#ifndef HAVE_GETWD
+char *getwd ();
+#define GETWD(buf, max) getwd (buf)
+#else
+char *getcwd ();
+#define GETWD(buf, max) getcwd (buf, max)
+#endif
+
+/* Amount by which to increase buffer size when allocating more space. */
+#define PATH_INCR 32
+
+char *xmalloc ();
+char *xrealloc ();
+
+/* Return the current directory, newly allocated, arbitrarily long.
+   Return NULL and set errno on error. */
+
+char *
+xgetwd ()
+{
+  char *cwd;
+  char *ret;
+  unsigned path_max;
+
+  errno = 0;
+  path_max = (unsigned) PATH_MAX;
+  path_max += 2;		/* The getcwd docs say to do this. */
+
+  cwd = xmalloc (path_max);
+
+  errno = 0;
+  while ((ret = GETWD (cwd, path_max)) == NULL && errno == ERANGE)
+    {
+      path_max += PATH_INCR;
+      cwd = xrealloc (cwd, path_max);
+      errno = 0;
+    }
+
+  if (ret == NULL)
+    {
+      int save_errno = errno;
+      free (cwd);
+      errno = save_errno;
+      return NULL;
+    }
+  return cwd;
+}