ENH: Initial import

17 files changed, 3037 insertions, 0 deletions

diff --git a/Utilities/cmtar/compat/README b/Utilities/cmtar/compat/README
new file mode 100644
index 0000000..fd23ced
--- /dev/null
+++ b/Utilities/cmtar/compat/README
@@ -0,0 +1,12 @@
+Compatibility Suite
+-------------------
+
+This directory contains a compatibility suite that provides alternate
+implementations of various library functions which are not available or
+not usable on some platforms.
+
+The original copyright information for each function is included in
+the source files.  I've modified the files slightly for integration
+into this suite, but the functionality has not been modified from
+the original source.
+
diff --git a/Utilities/cmtar/compat/basename.c b/Utilities/cmtar/compat/basename.c
new file mode 100644
index 0000000..21cc13d
--- /dev/null
+++ b/Utilities/cmtar/compat/basename.c
@@ -0,0 +1,75 @@
+/*  $OpenBSD: basename.c,v 1.4 1999/05/30 17:10:30 espie Exp $  */
+
+/*
+ * Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef lint
+static char rcsid[] = "$OpenBSD: basename.c,v 1.4 1999/05/30 17:10:30 espie Exp $";
+#endif /* not lint */
+
+#include <errno.h>
+#include <string.h>
+//#include <sys/param.h>
+#include <compat.h>
+
+char *
+openbsd_basename(path)
+  const char *path;
+{
+  static char bname[MAXPATHLEN];
+  register const char *endp, *startp;
+
+  /* Empty or NULL string gets treated as "." */
+  if (path == NULL || *path == '\0') {
+    (void)strcpy(bname, ".");
+    return(bname);
+  }
+
+  /* Strip trailing slashes */
+  endp = path + strlen(path) - 1;
+  while (endp > path && *endp == '/')
+    endp--;
+
+  /* All slashes becomes "/" */
+  if (endp == path && *endp == '/') {
+    (void)strcpy(bname, "/");
+    return(bname);
+  }
+
+  /* Find the start of the base */
+  startp = endp;
+  while (startp > path && *(startp - 1) != '/')
+    startp--;
+
+  if (endp - startp + 1 > sizeof(bname)) {
+    errno = ENAMETOOLONG;
+    return(NULL);
+  }
+  (void)strncpy(bname, startp, endp - startp + 1);
+  bname[endp - startp + 1] = '\0';
+  return(bname);
+}
diff --git a/Utilities/cmtar/compat/compat.h b/Utilities/cmtar/compat/compat.h
new file mode 100644
index 0000000..880f54b
--- /dev/null
+++ b/Utilities/cmtar/compat/compat.h
@@ -0,0 +1,314 @@
+/* prototypes for borrowed "compatibility" code */
+
+#include <libtar/config.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef STDC_HEADERS
+# include <stdarg.h>
+# include <stddef.h>
+#else
+# include <varargs.h>
+#endif
+
+#ifdef HAVE_LIBGEN_H
+# include <libgen.h>
+#endif
+
+
+#if defined(NEED_BASENAME) && !defined(HAVE_BASENAME)
+
+# ifdef basename
+#  undef basename    /* fix glibc brokenness */
+# endif
+
+char *openbsd_basename(const char *);
+# define basename openbsd_basename
+
+#endif /* NEED_BASENAME && ! HAVE_BASENAME */
+
+
+#if defined(NEED_DIRNAME) && !defined(HAVE_DIRNAME)
+
+char *openbsd_dirname(const char *);
+# define dirname openbsd_dirname
+
+#endif /* NEED_DIRNAME && ! HAVE_DIRNAME */
+
+
+#ifdef NEED_FNMATCH
+# ifndef HAVE_FNMATCH
+
+#  define FNM_NOMATCH  1  /* Match failed. */
+
+#  define FNM_NOESCAPE  0x01  /* Disable backslash escaping. */
+#  define FNM_PATHNAME  0x02  /* Slash must be matched by slash. */
+#  define FNM_PERIOD  0x04  /* Period must be matched by period. */
+
+#  define FNM_LEADING_DIR 0x08  /* Ignore /<tail> after Imatch. */
+#  define FNM_CASEFOLD  0x10  /* Case insensitive search. */
+#  define FNM_IGNORECASE FNM_CASEFOLD
+#  define FNM_FILE_NAME FNM_PATHNAME
+
+int openbsd_fnmatch(const char *, const char *, int);
+#  define fnmatch openbsd_fnmatch
+
+# else /* HAVE_FNMATCH */
+
+#  ifdef HAVE_FNMATCH_H
+#   include <fnmatch.h>
+#  endif
+
+# endif /* ! HAVE_FNMATCH */
+#endif /* NEED_FNMATCH */
+
+
+#ifdef NEED_GETHOSTBYNAME_R
+
+# include <netdb.h>
+
+# if GETHOSTBYNAME_R_NUM_ARGS != 6
+
+int compat_gethostbyname_r(const char *, struct hostent *,
+         char *, size_t, struct hostent **, int *);
+
+#  define gethostbyname_r compat_gethostbyname_r
+
+# endif /* GETHOSTBYNAME_R_NUM_ARGS != 6 */
+
+#endif /* NEED_GETHOSTBYNAME_R */
+
+
+#if defined(NEED_GETHOSTNAME) && !defined(HAVE_GETHOSTNAME)
+
+int gethostname(char *, size_t);
+
+#endif /* NEED_GETHOSTNAME && ! HAVE_GETHOSTNAME */
+
+
+#ifdef NEED_GETSERVBYNAME_R
+
+# include <netdb.h>
+
+# if GETSERVBYNAME_R_NUM_ARGS != 6
+
+int compat_getservbyname_r(const char *, const char *, struct servent *,
+         char *, size_t, struct servent **);
+
+#  define getservbyname_r compat_getservbyname_r
+
+# endif /* GETSERVBYNAME_R_NUM_ARGS != 6 */
+
+#endif /* NEED_GETSERVBYNAME_R */
+
+
+
+#ifdef NEED_GLOB
+# ifndef HAVE_GLOB
+
+typedef struct {
+  int gl_pathc;    /* Count of total paths so far. */
+  int gl_matchc;    /* Count of paths matching pattern. */
+  int gl_offs;    /* Reserved at beginning of gl_pathv. */
+  int gl_flags;    /* Copy of flags parameter to glob. */
+  char **gl_pathv;  /* List of paths matching pattern. */
+        /* Copy of errfunc parameter to glob. */
+  int (*gl_errfunc)(const char *, int);
+
+  /*
+   * Alternate filesystem access methods for glob; replacement
+   * versions of closedir(3), readdir(3), opendir(3), stat(2)
+   * and lstat(2).
+   */
+  void (*gl_closedir)(void *);
+  struct dirent *(*gl_readdir)(void *);
+  void *(*gl_opendir)(const char *);
+  int (*gl_lstat)(const char *, struct stat *);
+  int (*gl_stat)(const char *, struct stat *);
+} glob_t;
+
+/* Flags */
+#  define GLOB_APPEND  0x0001  /* Append to output from previous call. */
+#  define GLOB_DOOFFS  0x0002  /* Use gl_offs. */
+#  define GLOB_ERR  0x0004  /* Return on error. */
+#  define GLOB_MARK  0x0008  /* Append / to matching directories. */
+#  define GLOB_NOCHECK  0x0010  /* Return pattern itself if nothing matches. */
+#  define GLOB_NOSORT  0x0020  /* Don't sort. */
+
+#  define GLOB_ALTDIRFUNC 0x0040 /* Use alternately specified directory funcs. */
+#  define GLOB_BRACE  0x0080  /* Expand braces ala csh. */
+#  define GLOB_MAGCHAR  0x0100  /* Pattern had globbing characters. */
+#  define GLOB_NOMAGIC  0x0200  /* GLOB_NOCHECK without magic chars (csh). */
+#  define GLOB_QUOTE  0x0400  /* Quote special chars with \. */
+#  define GLOB_TILDE  0x0800  /* Expand tilde names from the passwd file. */
+#  define GLOB_NOESCAPE  0x1000  /* Disable backslash escaping. */
+
+/* Error values returned by glob(3) */
+#  define GLOB_NOSPACE  (-1)  /* Malloc call failed. */
+#  define GLOB_ABORTED  (-2)  /* Unignored error. */
+#  define GLOB_NOMATCH  (-3)  /* No match and GLOB_NOCHECK not set. */
+#  define GLOB_NOSYS  (-4)  /* Function not supported. */
+#  define GLOB_ABEND  GLOB_ABORTED
+
+int openbsd_glob(const char *, int, int (*)(const char *, int), glob_t *);
+void openbsd_globfree(glob_t *);
+#  define glob openbsd_glob
+#  define globfree openbsd_globfree
+
+# else /* HAVE_GLOB */
+
+#  ifdef HAVE_GLOB_H
+#   include <glob.h>
+#  endif
+
+# endif /* ! HAVE_GLOB */
+#endif /* NEED_GLOB */
+
+
+#if defined(NEED_INET_ATON) && !defined(HAVE_INET_ATON)
+
+int inet_aton(const char *, struct in_addr *);
+
+#endif /* NEED_INET_ATON && ! HAVE_INET_ATON */
+
+
+#ifdef NEED_MAKEDEV
+
+# ifdef MAJOR_IN_MKDEV
+#  include <sys/mkdev.h>
+# else
+#  ifdef MAJOR_IN_SYSMACROS
+#   include <sys/sysmacros.h>
+#  endif
+# endif
+
+/*
+** On most systems makedev() has two args.
+** Some weird systems, like QNX6, have makedev() functions that expect
+** an extra first argument for "node", which can be 0 for a local
+** machine.
+*/
+
+# ifdef MAKEDEV_THREE_ARGS
+#  define compat_makedev(maj, min)  makedev(0, maj, min)
+# else
+#  define compat_makedev    makedev
+# endif
+
+#endif /* NEED_MAKEDEV */
+
+#ifdef _MSC_VER //compile snprintf only onwin32
+//#if defined(NEED_SNPRINTF) && !defined(HAVE_SNPRINTF)
+#if !defined(HAVE_SNPRINTF)
+int mutt_snprintf(char *, size_t, const char *, ...);
+int mutt_vsnprintf(char *, size_t, const char *, va_list);
+#define snprintf mutt_snprintf
+#define vsnprintf mutt_vsnprintf
+
+#endif /* NEED_SNPRINTF && ! HAVE_SNPRINTF */
+#endif
+
+#if defined(NEED_STRLCAT) && !defined(HAVE_STRLCAT)
+
+size_t strlcat(char *, const char *, size_t);
+
+#endif /* NEED_STRLCAT && ! HAVE_STRLCAT */
+
+
+#if defined(NEED_STRLCPY) && !defined(HAVE_STRLCPY)
+
+size_t strlcpy(char *, const char *, size_t);
+
+#endif /* NEED_STRLCPY && ! HAVE_STRLCPY */
+
+
+#if defined(NEED_STRDUP) && !defined(HAVE_STRDUP)
+
+char *openbsd_strdup(const char *);
+# define strdup openbsd_strdup
+
+#endif /* NEED_STRDUP && ! HAVE_STRDUP */
+
+
+#if defined(NEED_STRMODE) && !defined(HAVE_STRMODE)
+
+void strmode(register mode_t, register char *);
+
+#endif /* NEED_STRMODE && ! HAVE_STRMODE */
+
+
+#if defined(NEED_STRRSTR) && !defined(HAVE_STRRSTR)
+
+char *strrstr(char *, char *);
+
+#endif /* NEED_STRRSTR && ! HAVE_STRRSTR */
+
+
+#ifdef NEED_STRSEP
+
+# ifdef HAVE_STRSEP
+#  define _LINUX_SOURCE_COMPAT    /* needed on AIX 4.3.3 */
+# else
+
+char *strsep(register char **, register const char *);
+
+# endif
+
+#endif /* NEED_STRSEP */
+
+#ifdef _MSC_VER
+#include <stdlib.h>
+#define MAXPATHLEN _MAX_PATH
+#ifndef O_ACCMODE
+# define O_ACCMODE 0x0003
+#endif
+#endif
+
+
+
+
+#ifndef S_ISREG
+#ifndef S_IFREG
+#ifndef _S_IFREG
+#define S_IFREG    (-1)
+#else
+#define S_IFREG    _S_IFREG
+#endif
+#endif
+#define S_ISREG(m)  (((m)&S_IFREG)==S_IFREG)
+#endif
+
+
+#ifndef S_ISDIR
+#ifndef S_IFDIR
+#ifndef _S_IFDIR
+#define S_IFDIR    (-1)
+#else
+#define S_IFDIR    _S_IFDIR
+#endif
+#endif
+#define S_ISDIR(m)  (((m)&S_IFDIR)==S_IFDIR)
+#endif
+
+#ifndef S_ISBLK
+#ifndef S_IFBLK
+#ifndef _S_IFBLK
+#define S_IFBLK    (-1)
+#else
+#define S_IFBLK    _S_IFBLK
+#endif
+#endif
+#define S_ISBLK(m)  (((m)&S_IFBLK)==S_IFBLK)
+#endif
+
+#ifndef S_ISFIFO
+#ifndef S_IFFIFO
+#ifndef _S_IFFIFO
+#define S_IFFIFO    (-1)
+#else
+#define S_IFFIFO    _S_IFFIFO
+#endif
+#endif
+#define S_ISFIFO(m)  (((m)&S_IFFIFO)==S_IFFIFO)
+#endif
diff --git a/Utilities/cmtar/compat/dirname.c b/Utilities/cmtar/compat/dirname.c
new file mode 100644
index 0000000..63455a9
--- /dev/null
+++ b/Utilities/cmtar/compat/dirname.c
@@ -0,0 +1,78 @@
+/*  $OpenBSD: dirname.c,v 1.4 1999/05/30 17:10:30 espie Exp $  */
+
+/*
+ * Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef lint
+static char rcsid[] = "$OpenBSD: dirname.c,v 1.4 1999/05/30 17:10:30 espie Exp $";
+#endif /* not lint */
+
+#include <errno.h>
+#include <string.h>
+//#include <sys/param.h>
+#include <compat.h>
+
+char *
+openbsd_dirname(path)
+  const char *path;
+{
+  static char bname[MAXPATHLEN];
+  register const char *endp;
+
+  /* Empty or NULL string gets treated as "." */
+  if (path == NULL || *path == '\0') {
+    (void)strcpy(bname, ".");
+    return(bname);
+  }
+
+  /* Strip trailing slashes */
+  endp = path + strlen(path) - 1;
+  while (endp > path && *endp == '/')
+    endp--;
+
+  /* Find the start of the dir */
+  while (endp > path && *endp != '/')
+    endp--;
+
+  /* Either the dir is "/" or there are no slashes */
+  if (endp == path) {
+    (void)strcpy(bname, *endp == '/' ? "/" : ".");
+    return(bname);
+  } else {
+    do {
+      endp--;
+    } while (endp > path && *endp == '/');
+  }
+
+  if (endp - path + 1 > sizeof(bname)) {
+    errno = ENAMETOOLONG;
+    return(NULL);
+  }
+  (void)strncpy(bname, path, endp - path + 1);
+  bname[endp - path + 1] = '\0';
+  return(bname);
+}
diff --git a/Utilities/cmtar/compat/fnmatch.c b/Utilities/cmtar/compat/fnmatch.c
new file mode 100644
index 0000000..f1c5da1
--- /dev/null
+++ b/Utilities/cmtar/compat/fnmatch.c
@@ -0,0 +1,237 @@
+/*  $OpenBSD: fnmatch.c,v 1.6 1998/03/19 00:29:59 millert Exp $  */
+
+/*
+ * Copyright (c) 1989, 1993, 1994
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the University of
+ *  California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)fnmatch.c  8.2 (Berkeley) 4/16/94";
+#else
+static char rcsid[] = "$OpenBSD: fnmatch.c,v 1.6 1998/03/19 00:29:59 millert Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
+ * Compares a filename or pathname to a pattern.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+
+#ifdef STDC_HEADERS
+# include <string.h>
+#endif
+
+#ifdef HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#include <compat.h>
+
+
+#define  EOS  '\0'
+
+#define  RANGE_MATCH  1
+#define  RANGE_NOMATCH  0
+#define  RANGE_ERROR  (-1)
+
+#ifdef NO_IBM_COMPILER_HORKAGE
+static int rangematch (const char *, char, int, char **);
+#else
+static int rangematch ();
+#endif
+
+int
+fnmatch(pattern, string, flags)
+  const char *pattern, *string;
+  int flags;
+{
+  const char *stringstart;
+  char *newp;
+  char c, test;
+
+  for (stringstart = string;;)
+    switch (c = *pattern++) {
+    case EOS:
+      if ((flags & FNM_LEADING_DIR) && *string == '/')
+        return (0);
+      return (*string == EOS ? 0 : FNM_NOMATCH);
+    case '?':
+      if (*string == EOS)
+        return (FNM_NOMATCH);
+      if (*string == '/' && (flags & FNM_PATHNAME))
+        return (FNM_NOMATCH);
+      if (*string == '.' && (flags & FNM_PERIOD) &&
+          (string == stringstart ||
+          ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+        return (FNM_NOMATCH);
+      ++string;
+      break;
+    case '*':
+      c = *pattern;
+      /* Collapse multiple stars. */
+      while (c == '*')
+        c = *++pattern;
+
+      if (*string == '.' && (flags & FNM_PERIOD) &&
+          (string == stringstart ||
+          ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+        return (FNM_NOMATCH);
+
+      /* Optimize for pattern with * at end or before /. */
+      if (c == EOS) {
+        if (flags & FNM_PATHNAME)
+          return ((flags & FNM_LEADING_DIR) ||
+              strchr(string, '/') == NULL ?
+              0 : FNM_NOMATCH);
+        else
+          return (0);
+      } else if (c == '/' && (flags & FNM_PATHNAME)) {
+        if ((string = strchr(string, '/')) == NULL)
+          return (FNM_NOMATCH);
+        break;
+      }
+
+      /* General case, use recursion. */
+      while ((test = *string) != EOS) {
+        if (!fnmatch(pattern, string, flags & ~FNM_PERIOD))
+          return (0);
+        if (test == '/' && (flags & FNM_PATHNAME))
+          break;
+        ++string;
+      }
+      return (FNM_NOMATCH);
+    case '[':
+      if (*string == EOS)
+        return (FNM_NOMATCH);
+      if (*string == '/' && (flags & FNM_PATHNAME))
+        return (FNM_NOMATCH);
+      if (*string == '.' && (flags & FNM_PERIOD) &&
+          (string == stringstart ||
+          ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+        return (FNM_NOMATCH);
+
+      switch (rangematch(pattern, *string, flags, &newp)) {
+      case RANGE_ERROR:
+        /* not a good range, treat as normal text */
+        goto normal;
+      case RANGE_MATCH:
+        pattern = newp;
+        break;
+      case RANGE_NOMATCH:
+        return (FNM_NOMATCH);
+      }
+      ++string;
+      break;
+    case '\\':
+      if (!(flags & FNM_NOESCAPE)) {
+        if ((c = *pattern++) == EOS) {
+          c = '\\';
+          --pattern;
+        }
+      }
+      /* FALLTHROUGH */
+    default:
+    normal:
+      if (c != *string && !((flags & FNM_CASEFOLD) &&
+         (tolower((unsigned char)c) ==
+         tolower((unsigned char)*string))))
+        return (FNM_NOMATCH);
+      ++string;
+      break;
+    }
+  /* NOTREACHED */
+}
+
+static int
+rangematch(pattern, test, flags, newp)
+  const char *pattern;
+  char test;
+  int flags;
+  char **newp;
+{
+  int negate, ok;
+  char c, c2;
+
+  /*
+   * A bracket expression starting with an unquoted circumflex
+   * character produces unspecified results (IEEE 1003.2-1992,
+   * 3.13.2).  This implementation treats it like '!', for
+   * consistency with the regular expression syntax.
+   * J.T. Conklin (conklin@ngai.kaleida.com)
+   */
+  if ((negate = (*pattern == '!' || *pattern == '^')))
+    ++pattern;
+
+  if (flags & FNM_CASEFOLD)
+    test = tolower((unsigned char)test);
+
+  /*
+   * A right bracket shall lose its special meaning and represent
+   * itself in a bracket expression if it occurs first in the list.
+   * -- POSIX.2 2.8.3.2
+   */
+  ok = 0;
+  c = *pattern++;
+  do {
+    if (c == '\\' && !(flags & FNM_NOESCAPE))
+      c = *pattern++;
+    if (c == EOS)
+      return (RANGE_ERROR);
+    if (c == '/' && (flags & FNM_PATHNAME))
+      return (RANGE_NOMATCH);
+    if ((flags & FNM_CASEFOLD))
+      c = tolower((unsigned char)c);
+    if (*pattern == '-'
+        && (c2 = *(pattern+1)) != EOS && c2 != ']') {
+      pattern += 2;
+      if (c2 == '\\' && !(flags & FNM_NOESCAPE))
+        c2 = *pattern++;
+      if (c2 == EOS)
+        return (RANGE_ERROR);
+      if (flags & FNM_CASEFOLD)
+        c2 = tolower((unsigned char)c2);
+      if (c <= test && test <= c2)
+        ok = 1;
+    } else if (c == test)
+      ok = 1;
+  } while ((c = *pattern++) != ']');
+
+  *newp = (char *)pattern;
+  return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
+}
diff --git a/Utilities/cmtar/compat/gethostbyname_r.c b/Utilities/cmtar/compat/gethostbyname_r.c
new file mode 100644
index 0000000..1b88bad
--- /dev/null
+++ b/Utilities/cmtar/compat/gethostbyname_r.c
@@ -0,0 +1,41 @@
+/*
+**  Copyright 2002 University of Illinois Board of Trustees
+**  Copyright 2002 Mark D. Roth
+**  All rights reserved.
+**
+**  gethostbyname_r.c - gethostbyname_r() function for compatibility library
+**
+**  Mark D. Roth <roth@uiuc.edu>
+**  Campus Information Technologies and Educational Services
+**  University of Illinois at Urbana-Champaign
+*/
+
+#include <config.h>
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <netdb.h>
+
+
+int
+compat_gethostbyname_r(const char *name, struct hostent *hp,
+           char *buf, size_t buflen,
+           struct hostent **hpp, int *herr)
+{
+#if GETHOSTBYNAME_R_NUM_ARGS == 5
+  *hpp = gethostbyname_r(name, hp, buf, buflen, herr);
+
+  if (*hpp == NULL)
+    return -1;
+  return 0;
+#elif GETHOSTBYNAME_R_NUM_ARGS == 3
+  struct hostent_data hdata;
+
+  if (gethostbyname_r(name, hp, &hdata) == -1)
+    return -1;
+  *hpp = hp;
+  return 0;
+#endif /* GETHOSTBYNAME_R_NUM_ARGS == 5 */
+}
+
+
diff --git a/Utilities/cmtar/compat/gethostname.c b/Utilities/cmtar/compat/gethostname.c
new file mode 100644
index 0000000..1abaae1
--- /dev/null
+++ b/Utilities/cmtar/compat/gethostname.c
@@ -0,0 +1,36 @@
+/* gethostname.c: minimal substitute for missing gethostname() function
+ * created 2000-Mar-02 jmk
+ * requires SVR4 uname() and -lc
+ *
+ * by Jim Knoble <jmknoble@pobox.com>
+ * Copyright ? 2000 Jim Knoble
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear in
+ * supporting documentation.
+ *
+ * This software is provided "as is", without warranty of any kind,
+ * express or implied, including but not limited to the warranties of
+ * merchantability, fitness for a particular purpose and
+ * noninfringement. In no event shall the author(s) be liable for any
+ * claim, damages or other liability, whether in an action of contract,
+ * tort or otherwise, arising from, out of or in connection with the
+ * software or the use or other dealings in the software.
+ */
+
+#include <string.h>
+#include <sys/utsname.h>
+
+int gethostname(char *name, size_t len)
+{
+   struct utsname u;
+   int status = uname(&u);
+   if (-1 != status) {
+      strncpy(name, u.nodename, len);
+      name[len - 1] = '\0';
+   }
+   return(status);
+}
+
diff --git a/Utilities/cmtar/compat/getservbyname_r.c b/Utilities/cmtar/compat/getservbyname_r.c
new file mode 100644
index 0000000..3afedf0
--- /dev/null
+++ b/Utilities/cmtar/compat/getservbyname_r.c
@@ -0,0 +1,41 @@
+/*
+**  Copyright 2002 University of Illinois Board of Trustees
+**  Copyright 2002 Mark D. Roth
+**  All rights reserved.
+**
+**  getservbyname_r.c - getservbyname_r() function for compatibility library
+**
+**  Mark D. Roth <roth@uiuc.edu>
+**  Campus Information Technologies and Educational Services
+**  University of Illinois at Urbana-Champaign
+*/
+
+#include <config.h>
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <netdb.h>
+
+
+int
+compat_getservbyname_r(const char *name, const char *proto,
+           struct servent *sp, char *buf, size_t buflen,
+           struct servent **spp)
+{
+#if GETSERVBYNAME_R_NUM_ARGS == 5
+  *spp = getservbyname_r(name, proto, sp, buf, buflen);
+
+  if (*spp == NULL)
+    return -1;
+  return 0;
+#elif GETSERVBYNAME_R_NUM_ARGS == 4
+  struct servent_data sdata;
+
+  if (getservbyname_r(name, proto, sp, &sdata) == -1)
+    return -1;
+  *spp = sp;
+  return 0;
+#endif /* GETSERVBYNAME_R_NUM_ARGS == 5 */
+}
+
+
diff --git a/Utilities/cmtar/compat/glob.c b/Utilities/cmtar/compat/glob.c
new file mode 100644
index 0000000..939d76f
--- /dev/null
+++ b/Utilities/cmtar/compat/glob.c
@@ -0,0 +1,874 @@
+/*
+ * Copyright (c) 1989, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the University of
+ *  California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)glob.c  8.3 (Berkeley) 10/13/93";
+#else
+static char rcsid[] = "$OpenBSD: glob.c,v 1.8 1998/08/14 21:39:30 deraadt Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * glob(3) -- a superset of the one defined in POSIX 1003.2.
+ *
+ * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
+ *
+ * Optional extra services, controlled by flags not defined by POSIX:
+ *
+ * GLOB_QUOTE:
+ *  Escaping convention: \ inhibits any special meaning the following
+ *  character might have (except \ at end of string is retained).
+ * GLOB_MAGCHAR:
+ *  Set in gl_flags if pattern contained a globbing character.
+ * GLOB_NOMAGIC:
+ *  Same as GLOB_NOCHECK, but it will only append pattern if it did
+ *  not contain any magic characters.  [Used in csh style globbing]
+ * GLOB_ALTDIRFUNC:
+ *  Use alternately specified directory access functions.
+ * GLOB_TILDE:
+ *  expand ~user/foo to the /home/dir/of/user/foo
+ * GLOB_BRACE:
+ *  expand {1,2}{a,b} to 1a 1b 2a 2b
+ * gl_matchc:
+ *  Number of matches in the current invocation of glob.
+ */
+
+#include <config.h>
+
+//#include <sys/param.h>
+#include <compat.h>
+#include <sys/stat.h>
+
+//#include <dirent.h>
+#include <errno.h>
+#include <pwd.h>
+#include <stdio.h>
+
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <string.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#include <compat.h>
+
+
+#define  DOLLAR    '$'
+#define  DOT    '.'
+#define  EOS    '\0'
+#define  LBRACKET  '['
+#define  NOT    '!'
+#define  QUESTION  '?'
+#define  QUOTE    '\\'
+#define  RANGE    '-'
+#define  RBRACKET  ']'
+#define  SEP    '/'
+#define  STAR    '*'
+#define  TILDE    '~'
+#define  UNDERSCORE  '_'
+#define  LBRACE    '{'
+#define  RBRACE    '}'
+#define  SLASH    '/'
+#define  COMMA    ','
+
+#ifndef DEBUG
+
+#define  M_QUOTE    0x8000
+#define  M_PROTECT  0x4000
+#define  M_MASK    0xffff
+#define  M_ASCII    0x00ff
+
+typedef u_short Char;
+
+#else
+
+#define  M_QUOTE    0x80
+#define  M_PROTECT  0x40
+#define  M_MASK    0xff
+#define  M_ASCII    0x7f
+
+typedef char Char;
+
+#endif
+
+
+#define  CHAR(c)    ((Char)((c)&M_ASCII))
+#define  META(c)    ((Char)((c)|M_QUOTE))
+#define  M_ALL    META('*')
+#define  M_END    META(']')
+#define  M_NOT    META('!')
+#define  M_ONE    META('?')
+#define  M_RNG    META('-')
+#define  M_SET    META('[')
+#define  ismeta(c)  (((c)&M_QUOTE) != 0)
+
+
+static int   compare (const void *, const void *);
+static void   g_Ctoc (const Char *, char *);
+static int   g_lstat (Char *, struct stat *, glob_t *);
+static DIR  *g_opendir (Char *, glob_t *);
+static Char  *g_strchr (Char *, int);
+#ifdef notdef
+static Char  *g_strcat (Char *, const Char *);
+#endif
+static int   g_stat (Char *, struct stat *, glob_t *);
+static int   glob0 (const Char *, glob_t *);
+static int   glob1 (Char *, glob_t *);
+static int   glob2 (Char *, Char *, Char *, glob_t *);
+static int   glob3 (Char *, Char *, Char *, Char *, glob_t *);
+static int   globextend (const Char *, glob_t *);
+static const Char *  globtilde (const Char *, Char *, size_t, glob_t *);
+static int   globexp1 (const Char *, glob_t *);
+static int   globexp2 (const Char *, const Char *, glob_t *, int *);
+static int   match (Char *, Char *, Char *);
+#ifdef DEBUG
+static void   qprintf (const char *, Char *);
+#endif
+
+int
+openbsd_glob(pattern, flags, errfunc, pglob)
+  const char *pattern;
+  int flags, (*errfunc) __P((const char *, int));
+  glob_t *pglob;
+{
+  const u_char *patnext;
+  int c;
+  Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];
+
+  patnext = (u_char *) pattern;
+  if (!(flags & GLOB_APPEND)) {
+    pglob->gl_pathc = 0;
+    pglob->gl_pathv = NULL;
+    if (!(flags & GLOB_DOOFFS))
+      pglob->gl_offs = 0;
+  }
+  pglob->gl_flags = flags & ~GLOB_MAGCHAR;
+  pglob->gl_errfunc = errfunc;
+  pglob->gl_matchc = 0;
+
+  bufnext = patbuf;
+  bufend = bufnext + MAXPATHLEN;
+  if (flags & GLOB_NOESCAPE)
+      while (bufnext < bufend && (c = *patnext++) != EOS)
+        *bufnext++ = c;
+  else {
+    /* Protect the quoted characters. */
+    while (bufnext < bufend && (c = *patnext++) != EOS)
+      if (c == QUOTE) {
+        if ((c = *patnext++) == EOS) {
+          c = QUOTE;
+          --patnext;
+        }
+        *bufnext++ = c | M_PROTECT;
+      }
+      else
+        *bufnext++ = c;
+  }
+  *bufnext = EOS;
+
+  if (flags & GLOB_BRACE)
+    return globexp1(patbuf, pglob);
+  else
+    return glob0(patbuf, pglob);
+}
+
+/*
+ * Expand recursively a glob {} pattern. When there is no more expansion
+ * invoke the standard globbing routine to glob the rest of the magic
+ * characters
+ */
+static int globexp1(pattern, pglob)
+  const Char *pattern;
+  glob_t *pglob;
+{
+  const Char* ptr = pattern;
+  int rv;
+
+  /* Protect a single {}, for find(1), like csh */
+  if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
+    return glob0(pattern, pglob);
+
+  while ((ptr = (const Char *) g_strchr((Char *) ptr, LBRACE)) != NULL)
+    if (!globexp2(ptr, pattern, pglob, &rv))
+      return rv;
+
+  return glob0(pattern, pglob);
+}
+
+
+/*
+ * Recursive brace globbing helper. Tries to expand a single brace.
+ * If it succeeds then it invokes globexp1 with the new pattern.
+ * If it fails then it tries to glob the rest of the pattern and returns.
+ */
+static int globexp2(ptr, pattern, pglob, rv)
+  const Char *ptr, *pattern;
+  glob_t *pglob;
+  int *rv;
+{
+  int     i;
+  Char   *lm, *ls;
+  const Char *pe, *pm, *pl;
+  Char    patbuf[MAXPATHLEN + 1];
+
+  /* copy part up to the brace */
+  for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
+    continue;
+  ls = lm;
+
+  /* Find the balanced brace */
+  for (i = 0, pe = ++ptr; *pe; pe++)
+    if (*pe == LBRACKET) {
+      /* Ignore everything between [] */
+      for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
+        continue;
+      if (*pe == EOS) {
+        /*
+         * We could not find a matching RBRACKET.
+         * Ignore and just look for RBRACE
+         */
+        pe = pm;
+      }
+    }
+    else if (*pe == LBRACE)
+      i++;
+    else if (*pe == RBRACE) {
+      if (i == 0)
+        break;
+      i--;
+    }
+
+  /* Non matching braces; just glob the pattern */
+  if (i != 0 || *pe == EOS) {
+    *rv = glob0(patbuf, pglob);
+    return 0;
+  }
+
+  for (i = 0, pl = pm = ptr; pm <= pe; pm++)
+    switch (*pm) {
+    case LBRACKET:
+      /* Ignore everything between [] */
+      for (pl = pm++; *pm != RBRACKET && *pm != EOS; pm++)
+        continue;
+      if (*pm == EOS) {
+        /*
+         * We could not find a matching RBRACKET.
+         * Ignore and just look for RBRACE
+         */
+        pm = pl;
+      }
+      break;
+
+    case LBRACE:
+      i++;
+      break;
+
+    case RBRACE:
+      if (i) {
+          i--;
+          break;
+      }
+      /* FALLTHROUGH */
+    case COMMA:
+      if (i && *pm == COMMA)
+        break;
+      else {
+        /* Append the current string */
+        for (lm = ls; (pl < pm); *lm++ = *pl++)
+          continue;
+        /*
+         * Append the rest of the pattern after the
+         * closing brace
+         */
+        for (pl = pe + 1; (*lm++ = *pl++) != EOS;)
+          continue;
+
+        /* Expand the current pattern */
+#ifdef DEBUG
+        qprintf("globexp2:", patbuf);
+#endif
+        *rv = globexp1(patbuf, pglob);
+
+        /* move after the comma, to the next string */
+        pl = pm + 1;
+      }
+      break;
+
+    default:
+      break;
+    }
+  *rv = 0;
+  return 0;
+}
+
+
+
+/*
+ * expand tilde from the passwd file.
+ */
+static const Char *
+globtilde(pattern, patbuf, patbuf_len, pglob)
+  const Char *pattern;
+  Char *patbuf;
+  size_t patbuf_len;
+  glob_t *pglob;
+{
+  struct passwd *pwd;
+  char *h;
+  const Char *p;
+  Char *b, *eb;
+
+  if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
+    return pattern;
+
+  /* Copy up to the end of the string or / */
+  eb = &patbuf[patbuf_len - 1];
+  for (p = pattern + 1, h = (char *) patbuf;
+      h < (char *)eb && *p && *p != SLASH; *h++ = *p++)
+    continue;
+
+  *h = EOS;
+
+  if (((char *) patbuf)[0] == EOS) {
+    /*
+     * handle a plain ~ or ~/ by expanding $HOME
+     * first and then trying the password file
+     */
+#ifdef HAVE_ISSETUGID
+    if (issetugid() != 0 || (h = getenv("HOME")) == NULL) {
+#endif
+      if ((pwd = getpwuid(getuid())) == NULL)
+        return pattern;
+      else
+        h = pwd->pw_dir;
+#ifdef HAVE_ISSETUGID
+    }
+#endif
+  }
+  else {
+    /*
+     * Expand a ~user
+     */
+    if ((pwd = getpwnam((char*) patbuf)) == NULL)
+      return pattern;
+    else
+      h = pwd->pw_dir;
+  }
+
+  /* Copy the home directory */
+  for (b = patbuf; b < eb && *h; *b++ = *h++)
+    continue;
+
+  /* Append the rest of the pattern */
+  while (b < eb && (*b++ = *p++) != EOS)
+    continue;
+  *b = EOS;
+
+  return patbuf;
+}
+
+
+/*
+ * The main glob() routine: compiles the pattern (optionally processing
+ * quotes), calls glob1() to do the real pattern matching, and finally
+ * sorts the list (unless unsorted operation is requested).  Returns 0
+ * if things went well, nonzero if errors occurred.  It is not an error
+ * to find no matches.
+ */
+static int
+glob0(pattern, pglob)
+  const Char *pattern;
+  glob_t *pglob;
+{
+  const Char *qpatnext;
+  int c, err, oldpathc;
+  Char *bufnext, patbuf[MAXPATHLEN+1];
+
+  qpatnext = globtilde(pattern, patbuf, sizeof(patbuf) / sizeof(Char),
+      pglob);
+  oldpathc = pglob->gl_pathc;
+  bufnext = patbuf;
+
+  /* We don't need to check for buffer overflow any more. */
+  while ((c = *qpatnext++) != EOS) {
+    switch (c) {
+    case LBRACKET:
+      c = *qpatnext;
+      if (c == NOT)
+        ++qpatnext;
+      if (*qpatnext == EOS ||
+          g_strchr((Char *) qpatnext+1, RBRACKET) == NULL) {
+        *bufnext++ = LBRACKET;
+        if (c == NOT)
+          --qpatnext;
+        break;
+      }
+      *bufnext++ = M_SET;
+      if (c == NOT)
+        *bufnext++ = M_NOT;
+      c = *qpatnext++;
+      do {
+        *bufnext++ = CHAR(c);
+        if (*qpatnext == RANGE &&
+            (c = qpatnext[1]) != RBRACKET) {
+          *bufnext++ = M_RNG;
+          *bufnext++ = CHAR(c);
+          qpatnext += 2;
+        }
+      } while ((c = *qpatnext++) != RBRACKET);
+      pglob->gl_flags |= GLOB_MAGCHAR;
+      *bufnext++ = M_END;
+      break;
+    case QUESTION:
+      pglob->gl_flags |= GLOB_MAGCHAR;
+      *bufnext++ = M_ONE;
+      break;
+    case STAR:
+      pglob->gl_flags |= GLOB_MAGCHAR;
+      /* collapse adjacent stars to one,
+       * to avoid exponential behavior
+       */
+      if (bufnext == patbuf || bufnext[-1] != M_ALL)
+          *bufnext++ = M_ALL;
+      break;
+    default:
+      *bufnext++ = CHAR(c);
+      break;
+    }
+  }
+  *bufnext = EOS;
+#ifdef DEBUG
+  qprintf("glob0:", patbuf);
+#endif
+
+  if ((err = glob1(patbuf, pglob)) != 0)
+    return(err);
+
+  /*
+   * If there was no match we are going to append the pattern
+   * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
+   * and the pattern did not contain any magic characters
+   * GLOB_NOMAGIC is there just for compatibility with csh.
+   */
+  if (pglob->gl_pathc == oldpathc) {
+    if ((pglob->gl_flags & GLOB_NOCHECK) ||
+        ((pglob->gl_flags & GLOB_NOMAGIC) &&
+        !(pglob->gl_flags & GLOB_MAGCHAR)))
+      return(globextend(pattern, pglob));
+    else
+      return(GLOB_NOMATCH);
+  }
+  if (!(pglob->gl_flags & GLOB_NOSORT))
+    qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
+        pglob->gl_pathc - oldpathc, sizeof(char *), compare);
+  return(0);
+}
+
+static int
+compare(p, q)
+  const void *p, *q;
+{
+  return(strcmp(*(char **)p, *(char **)q));
+}
+
+static int
+glob1(pattern, pglob)
+  Char *pattern;
+  glob_t *pglob;
+{
+  Char pathbuf[MAXPATHLEN+1];
+
+  /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
+  if (*pattern == EOS)
+    return(0);
+  return(glob2(pathbuf, pathbuf, pattern, pglob));
+}
+
+/*
+ * The functions glob2 and glob3 are mutually recursive; there is one level
+ * of recursion for each segment in the pattern that contains one or more
+ * meta characters.
+ */
+static int
+glob2(pathbuf, pathend, pattern, pglob)
+  Char *pathbuf, *pathend, *pattern;
+  glob_t *pglob;
+{
+  struct stat sb;
+  Char *p, *q;
+  int anymeta;
+
+  /*
+   * Loop over pattern segments until end of pattern or until
+   * segment with meta character found.
+   */
+  for (anymeta = 0;;) {
+    if (*pattern == EOS) {    /* End of pattern? */
+      *pathend = EOS;
+      if (g_lstat(pathbuf, &sb, pglob))
+        return(0);
+
+      if (((pglob->gl_flags & GLOB_MARK) &&
+          pathend[-1] != SEP) && (S_ISDIR(sb.st_mode)
+          || (S_ISLNK(sb.st_mode) &&
+          (g_stat(pathbuf, &sb, pglob) == 0) &&
+          S_ISDIR(sb.st_mode)))) {
+        *pathend++ = SEP;
+        *pathend = EOS;
+      }
+      ++pglob->gl_matchc;
+      return(globextend(pathbuf, pglob));
+    }
+
+    /* Find end of next segment, copy tentatively to pathend. */
+    q = pathend;
+    p = pattern;
+    while (*p != EOS && *p != SEP) {
+      if (ismeta(*p))
+        anymeta = 1;
+      *q++ = *p++;
+    }
+
+    if (!anymeta) {    /* No expansion, do next segment. */
+      pathend = q;
+      pattern = p;
+      while (*pattern == SEP)
+        *pathend++ = *pattern++;
+    } else      /* Need expansion, recurse. */
+      return(glob3(pathbuf, pathend, pattern, p, pglob));
+  }
+  /* NOTREACHED */
+}
+
+static int
+glob3(pathbuf, pathend, pattern, restpattern, pglob)
+  Char *pathbuf, *pathend, *pattern, *restpattern;
+  glob_t *pglob;
+{
+  register struct dirent *dp;
+  DIR *dirp;
+  int err;
+  char buf[MAXPATHLEN];
+
+  /*
+   * The readdirfunc declaration can't be prototyped, because it is
+   * assigned, below, to two functions which are prototyped in glob.h
+   * and dirent.h as taking pointers to differently typed opaque
+   * structures.
+   */
+  struct dirent *(*readdirfunc)();
+
+  *pathend = EOS;
+  errno = 0;
+
+  if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
+    /* TODO: don't call for ENOENT or ENOTDIR? */
+    if (pglob->gl_errfunc) {
+      g_Ctoc(pathbuf, buf);
+      if (pglob->gl_errfunc(buf, errno) ||
+          pglob->gl_flags & GLOB_ERR)
+        return (GLOB_ABORTED);
+    }
+    return(0);
+  }
+
+  err = 0;
+
+  /* Search directory for matching names. */
+  if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+    readdirfunc = pglob->gl_readdir;
+  else
+    readdirfunc = readdir;
+  while ((dp = (*readdirfunc)(dirp))) {
+    register u_char *sc;
+    register Char *dc;
+
+    /* Initial DOT must be matched literally. */
+    if (dp->d_name[0] == DOT && *pattern != DOT)
+      continue;
+    for (sc = (u_char *) dp->d_name, dc = pathend;
+         (*dc++ = *sc++) != EOS;)
+      continue;
+    if (!match(pathend, pattern, restpattern)) {
+      *pathend = EOS;
+      continue;
+    }
+    err = glob2(pathbuf, --dc, restpattern, pglob);
+    if (err)
+      break;
+  }
+
+  if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+    (*pglob->gl_closedir)(dirp);
+  else
+    closedir(dirp);
+  return(err);
+}
+
+
+/*
+ * Extend the gl_pathv member of a glob_t structure to accomodate a new item,
+ * add the new item, and update gl_pathc.
+ *
+ * This assumes the BSD realloc, which only copies the block when its size
+ * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
+ * behavior.
+ *
+ * Return 0 if new item added, error code if memory couldn't be allocated.
+ *
+ * Invariant of the glob_t structure:
+ *  Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
+ *  gl_pathv points to (gl_offs + gl_pathc + 1) items.
+ */
+static int
+globextend(path, pglob)
+  const Char *path;
+  glob_t *pglob;
+{
+  register char **pathv;
+  register int i;
+  u_int newsize;
+  char *copy;
+  const Char *p;
+
+  newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
+  pathv = pglob->gl_pathv ?
+        realloc((char *)pglob->gl_pathv, newsize) :
+        malloc(newsize);
+  if (pathv == NULL) {
+    if (pglob->gl_pathv)
+      free(pglob->gl_pathv);
+    return(GLOB_NOSPACE);
+  }
+
+  if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
+    /* first time around -- clear initial gl_offs items */
+    pathv += pglob->gl_offs;
+    for (i = pglob->gl_offs; --i >= 0; )
+      *--pathv = NULL;
+  }
+  pglob->gl_pathv = pathv;
+
+  for (p = path; *p++;)
+    continue;
+  if ((copy = malloc(p - path)) != NULL) {
+    g_Ctoc(path, copy);
+    pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
+  }
+  pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
+  return(copy == NULL ? GLOB_NOSPACE : 0);
+}
+
+
+/*
+ * pattern matching function for filenames.  Each occurrence of the *
+ * pattern causes a recursion level.
+ */
+static int
+match(name, pat, patend)
+  register Char *name, *pat, *patend;
+{
+  int ok, negate_range;
+  Char c, k;
+
+  while (pat < patend) {
+    c = *pat++;
+    switch (c & M_MASK) {
+    case M_ALL:
+      if (pat == patend)
+        return(1);
+      do
+          if (match(name, pat, patend))
+            return(1);
+      while (*name++ != EOS);
+      return(0);
+    case M_ONE:
+      if (*name++ == EOS)
+        return(0);
+      break;
+    case M_SET:
+      ok = 0;
+      if ((k = *name++) == EOS)
+        return(0);
+      if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)
+        ++pat;
+      while (((c = *pat++) & M_MASK) != M_END)
+        if ((*pat & M_MASK) == M_RNG) {
+          if (c <= k && k <= pat[1])
+            ok = 1;
+          pat += 2;
+        } else if (c == k)
+          ok = 1;
+      if (ok == negate_range)
+        return(0);
+      break;
+    default:
+      if (*name++ != c)
+        return(0);
+      break;
+    }
+  }
+  return(*name == EOS);
+}
+
+/* Free allocated data belonging to a glob_t structure. */
+void
+openbsd_globfree(pglob)
+  glob_t *pglob;
+{
+  register int i;
+  register char **pp;
+
+  if (pglob->gl_pathv != NULL) {
+    pp = pglob->gl_pathv + pglob->gl_offs;
+    for (i = pglob->gl_pathc; i--; ++pp)
+      if (*pp)
+        free(*pp);
+    free(pglob->gl_pathv);
+  }
+}
+
+static DIR *
+g_opendir(str, pglob)
+  register Char *str;
+  glob_t *pglob;
+{
+  char buf[MAXPATHLEN];
+
+  if (!*str)
+    strcpy(buf, ".");
+  else
+    g_Ctoc(str, buf);
+
+  if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+    return((*pglob->gl_opendir)(buf));
+
+  return(opendir(buf));
+}
+
+static int
+g_lstat(fn, sb, pglob)
+  register Char *fn;
+  struct stat *sb;
+  glob_t *pglob;
+{
+  char buf[MAXPATHLEN];
+
+  g_Ctoc(fn, buf);
+  if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+    return((*pglob->gl_lstat)(buf, sb));
+  return(lstat(buf, sb));
+}
+
+static int
+g_stat(fn, sb, pglob)
+  register Char *fn;
+  struct stat *sb;
+  glob_t *pglob;
+{
+  char buf[MAXPATHLEN];
+
+  g_Ctoc(fn, buf);
+  if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+    return((*pglob->gl_stat)(buf, sb));
+  return(stat(buf, sb));
+}
+
+static Char *
+g_strchr(str, ch)
+  Char *str;
+  int ch;
+{
+  do {
+    if (*str == ch)
+      return (str);
+  } while (*str++);
+  return (NULL);
+}
+
+#ifdef notdef
+static Char *
+g_strcat(dst, src)
+  Char *dst;
+  const Char* src;
+{
+  Char *sdst = dst;
+
+  while (*dst++)
+    continue;
+  --dst;
+  while((*dst++ = *src++) != EOS)
+      continue;
+
+  return (sdst);
+}
+#endif
+
+static void
+g_Ctoc(str, buf)
+  register const Char *str;
+  char *buf;
+{
+  register char *dc;
+
+  for (dc = buf; (*dc++ = *str++) != EOS;)
+    continue;
+}
+
+#ifdef DEBUG
+static void
+qprintf(str, s)
+  const char *str;
+  register Char *s;
+{
+  register Char *p;
+
+  (void)printf("%s:\n", str);
+  for (p = s; *p; p++)
+    (void)printf("%c", CHAR(*p));
+  (void)printf("\n");
+  for (p = s; *p; p++)
+    (void)printf("%c", *p & M_PROTECT ? '"' : ' ');
+  (void)printf("\n");
+  for (p = s; *p; p++)
+    (void)printf("%c", ismeta(*p) ? '_' : ' ');
+  (void)printf("\n");
+}
+#endif
diff --git a/Utilities/cmtar/compat/inet_aton.c b/Utilities/cmtar/compat/inet_aton.c
new file mode 100644
index 0000000..cc1e507
--- /dev/null
+++ b/Utilities/cmtar/compat/inet_aton.c
@@ -0,0 +1,27 @@
+/*
+**  Copyright 2002 University of Illinois Board of Trustees
+**  Copyright 2002 Mark D. Roth
+**  All rights reserved.
+**
+**  inet_aton.c - inet_aton() function for compatibility library
+**
+**  Mark D. Roth <roth@uiuc.edu>
+**  Campus Information Technologies and Educational Services
+**  University of Illinois at Urbana-Champaign
+*/
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+
+int
+inet_aton(const char *cp, struct in_addr *inp)
+{
+  inp->s_addr = inet_addr(cp);
+  if (inp->s_addr == -1)
+    return 0;
+  return 1;
+}
+
+
diff --git a/Utilities/cmtar/compat/snprintf.c b/Utilities/cmtar/compat/snprintf.c
new file mode 100644
index 0000000..a6d8c05
--- /dev/null
+++ b/Utilities/cmtar/compat/snprintf.c
@@ -0,0 +1,788 @@
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ *
+ * More Recently:
+ *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
+ *  This was ugly.  It is still ugly.  I opted out of floating point
+ *  numbers, but the formatter understands just about everything
+ *  from the normal C string format, at least as far as I can tell from
+ *  the Solaris 2.5 printf(3S) man page.
+ *
+ *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
+ *    Ok, added some minimal floating point support, which means this
+ *    probably requires libm on most operating systems.  Don't yet
+ *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
+ *    was pretty badly broken, it just wasn't being exercised in ways
+ *    which showed it, so that's been fixed.  Also, formated the code
+ *    to mutt conventions, and removed dead code left over from the
+ *    original.  Also, there is now a builtin-test, just compile with:
+ *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
+ *    and run snprintf for results.
+ * 
+ *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
+ *    The PGP code was using unsigned hexadecimal formats. 
+ *    Unfortunately, unsigned formats simply didn't work.
+ *
+ *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
+ *    The original code assumed that both snprintf() and vsnprintf() were
+ *    missing.  Some systems only have snprintf() but not vsnprintf(), so
+ *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
+ *
+ **************************************************************/
+
+#include <config.h>
+
+#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
+
+#include <string.h>
+# include <ctype.h>
+#include <sys/types.h>
+
+/* Define this as a fall through, HAVE_STDARG_H is probably already set */
+
+#define HAVE_VARARGS_H
+
+/* varargs declarations: */
+
+#if defined(HAVE_STDARG_H)
+# include <stdarg.h>
+# define HAVE_STDARGS    /* let's hope that works everywhere (mj) */
+# define VA_LOCAL_DECL   va_list ap
+# define VA_START(f)     va_start(ap, f)
+# define VA_SHIFT(v,t)  ;   /* no-op for ANSI */
+# define VA_END          va_end(ap)
+#else
+# if defined(HAVE_VARARGS_H)
+#  include <varargs.h>
+#  undef HAVE_STDARGS
+#  define VA_LOCAL_DECL   va_list ap
+#  define VA_START(f)     va_start(ap)      /* f is ignored! */
+#  define VA_SHIFT(v,t) v = va_arg(ap,t)
+#  define VA_END        va_end(ap)
+# else
+/*XX ** NO VARARGS ** XX*/
+# endif
+#endif
+
+/*int snprintf (char *str, size_t count, const char *fmt, ...);*/
+/*int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);*/
+
+static void dopr (char *buffer, size_t maxlen, const char *format, 
+                  va_list args);
+static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
+        char *value, int flags, int min, int max);
+static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
+        long value, int base, int min, int max, int flags);
+static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
+       long double fvalue, int min, int max, int flags);
+static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS   1
+#define DP_S_MIN     2
+#define DP_S_DOT     3
+#define DP_S_MAX     4
+#define DP_S_MOD     5
+#define DP_S_CONV    6
+#define DP_S_DONE    7
+
+/* format flags - Bits */
+#define DP_F_MINUS   (1 << 0)
+#define DP_F_PLUS    (1 << 1)
+#define DP_F_SPACE   (1 << 2)
+#define DP_F_NUM     (1 << 3)
+#define DP_F_ZERO    (1 << 4)
+#define DP_F_UP      (1 << 5)
+#define DP_F_UNSIGNED   (1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT   1
+#define DP_C_LONG    2
+#define DP_C_LDOUBLE 3
+
+#define char_to_int(p) (p - '0')
+#define MAX(p,q) ((p >= q) ? p : q)
+
+static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
+{
+  char ch;
+  long value;
+  long double fvalue;
+  char *strvalue;
+  int min;
+  int max;
+  int state;
+  int flags;
+  int cflags;
+  size_t currlen;
+  
+  state = DP_S_DEFAULT;
+  currlen = flags = cflags = min = 0;
+  max = -1;
+  ch = *format++;
+
+  while (state != DP_S_DONE)
+  {
+    if ((ch == '\0') || (currlen >= maxlen)) 
+      state = DP_S_DONE;
+
+    switch(state) 
+    {
+    case DP_S_DEFAULT:
+      if (ch == '%') 
+  state = DP_S_FLAGS;
+      else 
+  dopr_outch (buffer, &currlen, maxlen, ch);
+      ch = *format++;
+      break;
+    case DP_S_FLAGS:
+      switch (ch) 
+      {
+      case '-':
+  flags |= DP_F_MINUS;
+        ch = *format++;
+  break;
+      case '+':
+  flags |= DP_F_PLUS;
+        ch = *format++;
+  break;
+      case ' ':
+  flags |= DP_F_SPACE;
+        ch = *format++;
+  break;
+      case '#':
+  flags |= DP_F_NUM;
+        ch = *format++;
+  break;
+      case '0':
+  flags |= DP_F_ZERO;
+        ch = *format++;
+  break;
+      default:
+  state = DP_S_MIN;
+  break;
+      }
+      break;
+    case DP_S_MIN:
+      if (isdigit((unsigned char)ch)) 
+      {
+  min = 10*min + char_to_int (ch);
+  ch = *format++;
+      } 
+      else if (ch == '*') 
+      {
+  min = va_arg (args, int);
+  ch = *format++;
+  state = DP_S_DOT;
+      } 
+      else 
+  state = DP_S_DOT;
+      break;
+    case DP_S_DOT:
+      if (ch == '.') 
+      {
+  state = DP_S_MAX;
+  ch = *format++;
+      } 
+      else 
+  state = DP_S_MOD;
+      break;
+    case DP_S_MAX:
+      if (isdigit((unsigned char)ch)) 
+      {
+  if (max < 0)
+    max = 0;
+  max = 10*max + char_to_int (ch);
+  ch = *format++;
+      } 
+      else if (ch == '*') 
+      {
+  max = va_arg (args, int);
+  ch = *format++;
+  state = DP_S_MOD;
+      } 
+      else 
+  state = DP_S_MOD;
+      break;
+    case DP_S_MOD:
+      /* Currently, we don't support Long Long, bummer */
+      switch (ch) 
+      {
+      case 'h':
+  cflags = DP_C_SHORT;
+  ch = *format++;
+  break;
+      case 'l':
+  cflags = DP_C_LONG;
+  ch = *format++;
+  break;
+      case 'L':
+  cflags = DP_C_LDOUBLE;
+  ch = *format++;
+  break;
+      default:
+  break;
+      }
+      state = DP_S_CONV;
+      break;
+    case DP_S_CONV:
+      switch (ch) 
+      {
+      case 'd':
+      case 'i':
+  if (cflags == DP_C_SHORT) 
+    value = va_arg (args, short int);
+  else if (cflags == DP_C_LONG)
+    value = va_arg (args, long int);
+  else
+    value = va_arg (args, int);
+  fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+  break;
+      case 'o':
+  flags |= DP_F_UNSIGNED;
+  if (cflags == DP_C_SHORT)
+    value = va_arg (args, unsigned short int);
+  else if (cflags == DP_C_LONG)
+    value = va_arg (args, unsigned long int);
+  else
+    value = va_arg (args, unsigned int);
+  fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
+  break;
+      case 'u':
+  flags |= DP_F_UNSIGNED;
+  if (cflags == DP_C_SHORT)
+    value = va_arg (args, unsigned short int);
+  else if (cflags == DP_C_LONG)
+    value = va_arg (args, unsigned long int);
+  else
+    value = va_arg (args, unsigned int);
+  fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+  break;
+      case 'X':
+  flags |= DP_F_UP;
+      case 'x':
+  flags |= DP_F_UNSIGNED;
+  if (cflags == DP_C_SHORT)
+    value = va_arg (args, unsigned short int);
+  else if (cflags == DP_C_LONG)
+    value = va_arg (args, unsigned long int);
+  else
+    value = va_arg (args, unsigned int);
+  fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
+  break;
+      case 'f':
+  if (cflags == DP_C_LDOUBLE)
+    fvalue = va_arg (args, long double);
+  else
+    fvalue = va_arg (args, double);
+  /* um, floating point? */
+  fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
+  break;
+      case 'E':
+  flags |= DP_F_UP;
+      case 'e':
+  if (cflags == DP_C_LDOUBLE)
+    fvalue = va_arg (args, long double);
+  else
+    fvalue = va_arg (args, double);
+  break;
+      case 'G':
+  flags |= DP_F_UP;
+      case 'g':
+  if (cflags == DP_C_LDOUBLE)
+    fvalue = va_arg (args, long double);
+  else
+    fvalue = va_arg (args, double);
+  break;
+      case 'c':
+  dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
+  break;
+      case 's':
+  strvalue = va_arg (args, char *);
+  if (max < 0) 
+    max = maxlen; /* ie, no max */
+  fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
+  break;
+      case 'p':
+  strvalue = va_arg (args, void *);
+  fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
+  break;
+      case 'n':
+  if (cflags == DP_C_SHORT) 
+  {
+    short int *num;
+    num = va_arg (args, short int *);
+    *num = currlen;
+        } 
+  else if (cflags == DP_C_LONG) 
+  {
+    long int *num;
+    num = va_arg (args, long int *);
+    *num = currlen;
+        } 
+  else 
+  {
+    int *num;
+    num = va_arg (args, int *);
+    *num = currlen;
+        }
+  break;
+      case '%':
+  dopr_outch (buffer, &currlen, maxlen, ch);
+  break;
+      case 'w':
+  /* not supported yet, treat as next char */
+  ch = *format++;
+  break;
+      default:
+  /* Unknown, skip */
+  break;
+      }
+      ch = *format++;
+      state = DP_S_DEFAULT;
+      flags = cflags = min = 0;
+      max = -1;
+      break;
+    case DP_S_DONE:
+      break;
+    default:
+      /* hmm? */
+      break; /* some picky compilers need this */
+    }
+  }
+  if (currlen < maxlen - 1) 
+    buffer[currlen] = '\0';
+  else 
+    buffer[maxlen - 1] = '\0';
+}
+
+static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
+        char *value, int flags, int min, int max)
+{
+  int padlen, strln;     /* amount to pad */
+  int cnt = 0;
+  
+  if (value == 0)
+  {
+    value = "<NULL>";
+  }
+
+  for (strln = 0; value[strln]; ++strln); /* strlen */
+  padlen = min - strln;
+  if (padlen < 0) 
+    padlen = 0;
+  if (flags & DP_F_MINUS) 
+    padlen = -padlen; /* Left Justify */
+
+  while ((padlen > 0) && (cnt < max)) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --padlen;
+    ++cnt;
+  }
+  while (*value && (cnt < max)) 
+  {
+    dopr_outch (buffer, currlen, maxlen, *value++);
+    ++cnt;
+  }
+  while ((padlen < 0) && (cnt < max)) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++padlen;
+    ++cnt;
+  }
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
+        long value, int base, int min, int max, int flags)
+{
+  int signvalue = 0;
+  unsigned long uvalue;
+  char convert[20];
+  int place = 0;
+  int spadlen = 0; /* amount to space pad */
+  int zpadlen = 0; /* amount to zero pad */
+  int caps = 0;
+  
+  if (max < 0)
+    max = 0;
+
+  uvalue = value;
+
+  if(!(flags & DP_F_UNSIGNED))
+  {
+    if( value < 0 ) {
+      signvalue = '-';
+      uvalue = -value;
+    }
+    else
+      if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+  signvalue = '+';
+    else
+      if (flags & DP_F_SPACE)
+  signvalue = ' ';
+  }
+  
+  if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+
+  do {
+    convert[place++] =
+      (caps? "0123456789ABCDEF":"0123456789abcdef")
+      [uvalue % (unsigned)base  ];
+    uvalue = (uvalue / (unsigned)base );
+  } while(uvalue && (place < 20));
+  if (place == 20) place--;
+  convert[place] = 0;
+
+  zpadlen = max - place;
+  spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
+  if (zpadlen < 0) zpadlen = 0;
+  if (spadlen < 0) spadlen = 0;
+  if (flags & DP_F_ZERO)
+  {
+    zpadlen = MAX(zpadlen, spadlen);
+    spadlen = 0;
+  }
+  if (flags & DP_F_MINUS) 
+    spadlen = -spadlen; /* Left Justifty */
+
+#ifdef DEBUG_SNPRINTF
+  dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
+      zpadlen, spadlen, min, max, place));
+#endif
+
+  /* Spaces */
+  while (spadlen > 0) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --spadlen;
+  }
+
+  /* Sign */
+  if (signvalue) 
+    dopr_outch (buffer, currlen, maxlen, signvalue);
+
+  /* Zeros */
+  if (zpadlen > 0) 
+  {
+    while (zpadlen > 0)
+    {
+      dopr_outch (buffer, currlen, maxlen, '0');
+      --zpadlen;
+    }
+  }
+
+  /* Digits */
+  while (place > 0) 
+    dopr_outch (buffer, currlen, maxlen, convert[--place]);
+  
+  /* Left Justified spaces */
+  while (spadlen < 0) {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++spadlen;
+  }
+}
+
+static long double abs_val (long double value)
+{
+  long double result = value;
+
+  if (value < 0)
+    result = -value;
+
+  return result;
+}
+
+static long double pow10 (int exp)
+{
+  long double result = 1;
+
+  while (exp)
+  {
+    result *= 10;
+    exp--;
+  }
+  
+  return result;
+}
+
+static long round (long double value)
+{
+  long intpart;
+
+  intpart = value;
+  value = value - intpart;
+  if (value >= 0.5)
+    intpart++;
+
+  return intpart;
+}
+
+static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
+       long double fvalue, int min, int max, int flags)
+{
+  int signvalue = 0;
+  long double ufvalue;
+  char iconvert[20];
+  char fconvert[20];
+  int iplace = 0;
+  int fplace = 0;
+  int padlen = 0; /* amount to pad */
+  int zpadlen = 0; 
+  int caps = 0;
+  long intpart;
+  long fracpart;
+  
+  /* 
+   * AIX manpage says the default is 0, but Solaris says the default
+   * is 6, and sprintf on AIX defaults to 6
+   */
+  if (max < 0)
+    max = 6;
+
+  ufvalue = abs_val (fvalue);
+
+  if (fvalue < 0)
+    signvalue = '-';
+  else
+    if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+      signvalue = '+';
+    else
+      if (flags & DP_F_SPACE)
+  signvalue = ' ';
+
+#if 0
+  if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+#endif
+
+  intpart = ufvalue;
+
+  /* 
+   * Sorry, we only support 9 digits past the decimal because of our 
+   * conversion method
+   */
+  if (max > 9)
+    max = 9;
+
+  /* We "cheat" by converting the fractional part to integer by
+   * multiplying by a factor of 10
+   */
+  fracpart = round ((pow10 (max)) * (ufvalue - intpart));
+
+  if (fracpart >= pow10 (max))
+  {
+    intpart++;
+    fracpart -= pow10 (max);
+  }
+
+#ifdef DEBUG_SNPRINTF
+  dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart));
+#endif
+
+  /* Convert integer part */
+  do {
+    iconvert[iplace++] =
+      (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
+    intpart = (intpart / 10);
+  } while(intpart && (iplace < 20));
+  if (iplace == 20) iplace--;
+  iconvert[iplace] = 0;
+
+  /* Convert fractional part */
+  do {
+    fconvert[fplace++] =
+      (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
+    fracpart = (fracpart / 10);
+  } while(fracpart && (fplace < 20));
+  if (fplace == 20) fplace--;
+  fconvert[fplace] = 0;
+
+  /* -1 for decimal point, another -1 if we are printing a sign */
+  padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
+  zpadlen = max - fplace;
+  if (zpadlen < 0)
+    zpadlen = 0;
+  if (padlen < 0) 
+    padlen = 0;
+  if (flags & DP_F_MINUS) 
+    padlen = -padlen; /* Left Justifty */
+
+  if ((flags & DP_F_ZERO) && (padlen > 0)) 
+  {
+    if (signvalue) 
+    {
+      dopr_outch (buffer, currlen, maxlen, signvalue);
+      --padlen;
+      signvalue = 0;
+    }
+    while (padlen > 0)
+    {
+      dopr_outch (buffer, currlen, maxlen, '0');
+      --padlen;
+    }
+  }
+  while (padlen > 0)
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --padlen;
+  }
+  if (signvalue) 
+    dopr_outch (buffer, currlen, maxlen, signvalue);
+
+  while (iplace > 0) 
+    dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
+
+  /*
+   * Decimal point.  This should probably use locale to find the correct
+   * char to print out.
+   */
+  dopr_outch (buffer, currlen, maxlen, '.');
+
+  while (fplace > 0) 
+    dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
+
+  while (zpadlen > 0)
+  {
+    dopr_outch (buffer, currlen, maxlen, '0');
+    --zpadlen;
+  }
+
+  while (padlen < 0) 
+  {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++padlen;
+  }
+}
+
+static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
+{
+  if (*currlen < maxlen)
+    buffer[(*currlen)++] = c;
+}
+#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */
+
+#ifndef HAVE_VSNPRINTF
+int mutt_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
+{
+  str[0] = 0;
+  dopr(str, count, fmt, args);
+  return(strlen(str));
+}
+#endif /* !HAVE_VSNPRINTF */
+
+#ifndef HAVE_SNPRINTF
+/* VARARGS3 */
+#ifdef HAVE_STDARGS
+int mutt_snprintf (char *str,size_t count,const char *fmt,...)
+#else
+int mutt_snprintf (va_alist) va_dcl
+#endif
+{
+#ifndef HAVE_STDARGS
+  char *str;
+  size_t count;
+  char *fmt;
+#endif
+  VA_LOCAL_DECL;
+    
+  VA_START (fmt);
+  VA_SHIFT (str, char *);
+  VA_SHIFT (count, size_t );
+  VA_SHIFT (fmt, char *);
+  (void) mutt_vsnprintf(str, count, fmt, ap);
+  VA_END;
+  return(strlen(str));
+}
+
+#ifdef TEST_SNPRINTF
+#ifndef LONG_STRING
+#define LONG_STRING 1024
+#endif
+int main (void)
+{
+  char buf1[LONG_STRING];
+  char buf2[LONG_STRING];
+  char *fp_fmt[] = {
+    "%-1.5f",
+    "%1.5f",
+    "%123.9f",
+    "%10.5f",
+    "% 10.5f",
+    "%+22.9f",
+    "%+4.9f",
+    "%01.3f",
+    "%4f",
+    "%3.1f",
+    "%3.2f",
+    NULL
+  };
+  double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
+    0.9996, 1.996, 4.136, 0};
+  char *int_fmt[] = {
+    "%-1.5d",
+    "%1.5d",
+    "%123.9d",
+    "%5.5d",
+    "%10.5d",
+    "% 10.5d",
+    "%+22.33d",
+    "%01.3d",
+    "%4d",
+    NULL
+  };
+  long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
+  int x, y;
+  int fail = 0;
+  int num = 0;
+
+  printf ("Testing snprintf format codes against system sprintf...\n");
+
+  for (x = 0; fp_fmt[x] != NULL ; x++)
+    for (y = 0; fp_nums[y] != 0 ; y++)
+    {
+      mutt_snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
+      sprintf (buf2, fp_fmt[x], fp_nums[y]);
+      if (strcmp (buf1, buf2))
+      {
+  printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
+      fp_fmt[x], buf1, buf2);
+  fail++;
+      }
+      num++;
+    }
+
+  for (x = 0; int_fmt[x] != NULL ; x++)
+    for (y = 0; int_nums[y] != 0 ; y++)
+    {
+      mutt_snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]);
+      sprintf (buf2, int_fmt[x], int_nums[y]);
+      if (strcmp (buf1, buf2))
+      {
+  printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
+      int_fmt[x], buf1, buf2);
+  fail++;
+      }
+      num++;
+    }
+  printf ("%d tests failed out of %d.\n", fail, num);
+}
+#endif /* SNPRINTF_TEST */
+
+#endif /* !HAVE_SNPRINTF */
diff --git a/Utilities/cmtar/compat/strdup.c b/Utilities/cmtar/compat/strdup.c
new file mode 100644
index 0000000..9dabf37
--- /dev/null
+++ b/Utilities/cmtar/compat/strdup.c
@@ -0,0 +1,62 @@
+/*  $OpenBSD: strdup.c,v 1.3 1997/08/20 04:18:52 millert Exp $  */
+
+/*
+ * Copyright (c) 1988, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the University of
+ *  California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)strdup.c  8.1 (Berkeley) 6/4/93";
+#else
+static char *rcsid = "$OpenBSD: strdup.c,v 1.3 1997/08/20 04:18:52 millert Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *
+openbsd_strdup(str)
+  const char *str;
+{
+  size_t siz;
+  char *copy;
+
+  siz = strlen(str) + 1;
+  if ((copy = malloc(siz)) == NULL)
+    return(NULL);
+  (void)memcpy(copy, str, siz);
+  return(copy);
+}
diff --git a/Utilities/cmtar/compat/strlcat.c b/Utilities/cmtar/compat/strlcat.c
new file mode 100644
index 0000000..e8945c1
--- /dev/null
+++ b/Utilities/cmtar/compat/strlcat.c
@@ -0,0 +1,72 @@
+/*  $OpenBSD: strlcat.c,v 1.5 2001/01/13 16:17:24 millert Exp $  */
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: strlcat.c,v 1.5 2001/01/13 16:17:24 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(initial dst) + strlen(src); if retval >= siz,
+ * truncation occurred.
+ */
+size_t strlcat(dst, src, siz)
+  char *dst;
+  const char *src;
+  size_t siz;
+{
+  register char *d = dst;
+  register const char *s = src;
+  register size_t n = siz;
+  size_t dlen;
+
+  /* Find the end of dst and adjust bytes left but don't go past end */
+  while (n-- != 0 && *d != '\0')
+    d++;
+  dlen = d - dst;
+  n = siz - dlen;
+
+  if (n == 0)
+    return(dlen + strlen(s));
+  while (*s != '\0') {
+    if (n != 1) {
+      *d++ = *s;
+      n--;
+    }
+    s++;
+  }
+  *d = '\0';
+
+  return(dlen + (s - src));  /* count does not include NUL */
+}
diff --git a/Utilities/cmtar/compat/strlcpy.c b/Utilities/cmtar/compat/strlcpy.c
new file mode 100644
index 0000000..f85c71b
--- /dev/null
+++ b/Utilities/cmtar/compat/strlcpy.c
@@ -0,0 +1,68 @@
+/*  $OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp $  */
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t strlcpy(dst, src, siz)
+  char *dst;
+  const char *src;
+  size_t siz;
+{
+  register char *d = dst;
+  register const char *s = src;
+  register size_t n = siz;
+
+  /* Copy as many bytes as will fit */
+  if (n != 0 && --n != 0) {
+    do {
+      if ((*d++ = *s++) == 0)
+        break;
+    } while (--n != 0);
+  }
+
+  /* Not enough room in dst, add NUL and traverse rest of src */
+  if (n == 0) {
+    if (siz != 0)
+      *d = '\0';    /* NUL-terminate dst */
+    while (*s++)
+      ;
+  }
+
+  return(s - src - 1);  /* count does not include NUL */
+}
diff --git a/Utilities/cmtar/compat/strmode.c b/Utilities/cmtar/compat/strmode.c
new file mode 100644
index 0000000..832b0e7
--- /dev/null
+++ b/Utilities/cmtar/compat/strmode.c
@@ -0,0 +1,185 @@
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the University of
+ *  California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: strmode.c,v 1.3 1997/06/13 13:57:20 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <libtar/compat.h>
+
+void
+strmode(mode, p)
+  register mode_t mode;
+  register char *p;
+{
+   /* print type */
+  switch (mode & S_IFMT) {
+  case S_IFDIR:      /* directory */
+    *p++ = 'd';
+    break;
+  case S_IFCHR:      /* character special */
+    *p++ = 'c';
+    break;
+  case S_IFBLK:      /* block special */
+    *p++ = 'b';
+    break;
+  case S_IFREG:      /* regular */
+    *p++ = '-';
+    break;
+#ifdef S_IFLNK
+  case S_IFLNK:      /* symbolic link */
+    *p++ = 'l';
+    break;
+#endif
+#ifdef S_IFSOCK
+  case S_IFSOCK:      /* socket */
+    *p++ = 's';
+    break;
+#endif
+#ifdef S_IFIFO
+  case S_IFIFO:      /* fifo */
+    *p++ = 'p';
+    break;
+#endif
+#ifdef S_IFWHT
+  case S_IFWHT:      /* whiteout */
+    *p++ = 'w';
+    break;
+#endif
+  default:      /* unknown */
+    *p++ = '?';
+    break;
+  }
+  /* usr */
+#ifdef S_IRUSR
+  if (mode & S_IRUSR)
+    *p++ = 'r';
+  else
+#endif
+    *p++ = '-';
+
+#ifdef S_IWUSR
+  if (mode & S_IWUSR)
+    *p++ = 'w';
+  else
+#endif
+    *p++ = '-';
+
+#ifndef _MSC_VER
+#ifdef S_ISUID
+  switch (mode & (S_IXUSR | S_ISUID)) {
+#else
+  switch (mode & (S_IXUSR)) {
+#endif
+  case 0:
+    *p++ = '-';
+    break;
+  case S_IXUSR:
+    *p++ = 'x';
+    break;
+#ifdef S_ISUID
+  case S_ISUID:
+    *p++ = 'S';
+    break;
+  case S_IXUSR | S_ISUID:
+    *p++ = 's';
+    break;
+#endif
+  }
+#endif
+  /* group */
+#ifdef S_IRGRP
+  if (mode & S_IRGRP)
+    *p++ = 'r';
+  else
+#endif
+    *p++ = '-';
+#ifdef S_IWGRP
+  if (mode & S_IWGRP)
+    *p++ = 'w';
+  else
+#endif
+    *p++ = '-';
+#if defined(S_IXGRP) && defined(S_ISGID)
+  switch (mode & (S_IXGRP | S_ISGID)) {
+  case 0:
+    *p++ = '-';
+    break;
+  case S_IXGRP:
+    *p++ = 'x';
+    break;
+  case S_ISGID:
+    *p++ = 'S';
+    break;
+  case S_IXGRP | S_ISGID:
+    *p++ = 's';
+    break;
+  }
+#else
+  *p++ = '-';
+#endif
+#ifndef WIN32
+  /* other */
+  if (mode & S_IROTH)
+    *p++ = 'r';
+  else
+    *p++ = '-';
+  if (mode & S_IWOTH)
+    *p++ = 'w';
+  else
+    *p++ = '-';
+  switch (mode & (S_IXOTH | S_ISVTX)) {
+  case 0:
+    *p++ = '-';
+    break;
+  case S_IXOTH:
+    *p++ = 'x';
+    break;
+  case S_ISVTX:
+    *p++ = 'T';
+    break;
+  case S_IXOTH | S_ISVTX:
+    *p++ = 't';
+    break;
+  }
+#else
+  *p++ = '-';
+  *p++ = '-';
+  *p++ = '-';
+#endif
+  *p++ = ' ';    /* will be a '+' if ACL's implemented */
+  *p = '\0';
+}
diff --git a/Utilities/cmtar/compat/strrstr.c b/Utilities/cmtar/compat/strrstr.c
new file mode 100644
index 0000000..8b7f299
--- /dev/null
+++ b/Utilities/cmtar/compat/strrstr.c
@@ -0,0 +1,40 @@
+/*
+**  Copyright 1998-2002 University of Illinois Board of Trustees
+**  Copyright 1998-2002 Mark D. Roth
+**  All rights reserved.
+**
+**  strrstr.c - strrstr() function for compatibility library
+**
+**  Mark D. Roth <roth@uiuc.edu>
+**  Campus Information Technologies and Educational Services
+**  University of Illinois at Urbana-Champaign
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+
+#include <string.h>
+
+
+/*
+** find the last occurrance of find in string
+*/
+char *
+strrstr(char *string, char *find)
+{
+  size_t stringlen, findlen;
+  char *cp;
+
+  findlen = strlen(find);
+  stringlen = strlen(string);
+  if (findlen > stringlen)
+    return NULL;
+
+  for (cp = string + stringlen - findlen; cp >= string; cp--)
+    if (strncmp(cp, find, findlen) == 0)
+      return cp;
+
+  return NULL;
+}
+
+
diff --git a/Utilities/cmtar/compat/strsep.c b/Utilities/cmtar/compat/strsep.c
new file mode 100644
index 0000000..9d036a9
--- /dev/null
+++ b/Utilities/cmtar/compat/strsep.c
@@ -0,0 +1,87 @@
+/*  $OpenBSD: strsep.c,v 1.3 1997/08/20 04:28:14 millert Exp $  */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *  The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *  This product includes software developed by the University of
+ *  California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)strsep.c  8.1 (Berkeley) 6/4/93";
+#else
+static char *rcsid = "$OpenBSD: strsep.c,v 1.3 1997/08/20 04:28:14 millert Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#ifndef HAVE_STRSEP
+/*
+ * Get next token from string *stringp, where tokens are possibly-empty
+ * strings separated by characters from delim.  
+ *
+ * Writes NULs into the string at *stringp to end tokens.
+ * delim need not remain constant from call to call.
+ * On return, *stringp points past the last NUL written (if there might
+ * be further tokens), or is NULL (if there are definitely no more tokens).
+ *
+ * If *stringp is NULL, strsep returns NULL.
+ */
+char *
+strsep(stringp, delim)
+  register char **stringp;
+  register const char *delim;
+{
+  register char *s;
+  register const char *spanp;
+  register int c, sc;
+  char *tok;
+
+  if ((s = *stringp) == NULL)
+    return (NULL);
+  for (tok = s;;) {
+    c = *s++;
+    spanp = delim;
+    do {
+      if ((sc = *spanp++) == c) {
+        if (c == 0)
+          s = NULL;
+        else
+          s[-1] = 0;
+        *stringp = s;
+        return (tok);
+      }
+    } while (sc != 0);
+  }
+  /* NOTREACHED */
+}
+#endif /* ! HAVE_STRSEP */