jimzah/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src.git synced 2024-11-30 10:52:50 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

MFC r344063,r344088:

Browse Source 
MFC r344063:
Sync libarchive with vendor.

Relevant vendor changes:
  PR #1085: Fix a null pointer dereference bug in zip writer
  PR #1110: ZIP reader added support for XZ, LZMA, PPMD8 and BZIP2
            decopmpression
  PR #1116: Add support for 64-bit ar format
  PR #1120: Fix a 7zip crash [1] and a ISO9660 infinite loop [2]
  PR #1125: RAR5 reader - fix an invalid read and a memory leak
  PR #1131: POSIX reader - do not fail when tree_current_lstat() fails
            due to ENOENT [3]
  PR #1134: Delete unnecessary null pointer checks before calls of free()
  OSS-Fuzz 10843: Force intermediate to uint64_t to make UBSAN happy.
  OSS-Fuzz 11011: Avoid buffer overflow in rar5 reader

MFC r344088:
  archive_read_disk_posix.c: initialize delayed_errno

PR:		233006 [3]
Security:	CVE-2019-1000019 [1], CVE-2019-1000020 [2]
This commit is contained in:
Martin Matuska 2019-02-28 22:57:09 +00:00
parent b82d523565
commit 42efdf8868
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/stable/10/; revision=344674
38 changed files with 3255 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
contrib/libarchive/cpio/test/test_option_t.c
View File

@ -88,11 +88,11 @@ DEFINE_TEST(test_option_t)
setlocale(LC_ALL, "");
#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
strftime(date2, sizeof(date), "%b %d %Y", localtime(&mtime));
_snprintf(date, sizeof(date)-1, "%12s file", date2);
strftime(date2, sizeof(date2)-1, "%b %d %Y", localtime(&mtime));
_snprintf(date, sizeof(date)-1, "%12.12s file", date2);
#else
strftime(date2, sizeof(date), "%b %e %Y", localtime(&mtime));
snprintf(date, sizeof(date)-1, "%12s file", date2);
strftime(date2, sizeof(date2)-1, "%b %e %Y", localtime(&mtime));
snprintf(date, sizeof(date)-1, "%12.12s file", date2);
#endif
assertEqualMem(p + 42, date, strlen(date));
free(p);

24
contrib/libarchive/libarchive/archive_acl.c
View File

@ -138,14 +138,10 @@ archive_acl_clear(struct archive_acl *acl)
free(acl->acl_head);
acl->acl_head = ap;
}
if (acl->acl_text_w != NULL) {
free(acl->acl_text_w);
acl->acl_text_w = NULL;
}
if (acl->acl_text != NULL) {
free(acl->acl_text);
acl->acl_text = NULL;
}
free(acl->acl_text_w);
acl->acl_text_w = NULL;
free(acl->acl_text);
acl->acl_text = NULL;
acl->acl_p = NULL;
acl->acl_types = 0;
acl->acl_state = 0; /* Not counting. */
@ -324,14 +320,10 @@ acl_new_entry(struct archive_acl *acl,
return (NULL);
}
if (acl->acl_text_w != NULL) {
free(acl->acl_text_w);
acl->acl_text_w = NULL;
}
if (acl->acl_text != NULL) {
free(acl->acl_text);
acl->acl_text = NULL;
}
free(acl->acl_text_w);
acl->acl_text_w = NULL;
free(acl->acl_text);
acl->acl_text = NULL;
/*
* If there's a matching entry already in the list, overwrite it.

18
contrib/libarchive/libarchive/archive_entry.c
View File

@ -1560,10 +1560,8 @@ archive_entry_acl_text_compat(int *flags)
const wchar_t *
archive_entry_acl_text_w(struct archive_entry *entry, int flags)
{
if (entry->acl.acl_text_w != NULL) {
free(entry->acl.acl_text_w);
entry->acl.acl_text_w = NULL;
}
free(entry->acl.acl_text_w);
entry->acl.acl_text_w = NULL;
if (archive_entry_acl_text_compat(&flags) == 0)
entry->acl.acl_text_w = archive_acl_to_text_w(&entry->acl,
NULL, flags, entry->archive);
@ -1574,10 +1572,8 @@ archive_entry_acl_text_w(struct archive_entry *entry, int flags)
const char *
archive_entry_acl_text(struct archive_entry *entry, int flags)
{
if (entry->acl.acl_text != NULL) {
free(entry->acl.acl_text);
entry->acl.acl_text = NULL;
}
free(entry->acl.acl_text);
entry->acl.acl_text = NULL;
if (archive_entry_acl_text_compat(&flags) == 0)
entry->acl.acl_text = archive_acl_to_text_l(&entry->acl, NULL,
flags, NULL);
@ -1590,10 +1586,8 @@ int
_archive_entry_acl_text_l(struct archive_entry *entry, int flags,
const char **acl_text, size_t *len, struct archive_string_conv *sc)
{
if (entry->acl.acl_text != NULL) {
free(entry->acl.acl_text);
entry->acl.acl_text = NULL;
}
free(entry->acl.acl_text);
entry->acl.acl_text = NULL;
if (archive_entry_acl_text_compat(&flags) == 0)
entry->acl.acl_text = archive_acl_to_text_l(&entry->acl,

3
contrib/libarchive/libarchive/archive_pack_dev.c
View File

@ -60,6 +60,9 @@ __RCSID("$NetBSD$");
#ifdef HAVE_SYS_SYSMACROS_H
#include <sys/sysmacros.h>
#endif
#ifdef HAVE_SYS_MKDEV_H
#include <sys/mkdev.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

1287
contrib/libarchive/libarchive/archive_ppmd8.c Normal file
View File

File diff suppressed because it is too large Load Diff

148
contrib/libarchive/libarchive/archive_ppmd8_private.h Normal file
View File

@ -0,0 +1,148 @@
/* Ppmd8.h -- PPMdI codec
2011-01-27 : Igor Pavlov : Public domain
This code is based on:
PPMd var.I (2002): Dmitry Shkarin : Public domain
Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
#ifndef __PPMD8_H
#define __PPMD8_H
#include "archive_ppmd_private.h"
#define PPMD8_MIN_ORDER 2
#define PPMD8_MAX_ORDER 16
struct CPpmd8_Context_;
typedef
#ifdef PPMD_32BIT
struct CPpmd8_Context_ *
#else
UInt32
#endif
CPpmd8_Context_Ref;
#pragma pack(push, 1)
typedef struct CPpmd8_Context_
{
Byte NumStats;
Byte Flags;
UInt16 SummFreq;
CPpmd_State_Ref Stats;
CPpmd8_Context_Ref Suffix;
} CPpmd8_Context;
#pragma pack(pop)
#define Ppmd8Context_OneState(p) ((CPpmd_State *)&(p)->SummFreq)
/* The BUG in Shkarin's code for FREEZE mode was fixed, but that fixed
code is not compatible with original code for some files compressed
in FREEZE mode. So we disable FREEZE mode support. */
enum
{
PPMD8_RESTORE_METHOD_RESTART,
PPMD8_RESTORE_METHOD_CUT_OFF
#ifdef PPMD8_FREEZE_SUPPORT
, PPMD8_RESTORE_METHOD_FREEZE
#endif
};
typedef struct
{
CPpmd8_Context *MinContext, *MaxContext;
CPpmd_State *FoundState;
unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder;
Int32 RunLength, InitRL; /* must be 32-bit at least */
UInt32 Size;
UInt32 GlueCount;
Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;
UInt32 AlignOffset;
unsigned RestoreMethod;
/* Range Coder */
UInt32 Range;
UInt32 Code;
UInt32 Low;
union
{
IByteIn *In;
IByteOut *Out;
} Stream;
Byte Indx2Units[PPMD_NUM_INDEXES];
Byte Units2Indx[128];
CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];
UInt32 Stamps[PPMD_NUM_INDEXES];
Byte NS2BSIndx[256], NS2Indx[260];
CPpmd_See DummySee, See[24][32];
UInt16 BinSumm[25][64];
} CPpmd8;
void Ppmd8_Construct(CPpmd8 *p);
Bool Ppmd8_Alloc(CPpmd8 *p, UInt32 size);
void Ppmd8_Free(CPpmd8 *p);
void Ppmd8_Init(CPpmd8 *p, unsigned maxOrder, unsigned restoreMethod);
#define Ppmd8_WasAllocated(p) ((p)->Base != NULL)
/* ---------- Internal Functions ---------- */
extern const Byte PPMD8_kExpEscape[16];
#ifdef PPMD_32BIT
#define Ppmd8_GetPtr(p, ptr) (ptr)
#define Ppmd8_GetContext(p, ptr) (ptr)
#define Ppmd8_GetStats(p, ctx) ((ctx)->Stats)
#else
#define Ppmd8_GetPtr(p, offs) ((void *)((p)->Base + (offs)))
#define Ppmd8_GetContext(p, offs) ((CPpmd8_Context *)Ppmd8_GetPtr((p), (offs)))
#define Ppmd8_GetStats(p, ctx) ((CPpmd_State *)Ppmd8_GetPtr((p), ((ctx)->Stats)))
#endif
void Ppmd8_Update1(CPpmd8 *p);
void Ppmd8_Update1_0(CPpmd8 *p);
void Ppmd8_Update2(CPpmd8 *p);
void Ppmd8_UpdateBin(CPpmd8 *p);
#define Ppmd8_GetBinSumm(p) \
&p->BinSumm[p->NS2Indx[Ppmd8Context_OneState(p->MinContext)->Freq - 1]][ \
p->NS2BSIndx[Ppmd8_GetContext(p, p->MinContext->Suffix)->NumStats] + \
p->PrevSuccess + p->MinContext->Flags + ((p->RunLength >> 26) & 0x20)]
CPpmd_See *Ppmd8_MakeEscFreq(CPpmd8 *p, unsigned numMasked, UInt32 *scale);
/* ---------- Decode ---------- */
Bool Ppmd8_RangeDec_Init(CPpmd8 *p);
#define Ppmd8_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
int Ppmd8_DecodeSymbol(CPpmd8 *p); /* returns: -1 as EndMarker, -2 as DataError */
/* ---------- Encode ---------- */
#define Ppmd8_RangeEnc_Init(p) { (p)->Low = 0; (p)->Range = 0xFFFFFFFF; }
void Ppmd8_RangeEnc_FlushData(CPpmd8 *p);
void Ppmd8_EncodeSymbol(CPpmd8 *p, int symbol); /* symbol = -1 means EndMarker */
typedef struct
{
/* Base Functions */
void (*Ppmd8_Construct)(CPpmd8 *p);
Bool (*Ppmd8_Alloc)(CPpmd8 *p, UInt32 size);
void (*Ppmd8_Free)(CPpmd8 *p);
void (*Ppmd8_Init)(CPpmd8 *p, unsigned max_order, unsigned restore_method);
#define Ppmd7_WasAllocated(p) ((p)->Base != NULL)
/* Decode Functions */
int (*Ppmd8_RangeDec_Init)(CPpmd8 *p);
int (*Ppmd8_DecodeSymbol)(CPpmd8 *p);
} IPpmd8;
extern const IPpmd8 __archive_ppmd8_functions;
#endif

31
contrib/libarchive/libarchive/archive_read_disk_posix.c
View File

@ -856,7 +856,12 @@ next_entry(struct archive_read_disk *a, struct tree *t,
const struct stat *st; /* info to use for this entry */
const struct stat *lst;/* lstat() information */
const char *name;
int descend, r;
int delayed, delayed_errno, descend, r;
struct archive_string delayed_str;
delayed = ARCHIVE_OK;
delayed_errno = 0;
archive_string_init(&delayed_str);
st = NULL;
lst = NULL;
@ -885,11 +890,23 @@ next_entry(struct archive_read_disk *a, struct tree *t,
case TREE_REGULAR:
lst = tree_current_lstat(t);
if (lst == NULL) {
if (errno == ENOENT && t->depth > 0) {
delayed = ARCHIVE_WARN;
delayed_errno = errno;
if (delayed_str.length == 0) {
archive_string_sprintf(&delayed_str,
"%s", tree_current_path(t));
} else {
archive_string_sprintf(&delayed_str,
" %s", tree_current_path(t));
}
} else {
archive_set_error(&a->archive, errno,
"%s: Cannot stat",
tree_current_path(t));
tree_enter_initial_dir(t);
return (ARCHIVE_FAILED);
}
}
break;
}
@ -1083,6 +1100,18 @@ next_entry(struct archive_read_disk *a, struct tree *t,
r = archive_read_disk_entry_from_file(&(a->archive), entry,
t->entry_fd, st);
if (r == ARCHIVE_OK) {
r = delayed;
if (r != ARCHIVE_OK) {
archive_string_sprintf(&delayed_str, ": %s",
"File removed before we read it");
archive_set_error(&(a->archive), delayed_errno,
"%s", delayed_str.s);
}
}
if (!archive_string_empty(&delayed_str))
archive_string_free(&delayed_str);
return (r);
}

3
contrib/libarchive/libarchive/archive_read_open_file.c
View File

@ -174,8 +174,7 @@ file_close(struct archive *a, void *client_data)
struct read_FILE_data *mine = (struct read_FILE_data *)client_data;
(void)a; /* UNUSED */
if (mine->buffer != NULL)
free(mine->buffer);
free(mine->buffer);
free(mine);
return (ARCHIVE_OK);
}

11
contrib/libarchive/libarchive/archive_read_support_format_7zip.c
View File

@ -2964,13 +2964,7 @@ get_uncompressed_data(struct archive_read *a, const void **buff, size_t size,
if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
/* Copy mode. */
/*
* Note: '1' here is a performance optimization.
* Recall that the decompression layer returns a count of
* available bytes; asking for more than that forces the
* decompressor to combine reads by copying data.
*/
*buff = __archive_read_ahead(a, 1, &bytes_avail);
*buff = __archive_read_ahead(a, minimum, &bytes_avail);
if (bytes_avail <= 0) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
@ -3323,8 +3317,7 @@ setup_decode_folder(struct archive_read *a, struct _7z_folder *folder,
* Release the memory which the previous folder used for BCJ2.
*/
for (i = 0; i < 3; i++) {
if (zip->sub_stream_buff[i] != NULL)
free(zip->sub_stream_buff[i]);
free(zip->sub_stream_buff[i]);
zip->sub_stream_buff[i] = NULL;
}

8
contrib/libarchive/libarchive/archive_read_support_format_ar.c
View File

@ -138,8 +138,7 @@ archive_read_format_ar_cleanup(struct archive_read *a)
struct ar *ar;
ar = (struct ar *)(a->format->data);
if (ar->strtab)
free(ar->strtab);
free(ar->strtab);
free(ar);
(a->format->data) = NULL;
return (ARCHIVE_OK);
@ -388,9 +387,10 @@ _ar_read_header(struct archive_read *a, struct archive_entry *entry,
/*
* "/" is the SVR4/GNU archive symbol table.
* "/SYM64/" is the SVR4/GNU 64-bit variant archive symbol table.
*/
if (strcmp(filename, "/") == 0) {
archive_entry_copy_pathname(entry, "/");
if (strcmp(filename, "/") == 0 || strcmp(filename, "/SYM64/") == 0) {
archive_entry_copy_pathname(entry, filename);
/* Parse the time, owner, mode, size fields. */
r = ar_parse_common_header(ar, entry, h);
/* Force the file type to a regular file. */

3
contrib/libarchive/libarchive/archive_read_support_format_cpio.c
View File

@ -955,8 +955,7 @@ archive_read_format_cpio_cleanup(struct archive_read *a)
while (cpio->links_head != NULL) {
struct links_entry *lp = cpio->links_head->next;
if (cpio->links_head->name)
free(cpio->links_head->name);
free(cpio->links_head->name);
free(cpio->links_head);
cpio->links_head = lp;
}

17
contrib/libarchive/libarchive/archive_read_support_format_iso9660.c
View File

@ -1724,8 +1724,7 @@ archive_read_format_iso9660_cleanup(struct archive_read *a)
free(iso9660->read_ce_req.reqs);
archive_string_free(&iso9660->pathname);
archive_string_free(&iso9660->previous_pathname);
if (iso9660->pending_files.files)
free(iso9660->pending_files.files);
free(iso9660->pending_files.files);
#ifdef HAVE_ZLIB_H
free(iso9660->entry_zisofs.uncompressed_buffer);
free(iso9660->entry_zisofs.block_pointers);
@ -2102,6 +2101,7 @@ parse_rockridge(struct archive_read *a, struct file_info *file,
const unsigned char *p, const unsigned char *end)
{
struct iso9660 *iso9660;
int entry_seen = 0;
iso9660 = (struct iso9660 *)(a->format->data);
@ -2257,8 +2257,16 @@ parse_rockridge(struct archive_read *a, struct file_info *file,
}
p += p[2];
entry_seen = 1;
}
if (entry_seen)
return (ARCHIVE_OK);
else {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Tried to parse Rockridge extensions, but none found");
return (ARCHIVE_WARN);
}
return (ARCHIVE_OK);
}
static int
@ -3029,8 +3037,7 @@ heap_add_entry(struct archive_read *a, struct heap_queue *heap,
if (heap->allocated)
memcpy(new_pending_files, heap->files,
heap->allocated * sizeof(new_pending_files[0]));
if (heap->files != NULL)
free(heap->files);
free(heap->files);
heap->files = new_pending_files;
heap->allocated = new_size;
}

49
contrib/libarchive/libarchive/archive_read_support_format_rar5.c
View File

@ -578,8 +578,7 @@ static int run_filter(struct archive_read* a, struct filter_info* flt) {
int ret;
struct rar5* rar = get_context(a);
if(rar->cstate.filtered_buf)
free(rar->cstate.filtered_buf);
free(rar->cstate.filtered_buf);
rar->cstate.filtered_buf = malloc(flt->block_length);
if(!rar->cstate.filtered_buf) {
@ -762,7 +761,7 @@ static void free_filters(struct rar5* rar) {
struct filter_info* f = NULL;
/* Pop_front will also decrease the collection's size. */
if(CDE_OK == cdeque_pop_front(d, cdeque_filter_p(&f)) && f != NULL)
if (CDE_OK == cdeque_pop_front(d, cdeque_filter_p(&f)))
free(f);
}
@ -863,7 +862,7 @@ static int read_var(struct archive_read* a, uint64_t* pvalue,
/* Strip the MSB from the input byte and add the resulting number
* to the `result`. */
result += (b & 0x7F) << shift;
result += (b & (uint64_t)0x7F) << shift;
/* MSB set to 1 means we need to continue decoding process. MSB set
* to 0 means we're done.
@ -1289,7 +1288,7 @@ static int process_head_file(struct archive_read* a, struct rar5* rar,
char name_utf8_buf[2048 * 4];
const uint8_t* p;
memset(entry, 0, sizeof(struct archive_entry));
archive_entry_clear(entry);
/* Do not reset file context if we're switching archives. */
if(!rar->cstate.switch_multivolume) {
@ -1782,8 +1781,14 @@ static int skip_base_block(struct archive_read* a) {
int ret;
struct rar5* rar = get_context(a);
struct archive_entry entry;
ret = process_base_block(a, &entry);
/* Create a new local archive_entry structure that will be operated on
* by header reader; operations on this archive_entry will be discarded.
*/
struct archive_entry* entry = archive_entry_new();
ret = process_base_block(a, entry);
/* Discard operations on this archive_entry structure. */
archive_entry_free(entry);
if(rar->generic.last_header_id == 2 && rar->generic.split_before > 0)
return ARCHIVE_OK;
@ -1823,13 +1828,14 @@ static int rar5_read_header(struct archive_read *a,
static void init_unpack(struct rar5* rar) {
rar->file.calculated_crc32 = 0;
rar->cstate.window_mask = rar->cstate.window_size - 1;
if (rar->cstate.window_size)
rar->cstate.window_mask = rar->cstate.window_size - 1;
else
rar->cstate.window_mask = 0;
if(rar->cstate.window_buf)
free(rar->cstate.window_buf);
free(rar->cstate.window_buf);
if(rar->cstate.filtered_buf)
free(rar->cstate.filtered_buf);
free(rar->cstate.filtered_buf);
rar->cstate.window_buf = calloc(1, rar->cstate.window_size);
rar->cstate.filtered_buf = calloc(1, rar->cstate.window_size);
@ -2663,13 +2669,21 @@ static int merge_block(struct archive_read* a, ssize_t block_size,
if(rar->vol.push_buf)
free((void*) rar->vol.push_buf);
rar->vol.push_buf = malloc(block_size);
/* Increasing the allocation block by 8 is due to bit reading functions,
* which are using additional 2 or 4 bytes. Allocating the block size
* by exact value would make bit reader perform reads from invalid memory
* block when reading the last byte from the buffer. */
rar->vol.push_buf = malloc(block_size + 8);
if(!rar->vol.push_buf) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate memory for a "
"merge block buffer.");
return ARCHIVE_FATAL;
}
/* Valgrind complains if the extension block for bit reader is not
* initialized, so initialize it. */
memset(&rar->vol.push_buf[block_size], 0, 8);
/* A single block can span across multiple multivolume archive files,
* so we use a loop here. This loop will consume enough multivolume
* archive files until the whole block is read. */
@ -3366,14 +3380,11 @@ static int64_t rar5_seek_data(struct archive_read *a, int64_t offset,
static int rar5_cleanup(struct archive_read *a) {
struct rar5* rar = get_context(a);
if(rar->cstate.window_buf)
free(rar->cstate.window_buf);
free(rar->cstate.window_buf);
if(rar->cstate.filtered_buf)
free(rar->cstate.filtered_buf);
free(rar->cstate.filtered_buf);
if(rar->vol.push_buf)
free(rar->vol.push_buf);
free(rar->vol.push_buf);
free_filters(rar);
cdeque_free(&rar->cstate.filters);

3
contrib/libarchive/libarchive/archive_read_support_format_xar.c
View File

@ -1229,8 +1229,7 @@ heap_add_entry(struct archive_read *a,
}
memcpy(new_pending_files, heap->files,
heap->allocated * sizeof(new_pending_files[0]));
if (heap->files != NULL)
free(heap->files);
free(heap->files);
heap->files = new_pending_files;
heap->allocated = new_size;
}

820
contrib/libarchive/libarchive/archive_read_support_format_zip.c
View File

@ -52,6 +52,12 @@ __FBSDID("$FreeBSD$");
#ifdef HAVE_ZLIB_H
#include <zlib.h>
#endif
#ifdef HAVE_BZLIB_H
#include <bzlib.h>
#endif
#ifdef HAVE_LZMA_H
#include <lzma.h>
#endif
#include "archive.h"
#include "archive_digest_private.h"
@ -63,6 +69,7 @@ __FBSDID("$FreeBSD$");
#include "archive_private.h"
#include "archive_rb.h"
#include "archive_read_private.h"
#include "archive_ppmd8_private.h"
#ifndef HAVE_ZLIB_H
#include "archive_crc32.h"
@ -165,13 +172,29 @@ struct zip {
char decompress_init;
char end_of_entry;
#ifdef HAVE_ZLIB_H
unsigned char *uncompressed_buffer;
size_t uncompressed_buffer_size;
#ifdef HAVE_ZLIB_H
z_stream stream;
char stream_valid;
#endif
#if HAVE_LZMA_H && HAVE_LIBLZMA
lzma_stream zipx_lzma_stream;
char zipx_lzma_valid;
#endif
#ifdef HAVE_BZLIB_H
bz_stream bzstream;
char bzstream_valid;
#endif
IByteIn zipx_ppmd_stream;
ssize_t zipx_ppmd_read_compressed;
CPpmd8 ppmd8;
char ppmd8_valid;
struct archive_string_conv *sconv;
struct archive_string_conv *sconv_default;
struct archive_string_conv *sconv_utf8;
@ -222,6 +245,27 @@ struct zip {
/* Many systems define min or MIN, but not all. */
#define zipmin(a,b) ((a) < (b) ? (a) : (b))
/* This function is used by Ppmd8_DecodeSymbol during decompression of Ppmd8
* streams inside ZIP files. It has 2 purposes: one is to fetch the next
* compressed byte from the stream, second one is to increase the counter how
* many compressed bytes were read. */
static Byte
ppmd_read(void* p) {
/* Get the handle to current decompression context. */
struct archive_read *a = ((IByteIn*)p)->a;
struct zip *zip = (struct zip*) a->format->data;
/* Fetch next byte. */
const uint8_t* data = __archive_read_ahead(a, 1, NULL);
__archive_read_consume(a, 1);
/* Increment the counter. */
++zip->zipx_ppmd_read_compressed;
/* Return the next compressed byte. */
return data[0];
}
/* ------------------------------------------------------------------------ */
/*
@ -372,6 +416,8 @@ static const struct {
{17, "reserved"}, /* Reserved by PKWARE */
{18, "ibm-terse-new"}, /* File is compressed using IBM TERSE (new) */
{19, "ibm-lz777"},/* IBM LZ77 z Architecture (PFS) */
{95, "xz"}, /* XZ compressed data */
{96, "jpeg"}, /* JPEG compressed data */
{97, "wav-pack"}, /* WavPack compressed data */
{98, "ppmd-1"}, /* PPMd version I, Rev 1 */
{99, "aes"} /* WinZip AES encryption */
@ -1296,6 +1342,695 @@ zip_read_data_none(struct archive_read *a, const void **_buff,
return (ARCHIVE_OK);
}
static int
consume_optional_marker(struct archive_read *a, struct zip *zip)
{
if (zip->end_of_entry && (zip->entry->zip_flags & ZIP_LENGTH_AT_END)) {
const char *p;
if (NULL == (p = __archive_read_ahead(a, 24, NULL))) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP end-of-file record");
return (ARCHIVE_FATAL);
}
/* Consume the optional PK\007\010 marker. */
if (p[0] == 'P' && p[1] == 'K' &&
p[2] == '\007' && p[3] == '\010') {
p += 4;
zip->unconsumed = 4;
}
if (zip->entry->flags & LA_USED_ZIP64) {
uint64_t compressed, uncompressed;
zip->entry->crc32 = archive_le32dec(p);
compressed = archive_le64dec(p + 4);
uncompressed = archive_le64dec(p + 12);
if (compressed > INT64_MAX || uncompressed > INT64_MAX) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Overflow of 64-bit file sizes");
return ARCHIVE_FAILED;
}
zip->entry->compressed_size = compressed;
zip->entry->uncompressed_size = uncompressed;
zip->unconsumed += 20;
} else {
zip->entry->crc32 = archive_le32dec(p);
zip->entry->compressed_size = archive_le32dec(p + 4);
zip->entry->uncompressed_size = archive_le32dec(p + 8);
zip->unconsumed += 12;
}
}
return (ARCHIVE_OK);
}
#if HAVE_LZMA_H && HAVE_LIBLZMA
static int
zipx_xz_init(struct archive_read *a, struct zip *zip)
{
lzma_ret r;
if(zip->zipx_lzma_valid) {
lzma_end(&zip->zipx_lzma_stream);
zip->zipx_lzma_valid = 0;
}
memset(&zip->zipx_lzma_stream, 0, sizeof(zip->zipx_lzma_stream));
r = lzma_stream_decoder(&zip->zipx_lzma_stream, UINT64_MAX, 0);
if (r != LZMA_OK) {
archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
"xz initialization failed(%d)",
r);
return (ARCHIVE_FAILED);
}
zip->zipx_lzma_valid = 1;
free(zip->uncompressed_buffer);
zip->uncompressed_buffer_size = 256 * 1024;
zip->uncompressed_buffer =
(uint8_t*) malloc(zip->uncompressed_buffer_size);
if (zip->uncompressed_buffer == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory for xz decompression");
return (ARCHIVE_FATAL);
}
zip->decompress_init = 1;
return (ARCHIVE_OK);
}
static int
zipx_lzma_alone_init(struct archive_read *a, struct zip *zip)
{
lzma_ret r;
const uint8_t* p;
#pragma pack(push)
#pragma pack(1)
struct _alone_header {
uint8_t bytes[5];
uint64_t uncompressed_size;
} alone_header;
#pragma pack(pop)
/* To unpack ZIPX's "LZMA" (id 14) stream we can use standard liblzma that
* is a part of XZ Utils. The stream format stored inside ZIPX file is a
* modified "lzma alone" file format, that was used by the `lzma` utility
* which was later deprecated in favour of `xz` utility. Since those
* formats are nearly the same, we can use a standard "lzma alone" decoder
* from XZ Utils. */
memset(&zip->zipx_lzma_stream, 0, sizeof(zip->zipx_lzma_stream));
r = lzma_alone_decoder(&zip->zipx_lzma_stream, UINT64_MAX);
if (r != LZMA_OK) {
archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
"lzma initialization failed(%d)", r);
return (ARCHIVE_FAILED);
}
/* Flag the cleanup function that we want our lzma-related structures
* to be freed later. */
zip->zipx_lzma_valid = 1;
/* The "lzma alone" file format and the stream format inside ZIPx are
* almost the same. Here's an example of a structure of "lzma alone"
* format:
*
* $ cat /bin/ls | lzma | xxd | head -n 1
* 00000000: 5d00 0080 00ff ffff ffff ffff ff00 2814
*
* 5 bytes 8 bytes n bytes
* <lzma_params><uncompressed_size><data...>
*
* lzma_params is a 5-byte blob that has to be decoded to extract
* parameters of this LZMA stream. The uncompressed_size field is an
* uint64_t value that contains information about the size of the
* uncompressed file, or UINT64_MAX if this value is unknown. The <data...>
* part is the actual lzma-compressed data stream.
*
* Now here's the structure of the stream inside the ZIPX file:
*
* $ cat stream_inside_zipx | xxd | head -n 1
* 00000000: 0914 0500 5d00 8000 0000 2814 .... ....
*
* 2byte 2byte 5 bytes n bytes
* <magic1><magic2><lzma_params><data...>
*
* This means that the ZIPX file contains an additional magic1 and magic2
* headers, the lzma_params field contains the same parameter set as in the
* "lzma alone" format, and the <data...> field is the same as in the "lzma
* alone" format as well. Note that also the zipx format is missing the
* uncompressed_size field.
*
* So, in order to use the "lzma alone" decoder for the zipx lzma stream,
* we simply need to shuffle around some fields, prepare a new lzma alone
* header, feed it into lzma alone decoder so it will initialize itself
* properly, and then we can start feeding normal zipx lzma stream into the
* decoder.
*/
/* Read magic1,magic2,lzma_params from the ZIPX stream. */
if((p = __archive_read_ahead(a, 9, NULL)) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated lzma data");
return (ARCHIVE_FATAL);
}
if(p[2] != 0x05 || p[3] != 0x00) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Invalid lzma data");
return (ARCHIVE_FATAL);
}
/* Prepare an lzma alone header: copy the lzma_params blob into a proper
* place into the lzma alone header. */
memcpy(&alone_header.bytes[0], p + 4, 5);
/* Initialize the 'uncompressed size' field to unknown; we'll manually
* monitor how many bytes there are still to be uncompressed. */
alone_header.uncompressed_size = UINT64_MAX;
if(!zip->uncompressed_buffer) {
zip->uncompressed_buffer_size = 256 * 1024;
zip->uncompressed_buffer =
(uint8_t*) malloc(zip->uncompressed_buffer_size);
if (zip->uncompressed_buffer == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory for lzma decompression");
return (ARCHIVE_FATAL);
}
}
zip->zipx_lzma_stream.next_in = (void*) &alone_header;
zip->zipx_lzma_stream.avail_in = sizeof(alone_header);
zip->zipx_lzma_stream.total_in = 0;
zip->zipx_lzma_stream.next_out = zip->uncompressed_buffer;
zip->zipx_lzma_stream.avail_out = zip->uncompressed_buffer_size;
zip->zipx_lzma_stream.total_out = 0;
/* Feed only the header into the lzma alone decoder. This will effectively
* initialize the decoder, and will not produce any output bytes yet. */
r = lzma_code(&zip->zipx_lzma_stream, LZMA_RUN);
if (r != LZMA_OK) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"lzma stream initialization error");
return ARCHIVE_FATAL;
}
/* We've already consumed some bytes, so take this into account. */
__archive_read_consume(a, 9);
zip->entry_bytes_remaining -= 9;
zip->entry_compressed_bytes_read += 9;
zip->decompress_init = 1;
return (ARCHIVE_OK);
}
static int
zip_read_data_zipx_xz(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip* zip = (struct zip *)(a->format->data);
int ret;
lzma_ret lz_ret;
const void* compressed_buf;
ssize_t bytes_avail, in_bytes, to_consume = 0;
(void) offset; /* UNUSED */
/* Initialize decompressor if not yet initialized. */
if (!zip->decompress_init) {
ret = zipx_xz_init(a, zip);
if (ret != ARCHIVE_OK)
return (ret);
}
compressed_buf = __archive_read_ahead(a, 1, &bytes_avail);
if (bytes_avail < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated xz file body");
return (ARCHIVE_FATAL);
}
in_bytes = zipmin(zip->entry_bytes_remaining, bytes_avail);
zip->zipx_lzma_stream.next_in = compressed_buf;
zip->zipx_lzma_stream.avail_in = in_bytes;
zip->zipx_lzma_stream.total_in = 0;
zip->zipx_lzma_stream.next_out = zip->uncompressed_buffer;
zip->zipx_lzma_stream.avail_out = zip->uncompressed_buffer_size;
zip->zipx_lzma_stream.total_out = 0;
/* Perform the decompression. */
lz_ret = lzma_code(&zip->zipx_lzma_stream, LZMA_RUN);
switch(lz_ret) {
case LZMA_DATA_ERROR:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"xz data error (error %d)", (int) lz_ret);
return (ARCHIVE_FATAL);
case LZMA_NO_CHECK:
case LZMA_OK:
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"xz unknown error %d", (int) lz_ret);
return (ARCHIVE_FATAL);
case LZMA_STREAM_END:
lzma_end(&zip->zipx_lzma_stream);
zip->zipx_lzma_valid = 0;
if((int64_t) zip->zipx_lzma_stream.total_in !=
zip->entry_bytes_remaining)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"xz premature end of stream");
return (ARCHIVE_FATAL);
}
zip->end_of_entry = 1;
break;
}
to_consume = zip->zipx_lzma_stream.total_in;
__archive_read_consume(a, to_consume);
zip->entry_bytes_remaining -= to_consume;
zip->entry_compressed_bytes_read += to_consume;
zip->entry_uncompressed_bytes_read += zip->zipx_lzma_stream.total_out;
*size = zip->zipx_lzma_stream.total_out;
*buff = zip->uncompressed_buffer;
ret = consume_optional_marker(a, zip);
if (ret != ARCHIVE_OK)
return (ret);
return (ARCHIVE_OK);
}
static int
zip_read_data_zipx_lzma_alone(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip* zip = (struct zip *)(a->format->data);
int ret;
lzma_ret lz_ret;
const void* compressed_buf;
ssize_t bytes_avail, in_bytes, to_consume;
(void) offset; /* UNUSED */
/* Initialize decompressor if not yet initialized. */
if (!zip->decompress_init) {
ret = zipx_lzma_alone_init(a, zip);
if (ret != ARCHIVE_OK)
return (ret);
}
/* Fetch more compressed data. The same note as in deflate handler applies
* here as well:
*
* Note: '1' here is a performance optimization. Recall that the
* decompression layer returns a count of available bytes; asking for more
* than that forces the decompressor to combine reads by copying data.
*/
compressed_buf = __archive_read_ahead(a, 1, &bytes_avail);
if (bytes_avail < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated lzma file body");
return (ARCHIVE_FATAL);
}
/* Set decompressor parameters. */
in_bytes = zipmin(zip->entry_bytes_remaining, bytes_avail);
zip->zipx_lzma_stream.next_in = compressed_buf;
zip->zipx_lzma_stream.avail_in = in_bytes;
zip->zipx_lzma_stream.total_in = 0;
zip->zipx_lzma_stream.next_out = zip->uncompressed_buffer;
zip->zipx_lzma_stream.avail_out =
/* These lzma_alone streams lack end of stream marker, so let's make
* sure the unpacker won't try to unpack more than it's supposed to. */
zipmin((int64_t) zip->uncompressed_buffer_size,
zip->entry->uncompressed_size -
zip->entry_uncompressed_bytes_read);
zip->zipx_lzma_stream.total_out = 0;
/* Perform the decompression. */
lz_ret = lzma_code(&zip->zipx_lzma_stream, LZMA_RUN);
switch(lz_ret) {
case LZMA_DATA_ERROR:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"lzma data error (error %d)", (int) lz_ret);
return (ARCHIVE_FATAL);
case LZMA_OK:
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"lzma unknown error %d", (int) lz_ret);
return (ARCHIVE_FATAL);
}
to_consume = zip->zipx_lzma_stream.total_in;
/* Update pointers. */
__archive_read_consume(a, to_consume);
zip->entry_bytes_remaining -= to_consume;
zip->entry_compressed_bytes_read += to_consume;
zip->entry_uncompressed_bytes_read += zip->zipx_lzma_stream.total_out;
if(zip->entry_bytes_remaining == 0) {
zip->end_of_entry = 1;
}
/* Return values. */
*size = zip->zipx_lzma_stream.total_out;
*buff = zip->uncompressed_buffer;
/* Behave the same way as during deflate decompression. */
ret = consume_optional_marker(a, zip);
if (ret != ARCHIVE_OK)
return (ret);
/* Free lzma decoder handle because we'll no longer need it. */
if(zip->end_of_entry) {
lzma_end(&zip->zipx_lzma_stream);
zip->zipx_lzma_valid = 0;
}
/* If we're here, then we're good! */
return (ARCHIVE_OK);
}
#endif /* HAVE_LZMA_H && HAVE_LIBLZMA */
static int
zipx_ppmd8_init(struct archive_read *a, struct zip *zip)
{
const void* p;
uint32_t val;
uint32_t order;
uint32_t mem;
uint32_t restore_method;
/* Remove previous decompression context if it exists. */
if(zip->ppmd8_valid) {
__archive_ppmd8_functions.Ppmd8_Free(&zip->ppmd8);
zip->ppmd8_valid = 0;
}
/* Create a new decompression context. */
__archive_ppmd8_functions.Ppmd8_Construct(&zip->ppmd8);
/* Setup function pointers required by Ppmd8 decompressor. The
* 'ppmd_read' function will feed new bytes to the decompressor,
* and will increment the 'zip->zipx_ppmd_read_compressed' counter. */
zip->ppmd8.Stream.In = &zip->zipx_ppmd_stream;
zip->zipx_ppmd_stream.a = a;
zip->zipx_ppmd_stream.Read = &ppmd_read;
/* Reset number of read bytes to 0. */
zip->zipx_ppmd_read_compressed = 0;
/* Read Ppmd8 header (2 bytes). */
p = __archive_read_ahead(a, 2, NULL);
if(!p) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated file data in PPMd8 stream");
return (ARCHIVE_FATAL);
}
__archive_read_consume(a, 2);
/* Decode the stream's compression parameters. */
val = archive_le16dec(p);
order = (val & 15) + 1;
mem = ((val >> 4) & 0xff) + 1;
restore_method = (val >> 12);
if(order < 2 || restore_method > 2) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Invalid parameter set in PPMd8 stream (order=%d, "
"restore=%d)", order, restore_method);
return (ARCHIVE_FAILED);
}
/* Allocate the memory needed to properly decompress the file. */
if(!__archive_ppmd8_functions.Ppmd8_Alloc(&zip->ppmd8, mem << 20)) {
archive_set_error(&a->archive, ENOMEM,
"Unable to allocate memory for PPMd8 stream: %d bytes",
mem << 20);
return (ARCHIVE_FATAL);
}
/* Signal the cleanup function to release Ppmd8 context in the
* cleanup phase. */
zip->ppmd8_valid = 1;
/* Perform further Ppmd8 initialization. */
if(!__archive_ppmd8_functions.Ppmd8_RangeDec_Init(&zip->ppmd8)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"PPMd8 stream range decoder initialization error");
return (ARCHIVE_FATAL);
}
__archive_ppmd8_functions.Ppmd8_Init(&zip->ppmd8, order, restore_method);
/* Allocate the buffer that will hold uncompressed data. */
free(zip->uncompressed_buffer);
zip->uncompressed_buffer_size = 256 * 1024;
zip->uncompressed_buffer =
(uint8_t*) malloc(zip->uncompressed_buffer_size);
if(zip->uncompressed_buffer == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory for PPMd8 decompression");
return ARCHIVE_FATAL;
}
/* Ppmd8 initialization is done. */
zip->decompress_init = 1;
/* We've already read 2 bytes in the output stream. Additionally,
* Ppmd8 initialization code could read some data as well. So we
* are advancing the stream by 2 bytes plus whatever number of
* bytes Ppmd8 init function used. */
zip->entry_compressed_bytes_read += 2 + zip->zipx_ppmd_read_compressed;
return ARCHIVE_OK;
}
static int
zip_read_data_zipx_ppmd(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip* zip = (struct zip *)(a->format->data);
int ret;
size_t consumed_bytes = 0;
ssize_t bytes_avail = 0;
(void) offset; /* UNUSED */
/* If we're here for the first time, initialize Ppmd8 decompression
* context first. */
if(!zip->decompress_init) {
ret = zipx_ppmd8_init(a, zip);
if(ret != ARCHIVE_OK)
return ret;
}
/* Fetch for more data. We're reading 1 byte here, but libarchive should
* prefetch more bytes. */
(void) __archive_read_ahead(a, 1, &bytes_avail);
if(bytes_avail < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated PPMd8 file body");
return (ARCHIVE_FATAL);
}
/* This counter will be updated inside ppmd_read(), which at one
* point will be called by Ppmd8_DecodeSymbol. */
zip->zipx_ppmd_read_compressed = 0;
/* Decompression loop. */
do {
int sym = __archive_ppmd8_functions.Ppmd8_DecodeSymbol(&zip->ppmd8);
if(sym < 0) {
zip->end_of_entry = 1;
break;
}
zip->uncompressed_buffer[consumed_bytes] = (uint8_t) sym;
++consumed_bytes;
} while(consumed_bytes < zip->uncompressed_buffer_size);
/* Update pointers for libarchive. */
*buff = zip->uncompressed_buffer;
*size = consumed_bytes;
/* Update pointers so we can continue decompression in another call. */
zip->entry_bytes_remaining -= zip->zipx_ppmd_read_compressed;
zip->entry_compressed_bytes_read += zip->zipx_ppmd_read_compressed;
zip->entry_uncompressed_bytes_read += consumed_bytes;
/* If we're at the end of stream, deinitialize Ppmd8 context. */
if(zip->end_of_entry) {
__archive_ppmd8_functions.Ppmd8_Free(&zip->ppmd8);
zip->ppmd8_valid = 0;
}
/* Seek for optional marker, same way as in each zip entry. */
ret = consume_optional_marker(a, zip);
if (ret != ARCHIVE_OK)
return ret;
return ARCHIVE_OK;
}
#ifdef HAVE_BZLIB_H
static int
zipx_bzip2_init(struct archive_read *a, struct zip *zip)
{
int r;
/* Deallocate already existing BZ2 decompression context if it
* exists. */
if(zip->bzstream_valid) {
BZ2_bzDecompressEnd(&zip->bzstream);
zip->bzstream_valid = 0;
}
/* Allocate a new BZ2 decompression context. */
memset(&zip->bzstream, 0, sizeof(bz_stream));
r = BZ2_bzDecompressInit(&zip->bzstream, 0, 1);
if(r != BZ_OK) {
archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
"bzip2 initialization failed(%d)",
r);
return ARCHIVE_FAILED;
}
/* Mark the bzstream field to be released in cleanup phase. */
zip->bzstream_valid = 1;
/* (Re)allocate the buffer that will contain decompressed bytes. */
free(zip->uncompressed_buffer);
zip->uncompressed_buffer_size = 256 * 1024;
zip->uncompressed_buffer =
(uint8_t*) malloc(zip->uncompressed_buffer_size);
if (zip->uncompressed_buffer == NULL) {
archive_set_error(&a->archive, ENOMEM,
"No memory for bzip2 decompression");
return ARCHIVE_FATAL;
}
/* Initialization done. */
zip->decompress_init = 1;
return ARCHIVE_OK;
}
static int
zip_read_data_zipx_bzip2(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip *zip = (struct zip *)(a->format->data);
ssize_t bytes_avail = 0, in_bytes, to_consume;
const void *compressed_buff;
int r;
uint64_t total_out;
(void) offset; /* UNUSED */
/* Initialize decompression context if we're here for the first time. */
if(!zip->decompress_init) {
r = zipx_bzip2_init(a, zip);
if(r != ARCHIVE_OK)
return r;
}
/* Fetch more compressed bytes. */
compressed_buff = __archive_read_ahead(a, 1, &bytes_avail);
if(bytes_avail < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated bzip2 file body");
return (ARCHIVE_FATAL);
}
in_bytes = zipmin(zip->entry_bytes_remaining, bytes_avail);
/* Setup buffer boundaries. */
zip->bzstream.next_in = (char*)(uintptr_t) compressed_buff;
zip->bzstream.avail_in = in_bytes;
zip->bzstream.total_in_hi32 = 0;
zip->bzstream.total_in_lo32 = 0;
zip->bzstream.next_out = (char*) zip->uncompressed_buffer;
zip->bzstream.avail_out = zip->uncompressed_buffer_size;
zip->bzstream.total_out_hi32 = 0;
zip->bzstream.total_out_lo32 = 0;
/* Perform the decompression. */
r = BZ2_bzDecompress(&zip->bzstream);
switch(r) {
case BZ_STREAM_END:
/* If we're at the end of the stream, deinitialize the
* decompression context now. */
switch(BZ2_bzDecompressEnd(&zip->bzstream)) {
case BZ_OK:
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Failed to clean up bzip2 decompressor");
return ARCHIVE_FATAL;
}
zip->end_of_entry = 1;
break;
case BZ_OK:
/* The decompressor has successfully decoded this chunk of
* data, but more data is still in queue. */
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"bzip2 decompression failed");
return ARCHIVE_FATAL;
}
/* Update the pointers so decompressor can continue decoding. */
to_consume = zip->bzstream.total_in_lo32;
__archive_read_consume(a, to_consume);
total_out = ((uint64_t) zip->bzstream.total_out_hi32 << 32) +
zip->bzstream.total_out_lo32;
zip->entry_bytes_remaining -= to_consume;
zip->entry_compressed_bytes_read += to_consume;
zip->entry_uncompressed_bytes_read += total_out;
/* Give libarchive its due. */
*size = total_out;
*buff = zip->uncompressed_buffer;
/* Seek for optional marker, like in other entries. */
r = consume_optional_marker(a, zip);
if(r != ARCHIVE_OK)
return r;
return ARCHIVE_OK;
}
#endif
#ifdef HAVE_ZLIB_H
static int
zip_deflate_init(struct archive_read *a, struct zip *zip)
@ -1470,42 +2205,9 @@ zip_read_data_deflate(struct archive_read *a, const void **buff,
return (r);
}
if (zip->end_of_entry && (zip->entry->zip_flags & ZIP_LENGTH_AT_END)) {
const char *p;
if (NULL == (p = __archive_read_ahead(a, 24, NULL))) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated ZIP end-of-file record");
return (ARCHIVE_FATAL);
}
/* Consume the optional PK\007\010 marker. */
if (p[0] == 'P' && p[1] == 'K' &&
p[2] == '\007' && p[3] == '\010') {
p += 4;
zip->unconsumed = 4;
}
if (zip->entry->flags & LA_USED_ZIP64) {
uint64_t compressed, uncompressed;
zip->entry->crc32 = archive_le32dec(p);
compressed = archive_le64dec(p + 4);
uncompressed = archive_le64dec(p + 12);
if (compressed > INT64_MAX || uncompressed > INT64_MAX) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Overflow of 64-bit file sizes");
return ARCHIVE_FAILED;
}
zip->entry->compressed_size = compressed;
zip->entry->uncompressed_size = uncompressed;
zip->unconsumed += 20;
} else {
zip->entry->crc32 = archive_le32dec(p);
zip->entry->compressed_size = archive_le32dec(p + 4);
zip->entry->uncompressed_size = archive_le32dec(p + 8);
zip->unconsumed += 12;
}
}
r = consume_optional_marker(a, zip);
if (r != ARCHIVE_OK)
return (r);
return (ARCHIVE_OK);
}
@ -1933,6 +2635,24 @@ archive_read_format_zip_read_data(struct archive_read *a,
case 0: /* No compression. */
r = zip_read_data_none(a, buff, size, offset);
break;
#ifdef HAVE_BZLIB_H
case 12: /* ZIPx bzip2 compression. */
r = zip_read_data_zipx_bzip2(a, buff, size, offset);
break;
#endif
#if HAVE_LZMA_H && HAVE_LIBLZMA
case 14: /* ZIPx LZMA compression. */
r = zip_read_data_zipx_lzma_alone(a, buff, size, offset);
break;
case 95: /* ZIPx XZ compression. */
r = zip_read_data_zipx_xz(a, buff, size, offset);
break;
#endif
/* PPMd support is built-in, so we don't need any #if guards. */
case 98: /* ZIPx PPMd compression. */
r = zip_read_data_zipx_ppmd(a, buff, size, offset);
break;
#ifdef HAVE_ZLIB_H
case 8: /* Deflate compression. */
r = zip_read_data_deflate(a, buff, size, offset);
@ -1941,8 +2661,8 @@ archive_read_format_zip_read_data(struct archive_read *a,
default: /* Unsupported compression. */
/* Return a warning. */
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Unsupported ZIP compression method (%s)",
compression_name(zip->entry->compression));
"Unsupported ZIP compression method (%d: %s)",
zip->entry->compression, compression_name(zip->entry->compression));
/* We can't decompress this entry, but we will
* be able to skip() it and try the next entry. */
return (ARCHIVE_FAILED);
@ -2000,11 +2720,29 @@ archive_read_format_zip_cleanup(struct archive_read *a)
struct zip_entry *zip_entry, *next_zip_entry;
zip = (struct zip *)(a->format->data);
#ifdef HAVE_ZLIB_H
if (zip->stream_valid)
inflateEnd(&zip->stream);
free(zip->uncompressed_buffer);
#endif
#if HAVA_LZMA_H && HAVE_LIBLZMA
if (zip->zipx_lzma_valid) {
lzma_end(&zip->zipx_lzma_stream);
}
#endif
#ifdef HAVE_BZLIB_H
if (zip->bzstream_valid) {
BZ2_bzDecompressEnd(&zip->bzstream);
}
#endif
free(zip->uncompressed_buffer);
if (zip->ppmd8_valid)
__archive_ppmd8_functions.Ppmd8_Free(&zip->ppmd8);
if (zip->zip_entries) {
zip_entry = zip->zip_entries;
while (zip_entry != NULL) {
@ -3146,3 +3884,5 @@ archive_read_support_format_zip_seekable(struct archive *_a)
free(zip);
return (ARCHIVE_OK);
}
/*# vim:set noet:*/

9
contrib/libarchive/libarchive/archive_write_disk_posix.c
View File

@ -1775,10 +1775,8 @@ finish_metadata:
a->fd = -1;
}
/* If there's an entry, we can release it now. */
if (a->entry) {
archive_entry_free(a->entry);
a->entry = NULL;
}
archive_entry_free(a->entry);
a->entry = NULL;
a->archive.state = ARCHIVE_STATE_HEADER;
return (ret);
}
@ -2373,8 +2371,7 @@ _archive_write_disk_free(struct archive *_a)
ret = _archive_write_disk_close(&a->archive);
archive_write_disk_set_group_lookup(&a->archive, NULL, NULL, NULL);
archive_write_disk_set_user_lookup(&a->archive, NULL, NULL, NULL);
if (a->entry)
archive_entry_free(a->entry);
archive_entry_free(a->entry);
archive_string_free(&a->_name_data);
archive_string_free(&a->archive.error_string);
archive_string_free(&a->path_safe);

6
contrib/libarchive/libarchive/archive_write_disk_set_standard_lookup.c
View File

@ -114,8 +114,7 @@ lookup_gid(void *private_data, const char *gname, int64_t gid)
return ((gid_t)b->id);
/* Free the cache slot for a new entry. */
if (b->name != NULL)
free(b->name);
free(b->name);
b->name = strdup(gname);
/* Note: If strdup fails, that's okay; we just won't cache. */
b->hash = h;
@ -184,8 +183,7 @@ lookup_uid(void *private_data, const char *uname, int64_t uid)
return ((uid_t)b->id);
/* Free the cache slot for a new entry. */
if (b->name != NULL)
free(b->name);
free(b->name);
b->name = strdup(uname);
/* Note: If strdup fails, that's okay; we just won't cache. */
b->hash = h;

5
contrib/libarchive/libarchive/archive_write_set_format_ar.c
View File

@ -187,6 +187,11 @@ archive_write_ar_header(struct archive_write *a, struct archive_entry *entry)
buff[AR_name_offset] = '/';
goto stat;
}
if (strcmp(pathname, "/SYM64/") == 0) {
/* Entry is archive symbol table in GNU 64-bit format */
memcpy(buff + AR_name_offset, "/SYM64/", 7);
goto stat;
}
if (strcmp(pathname, "__.SYMDEF") == 0) {
/* Entry is archive symbol table in BSD format */
memcpy(buff + AR_name_offset, "__.SYMDEF", 9);

3
contrib/libarchive/libarchive/archive_write_set_format_cpio.c
View File

@ -408,8 +408,7 @@ write_header(struct archive_write *a, struct archive_entry *entry)
}
}
exit_write_header:
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret_final);
}

3
contrib/libarchive/libarchive/archive_write_set_format_cpio_newc.c
View File

@ -366,8 +366,7 @@ write_header(struct archive_write *a, struct archive_entry *entry)
}
}
exit_write_header:
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret_final);
}

3
contrib/libarchive/libarchive/archive_write_set_format_gnutar.c
View File

@ -565,8 +565,7 @@ archive_write_gnutar_header(struct archive_write *a,
gnutar->entry_bytes_remaining = archive_entry_size(entry);
gnutar->entry_padding = 0x1ff & (-(int64_t)gnutar->entry_bytes_remaining);
exit_write_header:
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret);
}

6
contrib/libarchive/libarchive/archive_write_set_format_shar.c
View File

@ -169,8 +169,7 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
}
/* Save the entry for the closing. */
if (shar->entry)
archive_entry_free(shar->entry);
archive_entry_free(shar->entry);
shar->entry = archive_entry_clone(entry);
name = archive_entry_pathname(entry);
@ -289,8 +288,7 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
"mkdir -p %s > /dev/null 2>&1\n",
shar->quoted_name.s);
/* Record that we just created this directory. */
if (shar->last_dir != NULL)
free(shar->last_dir);
free(shar->last_dir);
shar->last_dir = strdup(name);
/* Trim a trailing '/'. */

9
contrib/libarchive/libarchive/archive_write_set_format_ustar.c
View File

@ -352,14 +352,12 @@ archive_write_ustar_header(struct archive_write *a, struct archive_entry *entry)
#endif
ret = __archive_write_format_header_ustar(a, buff, entry, -1, 1, sconv);
if (ret < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret);
}
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret2);
}
if (ret2 < ret)
@ -367,8 +365,7 @@ archive_write_ustar_header(struct archive_write *a, struct archive_entry *entry)
ustar->entry_bytes_remaining = archive_entry_size(entry);
ustar->entry_padding = 0x1ff & (-(int64_t)ustar->entry_bytes_remaining);
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret);
}

9
contrib/libarchive/libarchive/archive_write_set_format_v7tar.c
View File

@ -330,14 +330,12 @@ archive_write_v7tar_header(struct archive_write *a, struct archive_entry *entry)
#endif
ret = format_header_v7tar(a, buff, entry, 1, sconv);
if (ret < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret);
}
ret2 = __archive_write_output(a, buff, 512);
if (ret2 < ARCHIVE_WARN) {
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret2);
}
if (ret2 < ret)
@ -345,8 +343,7 @@ archive_write_v7tar_header(struct archive_write *a, struct archive_entry *entry)
v7tar->entry_bytes_remaining = archive_entry_size(entry);
v7tar->entry_padding = 0x1ff & (-(int64_t)v7tar->entry_bytes_remaining);
if (entry_main)
archive_entry_free(entry_main);
archive_entry_free(entry_main);
return (ret);
}

9
contrib/libarchive/libarchive/archive_write_set_format_zip.c
View File

@ -564,10 +564,8 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
zip->entry_uses_zip64 = 0;
zip->entry_crc32 = zip->crc32func(0, NULL, 0);
zip->entry_encryption = 0;
if (zip->entry != NULL) {
archive_entry_free(zip->entry);
zip->entry = NULL;
}
archive_entry_free(zip->entry);
zip->entry = NULL;
if (zip->cctx_valid)
archive_encrypto_aes_ctr_release(&zip->cctx);
@ -1430,6 +1428,9 @@ write_path(struct archive_entry *entry, struct archive_write *archive)
type = archive_entry_filetype(entry);
written_bytes = 0;
if (path == NULL)
return (ARCHIVE_FATAL);
ret = __archive_write_output(archive, path, strlen(path));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);

153
contrib/libarchive/libarchive/test/test_compat_pax_libarchive_2x.c
View File

@ -1,153 +0,0 @@
/*-
* Copyright (c) 2011 Michihiro NAKAJIMA
* 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.
*
* 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.
*/
#include "test.h"
__FBSDID("$FreeBSD");
#include <locale.h>
/*
* Test "tar:compat-2x" option that enables the string conversion of
* libarchive 2.x, which made incorrect UTF-8 form filenames for the
* pax format on some platform the wchar_t of which was not Unicode form.
* The option is unneeded if people have been using UTF-8 locale during
* making tar files(in pax format).
*
* NOTE: The sample tar file was made with bsdtar 2.x in LANG=KOI8-R on
* FreeBSD.
*/
DEFINE_TEST(test_compat_pax_libarchive_2x)
{
#if (defined(_WIN32) && !defined(__CYGWIN__)) \
|| defined(__STDC_ISO_10646__) || defined(__APPLE__)
skipping("This test only for the platform the WCS of which is "
"not Unicode.");
#else
struct archive *a;
struct archive_entry *ae;
char c;
wchar_t wc;
const char *refname = "test_compat_pax_libarchive_2x.tar.Z";
/*
* Read incorrect format UTF-8 filename in ru_RU.KOI8-R with
* "tar:compat-2x" option. We should correctly
* read two filenames.
*/
if (NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
skipping("ru_RU.KOI8-R locale not available on this system.");
return;
}
/*
* Test if wchar_t format is the same as FreeBSD wchar_t.
*/
assert(-1 != wctomb(NULL, L'\0'));
wc = (wchar_t)0xd0;
c = 0;
if (wctomb(&c, wc) != 1 || (unsigned char)c != 0xd0) {
skipping("wchar_t format is different on this platform.");
return;
}
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_set_options(a, "tar:compat-2x"));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_filename(a, refname, 10240));
/* Verify regular first file. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
archive_entry_pathname(ae));
assertEqualInt(6, archive_entry_size(ae));
/* Verify regular second file. */
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
archive_entry_pathname(ae));
assertEqualInt(6, archive_entry_size(ae));
/* End of archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE,
archive_format(a));
/* Close the archive. */
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
/*
* Without "tar:compat-2x" option.
* Neither first file name nor second file name can be translated
* to KOI8-R.
*/
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_filename(a, refname, 10240));
/* We cannot correctly read the filename. */
// This test used to look for WARN here coming from a
// character-conversion failure. But: Newer iconv tables are
// more tolerant so we can't always detect the conversion
// failures.
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assert(strcmp("\xd0\xd2\xc9\xd7\xc5\xd4",
archive_entry_pathname(ae)) != 0);
assertEqualInt(6, archive_entry_size(ae));
/* We cannot correctly read the filename. */
// Same here: The test is still valid (it sill verifies that
// the converted pathname is different), but we can no longer
// rely on WARN here.
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assert(strcmp("\xf0\xf2\xe9\xf7\xe5\xf4",
archive_entry_pathname(ae)) != 0);
assertEqualInt(6, archive_entry_size(ae));
/* End of archive. */
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
/* Verify archive format. */
assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
assertEqualIntA(a, ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE,
archive_format(a));
/* Close the archive. */
assertEqualInt(ARCHIVE_OK, archive_read_close(a));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
#endif
}

15
contrib/libarchive/libarchive/test/test_compat_pax_libarchive_2x.tar.Z.uu
View File

@ -1,15 +0,0 @@
begin 644 test_compat_pax_libarchive_2x.tar.Z
M'YV04,+@05(F#)DR<EY`DY;L6C%J`")*G$BQHL6+&#-JW%@1AL<;-6J``.`Q
M!L@8(TN>3.FQ94D;-D#$B%&#QHT9,CS.B`DCADT;-P"`P,.QJ-&C2)-:K#.'
M3A@Y)&&,J5-&:<:I5:U>=.F1I<N16L.*'4NV;%D9*.&$H8.FQS!(PR0-2S3L
MTK!"PR@IR`EB#)TT;<KTB#$#!EJ0.&+@V`L#Q%K`@@D;QG$C!PX9.128!#%E
M")(D3+*X.&BG1XX:>V5P]@Q:=!HW;P87IE'C!@W-.%9_#NW"#9O7:P8K,$N\
MN/'CR),K7\Z\N?.)"QL^?$[=:$N0(J.:K(%2^\JH7%O&G%GS9DX8.T'T+`PC
MJ/KJ\)$R=0K5(];B]XF']]H2;/S_`"H'CSSIW%,./0$FJ.""##;HX(,01@A`
M0`,5=%!"`Q9XH(3Z?1022]MUIQ)W_+D4`TPRT6033CKQ1),,0`E%%(?PS?=4
M5/F9E6-9^X'7'XU`-H@6"&JQY18LP\@R3"K#W#),*</0PEA??P4FFV';);88
M7X]9*9D,E%F&F68WZ-;::&64=EIJ9O+V6FR2T082;FV*YAMPP@6IYYY\]NFG
M4AD:B."?9EWWH7<D(BIB>.*E6!Z+Z+DX0V'NP4!H<C;6)Q55^'':X5<^=G7I
>J,<%NB&IJ*:JZJJLMNKJJ[#&*NNLM-9JZZVXYDH<
`
end

447
contrib/libarchive/libarchive/test/test_read_format_zip.c
View File

@ -26,6 +26,76 @@
#include "test.h"
__FBSDID("$FreeBSD$");
#define __LIBARCHIVE_BUILD
#include <archive_crc32.h>
static
int extract_one(struct archive* a, struct archive_entry* ae, uint32_t crc)
{
la_ssize_t fsize, bytes_read;
uint8_t* buf;
int ret = 1;
uint32_t computed_crc;
fsize = archive_entry_size(ae);
buf = malloc(fsize);
if(buf == NULL)
return 1;
bytes_read = archive_read_data(a, buf, fsize);
if(bytes_read != fsize) {
assertEqualInt(bytes_read, fsize);
goto fn_exit;
}
computed_crc = crc32(0, buf, fsize);
assertEqualInt(computed_crc, crc);
ret = 0;
fn_exit:
free(buf);
return ret;
}
static
int extract_one_using_blocks(struct archive* a, int block_size, uint32_t crc)
{
uint8_t* buf;
int ret = 1;
uint32_t computed_crc = 0;
la_ssize_t bytes_read;
buf = malloc(block_size);
if(buf == NULL)
return 1;
while(1) {
bytes_read = archive_read_data(a, buf, block_size);
if(bytes_read == ARCHIVE_RETRY)
continue;
else if(bytes_read == 0)
break;
else if(bytes_read < 0) {
/* If we're here, it means the decompressor has failed
* to properly decode test file. */
assertA(0);
ret = 1;
goto fn_exit;
} else {
/* ok */
}
computed_crc = crc32(computed_crc, buf, bytes_read);
}
assertEqualInt(computed_crc, crc);
ret = 0;
fn_exit:
free(buf);
return ret;
}
/*
* The reference file for this has been manually tweaked so that:
* * file2 has length-at-end but file1 does not
@ -312,3 +382,380 @@ DEFINE_TEST(test_read_format_zip)
test_extract_length_at_end();
test_symlink();
}
DEFINE_TEST(test_read_format_zip_ppmd_one_file)
{
const char *refname = "test_read_format_zip_ppmd8.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_ppmd_one_file_blockread)
{
const char *refname = "test_read_format_zip_ppmd8.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_ppmd_multi)
{
const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("smartd.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("ts.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_ppmd_multi_blockread)
{
const char *refname = "test_read_format_zip_ppmd8_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("smartd.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("ts.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (ppmd-1)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_lzma_one_file)
{
const char *refname = "test_read_format_zip_lzma.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_lzma_one_file_blockread)
{
const char *refname = "test_read_format_zip_lzma.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_lzma_multi)
{
const char *refname = "test_read_format_zip_lzma_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("smartd.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("ts.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_lzma_multi_blockread)
{
const char *refname = "test_read_format_zip_lzma_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("smartd.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("ts.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 6.3 (lzma)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_bzip2_one_file)
{
const char *refname = "test_read_format_zip_bzip2.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_bzip2_one_file_blockread)
{
const char *refname = "test_read_format_zip_bzip2.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_bzip2_multi)
{
const char *refname = "test_read_format_zip_bzip2_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("smartd.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x8DD7379E));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("ts.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x7AE59B31));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_bzip2_multi_blockread)
{
const char *refname = "test_read_format_zip_bzip2_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("smartd.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0x8DD7379E));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("ts.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0x7AE59B31));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 4.6 (bzip)", archive_format_name(a));
assertEqualString("vimrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0xBA8E3BAA));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_xz_multi)
{
const char *refname = "test_read_format_zip_xz_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
assertEqualString("bash.bashrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xF751B8C9));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
assertEqualString("pacman.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0xB20B7F88));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
assertEqualString("profile", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one(a, ae, 0x2329F054));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_read_format_zip_xz_multi_blockread)
{
const char *refname = "test_read_format_zip_xz_multi.zipx";
struct archive *a;
struct archive_entry *ae;
extract_reference_file(refname);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_open_filename(a, refname, 37));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
assertEqualString("bash.bashrc", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 12, 0xF751B8C9));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
assertEqualString("pacman.conf", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 13, 0xB20B7F88));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assertEqualString("ZIP 2.0 (xz)", archive_format_name(a));
assertEqualString("profile", archive_entry_pathname(ae));
assertEqualIntA(a, 0, extract_one_using_blocks(a, 14, 0x2329F054));
assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}

19
contrib/libarchive/libarchive/test/test_read_format_zip_bzip2.zipx.uu Normal file
View File

@ -0,0 +1,19 @@
begin 644 bzip2.zipx
M4$L#!"X#```,`#TQD4VJ.XZZ-`(``)`#```%````=FEM<F-"6F@Y,4%9)E-9
MYPC!D@``3%^``!!TY^!2(B.7`+__W^%``C$[0!AJ>E,ID:&U-'E`T&C1IIIZ
M@8&J>$9":`IZ@``'J:/2&#```````!@`2FB$T:31D9"F@8FC0`\H^:+Y;81F
M6OH?UN<?%+%N:%31B%P(0RVO1<SQJ<1.]SV*&^IH14$2>^\U&IFQOP9(.Z29
MPY<T(I:;+;+%&$B@2M1Y72W?=(*2WDS,\HT0@,EKOQMPK@2EG,=`4I\L2`([
M5,]S''3%_7<)2">-_:/D\-$@RAM/2I>(FNV$2K!!&6I"Q+LXG0-YLG/4-JQE
M=%^\,6JL1H*""1!1W]<O1I!W61YH<W#N(;L:?>4\/.E))/*(3J)$L1_D*SPD
MAZY)I5-#7@)=-5H06@2PP-)YSB5D!.3J63\EJ*\X%RMDE]>>,6XG5O@<^@:T
MT671Y,.:/=ICJ(=@\88>!>M^W)$;,QY(*`F*%Q2YZ^%TF$V^/85:V;L\W53/
M?9[-IX&M.O38C\;C@Q';$E9[,C'?<#304$$9O&4U<2"$^;O(<O4$WDF@5")3
M:<V%Q;W"+5#B4$L8:VN_J<@<6I7.ME"(6?"""#O+0A5/?<$^+"0D5-NSRK//
M"%<_?]^4-QYYJ,(+(C;@Y3')J>0X:)KR2UT?=.E*K!>,09(4\>BYUO&*8;D4
MY=51BK5L/;$+WB"S8Z-?)M+GT/]^;,7$S'N0)))KF]$Z(GL[.L=F*G#!4NC)
M4)I$P%W)%.%"0YPC!DA02P$"/P,N`P``#``],9%-JCN.NC0"``"0`P``!0`D
M`````````""`I($`````=FEM<F,*`"````````$`&```EU'!QI74`8#"I,S&
AE=0!`)=1P<:5U`%02P4&``````$``0!7````5P(`````
`
end

96
contrib/libarchive/libarchive/test/test_read_format_zip_bzip2_multi.zipx.uu Normal file
View File

@ -0,0 +1,96 @@
begin 644 test_read_format_zip_bzip2_multi.zipx
M4$L#!"X#```,`)$XD4V>-]>-Q`H``"L:```+````<VUA<G1D+F-O;F9"6F@Y
M,4%9)E-9)%%XJ@`"I5^`4!!,Y__W?^??]+_O__1@"^U]9V%K:9UFZ$O2A7K'
M77-*UK(BDFF*DG<-30(`:9(V@@-2?JFGB)Z(TVIH9J>H'J-##(C0U&1)Y*>F
MF4:'E-&0:!H``-``)30B!0]3TFDVD])ZF(::`!Z@`T9#30,)"0@FBGD*9-IZ
MIZGE,F@9``-``&0'`````#````````)$00FC1,(TE/T:,HTVJ?J3/5-#,4]3
MU#TADVAYI!A\^>RT<GE6YYS5N0CDH-W\T^/EI(<6MF;^`>Q(BD3$3I$[^,/;
MLS`?JD6R.G5Z9H!*U7PV]92S^P:OR\HL0A0_3>$BI8)(/R)[BOOLC2%8YJD(
MA.HIB.`H&#CG`1Q7XZ?+[_/^7_[H%_86(A9>\@A,<LAFVO+>_,XZ=,XL5W'7
MHP4M+H9TD.>'-*H@_0+C17D%)P0)RW]IX%[$"C`LP1H=G0_&E!1":MS%AMXQ
M.;)R8XI%.5\07+<T%D;E`.H3-$BPXHC9O9][@4+5@?#H]U\C:>:U'.MSO0WA
M_'JHZ5GH`I2IS+,0&673'.$+E#O<4'!QIOJ(=A]MS$!DF&L:[UWD`N@'J&ON
MK"9F:A.4,3W/HWR,FFXKDW<H8/K$-R-J7+-EF/I^Y'"+NG5CCEZ+0:?KD<+3
M`"I<U;86QQF!%.4@B\T!6@0*$:O*&.M*[F3XHCB!PDNC=;?B?(XH83B<VJ3,
M@\!-,#RI8$6_#3WTX6'H[6MHG!,&=ACHLI1OX975N=BR)Q(P3"R]T*(N@FVS
MEY4+OL3<O1,KCHTPOX=VJF:N9O,42K4RCC=]+6O5$9[3/FKPO@0(HFMMCG(M
MS(TAPC;*E<FMNE0SN-MRQGSE<D$G2%7;F3AT+J@5+!!70<<",M>_PF?19FN:
M8JZ13*&(2TCX35$",$])GPS2BLBY&_H+ZVL;>UD^#7W[$P11S-:X+;I&4P_2
MY2FF=^Q>)*S'RAW&B*<0LART09,I)(!+E@9";HI&D+G>(HXB:0(%/23%!+S@
M:NR/5*I%\9CK3:PVI<JJC%D=$J4%/&554*(4_,7#440X'":4,8L63JN=>^LQ
MG?A&-RQT6VZ[1QPG2Y9UVU<7W0N_@W]>`:ZV*-IMC1AC'"5PL)0>9PPF\/OD
MXXHMUZ\<Z25(;=^+RI'$VR3AK-]]ZYZ5:F:A:K!+N/1,2[.%G;@BE(-[@.1`
M22/B@`/?%#.CZ)`,.^U9$,*\\.[JTU#1MZ7P>%[^LVOK%3L]),1F)*MOQ5)H
MBOICX8!01L:?$[E<$R]4`!$&F!"N^Z]2A2JH&\;#/"R\MG<`!XM)L2.#%FT@
MI$"[T#%/63SY#K=LX#RSQ*%:^J%L1'HN2F*:.2LQ2X?"^Y^<9@U@PV(.4E%C
MNS^(@N"/+X8L:9,0T^E]7FZXBP#;&@K7#\.W[MOUG8-`-,<'O._DJ$2@7*?N
M#ZO8W/#Q7.=4KXGTY)7:1_NJ7-3FF\<6*$<^N]+-!C)W4+U60F$@>:,&%)NE
M6U9J0*F"F4!.R,Y`.G*"*P_*(P>-<7WV6=I7*E]98+HG":L0P4Y,?%RY^X[*
MDSY./:P;H^X)PU&L=#"2/IS$=1]X>MB:/!;68(&.EX`-X^"ZW_F;B,/8(F45
M`_?U2XOBQ%&$HQ1YCTEC[_A42U:75Z>4-MI3.*/X>72/`C"+5Z>0B4C49O3A
M'N8'1IOJC95M$"-@1RC6(E"P.0[ZZ:;J?E0+#0?LP-6OA,=$^`?$]R<D,R:6
M&AO6\BZF>)HW%K-',>W@ZBCI&CX:1\Q,YOY&7QLLV_J,<-^S+:AAO&'.A;*V
M3AQROQ<,BPB$?,M'!#1QR@/4P#T<S7`8"66LBP\H218.SMGB,,\1%E*\/0*#
MQ_'#_%KC&V`62ZV)_`]OL^PI[Y+3Y'D:D>M5"<!K'\`NAZ/[F;AK;1&O\DA=
M0]#/L9O[-T_:F38NS8'QH!;O!*9%KW46U%$P7^K@8H&S*H\KD-/C1E92^52F
M)F1C$@7G-V(O%9#LFI%D%E!$P!\'1B(0-?))-42@&?](DR&2ZE`T8XW\%:FB
MF*Z1QI590R+_@5,W2:2C-`LE@8*Q&:H8NM`['><*D.$6U5>6NB0:@2#RD1AD
M(26E6M&U7;I&M?><,-FD48N@:,:2[U9AD#8DO`F8G`NH2VG:1>/.?`E4V(J^
M#5)1$;.G/E?/U7S,RZJL\[5*#)Y+2^&5-1.L.G9B!:4)5`06C6IFT)6E9!%+
M2NC400RE=1Y`*MU7P;V<R<"<-'X?;X97UARL<KW%NB7,<_XCW;#Y=&J42S?<
MCYV65#`1E'MK>=>_94Q:13C>/8$;NI99OUE6QCKTH&-VKEJ+?SICS8UQ>&55
MS!AN47T#J*?QEQ6,M2+`@9;Z#.*GM;18!J.<)J@Q;$1#.I*.KS4[,-,#$>-\
M)PO&"I/*D7`.K'08;Q%TA8:$`G^HT8=;C3N5_4;IF)[F0N$3TDH*Q0-P<[42
M,33G53,R)8(253>'`I(/(`C4Y$P=<ZI3<Q9F-%6NDX[@@<-.#$:"ZHK=Y"2W
ML':Y1S;)()A8F:NQI,Z6<4EA=#ZP7K"X9XEI=Y1^>LZC+Z#,LC!<`8.=$0&&
MHL)>D\@AT(1A;6.-(URT`6J-@0P%Y020G3VP:QRCZPM[@QB;&[&]I'1L3HG6
MHMV_<`9H[#0AJH/K\46RSPQC,;0Z:L!U8.MI-<Z53:%EM8O;@;NC/2H=';XV
M-Z@X,TK*TU++@]A*YJ;NAQ6:N!AY.&J8HED08VR&!22SM(6OK:A%ET7;U&!4
MVK6\B1<8S:RZ$2&P0S%>>!:8E!XF+SMT&6HO@%[!H\1%0L[N;T&#(0;8].D%
M:TK%I(F/ON*[L1CE)4QE?&7UU65^]]5"5--B;I#AF:-,&WEQ%G1QM<7=I+I-
M#%HED2A!O:62V29]+QED;,>@Q1/-)PPU+A@W!SW0+W/DU,0V*IU>![3,1S&>
MJH>)MQ]&0><M19/ROSLZEN3#B_9J<R3UR(K`N`N21DVKG"X%,+[7TX+(=*P1
MNJH*&-M^.1NI8I=_4LF'\I+3TCS]0COXP9&VQ[OL=S+9D5III],[VS7W')'H
MV^<R#4%Y)U(&T?;3\\!'6[>D=NTHM!=_;/K:@AM+BTH-:,C49$_(R)IC&^1Y
M[EI=1!L8O8:A+.F,:91'!%LGX.Y*[9W'8Q>2DN<Q$3J253N=[B+$M5`,`ZAP
MX#7D2G.9Q9&85E=C::&FQI#=#:77?K,:7Y2%%""A5E:3S95'D*ZI%['/%R@N
MPC:9L35R#[8BW=,#-3+S!A7!WNSP."]&D&T:/,C4#0L]K,!G8G9),'9JIE".
MT&JZK3L";)&ZF\:#Z+0V:/`NPWLAN#;)1&)7&:):CTRMF6MYRNVWEM,W"3=O
M9OBR&5B:>$BIBQ<M:6NS/6M-<.;%:!:CM-Q:7P+F[9<^U)ITR0:D$:JK$S%:
M9V8;[^0=S9:"MAG>(Y()FJNVR"%T-;E6?@6^'&XMHR)AAWR$C9972+M#HSN-
M);+!>$HVAW9>(FP:U,1BUS180R6S:<$UD99O<NY=G[''Z\C9AG)U+.%99@9C
M;.=-Q(V\S5@<WPQZ(`71O7+I2%C0S36*BC[[+MW<$P5LFC!]"[=Y5+L:1H65
MAB'!(B:A*;VK2KG,`:&Z<:9\L7<@'RG1`XHDFZ*SB=DQ(`&LRTFHZ?^+N2*<
M*$@2*+Q5`%!+`P0N`P``#`"(.)%-,9OE>L@!``!4`P``!P```'1S+F-O;F9"
M6F@Y,4%9)E-9[2!3B0``35^``!1(A>=")0$"`+__W^!``=V;:TML-3U*>D]I
M3`F]4]-(T9`T:&@T8I`F(U'ZIZ@!H`>IZ&`````P``"4T4R9-3U`$T]$`,0:
M9KMEA9T)[OUF#<]_H_:R!%VW(Z5<8GI,92Q$\@_99'.V;0!9M_JQW(Q83@(>
MU(&RK]97O.4,(?<D&2+:<8T+C,9*N8XBL0!($BWA2>9Q\O->C6^K@,2&/*Q^
MQ&&;:95MR[%C&6KSOTJXV':CWZ0#H?FO+]L:K$L-@\J??66K"[C''`Q(05A5
MAA`H<]68]Z8WD3,92%/*1-[+TH^&FHBX0;F(=TXT`&\A85\I0".^@K=W'6BV
M6W7I=FG(:-GP/>J!T.)K9&E&`70E\*O7<@B"XC8N],ESUC>J<#0$&LF`$Q"I
MPFSXM(AMXP]!B.B$A)+*A@FQI7N,888C3<<1)$V8APW#69B,^)R&)J6R?!9U
MVQ?F1G9TTEH&P"PV"U$F)!()!JGQ4/1670D)VLF!P-;I.\BHY"F((+!C$AZJ
MZ4L(AR$T$'4N]0NK3DSCOKGQ@9(O?$J:V8>5Q'*QHI5Q[SIJ>$D/XNY(IPH2
M':0*<2!02P,$+@,```P`/3&13:H[CKHT`@``D`,```4```!V:6UR8T)::#DQ
M05DF4UGG",&2``!,7X``$'3GX%(B(Y<`O__?X4`",3M`&&IZ4RF1H;4T>4#0
M:-&FFGJ!@:IX1D)H"GJ```>IH](8,```````&`!*:(31I-&1D*:!B:-`#RCY
MHOEMA&9:^A_6YQ\4L6YH5-&(7`A#+:]%S/&IQ$[W/8H;ZFA%01)[[S4:F;&_
M!D@[I)G#ES0BEILMLL482*!*U'E=+=]T@I+>3,SRC1"`R6N_&W"N!*6<QT!2
MGRQ(`CM4SW,<=,7]=PE()XW]H^3PT2#*&T]*EXB:[81*L$$9:D+$NSB=`WFR
M<]0VK&5T7[PQ:JQ&@H()$%'?UR]&D'=9'FAS<.XANQI]Y3P\Z4DD\HA.HD2Q
M'^0K/"2'KDFE4T->`ETU6A!:!+#`TGG.)60$Y.I9/R6HKS@7*V27UYXQ;B=6
M^!SZ!K319='DPYH]VF.HAV#QAAX%ZW[<D1LS'D@H"8H7%+GKX7283;X]A5K9
MNSS=5,]]GLVG@:TZ]-B/QN.#$=L25GLR,=]P--!001F\935Q((3YN\AR]03>
M2:!4(E-IS87%O<(M4.)02QAK:[^IR!Q:E<ZV4(A9\(((.\M"%4]]P3XL)"14
MV[/*L\\(5S]_WY0W'GFHP@LB-N#E,<FIY#AHFO)+71]TZ4JL%XQ!DA3QZ+G6
M\8IAN13EU5&*M6P]L0O>(+-CHU\FTN?0_WYLQ<3,>Y`DDFN;T3HB>SLZQV8J
M<,%2Z,E0FD3`7<D4X4)#G",&2%!+`0(_`RX#```,`)$XD4V>-]>-Q`H``"L:
M```+`"0`````````(("D@0````!S;6%R=&0N8V]N9@H`(````````0`8`(#N
M7F'.E=0!`,YV<<Z5U`&`[EYASI74`5!+`0(_`RX#```,`(@XD4TQF^5ZR`$`
M`%0#```'`"0`````````(("D@>T*``!T<RYC;VYF"@`@```````!`!@``/`\
M5\Z5U`$`SG9QSI74`0#P/%?.E=0!4$L!`C\#+@,```P`/3&13:H[CKHT`@``
MD`,```4`)``````````@@*2!V@P``'9I;7)C"@`@```````!`!@``)=1P<:5
HU`&`0`0-QY74`0`TN_O&E=0!4$L%!@`````#``,`#0$``#$/````````
`
end

19
contrib/libarchive/libarchive/test/test_read_format_zip_lzma.zipx.uu Normal file
View File

@ -0,0 +1,19 @@
begin 644 lzma.zipx
M4$L#!#\#```.`#TQD4VJ.XZZ.0(``)`#```%````=FEM<F,0`@4`70`0````
M$0@$J,)\D;(#4L%<^$P5TO^CM0KI0HWG08B&_].4<,CJ")TW/L>)82Q1PWAL
M+U`,N0L_$]^&650C/X$D6#4QFD$\A/"_![4!O/5O/!KH`WCQ*4?T2*]4P#/D
M0'9I?EZG=N69Z0V;H0I=C<!C<J6O^834W097PY1$%=-++.YUA'!>P*$?".I\
MGMG/80.A'^W>R4J'S/CZ%P`8`>F=R>R&R$2T@EM#X)"OQH1?A7,`:4IU9WV!
M#2W*DXT',;.4YIN4A:-X)O=IREL201ZSOC=YSAU[C4-::/YV8\)%"L17+>VC
M%/'B]ZCQN$2(Q*9*\KJZ`Y131`]5C&G';@1S-QES_RZF!2OX45@58+??ES%(
MUJ<(\`11M$NO)HK#/MK-9RT"15.2I:IZN8<TJR>VTM1_?$G\L#BH67]$S%[4
M%C-$\Q<+./&HV](4,7)OL-@C^M0F"2O!0N$OHOW54H87^QLBQVH*D%A<#SI%
M/#+-5U(W';:KC)RE>0Y^5YI!RECQNR"R4.UW9IR!@:B!UB8?_D5$FT8YCJHJ
M2[2"-&-_D2BJ6#XK[6G=%K"%;'^-+0]FHCY4ER#`^<I-M<!"D:-0H@);U"P"
MPYX+4#8!&$7\M.+%%MZ:KQ2GX0<]$"P7F^HT)J5JM<$VO9/D[#7KZ\'FITL/
MYIF"=GO+-L?F[8QS4KC7+=A)1`")V<.8DX629Q;;Y4XA\M-%O&MWC)^)`NO<
M.J6(5V2UY9"I(C*QKA[Z#)-#XU!+`0(_`S\#```.`#TQD4VJ.XZZ.0(``)`#
M```%`"0`````````(("D@0````!V:6UR8PH`(````````0`8``"74<'&E=0!
F`)=1P<:5U`$`EU'!QI74`5!+!08``````0`!`%<```!<`@``````
`
end

95
contrib/libarchive/libarchive/test/test_read_format_zip_lzma_multi.zipx.uu Normal file
View File

@ -0,0 +1,95 @@
begin 644 test_read_format_zip_lzma_multi.zipx
M4$L#!#\#```.`)$XD4V>-]>-A`H``"L:```+````<VUA<G1D+F-O;F80`@4`
M70`@````$8@&YWH`1\"K>?C+)VT(T,`U9;I1/'N)!6C.3M-O9LO]H<^=OZF\
MXD\QEZIMP!JM4)W+(F]%N;U#&+F]WZ%S9>>]&^75:X)0Q-5>)IRT/%INC887
ML0UF,PS8J@3;WGH95EW4\KBH,6ZK9,'![3$-(WL/C<S3&K[A1C?*`W/KQ4&Q
M`/BGQ$#SJ^?;Z_7,NJ_(<YJKYEW5LH4:QPH.Z]G1VW_M3E2QS5S'\6S@-/7M
M9+&F/N+H[TX:GRGI</0(-B-?I7II0M#&)*LQO[%N?0,S48\!,6C%"FGSL(59
MPVH.\D`%['MI;`8-TPQ<'NX'K:"0+`MQCQ)B*FT/.17CT@8%^,I/-[K?`GGD
M\2YAO1K`&COVK><[0.6%L9@]0;]_>&[A'#Q^##`6+*PM@YT+]E[B9<QN2EY>
M;QK38:)CO+S]4X2KF'=)BVO-GM+_#]PB0'*J89+$Q11IG\\+84M](58^RW.E
MGM3S6RH]#73P.KV0V,2=,/A!;G>2Y4R!!.4(0U+D<.'5V*%./ZZYD")=W4*4
M\SL"IUJLN])WM`-&4L&!9&U_-1%%SPU0N4*.^L5&33"A5MZ;@8F+I^D7JB'K
ME&,P>"UI]NT;ZX`<E]/3;Z;:;KU;K(9,W7@41O,3:LQJH%H%RXZ.<A,Y\=Q;
M`]D>UU->]V$?<H!@ZNFP0M6BYMPO95IJLC48"DOTCXD/#?VW%LVZD2SSZ7FN
M'KLU!HVB+H7FJ)Z@GPA7L"R'[&^62*7E6S:TJ[XYM+U?YR1K21?P]5TN],0/
MV05M[H@C9&OY+CA3(2G0HZD@0M2`"O;9&ORU2_2D#8T`3=,>KZV(DX&-6L>?
ME,(J<;DNA6/2.<9$>?-P]_!S8L3/2P@[C'H$FOA$WUOB>;X$)E7;K+7#X9M(
MM+H^AK#CML0LX<B:.L9A!G3PTXL5UK?O<K5?S00^"%V;EC>TO#P#I)J_5"@O
MMGH9+OXD^P7AG@<%QGH<>FIWE]/>L)6Q2Q\CC=[?TCG262"1EO)'_W_C_K4<
M8.7YNR"3\9WTQ"0-!>^,M>WT.Y0A&3AK.4/YN5EW]"&HQ1=8Q-NHQABVH7$%
M24Q:J/<8%F1EI)-!HND&FP_;]E,JI$*AGE&]Y#FJ5R6<(UM;;>U?KU@OQ,M_
MI/+:;0^0'8JA"==H5/;]Y10P&PS,1_M+D1I>`%>_Y\&F[_R/##784#0AQ1!O
M'8>IBY?;&;(VAOI$+Z[VMI>]WC!['W$&Z5/D+"6["[[.<DH&[&K^*"`/UB[Z
M2Q?D`J)9WKDL?`4\\V0;#,28BU'V+#=0IGN6YS1Y9,V,<-2!(-L@Z20XL8I:
M5#"QC1CFF*"!].U\TX1;$IL?#Y<\`1C*%*`XW?^@>[P!/?9C/;CD66^J/OC)
MO0JXP'Y6]PGW8N@X(#-XXWMP"A%E$A8L+X>QIC[0P,UT0A!IYQ/#+>E60KX/
M2JC'F-Z@_,-/$7+F5F$1\#^"CTSY;H2EAE,/8>F$^'5H!M2@D?2O@+NJ2&-O
M6IV-[<6F-JG0(,W-YJ%PJ<7T.F")'/+F_`F6B-<MX=E68$!XW'W(RG>HG436
MJM-VK0?>9*R?K#]OHC90!]BCG'^D&%!JZ2T_&[RWV?0Z?T:#_\B`?:MRC$D5
M1Z.)!/;3/=GT*T;DC/XLR;7S%VEP+U-M)-*V,1?M<377S9-`J]S4[OI4SR>V
M_?_H2WWH>\@*$V@`LZO?-<BM\X$'4(L'MF_HV4RT1V'^V>'Z[4_4"T2R@=%!
M!\1]:4M((1B=ATAJ)23HE7>]=,7I#SK5'2OUZLX0LX*_67!+6S:*0UL)^GS6
MM;$2!(-TY%4ME1>*'M)S'[0JP^&J%<A'CQ?7FI>"-&A[C1YE;1:X_4Y&K9*2
M'14NC*]O(JXNLX#M_(LDE6$G<0,+V/;44]-*^S%7G*.\$W&>2=9,EYB)/@XK
MX+E4?>NIP=*X]Z>3T,V?!"5:/M@<Y?5&/FI$@I@$N)0*3];_\;[7)(:*+#2,
M$JTT&;V1H(;O<>X-H%DZEV,*9WIK;T_C18UC5$%^Z5PY8;USNB?S]`D-K2V2
M-C#0-45C'YFF>#*$9JZ!$>%0;=VQ@LGY"J<.C.10"1'</GIK=$9`=+K0L,5<
M/])*:+OWS(:V1=R"?*)9&DJ;KZ/0ZI0L8,^</;B?N`=1UB<"P1!T-'$3:D-%
M8\K1LH+E![6M]42AXTZ]FR@_6W0Y*@?[L(<\D-<C[(//PKW-#"'].EG9-=!9
M'B9)"486TDIB/J5RT`,JO'_SX1LJI@H^47%.'QJ/KU`P5K<C!A3],-2995TS
M-5B#!(:B;,]CXTQ_ER3(3>JL^B(VXPNK^]Q97E\`HX0MG2)F=>38R,IFGK\R
MVH!.V3_)_D,II8A=SL;X1!2D9E67=.$P+_D6&'X^1;4%:`ERV>!,''7<#=NE
MP')[\,A89G35\;ZN:IIY5DDSB$(8D$[G>7-L!(+(-7=LQ0Q3=S`L-)R9YT;S
M;%ZYVD%6)M=I]*QS>!3='"SB'E/4>J#EQ.&]0*U<?2AYA#J0V*IJ#AC@C./2
M542_X#'@J3M.%(D.\<Q/^[S\^[K8P\I@1(RM[%G$O='.Q#'@6.:]E-P6$<9`
M6A_HT;>0H/Y1%DM].)E/UFD0?Q)B;_;;)-K_]6Z<)D_>^[=?49%4D4B@REC`
M,_KU,KX-N,44CL/:*^D>7X(;6_1&C;<;&`K3+4NY[=4%K2K:U"Q%T9)',7,"
M+PC``PBBDVNY9V-LN'V')B4@4;OH(\/M%UBX$S."4_!;&=9W\L`!2O\!ANM5
M8<J4RY>+""#5J&/M[2;M?47WN=0[4C*$<!KL:]JI#:F(GID#"X3/_+OW4^9$
MH(D!M_S%*9ME+?QP:[JJ)<;$_/.0R`B9\^)8##D)RWG"SP>7D#QB&`!*@5_0
M9(5SZ7,Q"N?0W!\0WGQF,0JKH[G-(<6^PMJZV&VHQIT?VKJ^7^!EW?)`EC`$
M0%,=?X0ME@T_&5UXJIJ9)5(<[=W]M#Y.$.96:_T8WM/H+"T_Q;QZN"`5DC&'
M.+(^")0XO=#&#@KVL2R9+.#F)P02=`6PT[21&>T*Q3Y2WVL><:PHB)R?*'+3
M+,OK(7PNXHXMVFT<GB/X]4Z(@V!G@I*W2+?/E8B$.YQWJ::$&5/A"L1:8E%K
MB=/,3Y3G]Y=64JWA"@J:$P16J+IAUZFU7R^QK;H&;^D;!``-$E-)!6#@YQ#"
M[4,OT;*U7IE$\KI[&:W.&KS7ZEO@1/GQZ\3O-'FX<<!+Z2>"!)??8!H^I,&V
M8BOE(Z/VYY(5WLSG$.+8$;.A>]+PVB`WV,9M@YL='Q_<%2STU?_IG.I17G^L
M>#-=')K6T<!)<XY!]\5&A$"^\9^X:W^2@`!L:56ZV^TU.)Y$<1%OM2BUNZ./
M&YD1MAR0^RP*&R%@"21'W-^R\=D,\1JM63J<>?C[^&,7Z)0!B[2-)2:&?*5,
M,;&-HI_/O(/V"4-:_E>0Z)=C=1/9HQJO$R:(&H@4RP"3%T[BOBZ`3_2>)K49
M\ZL-26)MQ\%(>T0S5A4>EUCU[),JI"_/9<5)*6X\97`N:8YSR0%)@*#_'9'?
M/E=RFK"L&(#RS$S_0[?/!DW.`\FH$M\#"JSQ@*&C*W\`4$L#!#\#```.`(@X
MD4TQF^5ZO0$``%0#```'````=',N8V]N9A`"!0!=`"`````1B`2H,L'S88)4
M*WW.8!PX^&C9J^P?<4.RSJ^WF7L-W#+OB4@(A-83?&.PVF@$.:VM<4\8K(_6
M`CRI/@MR:,)C8$&U*MZ&#04KA\W'KCI%E2GDYYE/SB'*\S@5]NO,ZBF!;HY@
M3Q=F"]@P02:6^LC>JT$T7BB(.:*G`I.?%/53CC#4I0N_ARFXFG`DZSI*$)UM
M1^X:IZ^^)T*5E,C6L<,L%=ASF-1:0CP6*FX_;?<K)^Q*:<'E!WV3Y^)QW7="
M/.)?WNY-<("[VKFR$BQ*_6D4][NEB\IZ<[_,,`1C%(([BG)4G[]C,^8$W5:S
M!X8MX+YUOE1,?OV<7IV(TJY<0RPDRI%4`^%8]HL^H?>R;<M-IR(=C:[/JFI\
M@1WIP=G)@F5A::X3B@1A;CYD=PUCB*'VM^R:X2:XWH8&"Y"ZB-A`SBC*D4SN
M3DAH,0A!PJ\ZHL?#PB)4OI"FOD^Y$@I+T0N$05U+3K3,)DW%,#3SCA:7=D#^
M&^`PD\!WF#VEY5I;2G@*ZN8XPLL!)AC#&5GR&:MW:!`3"^JARM%?H&>#]C:/
M)C@@M]\FLU4*%H^>8VW4@@%D0U!02P,$/P,```X`/3&13:H[CKHY`@``D`,`
M``4```!V:6UR8Q`"!0!=`"`````1"`2HPGR1L@-2P5SX3!72_Z.U"NE"C>=!
MB(;_TY1PR.H(G3<^QXEA+%'#>&PO4`RY"S\3WX995",_@218-3&:03R$\+\'
MM0&\]6\\&N@#>/$I1_1(KU3`,^1`=FE^7J=VY9GI#9NA"EV-P&-RI:_YA-3=
M!E?#E$05TTLL[G6$<%[`H1\(ZGR>V<]A`Z$?[=[)2H?,^/H7`!@!Z9W)[(;(
M1+2"6T/@D*_&A%^%<P!I2G5G?8$-+<J3C0<QLY3FFY2%HW@F]VG*6Q)!'K.^
M-WG.'7N-0UIH_G9CPD4*Q%<M[:,4\>+WJ/&X1(C$IDKRNKH#E%-$#U6,:<=N
M!',W&7/_+J8%*_A16!5@M]^7,4C6IPCP!%&T2Z\FBL,^VLUG+0)%4Y*EJGJY
MAS2K)[;2U']\2?RP.*A9?T3,7M06,T3S%PLX\:C;TA0Q<F^PV"/ZU"8)*\%"
MX2^B_=52AA?[&R+':@J06%P/.D4\,LU74C<=MJN,G*5Y#GY7FD'*6/&[(+)0
M[7=FG(&!J('6)A_^142;1CF.JBI+M((T8W^1**I8/BOM:=T6L(5L?XTM#V:B
M/E27(,#YRDVUP$*1HU"B`EO4+`+#G@M0-@$81?RTXL46WIJO%*?A!ST0+!>;
MZC0FI6JUP3:]D^3L->OKP>:G2P_FF8)V>\LVQ^;MC'-2N-<MV$E$`(G9PYB3
MA9)G%MOE3B'RTT6\:W>,GXD"Z]PZI8A79+7ED*DB,K&N'OH,DT/C4$L!`C\#
M/P,```X`D3B139XWUXV$"@``*QH```L`)``````````@@*2!`````'-M87)T
M9"YC;VYF"@`@```````!`!@`@.Y>8<Z5U`&`[EYASI74`8#N7F'.E=0!4$L!
M`C\#/P,```X`B#B133&;Y7J]`0``5`,```<`)``````````@@*2!K0H``'1S
M+F-O;F8*`"````````$`&```\#Q7SI74`0#P/%?.E=0!`/`\5\Z5U`%02P$"
M/P,_`P``#@`],9%-JCN.NCD"``"0`P``!0`D`````````""`I(&/#```=FEM
M<F,*`"````````$`&```EU'!QI74`8!`!`W'E=0!`#2[^\:5U`%02P4&````
/``,``P`-`0``ZPX`````
`
end

17
contrib/libarchive/libarchive/test/test_read_format_zip_ppmd8.zipx.uu Normal file
View File

@ -0,0 +1,17 @@
begin 644 ppmd8.zipx
M4$L#!#\#``!B`#TQD4VJ.XZZV`$``)`#```%````=FEM<F,'`"']JO"&\1[R
M;;G)@`(8>EJ>3<8@F_*<(\B>K]4_(WC8#)`_QSG+`7`B&_11VIJ)@#(<W.9L
M>K)_I8R^=`VUO2_S,1C=1CAU>-*`]CC+&6Q;EE'#CG-W=^[,F,+UR-TE(9,G
M1_&$NYD`,5WY5QX7@%5XX-*7+7&#W'1#XF+"?6*U!H=B063.]NTA`1+&\J(K
M&U]D<Z8#:-^E0@IRO9J$W&\^A>E8$ZYUU'UT\$!88I,6+(M/"=_+3@V5H+24
MBA0>^0?[W07K"B%SQ&OA-R)S9W>DH,<4##E@?5YF:%K<JGI_YMJ^QT4/IK3'
MME]>$?5U@W[IVG+2#8FC4'GT3-$L%_N,B$^)UY1GAD=.Z(HI#3[T"979&<`+
M`S]9G+PI';5"==`18UE,>N"?>"_C"MSHX<[!&8$+A6U_7][TK*6.^\-O-UK!
M`)>[*.D1:1H!I,?PEIPW,NQ5CCX2NCY+%UH"T5X!O$&=6+X#"()33:]FPF:F
ME-O)\652#KD$^ZFBJ7K`55]R/A"OA"T7\R6K%B(2&6*/H0>*-:@<P:\X15#O
M7`.(BCE?O\0!1%K[A;:`MWNF3\/K9SJ28+D-Z2I92^$J-BWY6";ANPDO&M><
MJ2V9^KJSL+P4A&$`4$L!`C\#/P,``&(`/3&13:H[CKK8`0``D`,```4`)```
M```````@@*2!`````'9I;7)C"@`@```````!`!@``)=1P<:5U`&`PJ3,QI74
?`0"74<'&E=0!4$L%!@`````!``$`5P```/L!````````
`
end

84
contrib/libarchive/libarchive/test/test_read_format_zip_ppmd8_multi.zipx.uu Normal file
View File

@ -0,0 +1,84 @@
begin 644 test_read_format_zip_ppmd8_multi.zipx
M4$L#!#\#``!B`)$XD4V>-]>-.0D``"L:```+````<VUA<G1D+F-O;F8'`"+\
MO.+63+[=I+F0!)GF1VJ,J;4U"`+-]H\Q#[5$#:5W]29`:.D\EI:7BM#X2\84
MDE)J.5>X%[[99#N5_N2Y@T-?"T%*8O@,-K>QSOR>-).,0-Q:=7)+:*Z&:B9'
M-YXDKOWK"T?"(.;F$3'A>TW+.W#W%Y0`:_5XI+35&4_L<0>95Q!XP,\T=VCM
MZB%S4G,4ED*-4T#5Y'BUCMS!0Z)0*50U=EQWM_F]2)<8#VF(432?^.!'O`I/
MLP!A8AN1>8;MQ:S?/4-$K07X@["K?T]0<=84:OJ]Y$.D)3MNMK`U.(ORV3M&
MV`2EDVHT&D'F-=\,_"^;UGWW!=,KJI4^NZAF72$S=N.*PW!#ZJ?KQ0;$7E!]
MFC,:ST/]Y(,:K3SK7,%&A_%1`($9H@/\G.RN$J7BA?C\P"[U&[8MITK*`U5E
MVH'&CJ8?%1+H-H0=B*8]_(F;;/P`371(@?QN2T<4C52L;%S-XV),E4-V05&I
MA.V?U+HM63;JH=1]LJ_E"@JM?QH\6#NQ7I\I*%-!)LWB?U):O^--2R=1C):^
M^@GFC0GETH%>LXD8_D*J'KS5[/M5+89M;6@3?]I.`M=;(S7*1?(?.9G!`S26
M([JDK/(RCM%WYC`>G*L7:NJ!5TS[7<CU3:8J00'UVNP^80ML:5-$)@YGVB]V
MRCR-N\+'6U?T;,];2KLQJK05&CW>MI^E[4/\RU9$&1XJ5#V;<'F^AX^R@P7<
M/2?UB;-2+I11]^X;,J\:,'^R=&8"@[EI0$J:":*LQ-F(IOSXC?1W>/;?4$P*
M;=V"OEY@<N7-M&<4#[>S\%3'&F-^K0FME.]%1DTO*OP8.:M('3W)\S"1.@8#
M6Y1&@L+#!YVL]8.,[UP/\HMAR1"O!M/2?DY-8[N'P[T&2J7-V5%=XWMRQ,EM
M7TL^99!FXY0+B1^7K36"#!85"WXE,WFEU=B!+GX2$D<)MW>&A,8A9RPL]CR(
M!=1JX99-:5D;PM@S4(>?<OGI*B\"Y0\$Z?+-^5A2D>BKTFAQ>"%9\Q^Y\6T\
MTS"*[M.TW7AE:#\(:M_JLJ#*-9-O,UW\T:PVW8G01OR!B59P=[:XNH0<C21F
M^#W^ZH9HB=LH)[+R]HC:HC(7GUO2YL]P^!VT?*^WF0VT2:4W-@W[3&)7]3B=
M(S`169(MJ"A4\AUA:?Z22".6">Y=OC9`KJ_%.>^)RW-,G^%%(U9HC957G/\@
MW1\J*,JLX*CF*,-!'^O*E7=V#S8_#G`9YQ)#%,AJ8"-4B,OR8RW4@L)8F$JB
M.3QD;;M_L<:*T3B>8\OECY@*'6?[2VYXB3B!`<:65*HB/.^@;]\`IE<HRA&2
MY[*2&*\%-#I).D+(^GQEE#E-F`8`X0#[ADT>)<D?R$&7^?/$"/0,Q_%FSX==
M"9!Q9!-0>HTIG=_X:*3A'#M\P0L*]^ZFWC\UL`O;WL@#?"!(_]OZ4=B<\QL/
MWD%/TL5<Q77`U;^:R@9J2]QL&U3HQ7B4]3:>[P\,^_3G\]WD-Q`?XU]K5LFW
MI6J$G\=W(Q+2_U&THGA'_6)`"WK=X74-OD_B%WJU+JH/A"K#JQ@)A<`>A6[H
MC2A>S7]ZV/H?/1KV&OR8B]IS\>Y:\5;B-:+E^V`:5_O[+(!,6LW0&[5(F4UH
MKM;R]_V\?PI6I+"7M1H%E':WL<1#J"O<P+?ZX&A,*";+5(?J&-:@61*&H;B.
M9B4X%W]`K]$KZPB]0A*A;G\=7?CYO>`>]S*UKS02ME,S7]X66@[B`_#?H$^)
MT&07IY[)18RK+`@#?UXT=8B=XC$J'SSJ>XP2<K$26GGWWM9=P5`,`X4UVP!@
M#MX&,/?QD)D![9=.L@S>RJ]>02[1J:R;0"M&L>KY(3*9QLH1N@K?LL%3J%O?
MR!>+JHS'L3_<*?;*81D1'/A-A"%%P..0%#Q32<!G</*&E4&O8A8B1KP*KTAB
MNX.M*01N][XQ_K3:G.`JQ5+G46/\J&RY*Q1_FP43*F"8.3"88\"4Z`\_P,%:
M7MCC4B.N40+?-*3IN6^F*9"3L(W1A1.&JJ7`)XZ/<L'9.UW>?L88\C'/'W?D
MG766\,!14W_TY,.;G,\C.+L1LR__7UR*_H!IE,1LZO,_+#?C[OW4+[4I`[7]
MZ;U%`5#@;6A5#JU]H+\E;^^LQBHQ$-T.P5.V/J<JU?4=KX>S69'PI06.%#D4
M%B.K!<G&.&@9I0RD;=/A_8R>F(.G*6@/>[P-FU3-#%N.EY%W*]P_]<>?07:7
MK&JYBO\0HXN^[/OA#_MP/QQG-+1?Z)7*WRL14*DMWL2795*UHMN/'POIN@Z=
M&&>Z/LT#HX00EWLZ%/G7)X<":!ST&P+Q0R)=V6!#D]TY1RYO!C&5&''Y<9UK
MK=LY46W;=`;(^L<>RMMG%(;??BF+AY,7=+H)6XSZ:2#^`W=RR7KIE>XQ/[_^
M^$F4*967)DE3/^&\(7W?:EKRJ,PN<L4,/5Q6W;5[+GEI+O/I3U!D$79IUE3M
M4HYO[&D19#(*'$P_OM/=UI,F,Z>@HOT:U_.!1-"7A-=LX\Y.=-37_355)/2H
M5V[LT(83$V*>?^YW7'6.SD=MYSM<`[M'IU<FJVD8>]?H2ZU8\SLD+R-Q__8G
M2A&2#H5-J+*NQHQ&ZX$YO_(.OC\W[3B6WB#"MKV?*/<=(JBTKB`D_X'X+7"Q
MJ$B]N)L:OTXC':GK/!QY<P!&UE.=,;$.PU*8==0B'Y6=#_?KY]GA9CQ^TW5O
MMU(;@UU')@:TC.W#]H(1XK7]P4"#7>SR.,%%T3XI6(C(3&XZV`.ZLS=\O7>0
M#N;$J[W)(Q.5<_I5G1K^FB10(.'.#Z!,B8Y'WX_=XOM8\+X/;Z\!"0HTWZG#
M[:0<%(2)`J>6>9=.B5&CWX.,@3RF>FN>'-0))N"!IY,\_?'B`DNYJ4'+!JK]
M\NX-@,,Y%)>#36Z7>CBBL=0S<@W(QRXPD3:VF-W)CS52HO!/T%NV[$0^B01.
MZH\`/9ZTF=$,",`0J\ANSPF&X.0O!?$8\^M%XSM$`D)W".C60(#6;('?*'.`
MTN9>^YI5M0P:-7MCSU2HCCU'`[!+^"9P9BH%1<=K_B#UZ3CDJWX+V\C^S$GD
M]M3M2VJY4''"]RN@>]D^K6B7ZGQG!<4'LZCK,BU]QH,1G(P$AB-W/G%7[.`!
M"P[DH--W#`"^#];7=H09``!02P,$/P,``&(`B#B133&;Y7IM`0``5`,```<`
M``!T<RYC;VYF!P`B_*OG:F'0^6V7Z#AEO-S)0GKA:ECH_T+"P;T[NJ]?$C0[
M,MX^7V9KZ9MU"@0<<.!D&=?F$.JS%K,#M#-;"1%O"UC,M?$.VW%?.TDHIS;*
M.J0W;IC-$^7I2N^-=M9TT780=OGC4U;LJ_"$@IGWJ.1$V$5P17*TMP&?G20!
MVWS"WCT0*.*S4`W48FN2YUA0]97ZY^`G/3LWH#9%8!"U:M];QEL0(FWB&J:H
MAJ<_\(Q\4;Q=KL-N!U/1BA-)>CE(/-F<.B*/H_C$3G..AVGS/6(LHZG/Y[UI
MO1E2,[]ZU6`C\+WOIWU\>8)Z?4>]`A<H/#+0&.W1ND$$W53&5&._B;GH@R=R
M7"5C8>@"D*I3B52YGN&M&ME*-/]I!1,P.R@8#3<S=7@F64SM_WL)G3,."XL\
MPIJ,X+\=FIQR7`R81]?13"]JIRC9U"6V[4X"?PAYT&+U;I:&./TNYQ.%T0OI
M2_`Y9V^P]/8%ZO&0MP!02P,$/P,``&(`/3&13:H[CKK8`0``D`,```4```!V
M:6UR8P<`(?VJ\(;Q'O)MN<F``AAZ6IY-QB";\IPCR)ZOU3\C>-@,D#_'.<L!
M<"(;]%':FHF`,AS<YFQZLG^EC+YT#;6]+_,Q&-U&.'5XTH#V.,L9;%N64<..
M<W=W[LR8PO7(W24ADR='\82[F0`Q7?E7'A>`57C@TI<M<8/<=$/B8L)]8K4&
MAV)!9,[V[2$!$L;RHBL;7V1SI@-HWZ5""G*]FH3<;SZ%Z5@3KG74?73P0%AB
MDQ8LBT\)W\M.#96@M)2*%![Y!_O=!>L*(7/$:^$W(G-G=Z2@QQ0,.6!]7F9H
M6MRJ>G_FVK['10^FM,>V7UX1]76#?NG:<M(-B:-0>?1,T2P7^XR(3XG7E&>&
M1T[HBBD-/O0)E=D9P`L#/UF<O"D=M4)UT!%C64QZX)]X+^,*W.CASL$9@0N%
M;7]?WO2LI8[[PV\W6L$`E[LHZ1%I&@&DQ_"6G#<R[%6./A*Z/DL76@+17@&\
M09U8O@,(@E--KV;"9J:4V\GQ95(.N03[J:*I>L!57W(^$*^$+1?S):L6(A(9
M8H^A!XHUJ!S!KSA%4.]<`XB*.5^_Q`%$6ON%MH"W>Z9/P^MG.I)@N0WI*EE+
MX2HV+?E8)N&["2\:UYRI+9GZNK.PO!2$80!02P$"/P,_`P``8@"1.)%-GC?7
MC3D)```K&@``"P`D`````````""`I($`````<VUA<G1D+F-O;F8*`"``````
M``$`&`"`[EYASI74`0#.=G'.E=0!@.Y>8<Z5U`%02P$"/P,_`P``8@"(.)%-
M,9OE>FT!``!4`P``!P`D`````````""`I(%B"0``=',N8V]N9@H`(```````
M`0`8``#P/%?.E=0!`,YV<<Z5U`$`\#Q7SI74`5!+`0(_`S\#``!B`#TQD4VJ
M.XZZV`$``)`#```%`"0`````````(("D@?0*``!V:6UR8PH`(````````0`8
M``"74<'&E=0!@$`$#<>5U`$`-+O[QI74`5!+!08``````P`#``T!``#O#```
"````
`
end

125
contrib/libarchive/libarchive/test/test_read_format_zip_xz_multi.zipx.uu Normal file
View File

@ -0,0 +1,125 @@
begin 644 test_read_format_zip_xz_multi.zipx
M4$L#!!0```!?`$JCP4K)N%'WP`0``,4(```+````8F%S:"YB87-H<F/]-WI8
M6@```/\2V4$"`"$!`````#<GE];@",0$A5X`$8@'"$]-R=[8/`@?.;[S=,Y&
M[VH\(ZKW[WW6#J*YR&@J,$#)$2NK8K]E/*C-X`:RK.Z[I<]8QM>%H<2H0"6A
MIYB7=GGPH!_8+Q:$I09*"\)&%HUP2'X^1_;,\T5=!'^A#5>U*#)2^Z>L/*E5
M%Y=SZRY&`Q_\(3_!//$I\E.SDZXL)WCSE7*0<#ZW/W*WM?^3CV,,)YEK01]T
MT,<7Y)@5O0':C!S_0^WG/9:,_0!\NG>*V2&:&Y6HU["3TUJ[%2F5'QVDJ49T
MXGT,!*J&0,&"B11L_MOP3I7+N6GR9P(1N,#/>TI'$'P9K@^7G77Y&\%&7G#U
M.(1KPE@G:PEDVEKT='HZIP\2CZXN#7@$BKO\_/`A&S$A2;^3%0VJ0B<>6Z7*
M'(W4;<E\MUPG7GLM/8N!$W4<+44KK,Q1"\NY'(>J5SB-RW4&#Z`/N2.@8_6$
M@.Y1A%M"F_0Y9)K*3PGD$TRK,@"9C'8J9SEZHM`Y$LI/?PG%_42+$3TP@+I`
M+:FR6X1[JU^A\'RX,7__;W>6RC#^PQ8?M\"W+\9N+5D6E<,I6YVTKS#\$JVA
MZ;K0DY^(!*H9_',HH[YJO:)!+$6'J^.N'A`#`W;24DH<EDV^*_J.:G@$T.&\
M:/WYUS#@;3V>V[N/$M_I"<*S-?4"H#MX!C`%KOF),."`K?#U%$R3O$^-3L$B
M4!;(W2EW.X`!YA8N;NJ=9MQ+0L:V/,NE<$C'^^VK:'5:ISTE3397ZF]A-RNV
M_0['T/F3^RM,C)6LKU.-W*KX4K%_0E/L1N*_EGPJ.$1^?N[5CQ%1QVWW7=PQ
MRBO*[C$);8<A:S3\W0T.G*[&4!<63#3W'!WA4W>)1VXE3/D#0,<6UN<]Z2^"
MDK"/$_T4Y*0'L%^0ZU9V*83*/A7Q58HO'/N:&4-[4C;Z<I(#5/G/"$&SNMJ_
M0QMHDX0AT[MY.CC5#/L_:`(I^V7\T9+UG-@C0!@;[DR,RI\,5R;LK5NJHJ\F
M$%LKFA;*KT/DTQ`!UH.UMH>"VG<LW`[2MG@-6Q;5^B0ZM6[SJ<T'0T#HA.V?
M11DT&2%F13N)M&"$V<?FW)M6)8%0YDI*9%M4O50%^6'LRE&.WT5A&N/LR_;M
M@ONUEVPG\YS589ME`KQ88?QHFH>4F*YB&&-DUJDN>P.WW_W/(C8EWN-?5&H`
ME(KXMK!7NU+"*$'9`APUBFPA)L:VI),V)&P9=E5XX@LEL0`6F[B]V<#9XN[&
MRCL*9L(.?C[(@XE%VY>?B<'!&6!:!_F-/_H10MNL_<GN1<NC>AK01%_7!^2_
MK-;P"DF0A;4'A4:'>AL55U%9:8*0`4^?W8+9DT"V0RD8LG/39(VE@V_M&V+K
MAMS@CU$V!O(Z>CG.!!.(;UXV'W%\:.5'^#G(S+5'+V!>C07US+?DIUL/62Z:
M&B4VHH.FA1S9(^$W)M3*NTHC:"FCSF;3$8P4Z@>L4)!K1Y*\<:F0-]$9L=HB
MY)E#TDD5?I!S4M5OOCCC'R/!D.`9%'K&$F[4E5VH"YP$-,%9!F'3#+:9192$
M+UB^3S-M%M@;228EH`````````&9"<41``!4)ENHJ``*_`(``````%E:4$L#
M!!0```!?`$DZ/4N(?PNR0`4```8*```+````<&%C;6%N+F-O;F;]-WI86@``
M`/\2V4$"`"$!`````#<GE];@"@4%"%X`$8*`DLR_*=QE1JN>[C.DH'JHS8W0
M#?$V8!+]F!+4KI<$@5HR#OF&_!+?L]N#167^N/Z\RR?GT6KQ]?CNM8>==$!O
M=?@QVU.*S@O@?_!ZYES=OXHQYJ$K_DR%MMLC^2[U):T3=<QHSS@T"PON#O/]
M]_CO:>"8KH6E\^#TM[(#:A4]+,_]N-'V@&OOT`,J)*`1$6H.A\AQ<:=18H%@
ML;39WZ/[&[?/?SG0:`)Z@@QK2DRGY04F&/;-K*Z2%^"N_BP_F6O6MO(I/U.T
M,L^0$-SQ!\_E:AA7X(VUV<S]4"ELYPD=P;@@.66.X-<G]R1I*I/^H6P6I/X(
M\!Z9KL/8S2H];49$#P%D'PAO'@@/K=`KRJLA>.Y`_]<]=`A6(D?^?S$N7OB;
MT(0U)^NL7%.Y4Y=[UNW8JWFUU2Z%N5G/Z:2V?%%%6/';]$%?%<3`>;=\3"TZ
MOQ<VD7BHNFKI30O`J1[3_^Q\.(#1S/ZI%92ID\(@2?UY0FH?NYZ!;VBDH'7A
M`TAC743^:7WL#7Q6XL:MM+>H>DR`T^1`8>\&>-+PCS8;)$M]WJ2O3&-M5NR)
M$WG>P*D3/:ZM,!QAAXTJ^?^DMH4:%0+):![`U`''+%K.;9,DM-OWB^)49!83
MO-XVJ-N?)]_]87HXQ6(V0%4!R+DSR&(F=2*,KFTT2V$[`UZVVMLSI3T^B.%"
M3D->'YYCN2Z9EC%"/S^=W%139%7:"`%-3":\73B.TK]C)8:O)4=W6=.WU7J2
M@Y#"B90[N&9_-Z@-5-#!_EI#N]D^NX!(OD[^I4G/L<]:Y&KD/P[5G?Q)6SR.
MDWT*.9G^KK"3^&1]@*+P6$#\Z4SCR,)E-_G'AVC:U4C%35O[,9B\$>QS9A//
M4-6<B.A;K708P1-X]Y+WF!XNW\DHC;<;*ID'M.O<W:(`W['F%65H7TLT[_,N
MGB29I+E'S=/2>)6T<XMX]'KC6:]DK/A)L_\X=I(8=,O:HM<0B@3"UZK1#++1
M.V9\WDZ@I[@!5Y*V[TF@"&_"[7Y[I-LO3\1_<Q*K*9_B>L?R;D":$KYVE+4"
M&J><3=ZH:XM&"9ZG5-4HEZVM<B9PK;(__N<"WY44Y`S>9YO'8X@P#G1HSFI)
M2W.U-!_N1K4*.N#AAUV?:`+5)2Q\ST04<\TLD-92B`V7$2.54`>G]G_GE!`]
M_IBNF"]3MS#G]1S*N!MZE$UQX#1ICZMB[T'>_#A&8:3CP,B^UU\D$[3QNZ\P
M=]=4'BLWD`?H@Z@Z1;^A03I/VJ2$9]*>-&-,(=@TI22.6-'S#KS*<STIRC.#
M@RD`\A%W+)QX'$-/M&SF`8&!792A8R`J0,SW"C3RZ]S.C&L4E78WA%*[\`D[
M;X![6?=Y*OWQ465EE5S/F`Z:NAM>+AT&AY64ZN7$Q'B,&TN<$OCO2W@';2/5
MEKGSV4@OF10@NP4EBO7\Z_Z/ET#+&R::*OH_-<8/2\VF!^Y["EA#=>3&>K=?
M3^N#$@0V@=Y#K\T!ZU-B?E02#N6U>="G!A6&D?[?!.55MDR7@#`#^[T2I%,A
M+@+0O`/8^4,FN!XRSE;S@C93NICEP.5CEB_787X1B`&3L2FW@E,@?%HW,)36
M&;CMA--B'7O,LRD\RJ3&]S+/5/3#/?F.Y/5_]51?5DU<Y%5OQ>T3'R5UY.+M
M3HA.NI":EB`FI,"L@%9/?/J.E'FE+AIF8,A&N_G:M,4%DNJM5&/OK\3N="=5
MYWM9VORAD0```9P*AA0```_X7#"H``K\`@``````65I02P,$%````%\`2J/!
M2E3P*2/$"0``R1D```<```!P<F]F:6QE_3=Z6%H```#_$ME!`@`A`0(```"\
M[YY\X!G("8E>`!&(!PA/3<G>V#P('SF^\W3.1N]J/".J]^]]U@ZBN<AH*C!`
MR1$KJV*_93RHS>`&LJSNNZ7/6,;7A:'$J$`EH:>8EW9Y\*`?V"\6A*4&2@O"
M1A:-<$A^/D?VS/-%701_H0U7M2@R4ONGK#RI51>7<^LN1@,?_"$_P3SQ*?)3
MLY.N+"=X\Y5RD'`^MS]RM[7_DX]C#">9:T$?=-#'%^28%;T!VHP<_T/MYSV6
MC/T`?+IWBMDAFAN5J->PD]-:NQ4IE1\=I*E&=.)]#`2JAD#!@HD4;/[;\$Z5
MR[EI\F<"$;C`SWM*1Q!\&:X/EYUU^1O!1EYP]3B$:\)8)VL)9-I:]'1Z.J</
M$H^N+@UX!(J[_/SP(1LJ?/$*R"5G\>-8JFWEH.CT0J&T-]!<(2-ZX3@)RN\J
MD0J4H/6N:=KFT$;\&+`]@#Q%F@SF+-%(65*C<K?8?5\U^M#E=M)1G;SV)&^#
MNC>B7!$HAZK&W*TS\4$TS&_-!XUFUI$7*A-;',>)+^5/P,ZD`[HWR.A9G^#C
M-6KTNK(S\@+HL$6:2FA5[-R2LQ[3WK4@G[G^^#%XET%6G82[QS;7(S,^%>P.
MYKA-5S)0G[)N+EKS^1K@1W;SU#4':SY-Q*(HA+6WR\"M,7!$$QQVKNVE\P[0
MBBWM8'\!):GY@^BZZ/>2OU-EQ9/907=8<Z!9`4MFZ3U">"CMA,Y1-O?0VM$[
M,QLUL^VK@(FD@-<=6)L`J(Q]$R2&TIS@=/S2CA0:)DA&H\H`$K>#+BZ#L5!&
M]8O1Y2#,@L6`*Z_D^1@3[G%I48$DK(:8@ZH;WXDD0/L?(I^Z'Y4Y+\D8XG`(
MSAG!!38.H:+L%5M[]Y^`-CTFJ#CX<7/IC$#M`L)E=Z68`.Z15.!\)150B=YZ
M<&XZF>5(BYL_(:&P;,V^D';WU2KR?A0+4-E:0%O1F9`\";RR09,+G:>77.C7
M]KV`K:4D9*B)Q7-\>:1&]N#JUDJ(<;NGJG2;_\!+&29%3S'E+/YN\/.CP_`+
M2C&6BOI"R]9V%EB^`F/J&*.2?`KS5D\7+CM*1],_W<7&0.MI\<*%EQY7Q@SQ
M]J35[E'P\:C"YF9--<<]IB4/#I9@9S3^CAVB3]UU"M=C#6^!]'`R!N<"BA3D
MN!$ISF;-DTGCY>18H,[#4UN),"U;=7J/F]7_C]<O]5R`K28E[0F*>K`/LRZ>
ML--U<[]+X!IV+&GCQ]@_E!=D2Y1SD_+@R,2:B,26E+GCGX,S56]3OA<@OBVL
MP`N1,^ZJXI1U"XKCE:I(CGLU!K\^_VU7+TJ2/;81PC?GHW(SPC^[!L2+DA`2
MY\B!@>P$N?<D]:T,Z)A[7-/MIQ1JBUD;K_]PB8>Z%:.G%!3DJDM;N*"DN*/0
M.&`?D?G/MZ-/H^LA*3<3>4'L">#EY&"!H9TB4M/1;]:<*%/-*%*ZZ2,FF"T`
M1-VLY<VH$W76[Q(`1P,4DDU"S\-I!#2(AA@-X@^_L"KL&[M33N&`;J-X`J\5
MX?[HHMI1Y<E.XR`(:_,&MIIK?[<`@.92!S"=O79P_S],\4.Y]!H1MU]2>D+N
M@QH1*4'INB@E6X<9,1=\T'`K<_PIF!F*CV&59B&:2$-.E\%OM2!\T"\X#?W)
M_\E.2DS4TN&FVR:GZQ#7+A4-!3L*KI`(NX#-0JA_OH3'J@OJ/G'C\>/BB@8\
MO9AR=;IRPX06AZX1'^R/RE>AE,'6#4](`V?FM0=BN]-3P7I*Y1N1VF>PL"IJ
MGF]0@PM>JH[PYGC*F^0"*N9OI-E(9C^LSD&NHWHEQ=_$X4]3I1L][E,)<J@6
M5]NI3VG%<\N<2#P[%02Y!OHRBB,L7/:@64Z"A]%5&[./@&=#.G@J;P9.N0_2
M6D==8ED)-C14(-%]Q+J9?SRI`"S01!VKK!Z;LF_&&-"YRBQ!_U[I,0',FCAY
M[1*J;":(1#V5`O:M>5C%OKU.]ZXIDSD]%)$8-'2>$@08,C&F")$0X!^:[H:2
M77[$CGQ]J0)I&=%/9U>ZZ!2Y93+,3^<38JQEC-]%YBW9?`S,U]*_N)5*MF1;
M6\2$>DXDY!G'+D3!)U47?ELRTEI9>)&;2]..PL(AM-=O/69L[N:Y:FYU$4OV
M^,N@H"C'ZH#0&TGK?'HWAY=!0Y!^[6!S_P:>A)^@YZ;N82NGABF]X@0;_,-?
M>;?A^0=`'34QXH8VW08:$;&O]ML<VNJ9Q47!GI)^+RX,T."9_"Z)J!-)MS<C
MD6;<."3*RZJI(V>ZDV-KC!/$@J-K$9[N0&GOS+2GI;?LN)L!M0MJD)X0D:^^
M)C-S@Y6IMQ)#AE,[..:E&_PK.Y=^1&=;H[0VN#H>-LQAW3+GYKV6I=X6B3=8
M.@Q5EULK;>80C>Q2*R&+D7DQ0E3,-2X+C]$9NN9R62RYTV[PC,4H>F[\5?A#
ML..XN!<+<NA[EF^-.*;3H5I\`B]HS(!-W=/#"$JF+\O,1'N;&F`1\5E\TZ?)
M9:F)!<(?>40H+7WGS&4<3H)3#?4%;XFXM&K'OQ*Z'L*"N<<IS07M\G?%U2W$
M?8S<#I)AB851@=^772M_X4IH:`C8/\8&L9Z7018'AAE0$[K1F6Y\C^2<&4IQ
M7>J@/Y%[H1GLJ4SH:YM^-V'+5CKLSP:+]J--=`-B,9Z+53^H2Q]->KE@3ZYY
M\OZ`-KB^'V-<@\MC.J++G-TJ>RS-M>)-3OU&NT5CLUM2@\\A+I;`GDR'T11U
MAW1H\ZECZZD*=!@DMO3,60<UI6SB2@!8'95NX14S<)A])Z`.MOU'3'_]#QNO
M(>R-<SR`[BR*@SZ=C3';<(`R#8WL'KSGQY$!I]-)OQL\-Z@06A_F7OCXKD5:
M<MDXBV4G@R`FZ\Y/FVOVHZM;/A#<VC1AHH5(8H(W6U>`\W7_X6C,8FB3C-2V
M(@S*@2LK1T%!';G7&%\&D>=1/;=64G$92-FPMB(<+37:DLED52:_VFEY47*O
M3ZKVJ;/.\O<_2Z?IB'U9W2:6S6_,X$F=(#VZO.@V-4CY<68\B@A`UKG0$AR1
MC3-VV!4W/,85QD39F&!67\SGM$KS:=TRN]$V"EC=+O7\PN8.A__Z)$@0>8,]
M!NHPA*?U=-A#U>OEK!#NG,RB2Y@@`5JNHJR0;9A'3FP'V/.UYMG+D*L*">.%
MKY&BW>NHE92\QT;V$D8_X^)[*WA-4GBAS.]:Q0"SGL>J*KNDX)76,LF["/13
M[SM72F%\\//WRT1^2GJA553G>V*&$Z9ZK.*:"0K;06@IC_N`Z$&Z<O$;4=9;
M)F$MK2SKZUO<>4?!2=`CN071_Z=#```````!G1/),P``5\:%:*@`"OP"````
M``!96E!+`0(4`!0```!?`$JCP4K)N%'WP`0``,4(```+`"0```````$`(```
M``````!B87-H+F)A<VAR8PH`(````````0`8`(#_S/$,V](!H&U5$).6U`$0
M=OM:DZ'3`5!+`0(4`!0```!?`$DZ/4N(?PNR0`4```8*```+`"0```````$`
M(````.D$``!P86-M86XN8V]N9@H`(````````0`8``#QLKWJ.-,!T%`4$9.6
MU`'0*<"<\7?4`5!+`0(4`!0```!?`$JCP4I4\"DCQ`D``,D9```'`"0`````
M``$`(````%(*``!P<F]F:6QE"@`@```````!`!@`@/_,\0S;T@&0.\4/DY;4
?`?#K!%N3H=,!4$L%!@`````#``,`$P$``#L4````````
`
end

6
contrib/libarchive/test_utils/test_main.c
View File

@ -2590,10 +2590,8 @@ sunacl_get(int cmd, int *aclcnt, int fd, const char *path)
cnt = facl(fd, cmd, cnt, aclp);
}
} else {
if (aclp != NULL) {
free(aclp);
aclp = NULL;
}
free(aclp);
aclp = NULL;
break;
}
}

1
lib/libarchive/Makefile
View File

@ -67,6 +67,7 @@ SRCS= archive_acl.c \
archive_pack_dev.c \
archive_pathmatch.c \
archive_ppmd7.c \
archive_ppmd8.c \
archive_random.c \
archive_rb.c \
archive_read.c \

8
lib/libarchive/tests/Makefile
View File

@ -358,7 +358,6 @@ FILES+= test_compat_lzop_2.tar.lzo.uu
FILES+= test_compat_lzop_3.tar.lzo.uu
FILES+= test_compat_mac-1.tar.Z.uu
FILES+= test_compat_mac-2.tar.Z.uu
FILES+= test_compat_pax_libarchive_2x.tar.Z.uu
FILES+= test_compat_perl_archive_tar.tar.uu
FILES+= test_compat_plexus_archiver_tar.tar.uu
FILES+= test_compat_solaris_pax_sparse_1.pax.Z.uu
@ -542,6 +541,8 @@ FILES+= test_read_format_ustar_filename_eucjp.tar.Z.uu
FILES+= test_read_format_ustar_filename_koi8r.tar.Z.uu
FILES+= test_read_format_warc.warc.uu
FILES+= test_read_format_zip.zip.uu
FILES+= test_read_format_zip_bzip2.zipx.uu
FILES+= test_read_format_zip_bzip2_multi.zipx.uu
FILES+= test_read_format_zip_comment_stored_1.zip.uu
FILES+= test_read_format_zip_comment_stored_2.zip.uu
FILES+= test_read_format_zip_encryption_data.zip.uu
@ -556,6 +557,8 @@ FILES+= test_read_format_zip_filename_utf8_ru2.zip.uu
FILES+= test_read_format_zip_high_compression.zip.uu
FILES+= test_read_format_zip_jar.jar.uu
FILES+= test_read_format_zip_length_at_end.zip.uu
FILES+= test_read_format_zip_lzma.zipx.uu
FILES+= test_read_format_zip_lzma_multi.zipx.uu
FILES+= test_read_format_zip_mac_metadata.zip.uu
FILES+= test_read_format_zip_malformed1.zip.uu
FILES+= test_read_format_zip_msdos.zip.uu
@ -564,6 +567,8 @@ FILES+= test_read_format_zip_nofiletype.zip.uu
FILES+= test_read_format_zip_padded1.zip.uu
FILES+= test_read_format_zip_padded2.zip.uu
FILES+= test_read_format_zip_padded3.zip.uu
FILES+= test_read_format_zip_ppmd8.zipx.uu
FILES+= test_read_format_zip_ppmd8_multi.zipx.uu
FILES+= test_read_format_zip_sfx.uu
FILES+= test_read_format_zip_symlink.zip.uu
FILES+= test_read_format_zip_traditional_encryption_data.zip.uu
@ -573,6 +578,7 @@ FILES+= test_read_format_zip_winzip_aes128.zip.uu
FILES+= test_read_format_zip_winzip_aes256.zip.uu
FILES+= test_read_format_zip_winzip_aes256_large.zip.uu
FILES+= test_read_format_zip_winzip_aes256_stored.zip.uu
FILES+= test_read_format_zip_xz_multi.zipx.uu
FILES+= test_read_format_zip_zip64a.zip.uu
FILES+= test_read_format_zip_zip64b.zip.uu
FILES+= test_read_large_splitted_rar_aa.uu