ENH: Merge from the cpack branch

1 files changed, 4067 insertions, 0 deletions

diff --git a/Source/CPack/cmCPackTGZGenerator.cxx b/Source/CPack/cmCPackTGZGenerator.cxx
new file mode 100644
index 0000000..594e414
--- /dev/null
+++ b/Source/CPack/cmCPackTGZGenerator.cxx
@@ -0,0 +1,4067 @@
+/*=========================================================================
+
+  Program:   CMake - Cross-Platform Makefile Generator
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
+  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even 
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     PURPOSE.  See the above copyright notices for more information.
+
+=========================================================================*/
+
+#include "cmCPackTGZGenerator.h"
+
+#include "cmake.h"
+#include "cmGlobalGenerator.h"
+#include "cmLocalGenerator.h"
+#include "cmSystemTools.h"
+#include "cmMakefile.h"
+#include "cmGeneratedFileStream.h"
+
+#include <cmsys/SystemTools.hxx>
+#include <cmzlib/zlib.h>
+
+#include <memory> // auto_ptr
+#include <fcntl.h> // O_WRONLY, O_CREAT
+
+//----------------------------------------------------------------------
+cmCPackTGZGenerator::cmCPackTGZGenerator()
+{
+}
+
+//----------------------------------------------------------------------
+cmCPackTGZGenerator::~cmCPackTGZGenerator()
+{
+}
+
+//----------------------------------------------------------------------
+int cmCPackTGZGenerator::ProcessGenerator()
+{
+  return this->Superclass::ProcessGenerator();
+}
+
+//----------------------------------------------------------------------
+int cmCPackTGZGenerator::Initialize(const char* name)
+{
+  return this->Superclass::Initialize(name);
+}
+
+//----------------------------------------------------------------------
+// The following code is modified version of bsdtar
+/*-
+* Copyright (c) 2003-2004 Tim Kientzle
+* 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
+*    in this position and unchanged.
+* 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.
+*
+* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``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(S) 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(HAVE_IO_H)
+#  include <io.h>
+#endif
+#if defined(HAVE_UNISTD_H)
+#  include <unistd.h> // for geteuid
+#endif
+#if defined(HAVE_INTTYPES_H)
+#  include <inttypes.h> // for uintptr_t
+#endif
+#include <sys/types.h>
+#include <errno.h> // for ENOMEM
+#include <sys/stat.h> // for struct stat
+#include <time.h> // for time
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+#  ifndef S_ISREG
+#    define S_ISREG(x) ((x) & _S_IFREG)
+#  endif
+#  ifndef S_ISLNK
+#    define S_ISLNK(x) (0)
+#  endif
+#endif
+
+  //--- archive_plarform.h
+  //
+  /* Set up defaults for internal error codes. */
+#ifndef ARCHIVE_ERRNO_FILE_FORMAT
+#if HAVE_EFTYPE
+#define ARCHIVE_ERRNO_FILE_FORMAT EFTYPE
+#else
+#if HAVE_EILSEQ
+#define ARCHIVE_ERRNO_FILE_FORMAT EILSEQ
+#else
+#define ARCHIVE_ERRNO_FILE_FORMAT EINVAL
+#endif
+#endif
+#endif
+
+#ifndef ARCHIVE_ERRNO_PROGRAMMER
+#define ARCHIVE_ERRNO_PROGRAMMER EINVAL
+#endif
+
+#ifndef ARCHIVE_ERRNO_MISC
+#define ARCHIVE_ERRNO_MISC (-1)
+#endif
+
+  /* Select the best way to set/get hi-res timestamps. */
+#if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC
+  /* FreeBSD uses "timespec" members. */
+#define ARCHIVE_STAT_ATIME_NANOS(st) (st)->st_atimespec.tv_nsec
+#define ARCHIVE_STAT_CTIME_NANOS(st) (st)->st_ctimespec.tv_nsec
+#define ARCHIVE_STAT_MTIME_NANOS(st) (st)->st_mtimespec.tv_nsec
+#define ARCHIVE_STAT_SET_ATIME_NANOS(st, n) (st)->st_atimespec.tv_nsec = (n)
+#define ARCHIVE_STAT_SET_CTIME_NANOS(st, n) (st)->st_ctimespec.tv_nsec = (n)
+#define ARCHIVE_STAT_SET_MTIME_NANOS(st, n) (st)->st_mtimespec.tv_nsec = (n)
+#else
+#if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
+  /* Linux uses "tim" members. */
+#define ARCHIVE_STAT_ATIME_NANOS(pstat) (pstat)->st_atim.tv_nsec
+#define ARCHIVE_STAT_CTIME_NANOS(pstat) (pstat)->st_ctim.tv_nsec
+#define ARCHIVE_STAT_MTIME_NANOS(pstat) (pstat)->st_mtim.tv_nsec
+#define ARCHIVE_STAT_SET_ATIME_NANOS(st, n) (st)->st_atim.tv_nsec = (n)
+#define ARCHIVE_STAT_SET_CTIME_NANOS(st, n) (st)->st_ctim.tv_nsec = (n)
+#define ARCHIVE_STAT_SET_MTIME_NANOS(st, n) (st)->st_mtim.tv_nsec = (n)
+#else
+  /* If we can't find a better way, just use stubs. */
+#define ARCHIVE_STAT_ATIME_NANOS(pstat) 0
+#define ARCHIVE_STAT_CTIME_NANOS(pstat) 0
+#define ARCHIVE_STAT_MTIME_NANOS(pstat) 0
+#define ARCHIVE_STAT_SET_ATIME_NANOS(st, n)
+#define ARCHIVE_STAT_SET_CTIME_NANOS(st, n)
+#define ARCHIVE_STAT_SET_MTIME_NANOS(st, n)
+#endif
+#endif
+
+  //--- archive.h
+
+#define ARCHIVE_BYTES_PER_RECORD   512
+#define ARCHIVE_DEFAULT_BYTES_PER_BLOCK 10240
+
+  /* Declare our basic types. */
+  struct archive;
+  struct archive_entry;
+
+  /*
+   * Error codes: Use archive_errno() and archive_error_string()
+   * to retrieve details.  Unless specified otherwise, all functions
+   * that return 'int' use these codes.
+   */
+#define ARCHIVE_EOF   1 /* Found end of archive. */
+#define ARCHIVE_OK   0 /* Operation was successful. */
+#define ARCHIVE_RETRY (-10) /* Retry might succeed. */
+#define ARCHIVE_WARN (-20) /* Partial sucess. */
+#define ARCHIVE_FATAL (-30) /* No more operations are possible. */
+
+  /*
+   * As far as possible, archive_errno returns standard platform errno codes.
+   * Of course, the details vary by platform, so the actual definitions
+   * here are stored in "archive_platform.h".  The symbols are listed here
+   * for reference; as a rule, clients should not need to know the exact
+   * platform-dependent error code.
+   */
+  /* Unrecognized or invalid file format. */
+  /* #define ARCHIVE_ERRNO_FILE_FORMAT */
+  /* Illegal usage of the library. */
+  /* #define ARCHIVE_ERRNO_PROGRAMMER_ERROR */
+  /* Unknown or unclassified error. */
+  /* #define ARCHIVE_ERRNO_MISC */
+
+  /*
+   * Callbacks are invoked to automatically read/write/open/close the archive.
+   * You can provide your own for complex tasks (like breaking archives
+   * across multiple tapes) or use standard ones built into the library.
+   */
+
+  /* Returns pointer and size of next block of data from archive. */
+  typedef ssize_t archive_read_callback(struct archive *, void *_client_data,
+    const void **_buffer);
+/* Returns size actually written, zero on EOF, -1 on error. */
+typedef ssize_t archive_write_callback(struct archive *, void *_client_data,
+  void *_buffer, size_t _length);
+typedef int archive_open_callback(struct archive *, void *_client_data);
+typedef int archive_close_callback(struct archive *, void *_client_data);
+
+/*
+ * Codes for archive_compression.
+ */
+#define ARCHIVE_COMPRESSION_NONE 0
+#define ARCHIVE_COMPRESSION_GZIP 1
+#define ARCHIVE_COMPRESSION_BZIP2 2
+#define ARCHIVE_COMPRESSION_COMPRESS 3
+
+/*
+ * Codes returned by archive_format.
+ *
+ * Top 16 bits identifies the format family (e.g., "tar"); lower
+ * 16 bits indicate the variant.  This is updated by read_next_header.
+ * Note that the lower 16 bits will often vary from entry to entry.
+ */
+#define ARCHIVE_FORMAT_BASE_MASK  0xff0000U
+#define ARCHIVE_FORMAT_CPIO   0x10000
+#define ARCHIVE_FORMAT_CPIO_POSIX  (ARCHIVE_FORMAT_CPIO | 1)
+#define ARCHIVE_FORMAT_SHAR   0x20000
+#define ARCHIVE_FORMAT_SHAR_BASE  (ARCHIVE_FORMAT_SHAR | 1)
+#define ARCHIVE_FORMAT_SHAR_DUMP  (ARCHIVE_FORMAT_SHAR | 2)
+#define ARCHIVE_FORMAT_TAR   0x30000
+#define ARCHIVE_FORMAT_TAR_USTAR  (ARCHIVE_FORMAT_TAR | 1)
+#define ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE (ARCHIVE_FORMAT_TAR | 2)
+#define ARCHIVE_FORMAT_TAR_PAX_RESTRICTED (ARCHIVE_FORMAT_TAR | 3)
+#define ARCHIVE_FORMAT_TAR_GNUTAR  (ARCHIVE_FORMAT_TAR | 4)
+#define ARCHIVE_FORMAT_ISO9660   0x40000
+#define ARCHIVE_FORMAT_ISO9660_ROCKRIDGE (ARCHIVE_FORMAT_ISO9660 | 1)
+#define ARCHIVE_FORMAT_ZIP   0x50000
+
+/*-
+ * Basic outline for reading an archive:
+ *   1) Ask archive_read_new for an archive reader object.
+ *   2) Update any global properties as appropriate.
+ *      In particular, you'll certainly want to call appropriate
+ *      archive_read_support_XXX functions.
+ *   3) Call archive_read_open_XXX to open the archive
+ *   4) Repeatedly call archive_read_next_header to get information about
+ *      successive archive entries.  Call archive_read_data to extract
+ *      data for entries of interest.
+ *   5) Call archive_read_finish to end processing.
+ */
+struct archive *archive_read_new(void);
+
+/*
+ * The archive_read_support_XXX calls enable auto-detect for this
+ * archive handle.  They also link in the necessary support code.
+ * For example, if you don't want bzlib linked in, don't invoke
+ * support_compression_bzip2().  The "all" functions provide the
+ * obvious shorthand.
+ */
+int   archive_read_support_compression_all(struct archive *);
+int   archive_read_support_compression_bzip2(struct archive *);
+int   archive_read_support_compression_compress(struct archive *);
+int   archive_read_support_compression_gzip(struct archive *);
+int   archive_read_support_compression_none(struct archive *);
+
+int   archive_read_support_format_all(struct archive *);
+int   archive_read_support_format_cpio(struct archive *);
+int   archive_read_support_format_gnutar(struct archive *);
+int   archive_read_support_format_iso9660(struct archive *);
+int   archive_read_support_format_tar(struct archive *);
+int   archive_read_support_format_tp(struct archive *a);
+int   archive_read_support_format_zip(struct archive *);
+
+
+/* Open the archive using callbacks for archive I/O. */
+int   archive_read_open(struct archive *, void *_client_data,
+  archive_open_callback *, archive_read_callback *,
+  archive_close_callback *);
+
+/*
+ * The archive_read_open_file function is a convenience function built
+ * on archive_read_open that uses a canned callback suitable for
+ * common situations.  Note that a NULL filename indicates stdin.
+ */
+int   archive_read_open_file(struct archive *, const char *_file,
+  size_t _block_size);
+int   archive_read_open_fd(struct archive *, int _fd,
+  size_t _block_size);
+
+/* Parses and returns next entry header. */
+int   archive_read_next_header(struct archive *,
+  struct archive_entry **);
+
+/*
+ * Retrieve the byte offset in UNCOMPRESSED data where last-read
+ * header started.
+ */
+int64_t   archive_read_header_position(struct archive *);
+
+/* Read data from the body of an entry.  Similar to read(2). */
+ssize_t   archive_read_data(struct archive *, void *, size_t);
+/*
+ * A zero-copy version of archive_read_data that also exposes the file offset
+ * of each returned block.  Note that the client has no way to specify
+ * the desired size of the block.  The API does gaurantee that offsets will
+ * be strictly increasing and that returned blocks will not overlap.
+ */
+int   archive_read_data_block(struct archive *a,
+  const void **buff, size_t *size, off_t *offset);
+
+/*-
+ * Some convenience functions that are built on archive_read_data:
+ *  'skip': skips entire entry
+ *  'into_buffer': writes data into memory buffer that you provide
+ *  'into_fd': writes data to specified filedes
+ */
+int   archive_read_data_skip(struct archive *);
+int   archive_read_data_into_buffer(struct archive *, void *buffer,
+  ssize_t len);
+int   archive_read_data_into_fd(struct archive *, int fd);
+
+/*-
+ * Convenience function to recreate the current entry (whose header
+ * has just been read) on disk.
+ *
+ * This does quite a bit more than just copy data to disk. It also:
+ *  - Creates intermediate directories as required.
+ *  - Manages directory permissions:  non-writable directories will
+ *    be initially created with write permission enabled; when the
+ *    archive is closed, dir permissions are edited to the values specified
+ *    in the archive.
+ *  - Checks hardlinks:  hardlinks will not be extracted unless the
+ *    linked-to file was also extracted within the same session. (TODO)
+ */
+
+/* The "flags" argument selects optional behavior, 'OR' the flags you want. */
+/* TODO: The 'Default' comments here are not quite correct; clean this up. */
+#define ARCHIVE_EXTRACT_OWNER (1) /* Default: owner/group not restored */
+#define ARCHIVE_EXTRACT_PERM (2) /* Default: restore perm only for reg file*/
+#define ARCHIVE_EXTRACT_TIME (4) /* Default: mod time not restored */
+#define ARCHIVE_EXTRACT_NO_OVERWRITE (8) /* Default: Replace files on disk */
+#define ARCHIVE_EXTRACT_UNLINK (16) /* Default: don't unlink existing files */
+#define ARCHIVE_EXTRACT_ACL (32) /* Default: don't restore ACLs */
+#define ARCHIVE_EXTRACT_FFLAGS (64) /* Default: don't restore fflags */
+
+int   archive_read_extract(struct archive *, struct archive_entry *,
+  int flags);
+void   archive_read_extract_set_progress_callback(struct archive *,
+  void (*_progress_func)(void *), void *_user_data);
+
+/* Close the file and release most resources. */
+int   archive_read_close(struct archive *);
+/* Release all resources and destroy the object. */
+/* Note that archive_read_finish will call archive_read_close for you. */
+void   archive_read_finish(struct archive *);
+
+/*-
+ * To create an archive:
+ *   1) Ask archive_write_new for a archive writer object.
+ *   2) Set any global properties.  In particular, you should set
+ *      the compression and format to use.
+ *   3) Call archive_write_open to open the file (most people
+ *       will use archive_write_open_file or archive_write_open_fd,
+ *       which provide convenient canned I/O callbacks for you).
+ *   4) For each entry:
+ *      - construct an appropriate struct archive_entry structure
+ *      - archive_write_header to write the header
+ *      - archive_write_data to write the entry data
+ *   5) archive_write_close to close the output
+ *   6) archive_write_finish to cleanup the writer and release resources
+ */
+struct archive *archive_write_new(void);
+int   archive_write_set_bytes_per_block(struct archive *,
+  int bytes_per_block);
+/* XXX This is badly misnamed; suggestions appreciated. XXX */
+int   archive_write_set_bytes_in_last_block(struct archive *,
+  int bytes_in_last_block);
+
+int   archive_write_set_compression_bzip2(struct archive *);
+int   archive_write_set_compression_gzip(struct archive *);
+int   archive_write_set_compression_none(struct archive *);
+/* A convenience function to set the format based on the code or name. */
+int   archive_write_set_format(struct archive *, int format_code);
+int   archive_write_set_format_by_name(struct archive *,
+  const char *name);
+/* To minimize link pollution, use one or more of the following. */
+int   archive_write_set_format_cpio(struct archive *);
+/* TODO: int archive_write_set_format_old_tar(struct archive *); */
+int   archive_write_set_format_pax(struct archive *);
+int   archive_write_set_format_pax_restricted(struct archive *);
+int   archive_write_set_format_shar(struct archive *);
+int   archive_write_set_format_shar_dump(struct archive *);
+int   archive_write_set_format_ustar(struct archive *);
+int   archive_write_open(struct archive *, void *,
+  archive_open_callback *, archive_write_callback *,
+  archive_close_callback *);
+int   archive_write_open_fd(struct archive *, int _fd);
+int   archive_write_open_file(struct archive *, const char *_file);
+
+/*
+ * Note that the library will truncate writes beyond the size provided
+ * to archive_write_header or pad if the provided data is short.
+ */
+int   archive_write_header(struct archive *,
+  struct archive_entry *);
+/* TODO: should be ssize_t, but that might require .so version bump? */
+int   archive_write_data(struct archive *, const void *, size_t);
+int   archive_write_close(struct archive *);
+void   archive_write_finish(struct archive *);
+
+/*
+ * Accessor functions to read/set various information in
+ * the struct archive object:
+ */
+/* Bytes written after compression or read before decompression. */
+int64_t   archive_position_compressed(struct archive *);
+/* Bytes written to compressor or read from decompressor. */
+int64_t   archive_position_uncompressed(struct archive *);
+
+const char *archive_compression_name(struct archive *);
+int   archive_compression(struct archive *);
+int   archive_errno(struct archive *);
+const char *archive_error_string(struct archive *);
+const char *archive_format_name(struct archive *);
+int   archive_format(struct archive *);
+void   archive_set_error(struct archive *, int _err, const char *fmt, ...);
+
+//--- archive_string.h
+/*
+ * Basic resizable/reusable string support a la Java's "StringBuffer."
+ *
+ * Unlike sbuf(9), the buffers here are fully reusable and track the
+ * length throughout.
+ *
+ * Note that all visible symbols here begin with "__archive" as they
+ * are internal symbols not intended for anyone outside of this library
+ * to see or use.
+ */
+
+struct archive_string {
+  char *s;  /* Pointer to the storage */
+  size_t  length; /* Length of 's' */
+  size_t  buffer_length; /* Length of malloc-ed storage */
+};
+
+/* Initialize an archive_string object on the stack or elsewhere. */
+#define archive_string_init(a) \
+  do { (a)->s = NULL; (a)->length = 0; (a)->buffer_length = 0; } while(0)
+
+/* Append a C char to an archive_string, resizing as necessary. */
+struct archive_string *
+__archive_strappend_char(struct archive_string *, char);
+#define archive_strappend_char __archive_strappend_char
+
+/* Append a char to an archive_string using UTF8. */
+struct archive_string *
+__archive_strappend_char_UTF8(struct archive_string *, int);
+#define archive_strappend_char_UTF8 __archive_strappend_char_UTF8
+
+/* Append an integer in the specified base (2 <= base <= 16). */
+struct archive_string *
+__archive_strappend_int(struct archive_string *as, int d, int base);
+#define archive_strappend_int __archive_strappend_int
+
+/* Basic append operation. */
+struct archive_string *
+__archive_string_append(struct archive_string *as, const char *p, size_t s);
+
+/* Ensure that the underlying buffer is at least as large as the request. */
+struct archive_string *
+__archive_string_ensure(struct archive_string *, size_t);
+#define archive_string_ensure __archive_string_ensure
+
+/* Append C string, which may lack trailing \0. */
+struct archive_string *
+__archive_strncat(struct archive_string *, const char *, size_t);
+#define archive_strncat  __archive_strncat
+
+/* Append a C string to an archive_string, resizing as necessary. */
+#define archive_strcat(as,p) __archive_string_append((as),(p),strlen(p))
+
+/* Copy a C string to an archive_string, resizing as necessary. */
+#define archive_strcpy(as,p) \
+  ((as)->length = 0, __archive_string_append((as), (p), strlen(p)))
+
+/* Copy a C string to an archive_string with limit, resizing as necessary. */
+#define archive_strncpy(as,p,l) \
+  ((as)->length=0, archive_strncat((as), (p), (l)))
+
+/* Return length of string. */
+#define archive_strlen(a) ((a)->length)
+
+/* Set string length to zero. */
+#define archive_string_empty(a) ((a)->length = 0)
+
+/* Release any allocated storage resources. */
+void __archive_string_free(struct archive_string *);
+#define archive_string_free  __archive_string_free
+
+/* Like 'vsprintf', but resizes the underlying string as necessary. */
+void __archive_string_vsprintf(struct archive_string *, const char *,
+  va_list);
+#define archive_string_vsprintf __archive_string_vsprintf
+//--- archive_private.h
+
+#define ARCHIVE_WRITE_MAGIC (0xb0c5c0deU)
+#define ARCHIVE_READ_MAGIC (0xdeb0c5U)
+
+struct archive {
+  /*
+   * The magic/state values are used to sanity-check the
+   * client's usage.  If an API function is called at a
+   * rediculous time, or the client passes us an invalid
+   * pointer, these values allow me to catch that.
+   */
+  unsigned   magic;
+  unsigned   state;
+
+  struct archive_entry *entry;
+  uid_t    user_uid; /* UID of current user. */
+
+  /* Dev/ino of the archive being read/written. */
+  dev_t    skip_file_dev;
+  ino_t    skip_file_ino;
+
+  /* Utility:  Pointer to a block of nulls. */
+  const unsigned char *nulls;
+  size_t    null_length;
+
+  /*
+   * Used by archive_read_data() to track blocks and copy
+   * data to client buffers, filling gaps with zero bytes.
+   */
+  const char  *read_data_block;
+  off_t    read_data_offset;
+  off_t    read_data_output_offset;
+  size_t    read_data_remaining;
+
+  /* Callbacks to open/read/write/close archive stream. */
+  archive_open_callback *client_opener;
+  archive_read_callback *client_reader;
+  archive_write_callback *client_writer;
+  archive_close_callback *client_closer;
+  void   *client_data;
+
+  /*
+   * Blocking information.  Note that bytes_in_last_block is
+   * misleadingly named; I should find a better name.  These
+   * control the final output from all compressors, including
+   * compression_none.
+   */
+  int    bytes_per_block;
+  int    bytes_in_last_block;
+
+  /*
+   * These control whether data within a gzip/bzip2 compressed
+   * stream gets padded or not.  If pad_uncompressed is set,
+   * the data will be padded to a full block before being
+   * compressed.  The pad_uncompressed_byte determines the value
+   * that will be used for padding.  Note that these have no
+   * effect on compression "none."
+   */
+  int    pad_uncompressed;
+  int    pad_uncompressed_byte; /* TODO: Support this. */
+
+  /* Position in UNCOMPRESSED data stream. */
+  off_t    file_position;
+  /* Position in COMPRESSED data stream. */
+  off_t    raw_position;
+  /* File offset of beginning of most recently-read header. */
+  off_t    header_position;
+
+  /*
+   * Detection functions for decompression: bid functions are
+   * given a block of data from the beginning of the stream and
+   * can bid on whether or not they support the data stream.
+   * General guideline: bid the number of bits that you actually
+   * test, e.g., 16 if you test a 2-byte magic value.  The
+   * highest bidder will have their init function invoked, which
+   * can set up pointers to specific handlers.
+   *
+   * On write, the client just invokes an archive_write_set function
+   * which sets up the data here directly.
+   */
+  int   compression_code; /* Currently active compression. */
+  const char *compression_name;
+  struct {
+    int (*bid)(const void *buff, size_t);
+    int (*init)(struct archive *, const void *buff, size_t);
+  } decompressors[4];
+  /* Read/write data stream (with compression). */
+  void  *compression_data;  /* Data for (de)compressor. */
+  int (*compression_init)(struct archive *); /* Initialize. */
+  int (*compression_finish)(struct archive *);
+  int (*compression_write)(struct archive *, const void *, size_t);
+  /*
+   * Read uses a peek/consume I/O model: the decompression code
+   * returns a pointer to the requested block and advances the
+   * file position only when requested by a consume call.  This
+   * reduces copying and also simplifies look-ahead for format
+   * detection.
+   */
+  ssize_t (*compression_read_ahead)(struct archive *,
+    const void **, size_t request);
+  ssize_t (*compression_read_consume)(struct archive *, size_t);
+
+  /*
+   * Format detection is mostly the same as compression
+   * detection, with two significant differences: The bidders
+   * use the read_ahead calls above to examine the stream rather
+   * than having the supervisor hand them a block of data to
+   * examine, and the auction is repeated for every header.
+   * Winning bidders should set the archive_format and
+   * archive_format_name appropriately.  Bid routines should
+   * check archive_format and decline to bid if the format of
+   * the last header was incompatible.
+   *
+   * Again, write support is considerably simpler because there's
+   * no need for an auction.
+   */
+  int    archive_format;
+  const char  *archive_format_name;
+
+  struct archive_format_descriptor {
+    int (*bid)(struct archive *);
+    int (*read_header)(struct archive *, struct archive_entry *);
+    int (*read_data)(struct archive *, const void **, size_t *, off_t *);
+    int (*read_data_skip)(struct archive *);
+    int (*cleanup)(struct archive *);
+    void  *format_data; /* Format-specific data for readers. */
+  } formats[8];
+  struct archive_format_descriptor *format; /* Active format. */
+
+  /*
+   * Storage for format-specific data.  Note that there can be
+   * multiple format readers active at one time, so we need to
+   * allow for multiple format readers to have their data
+   * available.  The pformat_data slot here is the solution: on
+   * read, it is gauranteed to always point to a void* variable
+   * that the format can use.
+   */
+  void **pformat_data;  /* Pointer to current format_data. */
+  void  *format_data;  /* Used by writers. */
+
+  /*
+   * Pointers to format-specific functions for writing.  They're
+   * initialized by archive_write_set_format_XXX() calls.
+   */
+  int (*format_init)(struct archive *); /* Only used on write. */
+  int (*format_finish)(struct archive *);
+  int (*format_finish_entry)(struct archive *);
+  int  (*format_write_header)(struct archive *,
+    struct archive_entry *);
+  int (*format_write_data)(struct archive *,
+    const void *buff, size_t);
+
+  /*
+   * Various information needed by archive_extract.
+   */
+  struct extract   *extract;
+  void   (*extract_progress)(void *);
+  void    *extract_progress_user_data;
+  void   (*cleanup_archive_extract)(struct archive *);
+
+  int    archive_error_number;
+  const char  *error;
+  struct archive_string error_string;
+};
+
+
+#define ARCHIVE_STATE_ANY 0xFFFFU
+#define ARCHIVE_STATE_NEW 1U
+#define ARCHIVE_STATE_HEADER 2U
+#define ARCHIVE_STATE_DATA 4U
+#define ARCHIVE_STATE_EOF 8U
+#define ARCHIVE_STATE_CLOSED 0x10U
+#define ARCHIVE_STATE_FATAL 0x8000U
+
+/* Check magic value and state; exit if it isn't valid. */
+void __archive_check_magic(struct archive *, unsigned magic,
+  unsigned state, const char *func);
+
+
+int __archive_read_register_format(struct archive *a,
+  void *format_data,
+  int (*bid)(struct archive *),
+  int (*read_header)(struct archive *, struct archive_entry *),
+  int (*read_data)(struct archive *, const void **, size_t *, off_t *),
+  int (*read_data_skip)(struct archive *),
+  int (*cleanup)(struct archive *));
+
+int __archive_read_register_compression(struct archive *a,
+  int (*bid)(const void *, size_t),
+  int (*init)(struct archive *, const void *, size_t));
+
+void __archive_errx(int retvalue, const char *msg);
+
+#define err_combine(a,b) ((a) < (b) ? (a) : (b))
+
+
+                                             /*
+                                              * Utility function to format a USTAR header into a buffer.  If
+                                              * "strict" is set, this tries to create the absolutely most portable
+                                              * version of a ustar header.  If "strict" is set to 0, then it will
+                                              * relax certain requirements.
+                                              *
+                                              * Generally, format-specific declarations don't belong in this
+                                              * header; this is a rare example of a function that is shared by
+                                              * two very similar formats (ustar and pax).
+                                              */
+                                             int
+                                             __archive_write_format_header_ustar(struct archive *, char buff[512],
+                                               struct archive_entry *, int tartype, int strict);
+
+//--- archive_entry.h
+
+/*
+ * Description of an archive entry.
+ *
+ * Basically, a "struct stat" with a few text fields added in.
+ *
+ * TODO: Add "comment", "charset", and possibly other entries that are
+ * supported by "pax interchange" format.  However, GNU, ustar, cpio,
+ * and other variants don't support these features, so they're not an
+ * excruciatingly high priority right now.
+ *
+ * TODO: "pax interchange" format allows essentially arbitrary
+ * key/value attributes to be attached to any entry.  Supporting
+ * such extensions may make this library useful for special
+ * applications (e.g., a package manager could attach special
+ * package-management attributes to each entry).
+ */
+struct archive_entry;
+
+/*
+ * Basic object manipulation
+ */
+
+struct archive_entry *archive_entry_clear(struct archive_entry *);
+/* The 'clone' function does a deep copy; all of the strings are copied too. */
+struct archive_entry *archive_entry_clone(struct archive_entry *);
+void    archive_entry_free(struct archive_entry *);
+struct archive_entry *archive_entry_new(void);
+
+/*
+ * Retrieve fields from an archive_entry.
+ */
+
+time_t    archive_entry_atime(struct archive_entry *);
+long    archive_entry_atime_nsec(struct archive_entry *);
+time_t    archive_entry_ctime(struct archive_entry *);
+long    archive_entry_ctime_nsec(struct archive_entry *);
+dev_t    archive_entry_dev(struct archive_entry *);
+void    archive_entry_fflags(struct archive_entry *,
+  unsigned long *set, unsigned long *clear);
+const char  *archive_entry_fflags_text(struct archive_entry *);
+gid_t    archive_entry_gid(struct archive_entry *);
+const char  *archive_entry_gname(struct archive_entry *);
+const wchar_t  *archive_entry_gname_w(struct archive_entry *);
+const char  *archive_entry_hardlink(struct archive_entry *);
+const wchar_t  *archive_entry_hardlink_w(struct archive_entry *);
+ino_t    archive_entry_ino(struct archive_entry *);
+mode_t    archive_entry_mode(struct archive_entry *);
+time_t    archive_entry_mtime(struct archive_entry *);
+long    archive_entry_mtime_nsec(struct archive_entry *);
+const char  *archive_entry_pathname(struct archive_entry *);
+const wchar_t  *archive_entry_pathname_w(struct archive_entry *);
+dev_t    archive_entry_rdev(struct archive_entry *);
+int64_t    archive_entry_size(struct archive_entry *);
+const struct stat *archive_entry_stat(struct archive_entry *);
+const char  *archive_entry_symlink(struct archive_entry *);
+const wchar_t  *archive_entry_symlink_w(struct archive_entry *);
+uid_t    archive_entry_uid(struct archive_entry *);
+const char  *archive_entry_uname(struct archive_entry *);
+const wchar_t  *archive_entry_uname_w(struct archive_entry *);
+
+/*
+ * Set fields in an archive_entry.
+ *
+ * Note that string 'set' functions do not copy the string, only the pointer.
+ * In contrast, 'copy' functions do copy the object pointed to.
+ */
+
+void archive_entry_copy_stat(struct archive_entry *, const struct stat *);
+void archive_entry_set_atime(struct archive_entry *, time_t, long);
+void archive_entry_set_ctime(struct archive_entry *, time_t, long);
+void archive_entry_set_fflags(struct archive_entry *,
+  unsigned long set, unsigned long clear);
+/* Returns pointer to start of first invalid token, or NULL if none. */
+/* Note that all recognized tokens are processed, regardless. */
+const wchar_t *archive_entry_copy_fflags_text_w(struct archive_entry *,
+  const wchar_t *);
+void archive_entry_set_gid(struct archive_entry *, gid_t);
+void archive_entry_set_gname(struct archive_entry *, const char *);
+void archive_entry_copy_gname_w(struct archive_entry *, const wchar_t *);
+void archive_entry_set_hardlink(struct archive_entry *, const char *);
+void archive_entry_copy_hardlink(struct archive_entry *, const char *);
+void archive_entry_copy_hardlink_w(struct archive_entry *, const wchar_t *);
+void archive_entry_set_link(struct archive_entry *, const char *);
+void archive_entry_set_mode(struct archive_entry *, mode_t);
+void archive_entry_set_mtime(struct archive_entry *, time_t, long);
+void archive_entry_set_pathname(struct archive_entry *, const char *);
+void archive_entry_copy_pathname(struct archive_entry *, const char *);
+void archive_entry_copy_pathname_w(struct archive_entry *, const wchar_t *);
+void archive_entry_set_size(struct archive_entry *, int64_t);
+void archive_entry_set_symlink(struct archive_entry *, const char *);
+void archive_entry_copy_symlink_w(struct archive_entry *, const wchar_t *);
+void archive_entry_set_uid(struct archive_entry *, uid_t);
+void archive_entry_set_uname(struct archive_entry *, const char *);
+void archive_entry_copy_uname_w(struct archive_entry *, const wchar_t *);
+
+/*
+ * ACL routines.  This used to simply store and return text-format ACL
+ * strings, but that proved insufficient for a number of reasons:
+ *   = clients need control over uname/uid and gname/gid mappings
+ *   = there are many different ACL text formats
+ *   = would like to be able to read/convert archives containing ACLs
+ *     on platforms that lack ACL libraries
+ */
+
+/*
+ * Permission bits mimic POSIX.1e.  Note that I've not followed POSIX.1e's
+ * "permset"/"perm" abstract type nonsense.  A permset is just a simple
+ * bitmap, following long-standing Unix tradition.
+ */
+#define ARCHIVE_ENTRY_ACL_EXECUTE 1
+#define ARCHIVE_ENTRY_ACL_WRITE  2
+#define ARCHIVE_ENTRY_ACL_READ  4
+
+/* We need to be able to specify either or both of these. */
+#define ARCHIVE_ENTRY_ACL_TYPE_ACCESS 256
+#define ARCHIVE_ENTRY_ACL_TYPE_DEFAULT 512
+
+/* Tag values mimic POSIX.1e */
+#define ARCHIVE_ENTRY_ACL_USER  10001 /* Specified user. */
+#define ARCHIVE_ENTRY_ACL_USER_OBJ  10002 /* User who owns the file. */
+#define ARCHIVE_ENTRY_ACL_GROUP  10003 /* Specified group. */
+#define ARCHIVE_ENTRY_ACL_GROUP_OBJ 10004 /* Group who owns the file. */
+#define ARCHIVE_ENTRY_ACL_MASK  10005 /* Modify group access. */
+#define ARCHIVE_ENTRY_ACL_OTHER  10006 /* Public. */
+
+/*
+ * Set the ACL by clearing it and adding entries one at a time.
+ * Unlike the POSIX.1e ACL routines, you must specify the type
+ * (access/default) for each entry.  Internally, the ACL data is just
+ * a soup of entries.  API calls here allow you to retrieve just the
+ * entries of interest.  This design (which goes against the spirit of
+ * POSIX.1e) is useful for handling archive formats that combine
+ * default and access information in a single ACL list.
+ */
+void  archive_entry_acl_clear(struct archive_entry *);
+void  archive_entry_acl_add_entry(struct archive_entry *,
+  int type, int permset, int tag, int qual, const char *name);
+void  archive_entry_acl_add_entry_w(struct archive_entry *,
+  int type, int permset, int tag, int qual, const wchar_t *name);
+
+/*
+ * To retrieve the ACL, first "reset", then repeatedly ask for the
+ * "next" entry.  The want_type parameter allows you to request only
+ * access entries or only default entries.
+ */
+int  archive_entry_acl_reset(struct archive_entry *, int want_type);
+int  archive_entry_acl_next(struct archive_entry *, int want_type,
+  int *type, int *permset, int *tag, int *qual, const char **name);
+int  archive_entry_acl_next_w(struct archive_entry *, int want_type,
+  int *type, int *permset, int *tag, int *qual,
+  const wchar_t **name);
+
+/*
+ * Construct a text-format ACL.  The flags argument is a bitmask that
+ * can include any of the following:
+ *
+ * ARCHIVE_ENTRY_ACL_TYPE_ACCESS - Include access entries.
+ * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT - Include default entries.
+ * ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID - Include extra numeric ID field in
+ *    each ACL entry.  (As used by 'star'.)
+ * ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT - Include "default:" before each
+ *    default ACL entry.
+ */
+#define ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID 1024
+#define ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT 2048
+const wchar_t *archive_entry_acl_text_w(struct archive_entry *, int flags);
+
+/* Return a count of entries matching 'want_type' */
+int  archive_entry_acl_count(struct archive_entry *, int want_type);
+
+/*
+ * Private ACL parser.  This is private because it handles some
+ * very weird formats that clients should not be messing with.
+ * Clients should only deal with their platform-native formats.
+ * Because of the need to support many formats cleanly, new arguments
+ * are likely to get added on a regular basis.  Clients who try to use
+ * this interface are likely to be surprised when it changes.
+ *
+ * You were warned!
+ */
+int   __archive_entry_acl_parse_w(struct archive_entry *,
+  const wchar_t *, int type);
+//--- archive_write.h
+
+/*
+ * Allocate, initialize and return an archive object.
+ */
+  struct archive *
+archive_write_new(void)
+{
+  struct archive *a;
+  unsigned char *nulls;
+
+  a = (struct archive*)malloc(sizeof(*a));
+  if (a == NULL)
+    return (NULL);
+  memset(a, 0, sizeof(*a));
+  a->magic = ARCHIVE_WRITE_MAGIC;
+#ifdef HAVE_GETEUID
+  a->user_uid = geteuid();
+#endif
+  a->bytes_per_block = ARCHIVE_DEFAULT_BYTES_PER_BLOCK;
+  a->bytes_in_last_block = -1; /* Default */
+  a->state = ARCHIVE_STATE_NEW;
+  a->pformat_data = &(a->format_data);
+
+  /* Initialize a block of nulls for padding purposes. */
+  a->null_length = 1024;
+  nulls = (unsigned char*)malloc(a->null_length);
+  if (nulls == NULL) {
+    free(a);
+    return (NULL);
+  }
+  memset(nulls, 0, a->null_length);
+  a->nulls = nulls;
+  /*
+   * Set default compression, but don't set a default format.
+   * Were we to set a default format here, we would force every
+   * client to link in support for that format, even if they didn't
+   * ever use it.
+   */
+  archive_write_set_compression_none(a);
+  return (a);
+}
+
+
+/*
+ * Set the block size.  Returns 0 if successful.
+ */
+  int
+archive_write_set_bytes_per_block(struct archive *a, int bytes_per_block)
+{
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_set_bytes_per_block");
+  a->bytes_per_block = bytes_per_block;
+  return (ARCHIVE_OK);
+}
+
+
+/*
+ * Set the size for the last block.
+ * Returns 0 if successful.
+ */
+  int
+archive_write_set_bytes_in_last_block(struct archive *a, int bytes)
+{
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_ANY, "archive_write_set_bytes_in_last_block");
+  a->bytes_in_last_block = bytes;
+  return (ARCHIVE_OK);
+}
+
+
+/*
+ * Open the archive using the current settings.
+ */
+  int
+archive_write_open(struct archive *a, void *client_data,
+  archive_open_callback *opener, archive_write_callback *writer,
+  archive_close_callback *closer)
+{
+  int ret;
+
+  ret = ARCHIVE_OK;
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_open");
+  archive_string_empty(&a->error_string);
+  a->state = ARCHIVE_STATE_HEADER;
+  a->client_data = client_data;
+  a->client_writer = writer;
+  a->client_opener = opener;
+  a->client_closer = closer;
+  ret = (a->compression_init)(a);
+  if (a->format_init && ret == ARCHIVE_OK)
+    ret = (a->format_init)(a);
+  return (ret);
+}
+
+
+/*
+ * Close out the archive.
+ *
+ * Be careful: user might just call write_new and then write_finish.
+ * Don't assume we actually wrote anything or performed any non-trivial
+ * initialization.
+ */
+  int
+archive_write_close(struct archive *a)
+{
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_ANY, "archive_write_close");
+
+  /* Finish the last entry. */
+  if (a->state & ARCHIVE_STATE_DATA)
+    ((a->format_finish_entry)(a));
+
+  /* Finish off the archive. */
+  if (a->format_finish != NULL)
+    (a->format_finish)(a);
+
+  /* Finish the compression and close the stream. */
+  if (a->compression_finish != NULL)
+    (a->compression_finish)(a);
+
+  a->state = ARCHIVE_STATE_CLOSED;
+  return (ARCHIVE_OK);
+}
+
+/*
+ * Destroy the archive structure.
+ */
+  void
+archive_write_finish(struct archive *a)
+{
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_ANY, "archive_write_finish");
+  if (a->state != ARCHIVE_STATE_CLOSED)
+    archive_write_close(a);
+
+  /* Release various dynamic buffers. */
+  free((void *)(uintptr_t)(const void *)a->nulls);
+  archive_string_free(&a->error_string);
+  a->magic = 0;
+  free(a);
+}
+
+
+/*
+ * Write the appropriate header.
+ */
+  int
+archive_write_header(struct archive *a, struct archive_entry *entry)
+{
+  int ret;
+
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC,
+    ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, "archive_write_header");
+  archive_string_empty(&a->error_string);
+
+  /* Finish last entry. */
+  if (a->state & ARCHIVE_STATE_DATA)
+    ((a->format_finish_entry)(a));
+
+  if (archive_entry_dev(entry) == a->skip_file_dev &&
+    archive_entry_ino(entry) == a->skip_file_ino) {
+    archive_set_error(a, 0, "Can't add archive to itself");
+    return (ARCHIVE_WARN);
+  }
+
+  /* Format and write header. */
+  ret = ((a->format_write_header)(a, entry));
+
+  a->state = ARCHIVE_STATE_DATA;
+  return (ret);
+}
+
+/*
+ * Note that the compressor is responsible for blocking.
+ */
+/* Should be "ssize_t", but that breaks the ABI.  <sigh> */
+  int
+archive_write_data(struct archive *a, const void *buff, size_t s)
+{
+  int ret;
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_DATA, "archive_write_data");
+  archive_string_empty(&a->error_string);
+  ret = (a->format_write_data)(a, buff, s);
+  return (ret == ARCHIVE_OK ? (ssize_t)s : -1);
+}
+
+//--- archive_write_set_compression_none.c
+
+static int archive_compressor_none_finish(struct archive *a);
+static int archive_compressor_none_init(struct archive *);
+static int archive_compressor_none_write(struct archive *, const void *,
+  size_t);
+
+struct archive_none {
+  char *buffer;
+  ssize_t  buffer_size;
+  char *next;  /* Current insert location */
+  ssize_t  avail;  /* Free space left in buffer */
+};
+
+  int
+archive_write_set_compression_none(struct archive *a)
+{
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_set_compression_none");
+  a->compression_init = &archive_compressor_none_init;
+  a->compression_code = ARCHIVE_COMPRESSION_NONE;
+  a->compression_name = "none";
+  return (0);
+}
+
+/*
+ * Setup callback.
+ */
+  static int
+archive_compressor_none_init(struct archive *a)
+{
+  int ret;
+  struct archive_none *state;
+
+  a->compression_code = ARCHIVE_COMPRESSION_NONE;
+  a->compression_name = "none";
+
+  if (a->client_opener != NULL) {
+    ret = (a->client_opener)(a, a->client_data);
+    if (ret != 0)
+      return (ret);
+  }
+
+  state = (struct archive_none *)malloc(sizeof(*state));
+  if (state == NULL) {
+    archive_set_error(a, ENOMEM,
+      "Can't allocate data for output buffering");
+    return (ARCHIVE_FATAL);
+  }
+  memset(state, 0, sizeof(*state));
+
+  state->buffer_size = a->bytes_per_block;
+  state->buffer = (char*)malloc(state->buffer_size);
+
+  if (state->buffer == NULL) {
+    archive_set_error(a, ENOMEM,
+      "Can't allocate output buffer");
+    free(state);
+    return (ARCHIVE_FATAL);
+  }
+
+  state->next = state->buffer;
+  state->avail = state->buffer_size;
+
+  a->compression_data = state;
+  a->compression_write = archive_compressor_none_write;
+  a->compression_finish = archive_compressor_none_finish;
+  return (ARCHIVE_OK);
+}
+
+/*
+ * Write data to the stream.
+ */
+  static int
+archive_compressor_none_write(struct archive *a, const void *vbuff,
+  size_t length)
+{
+  const char *buff;
+  ssize_t remaining, to_copy;
+  ssize_t bytes_written;
+  struct archive_none *state;
+
+  state = (struct archive_none*)a->compression_data;
+  buff = (const char*)vbuff;
+  if (a->client_writer == NULL) {
+    archive_set_error(a, ARCHIVE_ERRNO_PROGRAMMER,
+      "No write callback is registered?  "
+      "This is probably an internal programming error.");
+    return (ARCHIVE_FATAL);
+  }
+
+  remaining = length;
+  while (remaining > 0) {
+    /*
+     * If we have a full output block, write it and reset the
+     * output buffer.
+     */
+    if (state->avail == 0) {
+      bytes_written = (a->client_writer)(a, a->client_data,
+        state->buffer, state->buffer_size);
+      if (bytes_written <= 0)
+        return (ARCHIVE_FATAL);
+      /* XXX TODO: if bytes_written < state->buffer_size */
+      a->raw_position += bytes_written;
+      state->next = state->buffer;
+      state->avail = state->buffer_size;
+    }
+
+    /* Now we have space in the buffer; copy new data into it. */
+    to_copy = (remaining > state->avail) ?
+      state->avail : remaining;
+    memcpy(state->next, buff, to_copy);
+    state->next += to_copy;
+    state->avail -= to_copy;
+    buff += to_copy;
+    remaining -= to_copy;
+  }
+  a->file_position += length;
+  return (ARCHIVE_OK);
+}
+
+
+/*
+ * Finish the compression.
+ */
+  static int
+archive_compressor_none_finish(struct archive *a)
+{
+  ssize_t block_length;
+  ssize_t target_block_length;
+  ssize_t bytes_written;
+  int ret;
+  int ret2;
+  struct archive_none *state;
+
+  state = (struct archive_none*)a->compression_data;
+  ret = ret2 = ARCHIVE_OK;
+  if (a->client_writer == NULL) {
+    archive_set_error(a, ARCHIVE_ERRNO_PROGRAMMER,
+      "No write callback is registered?  "
+      "This is probably an internal programming error.");
+    return (ARCHIVE_FATAL);
+  }
+
+  /* If there's pending data, pad and write the last block */
+  if (state->next != state->buffer) {
+    block_length = state->buffer_size - state->avail;
+
+    /* Tricky calculation to determine size of last block */
+    target_block_length = block_length;
+    if (a->bytes_in_last_block <= 0)
+      /* Default or Zero: pad to full block */
+      target_block_length = a->bytes_per_block;
+    else
+      /* Round to next multiple of bytes_in_last_block. */
+      target_block_length = a->bytes_in_last_block *
+        ( (block_length + a->bytes_in_last_block - 1) /
+          a->bytes_in_last_block);
+    if (target_block_length > a->bytes_per_block)
+      target_block_length = a->bytes_per_block;
+    if (block_length < target_block_length) {
+      memset(state->next, 0,
+        target_block_length - block_length);
+      block_length = target_block_length;
+    }
+    bytes_written = (a->client_writer)(a, a->client_data,
+      state->buffer, block_length);
+    if (bytes_written <= 0)
+      ret = ARCHIVE_FATAL;
+    else {
+      a->raw_position += bytes_written;
+      ret = ARCHIVE_OK;
+    }
+  }
+
+  /* Close the output */
+  if (a->client_closer != NULL)
+    ret2 = (a->client_closer)(a, a->client_data);
+
+  free(state->buffer);
+  free(state);
+  a->compression_data = NULL;
+
+  return (ret != ARCHIVE_OK ? ret : ret2);
+}
+
+//--- archive_check_magic.c
+
+  static void
+errmsg(const char *m)
+{
+  cmSystemTools::Error("CPack error: ", m);
+}
+
+  static void
+diediedie(void)
+{
+  *(char *)0 = 1; /* Deliberately segfault and force a coredump. */
+  _exit(1); /* If that didn't work, just exit with an error. */
+}
+
+  static const char *
+state_name(unsigned s)
+{
+  switch (s) {
+  case ARCHIVE_STATE_NEW:  return ("new");
+  case ARCHIVE_STATE_HEADER: return ("header");
+  case ARCHIVE_STATE_DATA: return ("data");
+  case ARCHIVE_STATE_EOF:  return ("eof");
+  case ARCHIVE_STATE_CLOSED: return ("closed");
+  case ARCHIVE_STATE_FATAL: return ("fatal");
+  default:   return ("??");
+  }
+}
+
+
+  static void
+write_all_states(int states)
+{
+  unsigned lowbit;
+
+  /* A trick for computing the lowest set bit. */
+  while ((lowbit = states & (-states)) != 0) {
+    states &= ~lowbit;  /* Clear the low bit. */
+    errmsg(state_name(lowbit));
+    if (states != 0)
+      errmsg("/");
+  }
+}
+
+/*
+ * Check magic value and current state; bail if it isn't valid.
+ *
+ * This is designed to catch serious programming errors that violate
+ * the libarchive API.
+ */
+  void
+__archive_check_magic(struct archive *a, unsigned magic, unsigned state,
+  const char *function)
+{
+  if (a->magic != magic) {
+    errmsg("INTERNAL ERROR: Function ");
+    errmsg(function);
+    errmsg(" invoked with invalid struct archive structure.\n");
+    diediedie();
+  }
+
+  if (state == ARCHIVE_STATE_ANY)
+    return;
+
+  if ((a->state & state) == 0) {
+    errmsg("INTERNAL ERROR: Function '");
+    errmsg(function);
+    errmsg("' invoked with archive structure in state '");
+    write_all_states(a->state);
+    errmsg("', should be in state '");
+    write_all_states(state);
+    errmsg("'\n");
+    diediedie();
+  }
+}
+
+//--- archive_util.c
+  int
+archive_errno(struct archive *a)
+{
+  return (a->archive_error_number);
+}
+
+  const char *
+archive_error_string(struct archive *a)
+{
+
+  if (a->error != NULL  &&  *a->error != '\0')
+    return (a->error);
+  else
+    return ("(Empty error message)");
+}
+
+
+  int
+archive_format(struct archive *a)
+{
+  return (a->archive_format);
+}
+
+  const char *
+archive_format_name(struct archive *a)
+{
+  return (a->archive_format_name);
+}
+
+
+  int
+archive_compression(struct archive *a)
+{
+  return (a->compression_code);
+}
+
+  const char *
+archive_compression_name(struct archive *a)
+{
+  return (a->compression_name);
+}
+
+
+/*
+ * Return a count of the number of compressed bytes processed.
+ */
+  int64_t
+archive_position_compressed(struct archive *a)
+{
+  return (a->raw_position);
+}
+
+/*
+ * Return a count of the number of uncompressed bytes processed.
+ */
+  int64_t
+archive_position_uncompressed(struct archive *a)
+{
+  return (a->file_position);
+}
+
+
+  void
+archive_set_error(struct archive *a, int error_number, const char *fmt, ...)
+{
+  va_list ap;
+#ifdef HAVE_STRERROR_R
+  char errbuff[512];
+#endif
+  char *errp;
+
+  a->archive_error_number = error_number;
+  if (fmt == NULL) {
+    a->error = NULL;
+    return;
+  }
+
+  va_start(ap, fmt);
+  archive_string_vsprintf(&(a->error_string), fmt, ap);
+  if (error_number > 0) {
+    archive_strcat(&(a->error_string), ": ");
+#ifdef HAVE_STRERROR_R
+#ifdef STRERROR_R_CHAR_P
+    errp = strerror_r(error_number, errbuff, sizeof(errbuff));
+#else
+    strerror_r(error_number, errbuff, sizeof(errbuff));
+    errp = errbuff;
+#endif
+#else
+    /* Note: this is not threadsafe! */
+    errp = strerror(error_number);
+#endif
+    archive_strcat(&(a->error_string), errp);
+  }
+  a->error = a->error_string.s;
+  va_end(ap);
+}
+
+  void
+__archive_errx(int retvalue, const char *msg)
+{
+  static const char *msg1 = "Fatal Internal Error in libarchive: ";
+  write(2, msg1, strlen(msg1));
+  write(2, msg, strlen(msg));
+  write(2, "\n", 1);
+  exit(retvalue);
+}
+
+//--- archive_string.c
+  struct archive_string *
+__archive_string_append(struct archive_string *as, const char *p, size_t s)
+{
+  __archive_string_ensure(as, as->length + s + 1);
+  memcpy(as->s + as->length, p, s);
+  as->s[as->length + s] = 0;
+  as->length += s;
+  return (as);
+}
+
+  void
+__archive_string_free(struct archive_string *as)
+{
+  as->length = 0;
+  as->buffer_length = 0;
+  if (as->s != NULL)
+    free(as->s);
+}
+
+  struct archive_string *
+__archive_string_ensure(struct archive_string *as, size_t s)
+{
+  if (as->s && (s <= as->buffer_length))
+    return (as);
+
+  if (as->buffer_length < 32)
+    as->buffer_length = 32;
+  while (as->buffer_length < s)
+    as->buffer_length *= 2;
+  as->s = (char*)realloc(as->s, as->buffer_length);
+  /* TODO: Return null instead and fix up all of our callers to
+   * handle this correctly. */
+  if (as->s == NULL)
+    __archive_errx(1, "Out of memory");
+  return (as);
+}
+
+  struct archive_string *
+__archive_strncat(struct archive_string *as, const char *p, size_t n)
+{
+  size_t s;
+  const char *pp;
+
+  /* Like strlen(p), except won't examine positions beyond p[n]. */
+  s = 0;
+  pp = p;
+  while (*pp && s < n) {
+    pp++;
+    s++;
+  }
+  return (__archive_string_append(as, p, s));
+}
+
+  struct archive_string *
+__archive_strappend_char(struct archive_string *as, char c)
+{
+  return (__archive_string_append(as, &c, 1));
+}
+
+  struct archive_string *
+__archive_strappend_int(struct archive_string *as, int d, int base)
+{
+  static const char *digits = "0123457890abcdef";
+
+  if (d < 0) {
+    __archive_strappend_char(as, '-');
+    d = -d;
+  }
+  if (d >= base)
+    __archive_strappend_int(as, d/base, base);
+  __archive_strappend_char(as, digits[d % base]);
+  return (as);
+}
+
+//--- archive_entry.c
+/* Obtain suitable wide-character manipulation functions. */
+#ifdef HAVE_WCHAR_H
+#include <wchar.h>
+#else
+static size_t wcslen(const wchar_t *s)
+{
+  const wchar_t *p = s;
+  while (*p != L'\0')
+    ++p;
+  return p - s;
+}
+static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)
+{
+  wchar_t *dest = s1;
+  while((*s1 = *s2) != L'\0')
+    ++s1, ++s2;
+  return dest;
+}
+#define wmemcpy(a,b,i)  (wchar_t *)memcpy((a),(b),(i)*sizeof(wchar_t))
+/* Good enough for simple equality testing, but not for sorting. */
+#define wmemcmp(a,b,i)  memcmp((a),(b),(i)*sizeof(wchar_t))
+#endif
+
+#undef max
+#define max(a, b) ((a)>(b)?(a):(b))
+
+                                /*
+                                 * Handle wide character (i.e., Unicode) and non-wide character
+                                 * strings transparently.
+                                 *
+                                 */
+
+                                struct aes {
+                                  const char *aes_mbs;
+                                  char *aes_mbs_alloc;
+                                  const wchar_t *aes_wcs;
+                                  wchar_t *aes_wcs_alloc;
+                                };
+
+struct ae_acl {
+  struct ae_acl *next;
+  int type;   /* E.g., access or default */
+  int tag;   /* E.g., user/group/other/mask */
+  int permset;  /* r/w/x bits */
+  int id;   /* uid/gid for user/group */
+  struct aes name;  /* uname/gname */
+};
+
+static void aes_clean(struct aes *);
+static void aes_copy(struct aes *dest, struct aes *src);
+static const char * aes_get_mbs(struct aes *);
+static const wchar_t * aes_get_wcs(struct aes *);
+static void aes_set_mbs(struct aes *, const char *mbs);
+static void aes_copy_mbs(struct aes *, const char *mbs);
+/* static void aes_set_wcs(struct aes *, const wchar_t *wcs); */
+static void aes_copy_wcs(struct aes *, const wchar_t *wcs);
+
+static char *  ae_fflagstostr(unsigned long bitset, unsigned long bitclear);
+static const wchar_t *ae_wcstofflags(const wchar_t *stringp,
+  unsigned long *setp, unsigned long *clrp);
+static void append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag,
+  const wchar_t *wname, int perm, int id);
+static void append_id_w(wchar_t **wp, int id);
+
+static int acl_special(struct archive_entry *entry,
+  int type, int permset, int tag);
+static struct ae_acl *acl_new_entry(struct archive_entry *entry,
+  int type, int permset, int tag, int id);
+static void next_field_w(const wchar_t **wp, const wchar_t **start,
+  const wchar_t **end, wchar_t *sep);
+static int prefix_w(const wchar_t *start, const wchar_t *end,
+  const wchar_t *test);
+
+
+/*
+ * Description of an archive entry.
+ *
+ * Basically, this is a "struct stat" with a few text fields added in.
+ *
+ * TODO: Add "comment", "charset", and possibly other entries
+ * that are supported by "pax interchange" format.  However, GNU, ustar,
+ * cpio, and other variants don't support these features, so they're not an
+ * excruciatingly high priority right now.
+ *
+ * TODO: "pax interchange" format allows essentially arbitrary
+ * key/value attributes to be attached to any entry.  Supporting
+ * such extensions may make this library useful for special
+ * applications (e.g., a package manager could attach special
+ * package-management attributes to each entry).  There are tricky
+ * API issues involved, so this is not going to happen until
+ * there's a real demand for it.
+ *
+ * TODO: Design a good API for handling sparse files.
+ */
+struct archive_entry {
+  /*
+   * Note that ae_stat.st_mode & S_IFMT  can be  0!
+   *
+   * This occurs when the actual file type of the object is not
+   * in the archive.  For example, 'tar' archives store
+   * hardlinks without marking the type of the underlying
+   * object.
+   */
+  struct stat ae_stat;
+
+  /*
+   * Use aes here so that we get transparent mbs<->wcs conversions.
+   */
+  struct aes ae_fflags_text; /* Text fflags per fflagstostr(3) */
+  unsigned long ae_fflags_set;  /* Bitmap fflags */
+  unsigned long ae_fflags_clear;
+  struct aes ae_gname;  /* Name of owning group */
+  struct aes ae_hardlink; /* Name of target for hardlink */
+  struct aes ae_pathname; /* Name of entry */
+  struct aes ae_symlink;  /* symlink contents */
+  struct aes ae_uname;  /* Name of owner */
+
+  struct ae_acl *acl_head;
+  struct ae_acl *acl_p;
+  int   acl_state; /* See acl_next for details. */
+  wchar_t  *acl_text_w;
+};
+
+  static void
+aes_clean(struct aes *aes)
+{
+  if (aes->aes_mbs_alloc) {
+    free(aes->aes_mbs_alloc);
+    aes->aes_mbs_alloc = NULL;
+  }
+  if (aes->aes_wcs_alloc) {
+    free(aes->aes_wcs_alloc);
+    aes->aes_wcs_alloc = NULL;
+  }
+  memset(aes, 0, sizeof(*aes));
+}
+
+  static void
+aes_copy(struct aes *dest, struct aes *src)
+{
+  *dest = *src;
+  if (src->aes_mbs != NULL) {
+    dest->aes_mbs_alloc = strdup(src->aes_mbs);
+    dest->aes_mbs = dest->aes_mbs_alloc;
+    if (dest->aes_mbs == NULL)
+      __archive_errx(1, "No memory for aes_copy()");
+  }
+
+  if (src->aes_wcs != NULL) {
+    dest->aes_wcs_alloc = (wchar_t*)malloc((wcslen(src->aes_wcs) + 1)
+      * sizeof(wchar_t));
+    dest->aes_wcs = dest->aes_wcs_alloc;
+    if (dest->aes_wcs == NULL)
+      __archive_errx(1, "No memory for aes_copy()");
+    wcscpy(dest->aes_wcs_alloc, src->aes_wcs);
+  }
+}
+
+  static const char *
+aes_get_mbs(struct aes *aes)
+{
+  if (aes->aes_mbs == NULL && aes->aes_wcs == NULL)
+    return NULL;
+  if (aes->aes_mbs == NULL && aes->aes_wcs != NULL) {
+    /*
+     * XXX Need to estimate the number of byte in the
+     * multi-byte form.  Assume that, on average, wcs
+     * chars encode to no more than 3 bytes.  There must
+     * be a better way... XXX
+     */
+    int mbs_length = wcslen(aes->aes_wcs) * 3 + 64;
+    aes->aes_mbs_alloc = (char*)malloc(mbs_length);
+    aes->aes_mbs = aes->aes_mbs_alloc;
+    if (aes->aes_mbs == NULL)
+      __archive_errx(1, "No memory for aes_get_mbs()");
+    wcstombs(aes->aes_mbs_alloc, aes->aes_wcs, mbs_length - 1);
+    aes->aes_mbs_alloc[mbs_length - 1] = 0;
+  }
+  return (aes->aes_mbs);
+}
+
+  static const wchar_t *
+aes_get_wcs(struct aes *aes)
+{
+  if (aes->aes_wcs == NULL && aes->aes_mbs == NULL)
+    return NULL;
+  if (aes->aes_wcs == NULL && aes->aes_mbs != NULL) {
+    /*
+     * No single byte will be more than one wide character,
+     * so this length estimate will always be big enough.
+     */
+    int wcs_length = strlen(aes->aes_mbs);
+    aes->aes_wcs_alloc
+      = (wchar_t*)malloc((wcs_length + 1) * sizeof(wchar_t));
+    aes->aes_wcs = aes->aes_wcs_alloc;
+    if (aes->aes_wcs == NULL)
+      __archive_errx(1, "No memory for aes_get_wcs()");
+    mbstowcs(aes->aes_wcs_alloc, aes->aes_mbs, wcs_length);
+    aes->aes_wcs_alloc[wcs_length] = 0;
+  }
+  return (aes->aes_wcs);
+}
+
+  static void
+aes_set_mbs(struct aes *aes, const char *mbs)
+{
+  if (aes->aes_mbs_alloc) {
+    free(aes->aes_mbs_alloc);
+    aes->aes_mbs_alloc = NULL;
+  }
+  if (aes->aes_wcs_alloc) {
+    free(aes->aes_wcs_alloc);
+    aes->aes_wcs_alloc = NULL;
+  }
+  aes->aes_mbs = mbs;
+  aes->aes_wcs = NULL;
+}
+
+  static void
+aes_copy_mbs(struct aes *aes, const char *mbs)
+{
+  if (aes->aes_mbs_alloc) {
+    free(aes->aes_mbs_alloc);
+    aes->aes_mbs_alloc = NULL;
+  }
+  if (aes->aes_wcs_alloc) {
+    free(aes->aes_wcs_alloc);
+    aes->aes_wcs_alloc = NULL;
+  }
+  aes->aes_mbs_alloc = (char*)malloc((strlen(mbs) + 1) * sizeof(char));
+  if (aes->aes_mbs_alloc == NULL)
+    __archive_errx(1, "No memory for aes_copy_mbs()");
+  strcpy(aes->aes_mbs_alloc, mbs);
+  aes->aes_mbs = aes->aes_mbs_alloc;
+  aes->aes_wcs = NULL;
+}
+
+#if 0
+  static void
+aes_set_wcs(struct aes *aes, const wchar_t *wcs)
+{
+  if (aes->aes_mbs_alloc) {
+    free(aes->aes_mbs_alloc);
+    aes->aes_mbs_alloc = NULL;
+  }
+  if (aes->aes_wcs_alloc) {
+    free(aes->aes_wcs_alloc);
+    aes->aes_wcs_alloc = NULL;
+  }
+  aes->aes_mbs = NULL;
+  aes->aes_wcs = wcs;
+}
+#endif
+
+  static void
+aes_copy_wcs(struct aes *aes, const wchar_t *wcs)
+{
+  if (aes->aes_mbs_alloc) {
+    free(aes->aes_mbs_alloc);
+    aes->aes_mbs_alloc = NULL;
+  }
+  if (aes->aes_wcs_alloc) {
+    free(aes->aes_wcs_alloc);
+    aes->aes_wcs_alloc = NULL;
+  }
+  aes->aes_mbs = NULL;
+  aes->aes_wcs_alloc = (wchar_t*)malloc((wcslen(wcs) + 1) * sizeof(wchar_t));
+  if (aes->aes_wcs_alloc == NULL)
+    __archive_errx(1, "No memory for aes_copy_wcs()");
+  wcscpy(aes->aes_wcs_alloc, wcs);
+  aes->aes_wcs = aes->aes_wcs_alloc;
+}
+
+  struct archive_entry *
+archive_entry_clear(struct archive_entry *entry)
+{
+  aes_clean(&entry->ae_fflags_text);
+  aes_clean(&entry->ae_gname);
+  aes_clean(&entry->ae_hardlink);
+  aes_clean(&entry->ae_pathname);
+  aes_clean(&entry->ae_symlink);
+  aes_clean(&entry->ae_uname);
+  archive_entry_acl_clear(entry);
+  memset(entry, 0, sizeof(*entry));
+  return entry;
+}
+
+  struct archive_entry *
+archive_entry_clone(struct archive_entry *entry)
+{
+  struct archive_entry *entry2;
+
+  /* Allocate new structure and copy over all of the fields. */
+  entry2 = (struct archive_entry*)malloc(sizeof(*entry2));
+  if (entry2 == NULL)
+    return (NULL);
+  memset(entry2, 0, sizeof(*entry2));
+  entry2->ae_stat = entry->ae_stat;
+  entry2->ae_fflags_set = entry->ae_fflags_set;
+  entry2->ae_fflags_clear = entry->ae_fflags_clear;
+
+  aes_copy(&entry2->ae_fflags_text, &entry->ae_fflags_text);
+  aes_copy(&entry2->ae_gname, &entry->ae_gname);
+  aes_copy(&entry2->ae_hardlink, &entry->ae_hardlink);
+  aes_copy(&entry2->ae_pathname, &entry->ae_pathname);
+  aes_copy(&entry2->ae_symlink, &entry->ae_symlink);
+  aes_copy(&entry2->ae_uname, &entry->ae_uname);
+
+  /* XXX TODO: Copy ACL data over as well. XXX */
+  return (entry2);
+}
+
+  void
+archive_entry_free(struct archive_entry *entry)
+{
+  archive_entry_clear(entry);
+  free(entry);
+}
+
+  struct archive_entry *
+archive_entry_new(void)
+{
+  struct archive_entry *entry;
+
+  entry = (struct archive_entry*)malloc(sizeof(*entry));
+  if (entry == NULL)
+    return (NULL);
+  memset(entry, 0, sizeof(*entry));
+  return (entry);
+}
+
+/*
+ * Functions for reading fields from an archive_entry.
+ */
+
+  time_t
+archive_entry_atime(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_atime);
+}
+
+  long
+archive_entry_atime_nsec(struct archive_entry *entry)
+{
+  (void)entry; /* entry can be unused here. */
+  return (ARCHIVE_STAT_ATIME_NANOS(&entry->ae_stat));
+}
+
+  time_t
+archive_entry_ctime(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_ctime);
+}
+
+  long
+archive_entry_ctime_nsec(struct archive_entry *entry)
+{
+  (void)entry; /* entry can be unused here. */
+  return (ARCHIVE_STAT_CTIME_NANOS(&entry->ae_stat));
+}
+
+  dev_t
+archive_entry_dev(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_dev);
+}
+
+  void
+archive_entry_fflags(struct archive_entry *entry,
+  unsigned long *set, unsigned long *clear)
+{
+  *set = entry->ae_fflags_set;
+  *clear = entry->ae_fflags_clear;
+}
+
+/*
+ * Note: if text was provided, this just returns that text.  If you
+ * really need the text to be rebuilt in a canonical form, set the
+ * text, ask for the bitmaps, then set the bitmaps.  (Setting the
+ * bitmaps clears any stored text.)  This design is deliberate: if
+ * we're editing archives, we don't want to discard flags just because
+ * they aren't supported on the current system.  The bitmap<->text
+ * conversions are platform-specific (see below).
+ */
+  const char *
+archive_entry_fflags_text(struct archive_entry *entry)
+{
+  const char *f;
+  char *p;
+
+  f = aes_get_mbs(&entry->ae_fflags_text);
+  if (f != NULL)
+    return (f);
+
+  if (entry->ae_fflags_set == 0  &&  entry->ae_fflags_clear == 0)
+    return (NULL);
+
+  p = ae_fflagstostr(entry->ae_fflags_set, entry->ae_fflags_clear);
+  if (p == NULL)
+    return (NULL);
+
+  aes_copy_mbs(&entry->ae_fflags_text, p);
+  free(p);
+  f = aes_get_mbs(&entry->ae_fflags_text);
+  return (f);
+}
+
+  gid_t
+archive_entry_gid(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_gid);
+}
+
+  const char *
+archive_entry_gname(struct archive_entry *entry)
+{
+  return (aes_get_mbs(&entry->ae_gname));
+}
+
+  const wchar_t *
+archive_entry_gname_w(struct archive_entry *entry)
+{
+  return (aes_get_wcs(&entry->ae_gname));
+}
+
+  const char *
+archive_entry_hardlink(struct archive_entry *entry)
+{
+  return (aes_get_mbs(&entry->ae_hardlink));
+}
+
+  const wchar_t *
+archive_entry_hardlink_w(struct archive_entry *entry)
+{
+  return (aes_get_wcs(&entry->ae_hardlink));
+}
+
+  ino_t
+archive_entry_ino(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_ino);
+}
+
+  mode_t
+archive_entry_mode(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_mode);
+}
+
+  time_t
+archive_entry_mtime(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_mtime);
+}
+
+  long
+archive_entry_mtime_nsec(struct archive_entry *entry)
+{
+  (void)entry; /* entry can be unused here. */
+  return (ARCHIVE_STAT_MTIME_NANOS(&entry->ae_stat));
+}
+
+  const char *
+archive_entry_pathname(struct archive_entry *entry)
+{
+  return (aes_get_mbs(&entry->ae_pathname));
+}
+
+  const wchar_t *
+archive_entry_pathname_w(struct archive_entry *entry)
+{
+  return (aes_get_wcs(&entry->ae_pathname));
+}
+
+  dev_t
+archive_entry_rdev(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_rdev);
+}
+
+  int64_t
+archive_entry_size(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_size);
+}
+
+  const struct stat *
+archive_entry_stat(struct archive_entry *entry)
+{
+  return (&entry->ae_stat);
+}
+
+  const char *
+archive_entry_symlink(struct archive_entry *entry)
+{
+  return (aes_get_mbs(&entry->ae_symlink));
+}
+
+  const wchar_t *
+archive_entry_symlink_w(struct archive_entry *entry)
+{
+  return (aes_get_wcs(&entry->ae_symlink));
+}
+
+  uid_t
+archive_entry_uid(struct archive_entry *entry)
+{
+  return (entry->ae_stat.st_uid);
+}
+
+  const char *
+archive_entry_uname(struct archive_entry *entry)
+{
+  return (aes_get_mbs(&entry->ae_uname));
+}
+
+  const wchar_t *
+archive_entry_uname_w(struct archive_entry *entry)
+{
+  return (aes_get_wcs(&entry->ae_uname));
+}
+
+/*
+ * Functions to set archive_entry properties.
+ */
+
+/*
+ * Note "copy" not "set" here.  The "set" functions that accept a pointer
+ * only store the pointer; they don't copy the underlying object.
+ */
+  void
+archive_entry_copy_stat(struct archive_entry *entry, const struct stat *st)
+{
+  entry->ae_stat = *st;
+}
+
+  void
+archive_entry_set_fflags(struct archive_entry *entry,
+  unsigned long set, unsigned long clear)
+{
+  aes_clean(&entry->ae_fflags_text);
+  entry->ae_fflags_set = set;
+  entry->ae_fflags_clear = clear;
+}
+
+  const wchar_t *
+archive_entry_copy_fflags_text_w(struct archive_entry *entry,
+  const wchar_t *flags)
+{
+  aes_copy_wcs(&entry->ae_fflags_text, flags);
+  return (ae_wcstofflags(flags,
+      &entry->ae_fflags_set, &entry->ae_fflags_clear));
+}
+
+  void
+archive_entry_set_gid(struct archive_entry *entry, gid_t g)
+{
+  entry->ae_stat.st_gid = g;
+}
+
+  void
+archive_entry_set_gname(struct archive_entry *entry, const char *name)
+{
+  aes_set_mbs(&entry->ae_gname, name);
+}
+
+  void
+archive_entry_copy_gname_w(struct archive_entry *entry, const wchar_t *name)
+{
+  aes_copy_wcs(&entry->ae_gname, name);
+}
+
+  void
+archive_entry_set_hardlink(struct archive_entry *entry, const char *target)
+{
+  aes_set_mbs(&entry->ae_hardlink, target);
+}
+
+  void
+archive_entry_copy_hardlink(struct archive_entry *entry, const char *target)
+{
+  aes_copy_mbs(&entry->ae_hardlink, target);
+}
+
+  void
+archive_entry_copy_hardlink_w(struct archive_entry *entry, const wchar_t *target)
+{
+  aes_copy_wcs(&entry->ae_hardlink, target);
+}
+
+  void
+archive_entry_set_atime(struct archive_entry *entry, time_t t, long ns)
+{
+  (void)ns;
+  entry->ae_stat.st_atime = t;
+  ARCHIVE_STAT_SET_ATIME_NANOS(&entry->ae_stat, ns);
+}
+
+  void
+archive_entry_set_ctime(struct archive_entry *entry, time_t t, long ns)
+{
+  (void)ns;
+  entry->ae_stat.st_ctime = t;
+  ARCHIVE_STAT_SET_CTIME_NANOS(&entry->ae_stat, ns);
+}
+
+/* Set symlink if symlink is already set, else set hardlink. */
+  void
+archive_entry_set_link(struct archive_entry *entry, const char *target)
+{
+  if (entry->ae_symlink.aes_mbs != NULL ||
+    entry->ae_symlink.aes_wcs != NULL)
+    aes_set_mbs(&entry->ae_symlink, target);
+  else
+    aes_set_mbs(&entry->ae_hardlink, target);
+}
+
+  void
+archive_entry_set_mode(struct archive_entry *entry, mode_t m)
+{
+  entry->ae_stat.st_mode = m;
+}
+
+  void
+archive_entry_set_mtime(struct archive_entry *entry, time_t m, long ns)
+{
+  (void)ns;
+  entry->ae_stat.st_mtime = m;
+  ARCHIVE_STAT_SET_MTIME_NANOS(&entry->ae_stat, ns);
+}
+
+  void
+archive_entry_set_pathname(struct archive_entry *entry, const char *name)
+{
+  aes_set_mbs(&entry->ae_pathname, name);
+}
+
+  void
+archive_entry_copy_pathname(struct archive_entry *entry, const char *name)
+{
+  aes_copy_mbs(&entry->ae_pathname, name);
+}
+
+  void
+archive_entry_copy_pathname_w(struct archive_entry *entry, const wchar_t *name)
+{
+  aes_copy_wcs(&entry->ae_pathname, name);
+}
+
+  void
+archive_entry_set_size(struct archive_entry *entry, int64_t s)
+{
+  entry->ae_stat.st_size = s;
+}
+
+  void
+archive_entry_set_symlink(struct archive_entry *entry, const char *linkname)
+{
+  aes_set_mbs(&entry->ae_symlink, linkname);
+}
+
+  void
+archive_entry_copy_symlink_w(struct archive_entry *entry, const wchar_t *linkname)
+{
+  aes_copy_wcs(&entry->ae_symlink, linkname);
+}
+
+  void
+archive_entry_set_uid(struct archive_entry *entry, uid_t u)
+{
+  entry->ae_stat.st_uid = u;
+}
+
+  void
+archive_entry_set_uname(struct archive_entry *entry, const char *name)
+{
+  aes_set_mbs(&entry->ae_uname, name);
+}
+
+  void
+archive_entry_copy_uname_w(struct archive_entry *entry, const wchar_t *name)
+{
+  aes_copy_wcs(&entry->ae_uname, name);
+}
+
+/*
+ * ACL management.  The following would, of course, be a lot simpler
+ * if: 1) the last draft of POSIX.1e were a really thorough and
+ * complete standard that addressed the needs of ACL archiving and 2)
+ * everyone followed it faithfully.  Alas, neither is true, so the
+ * following is a lot more complex than might seem necessary to the
+ * uninitiated.
+ */
+
+  void
+archive_entry_acl_clear(struct archive_entry *entry)
+{
+  struct ae_acl *ap;
+
+  while (entry->acl_head != NULL) {
+    ap = entry->acl_head->next;
+    aes_clean(&entry->acl_head->name);
+    free(entry->acl_head);
+    entry->acl_head = ap;
+  }
+  if (entry->acl_text_w != NULL) {
+    free(entry->acl_text_w);
+    entry->acl_text_w = NULL;
+  }
+  entry->acl_p = NULL;
+  entry->acl_state = 0; /* Not counting. */
+}
+
+/*
+ * Add a single ACL entry to the internal list of ACL data.
+ */
+  void
+archive_entry_acl_add_entry(struct archive_entry *entry,
+  int type, int permset, int tag, int id, const char *name)
+{
+  struct ae_acl *ap;
+
+  if (acl_special(entry, type, permset, tag) == 0)
+    return;
+  ap = acl_new_entry(entry, type, permset, tag, id);
+  if (ap == NULL) {
+    /* XXX Error XXX */
+    return;
+  }
+  if (name != NULL  &&  *name != '\0')
+    aes_copy_mbs(&ap->name, name);
+  else
+    aes_clean(&ap->name);
+}
+
+/*
+ * As above, but with a wide-character name.
+ */
+  void
+archive_entry_acl_add_entry_w(struct archive_entry *entry,
+  int type, int permset, int tag, int id, const wchar_t *name)
+{
+  struct ae_acl *ap;
+
+  if (acl_special(entry, type, permset, tag) == 0)
+    return;
+  ap = acl_new_entry(entry, type, permset, tag, id);
+  if (ap == NULL) {
+    /* XXX Error XXX */
+    return;
+  }
+  if (name != NULL  &&  *name != L'\0')
+    aes_copy_wcs(&ap->name, name);
+  else
+    aes_clean(&ap->name);
+}
+
+/*
+ * If this ACL entry is part of the standard POSIX permissions set,
+ * store the permissions in the stat structure and return zero.
+ */
+  static int
+acl_special(struct archive_entry *entry, int type, int permset, int tag)
+{
+  if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS) {
+    switch (tag) {
+    case ARCHIVE_ENTRY_ACL_USER_OBJ:
+      entry->ae_stat.st_mode &= ~0700;
+      entry->ae_stat.st_mode |= (permset & 7) << 6;
+      return (0);
+    case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
+      entry->ae_stat.st_mode &= ~0070;
+      entry->ae_stat.st_mode |= (permset & 7) << 3;
+      return (0);
+    case ARCHIVE_ENTRY_ACL_OTHER:
+      entry->ae_stat.st_mode &= ~0007;
+      entry->ae_stat.st_mode |= permset & 7;
+      return (0);
+    }
+  }
+  return (1);
+}
+
+/*
+ * Allocate and populate a new ACL entry with everything but the
+ * name.
+ */
+  static struct ae_acl *
+acl_new_entry(struct archive_entry *entry,
+  int type, int permset, int tag, int id)
+{
+  struct ae_acl *ap;
+
+  if (type != ARCHIVE_ENTRY_ACL_TYPE_ACCESS &&
+    type != ARCHIVE_ENTRY_ACL_TYPE_DEFAULT)
+    return (NULL);
+  if (entry->acl_text_w != NULL) {
+    free(entry->acl_text_w);
+    entry->acl_text_w = NULL;
+  }
+
+  /* XXX TODO: More sanity-checks on the arguments XXX */
+
+  /* If there's a matching entry already in the list, overwrite it. */
+  for (ap = entry->acl_head; ap != NULL; ap = ap->next) {
+    if (ap->type == type && ap->tag == tag && ap->id == id) {
+      ap->permset = permset;
+      return (ap);
+    }
+  }
+
+  /* Add a new entry to the list. */
+  ap = (struct ae_acl *)malloc(sizeof(*ap));
+  if (ap == NULL)
+    return (NULL);
+  memset(ap, 0, sizeof(*ap));
+  ap->next = entry->acl_head;
+  entry->acl_head = ap;
+  ap->type = type;
+  ap->tag = tag;
+  ap->id = id;
+  ap->permset = permset;
+  return (ap);
+}
+
+/*
+ * Return a count of entries matching "want_type".
+ */
+  int
+archive_entry_acl_count(struct archive_entry *entry, int want_type)
+{
+  int count;
+  struct ae_acl *ap;
+
+  count = 0;
+  ap = entry->acl_head;
+  while (ap != NULL) {
+    if ((ap->type & want_type) != 0)
+      count++;
+    ap = ap->next;
+  }
+
+  if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0))
+    count += 3;
+  return (count);
+}
+
+/*
+ * Prepare for reading entries from the ACL data.  Returns a count
+ * of entries matching "want_type", or zero if there are no
+ * non-extended ACL entries of that type.
+ */
+  int
+archive_entry_acl_reset(struct archive_entry *entry, int want_type)
+{
+  int count, cutoff;
+
+  count = archive_entry_acl_count(entry, want_type);
+
+  /*
+   * If the only entries are the three standard ones,
+   * then don't return any ACL data.  (In this case,
+   * client can just use chmod(2) to set permissions.)
+   */
+  if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
+    cutoff = 3;
+  else
+    cutoff = 0;
+
+  if (count > cutoff)
+    entry->acl_state = ARCHIVE_ENTRY_ACL_USER_OBJ;
+  else
+    entry->acl_state = 0;
+  entry->acl_p = entry->acl_head;
+  return (count);
+}
+
+/*
+ * Return the next ACL entry in the list.  Fake entries for the
+ * standard permissions and include them in the returned list.
+ */
+
+  int
+archive_entry_acl_next(struct archive_entry *entry, int want_type, int *type,
+  int *permset, int *tag, int *id, const char **name)
+{
+  *name = NULL;
+  *id = -1;
+
+  /*
+   * The acl_state is either zero (no entries available), -1
+   * (reading from list), or an entry type (retrieve that type
+   * from ae_stat.st_mode).
+   */
+  if (entry->acl_state == 0)
+    return (ARCHIVE_WARN);
+
+  /* The first three access entries are special. */
+  if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
+    switch (entry->acl_state) {
+    case ARCHIVE_ENTRY_ACL_USER_OBJ:
+      *permset = (entry->ae_stat.st_mode >> 6) & 7;
+      *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
+      *tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
+      entry->acl_state = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
+      return (ARCHIVE_OK);
+    case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
+      *permset = (entry->ae_stat.st_mode >> 3) & 7;
+      *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
+      *tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
+      entry->acl_state = ARCHIVE_ENTRY_ACL_OTHER;
+      return (ARCHIVE_OK);
+    case ARCHIVE_ENTRY_ACL_OTHER:
+      *permset = entry->ae_stat.st_mode & 7;
+      *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
+      *tag = ARCHIVE_ENTRY_ACL_OTHER;
+      entry->acl_state = -1;
+      entry->acl_p = entry->acl_head;
+      return (ARCHIVE_OK);
+    default:
+      break;
+    }
+  }
+
+  while (entry->acl_p != NULL && (entry->acl_p->type & want_type) == 0)
+    entry->acl_p = entry->acl_p->next;
+  if (entry->acl_p == NULL) {
+    entry->acl_state = 0;
+    return (ARCHIVE_WARN);
+  }
+  *type = entry->acl_p->type;
+  *permset = entry->acl_p->permset;
+  *tag = entry->acl_p->tag;
+  *id = entry->acl_p->id;
+  *name = aes_get_mbs(&entry->acl_p->name);
+  entry->acl_p = entry->acl_p->next;
+  return (ARCHIVE_OK);
+}
+
+/*
+ * Generate a text version of the ACL.  The flags parameter controls
+ * the style of the generated ACL.
+ */
+  const wchar_t *
+archive_entry_acl_text_w(struct archive_entry *entry, int flags)
+{
+  int count;
+  int length;
+  const wchar_t *wname;
+  const wchar_t *prefix;
+  wchar_t separator;
+  struct ae_acl *ap;
+  int id;
+  wchar_t *wp;
+
+  if (entry->acl_text_w != NULL) {
+    free (entry->acl_text_w);
+    entry->acl_text_w = NULL;
+  }
+
+  separator = L',';
+  count = 0;
+  length = 0;
+  ap = entry->acl_head;
+  while (ap != NULL) {
+    if ((ap->type & flags) != 0) {
+      count++;
+      if ((flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) &&
+        (ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT))
+        length += 8; /* "default:" */
+      length += 5; /* tag name */
+      length += 1; /* colon */
+      wname = aes_get_wcs(&ap->name);
+      if (wname != NULL)
+        length += wcslen(wname);
+      length ++; /* colon */
+      length += 3; /* rwx */
+      length += 1; /* colon */
+      length += max(sizeof(uid_t),sizeof(gid_t)) * 3 + 1;
+      length ++; /* newline */
+    }
+    ap = ap->next;
+  }
+
+  if (count > 0 && ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)) {
+    length += 10; /* "user::rwx\n" */
+    length += 11; /* "group::rwx\n" */
+    length += 11; /* "other::rwx\n" */
+  }
+
+  if (count == 0)
+    return (NULL);
+
+  /* Now, allocate the string and actually populate it. */
+  wp = entry->acl_text_w = (wchar_t*)malloc(length * sizeof(wchar_t));
+  if (wp == NULL)
+    __archive_errx(1, "No memory to generate the text version of the ACL");
+  count = 0;
+  if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
+    append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_USER_OBJ, NULL,
+      entry->ae_stat.st_mode & 0700, -1);
+    *wp++ = ',';
+    append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_GROUP_OBJ, NULL,
+      entry->ae_stat.st_mode & 0070, -1);
+    *wp++ = ',';
+    append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_OTHER, NULL,
+      entry->ae_stat.st_mode & 0007, -1);
+    count += 3;
+
+    ap = entry->acl_head;
+    while (ap != NULL) {
+      if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
+        wname = aes_get_wcs(&ap->name);
+        *wp++ = separator;
+        if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
+          id = ap->id;
+        else
+          id = -1;
+        append_entry_w(&wp, NULL, ap->tag, wname,
+          ap->permset, id);
+        count++;
+      }
+      ap = ap->next;
+    }
+  }
+
+
+  if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
+    if (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT)
+      prefix = L"default:";
+    else
+      prefix = NULL;
+    ap = entry->acl_head;
+    count = 0;
+    while (ap != NULL) {
+      if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
+        wname = aes_get_wcs(&ap->name);
+        if (count > 0)
+          *wp++ = separator;
+        if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
+          id = ap->id;
+        else
+          id = -1;
+        append_entry_w(&wp, prefix, ap->tag,
+          wname, ap->permset, id);
+        count ++;
+      }
+      ap = ap->next;
+    }
+  }
+
+  return (entry->acl_text_w);
+}
+
+  static void
+append_id_w(wchar_t **wp, int id)
+{
+  if (id > 9)
+    append_id_w(wp, id / 10);
+  *(*wp)++ = L"0123456789"[id % 10];
+}
+
+  static void
+append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag,
+  const wchar_t *wname, int perm, int id)
+{
+  if (prefix != NULL) {
+    wcscpy(*wp, prefix);
+    *wp += wcslen(*wp);
+  }
+  switch (tag) {
+  case ARCHIVE_ENTRY_ACL_USER_OBJ:
+    wname = NULL;
+    id = -1;
+    /* FALL THROUGH */
+  case ARCHIVE_ENTRY_ACL_USER:
+    wcscpy(*wp, L"user");
+    break;
+  case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
+    wname = NULL;
+    id = -1;
+    /* FALL THROUGH */
+  case ARCHIVE_ENTRY_ACL_GROUP:
+    wcscpy(*wp, L"group");
+    break;
+  case ARCHIVE_ENTRY_ACL_MASK:
+    wcscpy(*wp, L"mask");
+    wname = NULL;
+    id = -1;
+    break;
+  case ARCHIVE_ENTRY_ACL_OTHER:
+    wcscpy(*wp, L"other");
+    wname = NULL;
+    id = -1;
+    break;
+  }
+  *wp += wcslen(*wp);
+  *(*wp)++ = L':';
+  if (wname != NULL) {
+    wcscpy(*wp, wname);
+    *wp += wcslen(*wp);
+  }
+  *(*wp)++ = L':';
+  *(*wp)++ = (perm & 0444) ? L'r' : L'-';
+  *(*wp)++ = (perm & 0222) ? L'w' : L'-';
+  *(*wp)++ = (perm & 0111) ? L'x' : L'-';
+  if (id != -1) {
+    *(*wp)++ = L':';
+    append_id_w(wp, id);
+  }
+  **wp = L'\0';
+}
+
+/*
+ * Parse a textual ACL.  This automatically recognizes and supports
+ * extensions described above.  The 'type' argument is used to
+ * indicate the type that should be used for any entries not
+ * explicitly marked as "default:".
+ */
+  int
+__archive_entry_acl_parse_w(struct archive_entry *entry,
+  const wchar_t *text, int default_type)
+{
+  int type, tag, permset, id;
+  const wchar_t *start, *end;
+  const wchar_t *name_start, *name_end;
+  wchar_t sep;
+  wchar_t *namebuff;
+  int namebuff_length;
+
+  name_start = name_end = NULL;
+  namebuff = NULL;
+  namebuff_length = 0;
+
+  while (text != NULL  &&  *text != L'\0') {
+    next_field_w(&text, &start, &end, &sep);
+    if (sep != L':')
+      goto fail;
+
+    /*
+     * Solaris extension:  "defaultuser::rwx" is the
+     * default ACL corresponding to "user::rwx", etc.
+     */
+    if (end-start > 7  && wmemcmp(start, L"default", 7) == 0) {
+      type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
+      start += 7;
+    } else
+      type = default_type;
+
+    if (prefix_w(start, end, L"user")) {
+      next_field_w(&text, &start, &end, &sep);
+      if (sep != L':')
+        goto fail;
+      if (end > start) {
+        tag = ARCHIVE_ENTRY_ACL_USER;
+        name_start = start;
+        name_end = end;
+      } else
+        tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
+    } else if (prefix_w(start, end, L"group")) {
+      next_field_w(&text, &start, &end, &sep);
+      if (sep != L':')
+        goto fail;
+      if (end > start) {
+        tag = ARCHIVE_ENTRY_ACL_GROUP;
+        name_start = start;
+        name_end = end;
+      } else
+        tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
+    } else if (prefix_w(start, end, L"other")) {
+      next_field_w(&text, &start, &end, &sep);
+      if (sep != L':')
+        goto fail;
+      if (end > start)
+        goto fail;
+      tag = ARCHIVE_ENTRY_ACL_OTHER;
+    } else if (prefix_w(start, end, L"mask")) {
+      next_field_w(&text, &start, &end, &sep);
+      if (sep != L':')
+        goto fail;
+      if (end > start)
+        goto fail;
+      tag = ARCHIVE_ENTRY_ACL_MASK;
+    } else
+      goto fail;
+
+    next_field_w(&text, &start, &end, &sep);
+    permset = 0;
+    while (start < end) {
+      switch (*start++) {
+      case 'r': case 'R':
+        permset |= ARCHIVE_ENTRY_ACL_READ;
+        break;
+      case 'w': case 'W':
+        permset |= ARCHIVE_ENTRY_ACL_WRITE;
+        break;
+      case 'x': case 'X':
+        permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
+        break;
+      case '-':
+        break;
+      default:
+        goto fail;
+      }
+    }
+
+    /*
+     * Support star-compatible numeric UID/GID extension.
+     * This extension adds a ":" followed by the numeric
+     * ID so that "group:groupname:rwx", for example,
+     * becomes "group:groupname:rwx:999", where 999 is the
+     * numeric GID.  This extension makes it possible, for
+     * example, to correctly restore ACLs on a system that
+     * might have a damaged passwd file or be disconnected
+     * from a central NIS server.  This extension is compatible
+     * with POSIX.1e draft 17.
+     */
+    if (sep == L':' && (tag == ARCHIVE_ENTRY_ACL_USER ||
+        tag == ARCHIVE_ENTRY_ACL_GROUP)) {
+      next_field_w(&text, &start, &end, &sep);
+
+      id = 0;
+      while (start < end  && *start >= '0' && *start <= '9') {
+        if (id > (INT_MAX / 10))
+          id = INT_MAX;
+        else {
+          id *= 10;
+          id += *start - '0';
+          start++;
+        }
+      }
+    } else
+          id = -1; /* No id specified. */
+
+    /* Skip any additional entries. */
+    while (sep == L':') {
+      next_field_w(&text, &start, &end, &sep);
+    }
+
+    /* Add entry to the internal list. */
+    if (name_end == name_start) {
+      archive_entry_acl_add_entry_w(entry, type, permset,
+        tag, id, NULL);
+    } else {
+      if (namebuff_length <= name_end - name_start) {
+        if (namebuff != NULL)
+          free(namebuff);
+        namebuff_length = name_end - name_start + 256;
+        namebuff =
+          (wchar_t*)malloc(namebuff_length * sizeof(wchar_t));
+        if (namebuff == NULL)
+          goto fail;
+      }
+      wmemcpy(namebuff, name_start, name_end - name_start);
+      namebuff[name_end - name_start] = L'\0';
+      archive_entry_acl_add_entry_w(entry, type,
+        permset, tag, id, namebuff);
+    }
+  }
+  if (namebuff != NULL)
+    free(namebuff);
+  return (ARCHIVE_OK);
+
+fail:
+  if (namebuff != NULL)
+    free(namebuff);
+  return (ARCHIVE_WARN);
+}
+
+/*
+ * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
+ * to point to just after the separator.  *start points to the first
+ * character of the matched text and *end just after the last
+ * character of the matched identifier.  In particular *end - *start
+ * is the length of the field body, not including leading or trailing
+ * whitespace.
+ */
+  static void
+next_field_w(const wchar_t **wp, const wchar_t **start,
+  const wchar_t **end, wchar_t *sep)
+{
+  /* Skip leading whitespace to find start of field. */
+  while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') {
+    (*wp)++;
+  }
+  *start = *wp;
+
+  /* Scan for the separator. */
+  while (**wp != L'\0' && **wp != L',' && **wp != L':' &&
+    **wp != L'\n') {
+    (*wp)++;
+  }
+  *sep = **wp;
+
+  /* Trim trailing whitespace to locate end of field. */
+  *end = *wp - 1;
+  while (**end == L' ' || **end == L'\t' || **end == L'\n') {
+    (*end)--;
+  }
+  (*end)++;
+
+  /* Adjust scanner location. */
+  if (**wp != L'\0')
+    (*wp)++;
+}
+
+  static int
+prefix_w(const wchar_t *start, const wchar_t *end, const wchar_t *test)
+{
+  if (start == end)
+    return (0);
+
+  if (*start++ != *test++)
+    return (0);
+
+  while (start < end  &&  *start++ == *test++)
+    ;
+
+  if (start < end)
+    return (0);
+
+  return (1);
+}
+
+
+/*
+ * Following code is modified from UC Berkeley sources, and
+ * is subject to the following copyright notice.
+ */
+
+/*-
+ * Copyright (c) 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.
+ * 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.
+ */
+
+static struct flag {
+  const char *name;
+  const wchar_t *wname;
+  unsigned long  set;
+  unsigned long  clear;
+} flags[] = {
+  /* Preferred (shorter) names per flag first, all prefixed by "no" */
+#ifdef SF_APPEND
+    { "nosappnd", L"nosappnd",  SF_APPEND, 0 },
+    { "nosappend", L"nosappend",  SF_APPEND, 0 },
+#endif
+#ifdef  EXT2_APPEND_FL    /* 'a' */
+    { "nosappnd", L"nosappnd",  EXT2_APPEND_FL, 0 },
+    { "nosappend", L"nosappend",  EXT2_APPEND_FL, 0 },
+#endif
+#ifdef SF_ARCHIVED
+    { "noarch", L"noarch",  SF_ARCHIVED, 0 },
+    { "noarchived", L"noarchived",        SF_ARCHIVED, 0 },
+#endif
+#ifdef SF_IMMUTABLE
+    { "noschg", L"noschg",  SF_IMMUTABLE, 0 },
+    { "noschange", L"noschange",  SF_IMMUTABLE, 0 },
+    { "nosimmutable", L"nosimmutable", SF_IMMUTABLE, 0 },
+#endif
+#ifdef EXT2_IMMUTABLE_FL   /* 'i' */
+    { "noschg", L"noschg",  EXT2_IMMUTABLE_FL, 0 },
+    { "noschange", L"noschange",  EXT2_IMMUTABLE_FL, 0 },
+    { "nosimmutable", L"nosimmutable", EXT2_IMMUTABLE_FL, 0 },
+#endif
+#ifdef SF_NOUNLINK
+    { "nosunlnk", L"nosunlnk",  SF_NOUNLINK, 0 },
+    { "nosunlink", L"nosunlink",  SF_NOUNLINK, 0 },
+#endif
+#ifdef SF_SNAPSHOT
+    { "nosnapshot", L"nosnapshot", SF_SNAPSHOT, 0 },
+#endif
+#ifdef UF_APPEND
+    { "nouappnd", L"nouappnd",  UF_APPEND, 0 },
+    { "nouappend", L"nouappend",  UF_APPEND, 0 },
+#endif
+#ifdef UF_IMMUTABLE
+    { "nouchg", L"nouchg",  UF_IMMUTABLE, 0 },
+    { "nouchange", L"nouchange",  UF_IMMUTABLE, 0 },
+    { "nouimmutable", L"nouimmutable", UF_IMMUTABLE, 0 },
+#endif
+#ifdef UF_NODUMP
+    { "nodump", L"nodump",  0,  UF_NODUMP},
+#endif
+#ifdef EXT2_NODUMP_FL    /* 'd' */
+    { "nodump", L"nodump",  0,  EXT2_NODUMP_FL},
+#endif
+#ifdef UF_OPAQUE
+    { "noopaque", L"noopaque",  UF_OPAQUE, 0 },
+#endif
+#ifdef UF_NOUNLINK
+    { "nouunlnk", L"nouunlnk",  UF_NOUNLINK, 0 },
+    { "nouunlink", L"nouunlink",  UF_NOUNLINK, 0 },
+#endif
+#ifdef EXT2_COMPR_FL    /* 'c' */
+    { "nocompress", L"nocompress",        EXT2_COMPR_FL, 0 },
+#endif
+
+#ifdef EXT2_NOATIME_FL    /* 'A' */
+    { "noatime", L"noatime",  0,  EXT2_NOATIME_FL},
+#endif
+    { NULL,  NULL,   0,  0 }
+};
+
+/*
+ * fflagstostr --
+ * Convert file flags to a comma-separated string.  If no flags
+ * are set, return the empty string.
+ */
+  char *
+ae_fflagstostr(unsigned long bitset, unsigned long bitclear)
+{
+  char *string, *dp;
+  const char *sp;
+  unsigned long bits;
+  struct flag *flag;
+  int length;
+
+  bits = bitset | bitclear;
+  length = 0;
+  for (flag = flags; flag->name != NULL; flag++)
+    if (bits & (flag->set | flag->clear)) {
+      length += strlen(flag->name) + 1;
+      bits &= ~(flag->set | flag->clear);
+    }
+
+  if (length == 0)
+    return (NULL);
+  string = (char*)malloc(length);
+  if (string == NULL)
+    return (NULL);
+
+  dp = string;
+  for (flag = flags; flag->name != NULL; flag++) {
+    if (bitset & flag->set || bitclear & flag->clear) {
+      sp = flag->name + 2;
+    } else if (bitset & flag->clear  ||  bitclear & flag->set) {
+      sp = flag->name;
+    } else
+      continue;
+    bitset &= ~(flag->set | flag->clear);
+    bitclear &= ~(flag->set | flag->clear);
+    if (dp > string)
+      *dp++ = ',';
+    while ((*dp++ = *sp++) != '\0')
+      ;
+    dp--;
+  }
+
+  *dp = '\0';
+  return (string);
+}
+
+/*
+ * wcstofflags --
+ * Take string of arguments and return file flags.  This
+ * version works a little differently than strtofflags(3).
+ * In particular, it always tests every token, skipping any
+ * unrecognized tokens.  It returns a pointer to the first
+ * unrecognized token, or NULL if every token was recognized.
+ * This version is also const-correct and does not modify the
+ * provided string.
+ */
+  const wchar_t *
+ae_wcstofflags(const wchar_t *s, unsigned long *setp, unsigned long *clrp)
+{
+  const wchar_t *start, *end;
+  struct flag *flag;
+  unsigned long set, clear;
+  const wchar_t *failed;
+
+  set = clear = 0;
+  start = s;
+  failed = NULL;
+  /* Find start of first token. */
+  while (*start == L'\t'  ||  *start == L' '  ||  *start == L',')
+    start++;
+  while (*start != L'\0') {
+    /* Locate end of token. */
+    end = start;
+    while (*end != L'\0'  &&  *end != L'\t'  &&
+      *end != L' '  &&  *end != L',')
+      end++;
+    for (flag = flags; flag->wname != NULL; flag++) {
+      if (wmemcmp(start, flag->wname, end - start) == 0) {
+        /* Matched "noXXXX", so reverse the sense. */
+        clear |= flag->set;
+        set |= flag->clear;
+        break;
+      } else if (wmemcmp(start, flag->wname + 2, end - start)
+        == 0) {
+        /* Matched "XXXX", so don't reverse. */
+        set |= flag->set;
+        clear |= flag->clear;
+        break;
+      }
+    }
+    /* Ignore unknown flag names. */
+    if (flag->wname == NULL  &&  failed == NULL)
+      failed = start;
+
+    /* Find start of next token. */
+    start = end;
+    while (*start == L'\t'  ||  *start == L' '  ||  *start == L',')
+      start++;
+
+  }
+
+  if (setp)
+    *setp = set;
+  if (clrp)
+    *clrp = clear;
+
+  /* Return location of first failure. */
+  return (failed);
+}
+
+//--- archive_string_sprintf.c
+/*
+ * Like 'vsprintf', but ensures the target is big enough, resizing if
+ * necessary.
+ */
+  void
+__archive_string_vsprintf(struct archive_string *as, const char *fmt,
+  va_list ap)
+{
+  char long_flag;
+  intmax_t s; /* Signed integer temp. */
+  uintmax_t u; /* Unsigned integer temp. */
+  const char *p, *p2;
+
+  __archive_string_ensure(as, 64);
+
+  if (fmt == NULL) {
+    as->s[0] = 0;
+    return;
+  }
+
+  long_flag = '\0';
+  for (p = fmt; *p != '\0'; p++) {
+    const char *saved_p = p;
+
+    if (*p != '%') {
+      archive_strappend_char(as, *p);
+      continue;
+    }
+
+    p++;
+
+    switch(*p) {
+    case 'j':
+      long_flag = 'j';
+      p++;
+      break;
+    case 'l':
+      long_flag = 'l';
+      p++;
+      break;
+    }
+
+    switch (*p) {
+    case '%':
+      __archive_strappend_char(as, '%');
+      break;
+    case 'c':
+      s = va_arg(ap, int);
+      __archive_strappend_char(as, s);
+      break;
+    case 'd':
+      switch(long_flag) {
+      case 'j': s = va_arg(ap, intmax_t); break;
+      case 'l': s = va_arg(ap, long); break;
+      default:  s = va_arg(ap, int); break;
+      }
+      archive_strappend_int(as, s, 10);
+      break;
+    case 's':
+      p2 = va_arg(ap, char *);
+      archive_strcat(as, p2);
+      break;
+    case 'o': case 'u': case 'x': case 'X':
+      /* Common handling for unsigned integer formats. */
+      switch(long_flag) {
+      case 'j': u = va_arg(ap, uintmax_t); break;
+      case 'l': u = va_arg(ap, unsigned long); break;
+      default:  u = va_arg(ap, unsigned int); break;
+      }
+      /* Format it in the correct base. */
+      switch (*p) {
+      case 'o': archive_strappend_int(as, u, 8); break;
+      case 'u': archive_strappend_int(as, u, 10); break;
+      default: archive_strappend_int(as, u, 16); break;
+      }
+      break;
+    default:
+      /* Rewind and print the initial '%' literally. */
+      p = saved_p;
+      archive_strappend_char(as, *p);
+    }
+  }
+}
+
+//----------------------------------------------------------------------
+class cmCPackTGZ_Data
+{
+public:
+  cmCPackTGZ_Data(cmCPackTGZGenerator* gen) :
+    Name(0), OutputStream(0), Generator(gen) {}
+  const char *Name;
+  std::ostream* OutputStream;
+  cmCPackTGZGenerator* Generator;
+};
+
+//----------------------------------------------------------------------
+int cmCPackTGZGenerator::TGZ_Open(struct archive *a, void *client_data)
+{
+  cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
+
+  (void)a;
+  mydata->OutputStream = new cmGeneratedFileStream(mydata->Name);
+  if ( *mydata->OutputStream &&
+    mydata->Generator->GenerateHeader(mydata->OutputStream))
+    {
+    return (ARCHIVE_OK);
+    }
+  else
+    {
+    return (ARCHIVE_FATAL);
+    }
+}
+
+//----------------------------------------------------------------------
+ssize_t cmCPackTGZGenerator::TGZ_Write(struct archive *a, void *client_data, void *buff, size_t n)
+{
+  cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
+
+  (void)a;
+  mydata->OutputStream->write(reinterpret_cast<const char*>(buff), n);
+  if ( !*mydata->OutputStream )
+    {
+    return 0;
+    }
+  return n;
+}
+
+//----------------------------------------------------------------------
+int cmCPackTGZGenerator::TGZ_Close(struct archive *a, void *client_data)
+{
+  cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
+
+  (void)a;
+  delete mydata->OutputStream;
+  return (0);
+}
+
+//----------------------------------------------------------------------
+int cmCPackTGZGenerator::CompressFiles(const char* outFileName, const char* toplevel,
+  const std::vector<std::string>& files)
+{
+  std::cout << "Toplevel: " << toplevel << std::endl;
+  cmCPackTGZ_Data mydata(this);
+  struct archive *a;
+  struct archive_entry *entry;
+  struct stat st;
+  char buff[8192];
+  int len;
+  int fd;
+
+  a = archive_write_new();
+  mydata.Name = outFileName;
+  archive_write_set_compression_gzip(a);
+  archive_write_set_format_ustar(a);
+  archive_write_open(a, &mydata, cmCPackTGZGenerator::TGZ_Open,
+    cmCPackTGZGenerator::TGZ_Write, cmCPackTGZGenerator::TGZ_Close);
+  std::vector<std::string>::const_iterator fileIt;
+  for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
+    {
+    std::string fname = cmSystemTools::RelativePath(toplevel, fileIt->c_str());
+    const char* filename = fileIt->c_str();
+    stat(filename, &st);
+    entry = archive_entry_new();
+    archive_entry_copy_stat(entry, &st);
+    archive_entry_set_pathname(entry, fname.c_str());
+    archive_write_header(a, entry);
+    fd = open(filename, O_RDONLY);
+    len = read(fd, buff, sizeof(buff));
+    while ( len > 0 )
+      {
+      archive_write_data(a, buff, len);
+      len = read(fd, buff, sizeof(buff));
+      }
+    archive_entry_free(entry);
+    }
+  archive_write_finish(a);
+  return 1;
+}
+
+//--- archive_write_set_format_ustar.c
+struct ustar {
+  uint64_t entry_bytes_remaining;
+  uint64_t entry_padding;
+  char  written;
+};
+
+/*
+ * Define structure of POSIX 'ustar' tar header.
+ */
+struct archive_entry_header_ustar {
+  char name[100];
+  char mode[6];
+  char mode_padding[2];
+  char uid[6];
+  char uid_padding[2];
+  char gid[6];
+  char gid_padding[2];
+  char size[11];
+  char size_padding[1];
+  char mtime[11];
+  char mtime_padding[1];
+  char checksum[8];
+  char typeflag[1];
+  char linkname[100];
+  char magic[6]; /* For POSIX: "ustar\0" */
+  char version[2]; /* For POSIX: "00" */
+  char uname[32];
+  char gname[32];
+  char rdevmajor[6];
+  char rdevmajor_padding[2];
+  char rdevminor[6];
+  char rdevminor_padding[2];
+  char prefix[155];
+  char padding[12];
+};
+
+/*
+ * A filled-in copy of the header for initialization.
+ */
+static const struct archive_entry_header_ustar template_header = {
+    { "" },    /* name */
+    { '0','0','0','0','0','0' }, { ' ', '\0' }, /* mode, space-null termination. */
+    { '0','0','0','0','0','0' }, { ' ', '\0' }, /* uid, space-null termination. */
+    { '0','0','0','0','0','0' }, { ' ', '\0' }, /* gid, space-null termination. */
+    { '0','0','0','0','0','0','0','0','0','0','0' }, { ' ' }, /* size, space termination. */
+    { '0','0','0','0','0','0','0','0','0','0','0' }, { ' ' }, /* mtime, space termination. */
+    { ' ',' ',' ',' ',' ',' ',' ',' ' },   /* Initial checksum value. */
+    { '0' },   /* default: regular file */
+    { "" },    /* linkname */
+    { 'u','s','t','a','r' },   /* magic */
+    { '0', '0' },   /* version */
+    { "" },    /* uname */
+    { "" },    /* gname */
+    {'0','0','0','0','0','0'}, { ' ', '\0' }, /* rdevmajor, space-null termination */
+    {'0','0','0','0','0','0'}, { ' ', '\0' }, /* rdevminor, space-null termination */
+    { "" },    /* prefix */
+    { "" }    /* padding */
+};
+
+static int archive_write_ustar_data(struct archive *a, const void *buff,
+  size_t s);
+static int archive_write_ustar_finish(struct archive *);
+static int archive_write_ustar_finish_entry(struct archive *);
+static int archive_write_ustar_header(struct archive *,
+  struct archive_entry *entry);
+static int format_256(int64_t, char *, int);
+static int format_number(int64_t, char *, int size, int max, int strict);
+static int format_octal(int64_t, char *, int);
+static int write_nulls(struct archive *a, size_t);
+
+/*
+ * Set output format to 'ustar' format.
+ */
+  int
+archive_write_set_format_ustar(struct archive *a)
+{
+  struct ustar *ustar;
+
+  /* If someone else was already registered, unregister them. */
+  if (a->format_finish != NULL)
+    (a->format_finish)(a);
+
+  ustar = (struct ustar*)malloc(sizeof(*ustar));
+  if (ustar == NULL) {
+    archive_set_error(a, ENOMEM, "Can't allocate ustar data");
+    return (ARCHIVE_FATAL);
+  }
+  memset(ustar, 0, sizeof(*ustar));
+  a->format_data = ustar;
+
+  a->pad_uncompressed = 1; /* Mimic gtar in this respect. */
+  a->format_write_header = archive_write_ustar_header;
+  a->format_write_data = archive_write_ustar_data;
+  a->format_finish = archive_write_ustar_finish;
+  a->format_finish_entry = archive_write_ustar_finish_entry;
+  a->archive_format = ARCHIVE_FORMAT_TAR_USTAR;
+  a->archive_format_name = "POSIX ustar";
+  return (ARCHIVE_OK);
+}
+
+  static int
+archive_write_ustar_header(struct archive *a, struct archive_entry *entry)
+{
+  char buff[512];
+  int ret;
+  struct ustar *ustar;
+
+  ustar = (struct ustar*)a->format_data;
+  ustar->written = 1;
+
+  /* Only regular files (not hardlinks) have data. */
+  if (archive_entry_hardlink(entry) != NULL ||
+    archive_entry_symlink(entry) != NULL ||
+    !S_ISREG(archive_entry_mode(entry)))
+    archive_entry_set_size(entry, 0);
+
+  ret = __archive_write_format_header_ustar(a, buff, entry, -1, 1);
+  if (ret != ARCHIVE_OK)
+    return (ret);
+  ret = (a->compression_write)(a, buff, 512);
+  if (ret != ARCHIVE_OK)
+    return (ret);
+
+  ustar->entry_bytes_remaining = archive_entry_size(entry);
+  ustar->entry_padding = 0x1ff & (- ustar->entry_bytes_remaining);
+  return (ARCHIVE_OK);
+}
+
+/*
+ * Format a basic 512-byte "ustar" header.
+ *
+ * Returns -1 if format failed (due to field overflow).
+ * Note that this always formats as much of the header as possible.
+ * If "strict" is set to zero, it will extend numeric fields as
+ * necessary (overwriting terminators or using base-256 extensions).
+ *
+ * This is exported so that other 'tar' formats can use it.
+ */
+  int
+__archive_write_format_header_ustar(struct archive *a, char buff[512],
+  struct archive_entry *entry, int tartype, int strict)
+{
+  unsigned int checksum;
+  struct archive_entry_header_ustar *h;
+  int i, ret;
+  size_t copy_length;
+  const char *p, *pp;
+  const struct stat *st;
+  int mytartype;
+
+  ret = 0;
+  mytartype = -1;
+  /*
+   * The "template header" already includes the "ustar"
+   * signature, various end-of-field markers and other required
+   * elements.
+   */
+  memcpy(buff, &template_header, 512);
+
+  h = (struct archive_entry_header_ustar *)buff;
+
+  /*
+   * Because the block is already null-filled, and strings
+   * are allowed to exactly fill their destination (without null),
+   * I use memcpy(dest, src, strlen()) here a lot to copy strings.
+   */
+
+  pp = archive_entry_pathname(entry);
+  if (strlen(pp) <= sizeof(h->name))
+    memcpy(h->name, pp, strlen(pp));
+  else {
+    /* Store in two pieces, splitting at a '/'. */
+    p = strchr(pp + strlen(pp) - sizeof(h->name) - 1, '/');
+    /*
+     * If there is no path separator, or the prefix or
+     * remaining name are too large, return an error.
+     */
+    if (!p) {
+      archive_set_error(a, ENAMETOOLONG,
+        "Pathname too long");
+      ret = ARCHIVE_WARN;
+    } else if (p  > pp + sizeof(h->prefix)) {
+      archive_set_error(a, ENAMETOOLONG,
+        "Pathname too long");
+      ret = ARCHIVE_WARN;
+    } else {
+      /* Copy prefix and remainder to appropriate places */
+      memcpy(h->prefix, pp, p - pp);
+      memcpy(h->name, p + 1, pp + strlen(pp) - p - 1);
+    }
+  }
+
+  p = archive_entry_hardlink(entry);
+  if (p != NULL)
+    mytartype = '1';
+  else
+    p = archive_entry_symlink(entry);
+  if (p != NULL && p[0] != '\0') {
+    copy_length = strlen(p);
+    if (copy_length > sizeof(h->linkname)) {
+      archive_set_error(a, ENAMETOOLONG,
+        "Link contents too long");
+      ret = ARCHIVE_WARN;
+      copy_length = sizeof(h->linkname);
+    }
+    memcpy(h->linkname, p, copy_length);
+  }
+
+  p = archive_entry_uname(entry);
+  if (p != NULL && p[0] != '\0') {
+    copy_length = strlen(p);
+    if (copy_length > sizeof(h->uname)) {
+      archive_set_error(a, ARCHIVE_ERRNO_MISC,
+        "Username too long");
+      ret = ARCHIVE_WARN;
+      copy_length = sizeof(h->uname);
+    }
+    memcpy(h->uname, p, copy_length);
+  }
+
+  p = archive_entry_gname(entry);
+  if (p != NULL && p[0] != '\0') {
+    copy_length = strlen(p);
+    if (strlen(p) > sizeof(h->gname)) {
+      archive_set_error(a, ARCHIVE_ERRNO_MISC,
+        "Group name too long");
+      ret = ARCHIVE_WARN;
+      copy_length = sizeof(h->gname);
+    }
+    memcpy(h->gname, p, copy_length);
+  }
+
+  st = archive_entry_stat(entry);
+
+  if (format_number(st->st_mode & 07777, h->mode, sizeof(h->mode), 8, strict)) {
+    archive_set_error(a, ERANGE, "Numeric mode too large");
+    ret = ARCHIVE_WARN;
+  }
+
+  if (format_number(st->st_uid, h->uid, sizeof(h->uid), 8, strict)) {
+    archive_set_error(a, ERANGE, "Numeric user ID too large");
+    ret = ARCHIVE_WARN;
+  }
+
+  if (format_number(st->st_gid, h->gid, sizeof(h->gid), 8, strict)) {
+    archive_set_error(a, ERANGE, "Numeric group ID too large");
+    ret = ARCHIVE_WARN;
+  }
+
+  if (format_number(st->st_size, h->size, sizeof(h->size), 12, strict)) {
+    archive_set_error(a, ERANGE, "File size out of range");
+    ret = ARCHIVE_WARN;
+  }
+
+  if (format_number(st->st_mtime, h->mtime, sizeof(h->mtime), 12, strict)) {
+    archive_set_error(a, ERANGE,
+      "File modification time too large");
+    ret = ARCHIVE_WARN;
+  }
+
+#if defined(S_ISBLK)
+  if (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)) {
+    if (format_number(major(st->st_rdev), h->rdevmajor,
+        sizeof(h->rdevmajor), 8, strict)) {
+      archive_set_error(a, ERANGE,
+        "Major device number too large");
+      ret = ARCHIVE_WARN;
+    }
+
+    if (format_number(minor(st->st_rdev), h->rdevminor,
+        sizeof(h->rdevminor), 8, strict)) {
+      archive_set_error(a, ERANGE,
+        "Minor device number too large");
+      ret = ARCHIVE_WARN;
+    }
+  }
+#endif
+
+  if (tartype >= 0) {
+    h->typeflag[0] = tartype;
+  } else if (mytartype >= 0) {
+    h->typeflag[0] = mytartype;
+  } else {
+    switch (st->st_mode & S_IFMT) {
+    case S_IFREG: h->typeflag[0] = '0' ; break;
+#if defined(S_IFLNK)
+    case S_IFLNK: h->typeflag[0] = '2' ; break;
+#endif
+    case S_IFCHR: h->typeflag[0] = '3' ; break;
+#if defined(S_IFBLK)
+    case S_IFBLK: h->typeflag[0] = '4' ; break;
+#endif
+    case S_IFDIR: h->typeflag[0] = '5' ; break;
+#if defined(S_IFIFO)
+    case S_IFIFO: h->typeflag[0] = '6' ; break;
+#endif
+#if defined(S_IFSOCK)
+    case S_IFSOCK:
+                  archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
+                    "tar format cannot archive socket");
+                  ret = ARCHIVE_WARN;
+                  break;
+#endif
+    default:
+                  archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
+                    "tar format cannot archive this (mode=0%lo)",
+                    (unsigned long)st->st_mode);
+                  ret = ARCHIVE_WARN;
+    }
+  }
+
+  checksum = 0;
+  for (i = 0; i < 512; i++)
+    checksum += 255 & (unsigned int)buff[i];
+  h->checksum[6] = '\0'; /* Can't be pre-set in the template. */
+  /* h->checksum[7] = ' '; */ /* This is pre-set in the template. */
+  format_octal(checksum, h->checksum, 6);
+  return (ret);
+}
+
+/*
+ * Format a number into a field, with some intelligence.
+ */
+  static int
+format_number(int64_t v, char *p, int s, int maxsize, int strict)
+{
+  int64_t limit;
+
+  limit = ((int64_t)1 << (s*3));
+
+  /* "Strict" only permits octal values with proper termination. */
+  if (strict)
+    return (format_octal(v, p, s));
+
+  /*
+   * In non-strict mode, we allow the number to overwrite one or
+   * more bytes of the field termination.  Even old tar
+   * implementations should be able to handle this with no
+   * problem.
+   */
+  if (v >= 0) {
+    while (s <= maxsize) {
+      if (v < limit)
+        return (format_octal(v, p, s));
+      s++;
+      limit <<= 3;
+    }
+  }
+
+  /* Base-256 can handle any number, positive or negative. */
+  return (format_256(v, p, maxsize));
+}
+
+/*
+ * Format a number into the specified field using base-256.
+ */
+  static int
+format_256(int64_t v, char *p, int s)
+{
+  p += s;
+  while (s-- > 0) {
+    *--p = (char)(v & 0xff);
+    v >>= 8;
+  }
+  *p |= 0x80; /* Set the base-256 marker bit. */
+  return (0);
+}
+
+/*
+ * Format a number into the specified field.
+ */
+  static int
+format_octal(int64_t v, char *p, int s)
+{
+  int len;
+
+  len = s;
+
+  /* Octal values can't be negative, so use 0. */
+  if (v < 0) {
+    while (len-- > 0)
+      *p++ = '0';
+    return (-1);
+  }
+
+  p += s;  /* Start at the end and work backwards. */
+  while (s-- > 0) {
+    *--p = '0' + (v & 7);
+    v >>= 3;
+  }
+
+  if (v == 0)
+    return (0);
+
+  /* If it overflowed, fill field with max value. */
+  while (len-- > 0)
+    *p++ = '7';
+
+  return (-1);
+}
+
+  static int
+archive_write_ustar_finish(struct archive *a)
+{
+  struct ustar *ustar;
+  int r;
+
+  r = ARCHIVE_OK;
+  ustar = (struct ustar*)a->format_data;
+  /*
+   * Suppress end-of-archive if nothing else was ever written.
+   * This fixes a problem where setting one format, then another
+   * ends up writing a gratuitous end-of-archive marker.
+   */
+  if (ustar->written && a->compression_write != NULL)
+    r = write_nulls(a, 512*2);
+  free(ustar);
+  a->format_data = NULL;
+  return (r);
+}
+
+  static int
+archive_write_ustar_finish_entry(struct archive *a)
+{
+  struct ustar *ustar;
+  int ret;
+
+  ustar = (struct ustar*) a->format_data;
+  ret = write_nulls(a,
+    ustar->entry_bytes_remaining + ustar->entry_padding);
+  ustar->entry_bytes_remaining = ustar->entry_padding = 0;
+  return (ret);
+}
+
+  static int
+write_nulls(struct archive *a, size_t padding)
+{
+  int ret, to_write;
+
+  while (padding > 0) {
+    to_write = padding < a->null_length ? padding : a->null_length;
+    ret = (a->compression_write)(a, a->nulls, to_write);
+    if (ret != ARCHIVE_OK)
+      return (ret);
+    padding -= to_write;
+  }
+  return (ARCHIVE_OK);
+}
+
+  static int
+archive_write_ustar_data(struct archive *a, const void *buff, size_t s)
+{
+  struct ustar *ustar;
+  int ret;
+
+  ustar = (struct ustar*)a->format_data;
+  if (s > ustar->entry_bytes_remaining)
+    s = ustar->entry_bytes_remaining;
+  ret = (a->compression_write)(a, buff, s);
+  ustar->entry_bytes_remaining -= s;
+  return (ret);
+}
+
+//--- archive_write_set_compression_gzip.c
+
+struct private_data {
+  z_stream  stream;
+  int64_t   total_in;
+  unsigned char *compressed;
+  size_t   compressed_buffer_size;
+  unsigned long  crc;
+};
+
+
+/*
+ * Yuck.  zlib.h is not const-correct, so I need this one bit
+ * of ugly hackery to convert a const * pointer to a non-const pointer.
+ */
+#define SET_NEXT_IN(st,src)     \
+  (st)->stream.next_in = (Bytef*)(void *)(uintptr_t)(const void *)(src)
+
+static int archive_compressor_gzip_finish(struct archive *);
+static int archive_compressor_gzip_init(struct archive *);
+static int archive_compressor_gzip_write(struct archive *, const void *,
+  size_t);
+static int drive_compressor(struct archive *, struct private_data *,
+  int finishing);
+
+
+/*
+ * Allocate, initialize and return a archive object.
+ */
+  int
+archive_write_set_compression_gzip(struct archive *a)
+{
+  __archive_check_magic(a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_set_compression_gzip");
+  a->compression_init = &archive_compressor_gzip_init;
+  a->compression_code = ARCHIVE_COMPRESSION_GZIP;
+  a->compression_name = "gzip";
+  return (ARCHIVE_OK);
+}
+
+/*
+ * Setup callback.
+ */
+  static int
+archive_compressor_gzip_init(struct archive *a)
+{
+  int ret;
+  struct private_data *state;
+  time_t t;
+
+  a->compression_code = ARCHIVE_COMPRESSION_GZIP;
+  a->compression_name = "gzip";
+
+  if (a->client_opener != NULL) {
+    ret = (a->client_opener)(a, a->client_data);
+    if (ret != ARCHIVE_OK)
+      return (ret);
+  }
+
+  state = (struct private_data *)malloc(sizeof(*state));
+  if (state == NULL) {
+    archive_set_error(a, ENOMEM,
+      "Can't allocate data for compression");
+    return (ARCHIVE_FATAL);
+  }
+  memset(state, 0, sizeof(*state));
+
+  state->compressed_buffer_size = a->bytes_per_block;
+  state->compressed = (unsigned char*)malloc(state->compressed_buffer_size);
+  state->crc = crc32(0L, NULL, 0);
+
+  if (state->compressed == NULL) {
+    archive_set_error(a, ENOMEM,
+      "Can't allocate data for compression buffer");
+    free(state);
+    return (ARCHIVE_FATAL);
+  }
+
+  state->stream.next_out = state->compressed;
+  state->stream.avail_out = state->compressed_buffer_size;
+
+  /* Prime output buffer with a gzip header. */
+  t = time(NULL);
+  state->compressed[0] = 0x1f; /* GZip signature bytes */
+  state->compressed[1] = 0x8b;
+  state->compressed[2] = 0x08; /* "Deflate" compression */
+  state->compressed[3] = 0; /* No options */
+  state->compressed[4] = (t)&0xff;  /* Timestamp */
+  state->compressed[5] = (t>>8)&0xff;
+  state->compressed[6] = (t>>16)&0xff;
+  state->compressed[7] = (t>>24)&0xff;
+  state->compressed[8] = 0; /* No deflate options */
+  state->compressed[9] = 3; /* OS=Unix */
+  state->stream.next_out += 10;
+  state->stream.avail_out -= 10;
+
+  a->compression_write = archive_compressor_gzip_write;
+  a->compression_finish = archive_compressor_gzip_finish;
+
+  /* Initialize compression library. */
+  ret = deflateInit2(&(state->stream),
+    Z_DEFAULT_COMPRESSION,
+    Z_DEFLATED,
+    -15 /* < 0 to suppress zlib header */,
+    8,
+    Z_DEFAULT_STRATEGY);
+
+  if (ret == Z_OK) {
+    a->compression_data = state;
+    return (0);
+  }
+
+  /* Library setup failed: clean up. */
+  archive_set_error(a, ARCHIVE_ERRNO_MISC, "Internal error "
+    "initializing compression library");
+  free(state->compressed);
+  free(state);
+
+  /* Override the error message if we know what really went wrong. */
+  switch (ret) {
+  case Z_STREAM_ERROR:
+    archive_set_error(a, ARCHIVE_ERRNO_MISC,
+      "Internal error initializing "
+      "compression library: invalid setup parameter");
+    break;
+  case Z_MEM_ERROR:
+    archive_set_error(a, ENOMEM, "Internal error initializing "
+      "compression library");
+    break;
+  case Z_VERSION_ERROR:
+    archive_set_error(a, ARCHIVE_ERRNO_MISC,
+      "Internal error initializing "
+      "compression library: invalid library version");
+    break;
+  }
+
+  return (ARCHIVE_FATAL);
+}
+
+/*
+ * Write data to the compressed stream.
+ */
+  static int
+archive_compressor_gzip_write(struct archive *a, const void *buff,
+  size_t length)
+{
+  struct private_data *state;
+  int ret;
+
+  state = (struct private_data*)a->compression_data;
+  if (a->client_writer == NULL) {
+    archive_set_error(a, ARCHIVE_ERRNO_PROGRAMMER,
+      "No write callback is registered?  "
+      "This is probably an internal programming error.");
+    return (ARCHIVE_FATAL);
+  }
+
+  /* Update statistics */
+  state->crc = crc32(state->crc, (const Bytef*)buff, length);
+  state->total_in += length;
+
+  /* Compress input data to output buffer */
+  SET_NEXT_IN(state, buff);
+  state->stream.avail_in = length;
+  if ((ret = drive_compressor(a, state, 0)) != ARCHIVE_OK)
+    return (ret);
+
+  a->file_position += length;
+  return (ARCHIVE_OK);
+}
+
+
+/*
+ * Finish the compression...
+ */
+  static int
+archive_compressor_gzip_finish(struct archive *a)
+{
+  ssize_t block_length, target_block_length, bytes_written;
+  int ret;
+  struct private_data *state;
+  unsigned tocopy;
+  unsigned char trailer[8];
+
+  state = (struct private_data*)a->compression_data;
+  ret = 0;
+  if (a->client_writer == NULL) {
+    archive_set_error(a, ARCHIVE_ERRNO_PROGRAMMER,
+      "No write callback is registered?  "
+      "This is probably an internal programming error.");
+    ret = ARCHIVE_FATAL;
+    goto cleanup;
+  }
+
+  /* By default, always pad the uncompressed data. */
+  if (a->pad_uncompressed) {
+    tocopy = a->bytes_per_block -
+      (state->total_in % a->bytes_per_block);
+    while (tocopy > 0 && tocopy < (unsigned)a->bytes_per_block) {
+      SET_NEXT_IN(state, a->nulls);
+      state->stream.avail_in = tocopy < a->null_length ?
+        tocopy : a->null_length;
+      state->crc = crc32(state->crc, a->nulls,
+        state->stream.avail_in);
+      state->total_in += state->stream.avail_in;
+      tocopy -= state->stream.avail_in;
+      ret = drive_compressor(a, state, 0);
+      if (ret != ARCHIVE_OK)
+        goto cleanup;
+    }
+  }
+
+  /* Finish compression cycle */
+  if (((ret = drive_compressor(a, state, 1))) != ARCHIVE_OK)
+    goto cleanup;
+
+  /* Build trailer: 4-byte CRC and 4-byte length. */
+  trailer[0] = (state->crc)&0xff;
+  trailer[1] = (state->crc >> 8)&0xff;
+  trailer[2] = (state->crc >> 16)&0xff;
+  trailer[3] = (state->crc >> 24)&0xff;
+  trailer[4] = (state->total_in)&0xff;
+  trailer[5] = (state->total_in >> 8)&0xff;
+  trailer[6] = (state->total_in >> 16)&0xff;
+  trailer[7] = (state->total_in >> 24)&0xff;
+
+  /* Add trailer to current block. */
+  tocopy = 8;
+  if (tocopy > state->stream.avail_out)
+    tocopy = state->stream.avail_out;
+  memcpy(state->stream.next_out, trailer, tocopy);
+  state->stream.next_out += tocopy;
+  state->stream.avail_out -= tocopy;
+
+  /* If it overflowed, flush and start a new block. */
+  if (tocopy < 8) {
+    bytes_written = (a->client_writer)(a, a->client_data,
+      state->compressed, state->compressed_buffer_size);
+    if (bytes_written <= 0) {
+      ret = ARCHIVE_FATAL;
+      goto cleanup;
+    }
+    a->raw_position += bytes_written;
+    state->stream.next_out = state->compressed;
+    state->stream.avail_out = state->compressed_buffer_size;
+    memcpy(state->stream.next_out, trailer + tocopy, 8-tocopy);
+    state->stream.next_out += 8-tocopy;
+    state->stream.avail_out -= 8-tocopy;
+  }
+
+  /* Optionally, pad the final compressed block. */
+  block_length = state->stream.next_out - state->compressed;
+
+
+  /* Tricky calculation to determine size of last block. */
+  target_block_length = block_length;
+  if (a->bytes_in_last_block <= 0)
+    /* Default or Zero: pad to full block */
+    target_block_length = a->bytes_per_block;
+  else
+    /* Round length to next multiple of bytes_in_last_block. */
+    target_block_length = a->bytes_in_last_block *
+      ( (block_length + a->bytes_in_last_block - 1) /
+        a->bytes_in_last_block);
+  if (target_block_length > a->bytes_per_block)
+    target_block_length = a->bytes_per_block;
+  if (block_length < target_block_length) {
+    memset(state->stream.next_out, 0,
+      target_block_length - block_length);
+    block_length = target_block_length;
+  }
+
+  /* Write the last block */
+  bytes_written = (a->client_writer)(a, a->client_data,
+    state->compressed, block_length);
+  if (bytes_written <= 0) {
+    ret = ARCHIVE_FATAL;
+    goto cleanup;
+  }
+  a->raw_position += bytes_written;
+
+  /* Cleanup: shut down compressor, release memory, etc. */
+cleanup:
+  switch (deflateEnd(&(state->stream))) {
+  case Z_OK:
+    break;
+  default:
+    archive_set_error(a, ARCHIVE_ERRNO_MISC,
+      "Failed to clean up compressor");
+    ret = ARCHIVE_FATAL;
+  }
+  free(state->compressed);
+  free(state);
+
+  /* Close the output */
+  if (a->client_closer != NULL)
+    (a->client_closer)(a, a->client_data);
+
+  return (ret);
+}
+
+/*
+ * Utility function to push input data through compressor,
+ * writing full output blocks as necessary.
+ *
+ * Note that this handles both the regular write case (finishing ==
+ * false) and the end-of-archive case (finishing == true).
+ */
+  static int
+drive_compressor(struct archive *a, struct private_data *state, int finishing)
+{
+  ssize_t bytes_written;
+  int ret;
+
+  for (;;) {
+    if (state->stream.avail_out == 0) {
+      bytes_written = (a->client_writer)(a, a->client_data,
+        state->compressed, state->compressed_buffer_size);
+      if (bytes_written <= 0) {
+        /* TODO: Handle this write failure */
+        return (ARCHIVE_FATAL);
+      } else if ((size_t)bytes_written < state->compressed_buffer_size) {
+        /* Short write: Move remaining to
+         * front of block and keep filling */
+        memmove(state->compressed,
+          state->compressed + bytes_written,
+          state->compressed_buffer_size - bytes_written);
+      }
+      a->raw_position += bytes_written;
+      state->stream.next_out
+        = state->compressed +
+        state->compressed_buffer_size - bytes_written;
+      state->stream.avail_out = bytes_written;
+    }
+
+    ret = deflate(&(state->stream),
+      finishing ? Z_FINISH : Z_NO_FLUSH );
+
+    switch (ret) {
+    case Z_OK:
+      /* In non-finishing case, check if compressor
+       * consumed everything */
+      if (!finishing && state->stream.avail_in == 0)
+        return (ARCHIVE_OK);
+      /* In finishing case, this return always means
+       * there's more work */
+      break;
+    case Z_STREAM_END:
+      /* This return can only occur in finishing case. */
+      return (ARCHIVE_OK);
+    default:
+      /* Any other return value indicates an error. */
+      archive_set_error(a, ARCHIVE_ERRNO_MISC,
+        "GZip compression failed");
+      return (ARCHIVE_FATAL);
+    }
+  }
+}
+