4068 lines
118 KiB
C++
4068 lines
118 KiB
C++
/*=========================================================================
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|