MFV 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 PR: 233006 [3] Security: CVE-2019-1000019 [1], CVE-2019-1000020 [2] MFC after: 2 weeks
This commit is contained in:
commit
a39fc08da2
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=344065
@ -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);
|
||||
|
@ -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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
* If there's a matching entry already in the list, overwrite it.
|
||||
|
@ -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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
if (archive_entry_acl_text_compat(&flags) == 0)
|
||||
entry->acl.acl_text = archive_acl_to_text_l(&entry->acl,
|
||||
|
@ -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
1287
contrib/libarchive/libarchive/archive_ppmd8.c
Normal file
File diff suppressed because it is too large
Load Diff
148
contrib/libarchive/libarchive/archive_ppmd8_private.h
Normal file
148
contrib/libarchive/libarchive/archive_ppmd8_private.h
Normal 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
|
@ -856,7 +856,11 @@ 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;
|
||||
archive_string_init(&delayed_str);
|
||||
|
||||
st = NULL;
|
||||
lst = NULL;
|
||||
@ -885,12 +889,24 @@ 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;
|
||||
}
|
||||
} while (lst == NULL);
|
||||
@ -1083,6 +1099,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);
|
||||
}
|
||||
|
||||
|
@ -174,7 +174,6 @@ 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);
|
||||
return (ARCHIVE_OK);
|
||||
|
@ -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,7 +3317,6 @@ 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]);
|
||||
zip->sub_stream_buff[i] = NULL;
|
||||
}
|
||||
|
@ -138,7 +138,6 @@ 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);
|
||||
(a->format->data) = NULL;
|
||||
@ -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. */
|
||||
|
@ -955,7 +955,6 @@ 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);
|
||||
cpio->links_head = lp;
|
||||
|
@ -1724,7 +1724,6 @@ 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);
|
||||
#ifdef HAVE_ZLIB_H
|
||||
free(iso9660->entry_zisofs.uncompressed_buffer);
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
@ -3029,7 +3037,6 @@ 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);
|
||||
heap->files = new_pending_files;
|
||||
heap->allocated = new_size;
|
||||
|
@ -588,7 +588,6 @@ 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);
|
||||
|
||||
rar->cstate.filtered_buf = malloc(flt->block_length);
|
||||
@ -772,7 +771,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);
|
||||
}
|
||||
|
||||
@ -873,7 +872,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.
|
||||
@ -1301,7 +1300,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) {
|
||||
@ -1795,8 +1794,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;
|
||||
@ -1836,12 +1841,13 @@ static int rar5_read_header(struct archive_read *a,
|
||||
|
||||
static void init_unpack(struct rar5* rar) {
|
||||
rar->file.calculated_crc32 = 0;
|
||||
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);
|
||||
|
||||
if(rar->cstate.filtered_buf)
|
||||
free(rar->cstate.filtered_buf);
|
||||
|
||||
rar->cstate.window_buf = calloc(1, rar->cstate.window_size);
|
||||
@ -2676,13 +2682,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. */
|
||||
@ -3394,13 +3408,10 @@ 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);
|
||||
|
||||
if(rar->cstate.filtered_buf)
|
||||
free(rar->cstate.filtered_buf);
|
||||
|
||||
if(rar->vol.push_buf)
|
||||
free(rar->vol.push_buf);
|
||||
|
||||
free_filters(rar);
|
||||
|
@ -1229,7 +1229,6 @@ 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);
|
||||
heap->files = new_pending_files;
|
||||
heap->allocated = new_size;
|
||||
|
@ -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:*/
|
||||
|
@ -1791,10 +1791,8 @@ _archive_write_disk_finish_entry(struct archive *_a)
|
||||
a->fd = -1;
|
||||
}
|
||||
/* If there's an entry, we can release it now. */
|
||||
if (a->entry) {
|
||||
archive_entry_free(a->entry);
|
||||
a->entry = NULL;
|
||||
}
|
||||
a->archive.state = ARCHIVE_STATE_HEADER;
|
||||
return (ret);
|
||||
}
|
||||
@ -2398,7 +2396,6 @@ _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_string_free(&a->_name_data);
|
||||
archive_string_free(&a->archive.error_string);
|
||||
|
@ -114,7 +114,6 @@ 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);
|
||||
b->name = strdup(gname);
|
||||
/* Note: If strdup fails, that's okay; we just won't cache. */
|
||||
@ -184,7 +183,6 @@ 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);
|
||||
b->name = strdup(uname);
|
||||
/* Note: If strdup fails, that's okay; we just won't cache. */
|
||||
|
@ -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);
|
||||
|
@ -408,7 +408,6 @@ write_header(struct archive_write *a, struct archive_entry *entry)
|
||||
}
|
||||
}
|
||||
exit_write_header:
|
||||
if (entry_main)
|
||||
archive_entry_free(entry_main);
|
||||
return (ret_final);
|
||||
}
|
||||
|
@ -366,7 +366,6 @@ write_header(struct archive_write *a, struct archive_entry *entry)
|
||||
}
|
||||
}
|
||||
exit_write_header:
|
||||
if (entry_main)
|
||||
archive_entry_free(entry_main);
|
||||
return (ret_final);
|
||||
}
|
||||
|
@ -565,7 +565,6 @@ 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);
|
||||
return (ret);
|
||||
}
|
||||
|
@ -169,7 +169,6 @@ 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);
|
||||
shar->entry = archive_entry_clone(entry);
|
||||
name = archive_entry_pathname(entry);
|
||||
@ -289,7 +288,6 @@ 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);
|
||||
|
||||
shar->last_dir = strdup(name);
|
||||
|
@ -352,13 +352,11 @@ 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);
|
||||
return (ret);
|
||||
}
|
||||
ret2 = __archive_write_output(a, buff, 512);
|
||||
if (ret2 < ARCHIVE_WARN) {
|
||||
if (entry_main)
|
||||
archive_entry_free(entry_main);
|
||||
return (ret2);
|
||||
}
|
||||
@ -367,7 +365,6 @@ 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);
|
||||
return (ret);
|
||||
}
|
||||
|
@ -330,13 +330,11 @@ 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);
|
||||
return (ret);
|
||||
}
|
||||
ret2 = __archive_write_output(a, buff, 512);
|
||||
if (ret2 < ARCHIVE_WARN) {
|
||||
if (entry_main)
|
||||
archive_entry_free(entry_main);
|
||||
return (ret2);
|
||||
}
|
||||
@ -345,7 +343,6 @@ 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);
|
||||
return (ret);
|
||||
}
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
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);
|
||||
|
@ -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
|
||||
}
|
@ -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
|
@ -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));
|
||||
}
|
||||
|
@ -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
|
@ -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
|
@ -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
|
@ -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*MZKA\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
|
@ -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
|
@ -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
|
@ -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
|
@ -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;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -66,6 +66,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 \
|
||||
|
@ -72,7 +72,6 @@ TESTS_SRCS= \
|
||||
test_compat_lzma.c \
|
||||
test_compat_lzop.c \
|
||||
test_compat_mac.c \
|
||||
test_compat_pax_libarchive_2x.c \
|
||||
test_compat_perl_archive_tar.c \
|
||||
test_compat_plexus_archiver_tar.c \
|
||||
test_compat_solaris_tar_acl.c \
|
||||
@ -296,8 +295,6 @@ TESTS_SRCS= \
|
||||
BROKEN_TESTS+= test_archive_rmd160
|
||||
# Fails with `libarchive/test/test_archive_crypto.c:121: md != actualmd`
|
||||
BROKEN_TESTS+= test_archive_sha384
|
||||
# Fails with `test_compat_pax_libarchive_2x.c:122: ARCHIVE_WARN != archive_read_next_header(a, &ae)`
|
||||
BROKEN_TESTS+= test_compat_pax_libarchive_2x
|
||||
# Fails with `test_read_disk_directory_traversals.c:1094: File at has atime 886622, 1443306049 seconds ago`
|
||||
BROKEN_TESTS+= test_read_disk_directory_traversals
|
||||
|
||||
@ -358,7 +355,6 @@ ${PACKAGE}FILES+= test_compat_lzop_2.tar.lzo.uu
|
||||
${PACKAGE}FILES+= test_compat_lzop_3.tar.lzo.uu
|
||||
${PACKAGE}FILES+= test_compat_mac-1.tar.Z.uu
|
||||
${PACKAGE}FILES+= test_compat_mac-2.tar.Z.uu
|
||||
${PACKAGE}FILES+= test_compat_pax_libarchive_2x.tar.Z.uu
|
||||
${PACKAGE}FILES+= test_compat_perl_archive_tar.tar.uu
|
||||
${PACKAGE}FILES+= test_compat_plexus_archiver_tar.tar.uu
|
||||
${PACKAGE}FILES+= test_compat_solaris_pax_sparse_1.pax.Z.uu
|
||||
@ -542,6 +538,8 @@ ${PACKAGE}FILES+= test_read_format_ustar_filename_eucjp.tar.Z.uu
|
||||
${PACKAGE}FILES+= test_read_format_ustar_filename_koi8r.tar.Z.uu
|
||||
${PACKAGE}FILES+= test_read_format_warc.warc.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_bzip2.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_bzip2_multi.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_comment_stored_1.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_comment_stored_2.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_encryption_data.zip.uu
|
||||
@ -556,6 +554,8 @@ ${PACKAGE}FILES+= test_read_format_zip_filename_utf8_ru2.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_high_compression.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_jar.jar.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_length_at_end.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_lzma.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_lzma_multi.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_mac_metadata.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_malformed1.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_msdos.zip.uu
|
||||
@ -564,6 +564,8 @@ ${PACKAGE}FILES+= test_read_format_zip_nofiletype.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_padded1.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_padded2.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_padded3.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_ppmd8.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_ppmd8_multi.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_sfx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_symlink.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_traditional_encryption_data.zip.uu
|
||||
@ -573,6 +575,7 @@ ${PACKAGE}FILES+= test_read_format_zip_winzip_aes128.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_winzip_aes256.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_winzip_aes256_large.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_winzip_aes256_stored.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_xz_multi.zipx.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_zip64a.zip.uu
|
||||
${PACKAGE}FILES+= test_read_format_zip_zip64b.zip.uu
|
||||
${PACKAGE}FILES+= test_read_large_splitted_rar_aa.uu
|
||||
|
Loading…
Reference in New Issue
Block a user