diff options
| author | Arttu Tarkiainen <arttu.tarkiainen@qt.io> | 2022-02-22 14:58:06 +0200 |
|---|---|---|
| committer | Arttu Tarkiainen <arttu.tarkiainen@qt.io> | 2022-03-24 09:48:09 +0200 |
| commit | 5c56e4d64d38514c2318b28224e4e896e776a100 (patch) | |
| tree | dab1c40df68593fc9248f1b6ac3cd7973c108d58 /src/libs | |
| parent | ac1637b8976d7d85ac42f308c4be6de97dcf86cb (diff) | |
Update libarchive sources to 3.6.0 release
Release details:
https://github.com/libarchive/libarchive/releases/tag/v3.6.0
Change-Id: Ia3d322ffbea70aad2713b7641832f6a56bb75645
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Iikka Eklund <iikka.eklund@qt.io>
Reviewed-by: Katja Marttila <katja.marttila@qt.io>
Diffstat (limited to 'src/libs')
49 files changed, 1880 insertions, 727 deletions
diff --git a/src/libs/3rdparty/libarchive/archive.h b/src/libs/3rdparty/libarchive/archive.h index ca83cbd09..633c5ac30 100644 --- a/src/libs/3rdparty/libarchive/archive.h +++ b/src/libs/3rdparty/libarchive/archive.h @@ -36,7 +36,7 @@ * assert that ARCHIVE_VERSION_NUMBER >= 2012108. */ /* Note: Compiler will complain if this does not match archive_entry.h! */ -#define ARCHIVE_VERSION_NUMBER 3005002 +#define ARCHIVE_VERSION_NUMBER 3006000 #include <sys/stat.h> #include <stddef.h> /* for wchar_t */ @@ -97,7 +97,7 @@ typedef ssize_t la_ssize_t; #endif /* Large file support for Android */ -#ifdef __ANDROID__ +#if defined(__LIBARCHIVE_BUILD) && defined(__ANDROID__) #include "android_lf.h" #endif @@ -155,7 +155,7 @@ __LA_DECL int archive_version_number(void); /* * Textual name/version of the library, useful for version displays. */ -#define ARCHIVE_VERSION_ONLY_STRING "3.5.2" +#define ARCHIVE_VERSION_ONLY_STRING "3.6.0" #define ARCHIVE_VERSION_STRING "libarchive " ARCHIVE_VERSION_ONLY_STRING __LA_DECL const char * archive_version_string(void); @@ -1024,6 +1024,8 @@ __LA_DECL int archive_read_disk_set_atime_restored(struct archive *); #define ARCHIVE_READDISK_NO_ACL (0x0020) /* Default: File flags are read from disk. */ #define ARCHIVE_READDISK_NO_FFLAGS (0x0040) +/* Default: Sparse file information is read from disk. */ +#define ARCHIVE_READDISK_NO_SPARSE (0x0080) __LA_DECL int archive_read_disk_set_behavior(struct archive *, int flags); diff --git a/src/libs/3rdparty/libarchive/archive_blake2.h b/src/libs/3rdparty/libarchive/archive_blake2.h index dd6fe6fe5..8f6b5e922 100644 --- a/src/libs/3rdparty/libarchive/archive_blake2.h +++ b/src/libs/3rdparty/libarchive/archive_blake2.h @@ -21,8 +21,10 @@ #if defined(_MSC_VER) #define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop)) -#else +#elif defined(__GNUC__) #define BLAKE2_PACKED(x) x __attribute__((packed)) +#else +#define BLAKE2_PACKED(x) _Pragma("pack 1") x _Pragma("pack 0") #endif #if defined(__cplusplus) diff --git a/src/libs/3rdparty/libarchive/archive_blake2_impl.h b/src/libs/3rdparty/libarchive/archive_blake2_impl.h index 0f05defea..eb8619ca7 100644 --- a/src/libs/3rdparty/libarchive/archive_blake2_impl.h +++ b/src/libs/3rdparty/libarchive/archive_blake2_impl.h @@ -154,7 +154,7 @@ static BLAKE2_INLINE uint64_t rotr64( const uint64_t w, const unsigned c ) /* prevents compiler optimizing out memset() */ static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n) { - static void *(*const volatile memset_v)(void *, int, size_t) = &memset; + static void *(__LA_LIBC_CC *const volatile memset_v)(void *, int, size_t) = &memset; memset_v(v, 0, n); } diff --git a/src/libs/3rdparty/libarchive/archive_blake2s_ref.c b/src/libs/3rdparty/libarchive/archive_blake2s_ref.c index d92ffd0fc..b21a02ba6 100644 --- a/src/libs/3rdparty/libarchive/archive_blake2s_ref.c +++ b/src/libs/3rdparty/libarchive/archive_blake2s_ref.c @@ -17,6 +17,7 @@ #include <string.h> #include <stdio.h> +#include "archive_platform.h" #include "archive_blake2.h" #include "archive_blake2_impl.h" diff --git a/src/libs/3rdparty/libarchive/archive_blake2sp_ref.c b/src/libs/3rdparty/libarchive/archive_blake2sp_ref.c index aef101084..f412c8e2a 100644 --- a/src/libs/3rdparty/libarchive/archive_blake2sp_ref.c +++ b/src/libs/3rdparty/libarchive/archive_blake2sp_ref.c @@ -21,6 +21,7 @@ #include <omp.h> #endif +#include "archive_platform.h" #include "archive_blake2.h" #include "archive_blake2_impl.h" diff --git a/src/libs/3rdparty/libarchive/archive_cryptor.c b/src/libs/3rdparty/libarchive/archive_cryptor.c index d4bca906b..112baf161 100644 --- a/src/libs/3rdparty/libarchive/archive_cryptor.c +++ b/src/libs/3rdparty/libarchive/archive_cryptor.c @@ -401,14 +401,6 @@ aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) memcpy(ctx->key, key, key_len); memset(ctx->nonce, 0, sizeof(ctx->nonce)); ctx->encr_pos = AES_BLOCK_SIZE; -#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER) - if (!EVP_CIPHER_CTX_reset(ctx->ctx)) { - EVP_CIPHER_CTX_free(ctx->ctx); - ctx->ctx = NULL; - } -#else - EVP_CIPHER_CTX_init(ctx->ctx); -#endif return 0; } diff --git a/src/libs/3rdparty/libarchive/archive_entry.h b/src/libs/3rdparty/libarchive/archive_entry.h index bfba54f71..afcb8503b 100644 --- a/src/libs/3rdparty/libarchive/archive_entry.h +++ b/src/libs/3rdparty/libarchive/archive_entry.h @@ -30,7 +30,7 @@ #define ARCHIVE_ENTRY_H_INCLUDED /* Note: Compiler will complain if this does not match archive.h! */ -#define ARCHIVE_VERSION_NUMBER 3005002 +#define ARCHIVE_VERSION_NUMBER 3006000 /* * Note: archive_entry.h is for use outside of libarchive; the @@ -99,7 +99,7 @@ typedef ssize_t la_ssize_t; #endif /* Large file support for Android */ -#ifdef __ANDROID__ +#if defined(__LIBARCHIVE_BUILD) && defined(__ANDROID__) #include "android_lf.h" #endif diff --git a/src/libs/3rdparty/libarchive/archive_getdate.c b/src/libs/3rdparty/libarchive/archive_getdate.c index 3ec5bba88..39e224cb9 100644 --- a/src/libs/3rdparty/libarchive/archive_getdate.c +++ b/src/libs/3rdparty/libarchive/archive_getdate.c @@ -714,7 +714,7 @@ Convert(time_t Month, time_t Day, time_t Year, ? 29 : 28; /* Checking for 2038 bogusly assumes that time_t is 32 bits. But I'm too lazy to try to check for time_t overflow in another way. */ - if (Year < EPOCH || Year > 2038 + if (Year < EPOCH || Year >= 2038 || Month < 1 || Month > 12 /* Lint fluff: "conversion from long may lose accuracy" */ || Day < 1 || Day > DaysInMonth[(int)--Month] diff --git a/src/libs/3rdparty/libarchive/archive_pack_dev.c b/src/libs/3rdparty/libarchive/archive_pack_dev.c index f8286d821..d95444d97 100644 --- a/src/libs/3rdparty/libarchive/archive_pack_dev.c +++ b/src/libs/3rdparty/libarchive/archive_pack_dev.c @@ -77,7 +77,7 @@ static pack_t pack_12_20; static pack_t pack_14_18; static pack_t pack_8_24; static pack_t pack_bsdos; -static int compare_format(const void *, const void *); +static int __LA_LIBC_CC compare_format(const void *, const void *); static const char iMajorError[] = "invalid major number"; static const char iMinorError[] = "invalid minor number"; @@ -310,6 +310,7 @@ static const struct format { }; static int +__LA_LIBC_CC compare_format(const void *key, const void *element) { const char *name; diff --git a/src/libs/3rdparty/libarchive/archive_platform.h b/src/libs/3rdparty/libarchive/archive_platform.h index b8bcb52bc..3426975de 100644 --- a/src/libs/3rdparty/libarchive/archive_platform.h +++ b/src/libs/3rdparty/libarchive/archive_platform.h @@ -69,8 +69,16 @@ * either Windows or Posix APIs. */ #if (defined(__WIN32__) || defined(_WIN32) || defined(__WIN32)) && !defined(__CYGWIN__) #include "archive_windows.h" +/* The C library on Windows specifies a calling convention for callback + * functions and exports; when we interact with them (capture pointers, + * call and pass function pointers) we need to match their calling + * convention. + * This only matters when libarchive is built with /Gr, /Gz or /Gv + * (which change the default calling convention.) */ +#define __LA_LIBC_CC __cdecl #else #define la_stat(path,stref) stat(path,stref) +#define __LA_LIBC_CC #endif /* @@ -155,6 +163,28 @@ #define INTMAX_MIN ((intmax_t)(~INTMAX_MAX)) #endif +/* Some platforms lack the standard PRIxN/PRIdN definitions. */ +#if !HAVE_INTTYPES_H || !defined(PRIx32) || !defined(PRId32) +#ifndef PRIx32 +#if SIZEOF_INT == 4 +#define PRIx32 "x" +#elif SIZEOF_LONG == 4 +#define PRIx32 "lx" +#else +#error No suitable 32-bit unsigned integer type found for this platform +#endif +#endif // PRIx32 +#ifndef PRId32 +#if SIZEOF_INT == 4 +#define PRId32 "d" +#elif SIZEOF_LONG == 4 +#define PRId32 "ld" +#else +#error No suitable 32-bit signed integer type found for this platform +#endif +#endif // PRId32 +#endif // !HAVE_INTTYPES_H || !defined(PRIx32) || !defined(PRId32) + /* * If we can't restore metadata using a file descriptor, then * for compatibility's sake, close files before trying to restore metadata. diff --git a/src/libs/3rdparty/libarchive/archive_private.h b/src/libs/3rdparty/libarchive/archive_private.h index 55a8da18e..b2a2cda25 100644 --- a/src/libs/3rdparty/libarchive/archive_private.h +++ b/src/libs/3rdparty/libarchive/archive_private.h @@ -107,14 +107,11 @@ struct archive { * Some public API functions depend on the "real" type of the * archive object. */ - struct archive_vtable *vtable; + const struct archive_vtable *vtable; int archive_format; const char *archive_format_name; - int compression_code; /* Currently active compression. */ - const char *compression_name; - /* Number of file entries processed. */ int file_count; diff --git a/src/libs/3rdparty/libarchive/archive_read.c b/src/libs/3rdparty/libarchive/archive_read.c index c59f05153..45a38aed0 100644 --- a/src/libs/3rdparty/libarchive/archive_read.c +++ b/src/libs/3rdparty/libarchive/archive_read.c @@ -58,7 +58,6 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read.c 201157 2009-12-29 05:30:2 static int choose_filters(struct archive_read *); static int choose_format(struct archive_read *); static int close_filters(struct archive_read *); -static struct archive_vtable *archive_read_vtable(void); static int64_t _archive_filter_bytes(struct archive *, int); static int _archive_filter_code(struct archive *, int); static const char *_archive_filter_name(struct archive *, int); @@ -73,26 +72,18 @@ static int _archive_read_next_header2(struct archive *, struct archive_entry *); static int64_t advance_file_pointer(struct archive_read_filter *, int64_t); -static struct archive_vtable * -archive_read_vtable(void) -{ - static struct archive_vtable av; - static int inited = 0; - - if (!inited) { - av.archive_filter_bytes = _archive_filter_bytes; - av.archive_filter_code = _archive_filter_code; - av.archive_filter_name = _archive_filter_name; - av.archive_filter_count = _archive_filter_count; - av.archive_read_data_block = _archive_read_data_block; - av.archive_read_next_header = _archive_read_next_header; - av.archive_read_next_header2 = _archive_read_next_header2; - av.archive_free = _archive_read_free; - av.archive_close = _archive_read_close; - inited = 1; - } - return (&av); -} +static const struct archive_vtable +archive_read_vtable = { + .archive_filter_bytes = _archive_filter_bytes, + .archive_filter_code = _archive_filter_code, + .archive_filter_name = _archive_filter_name, + .archive_filter_count = _archive_filter_count, + .archive_read_data_block = _archive_read_data_block, + .archive_read_next_header = _archive_read_next_header, + .archive_read_next_header2 = _archive_read_next_header2, + .archive_free = _archive_read_free, + .archive_close = _archive_read_close, +}; /* * Allocate, initialize and return a struct archive object. @@ -109,7 +100,7 @@ archive_read_new(void) a->archive.state = ARCHIVE_STATE_NEW; a->entry = archive_entry_new2(&a->archive); - a->archive.vtable = archive_read_vtable(); + a->archive.vtable = &archive_read_vtable; a->passphrases.last = &a->passphrases.first; @@ -245,18 +236,17 @@ client_seek_proxy(struct archive_read_filter *self, int64_t offset, int whence) } static int -client_close_proxy(struct archive_read_filter *self) +read_client_close_proxy(struct archive_read *a) { int r = ARCHIVE_OK, r2; unsigned int i; - if (self->archive->client.closer == NULL) + if (a->client.closer == NULL) return (r); - for (i = 0; i < self->archive->client.nodes; i++) + for (i = 0; i < a->client.nodes; i++) { - r2 = (self->archive->client.closer) - ((struct archive *)self->archive, - self->archive->client.dataset[i].data); + r2 = (a->client.closer) + ((struct archive *)a, a->client.dataset[i].data); if (r > r2) r = r2; } @@ -264,6 +254,12 @@ client_close_proxy(struct archive_read_filter *self) } static int +client_close_proxy(struct archive_read_filter *self) +{ + return read_client_close_proxy(self->archive); +} + +static int client_open_proxy(struct archive_read_filter *self) { int r = ARCHIVE_OK; @@ -298,9 +294,7 @@ client_switch_proxy(struct archive_read_filter *self, unsigned int iindex) r1 = (self->archive->client.closer) ((struct archive *)self->archive, self->data); self->data = data2; - if (self->archive->client.opener != NULL) - r2 = (self->archive->client.opener) - ((struct archive *)self->archive, self->data); + r2 = client_open_proxy(self); } return (r1 < r2) ? r1 : r2; } @@ -457,13 +451,18 @@ archive_read_prepend_callback_data(struct archive *_a, void *client_data) return archive_read_add_callback_data(_a, client_data, 0); } +static const struct archive_read_filter_vtable +none_reader_vtable = { + .read = client_read_proxy, + .close = client_close_proxy, +}; + int archive_read_open1(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; struct archive_read_filter *filter, *tmp; int slot, e = ARCHIVE_OK; - unsigned int i; archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, "archive_read_open"); @@ -481,11 +480,7 @@ archive_read_open1(struct archive *_a) e = (a->client.opener)(&a->archive, a->client.dataset[0].data); if (e != 0) { /* If the open failed, call the closer to clean up. */ - if (a->client.closer) { - for (i = 0; i < a->client.nodes; i++) - (a->client.closer)(&a->archive, - a->client.dataset[i].data); - } + read_client_close_proxy(a); return (e); } } @@ -497,14 +492,11 @@ archive_read_open1(struct archive *_a) filter->upstream = NULL; filter->archive = a; filter->data = a->client.dataset[0].data; - filter->open = client_open_proxy; - filter->read = client_read_proxy; - filter->skip = client_skip_proxy; - filter->seek = client_seek_proxy; - filter->close = client_close_proxy; - filter->sswitch = client_switch_proxy; + filter->vtable = &none_reader_vtable; filter->name = "none"; filter->code = ARCHIVE_FILTER_NONE; + filter->can_skip = 1; + filter->can_seek = 1; a->client.dataset[0].begin_position = 0; if (!a->filter || !a->bypass_filter_bidding) @@ -570,12 +562,12 @@ choose_filters(struct archive_read *a) bidder = a->bidders; for (i = 0; i < number_bidders; i++, bidder++) { - if (bidder->bid != NULL) { - bid = (bidder->bid)(bidder, a->filter); - if (bid > best_bid) { - best_bid = bid; - best_bidder = bidder; - } + if (bidder->vtable == NULL) + continue; + bid = (bidder->vtable->bid)(bidder, a->filter); + if (bid > best_bid) { + best_bid = bid; + best_bidder = bidder; } } @@ -587,8 +579,6 @@ choose_filters(struct archive_read *a) __archive_read_free_filters(a); return (ARCHIVE_FATAL); } - a->archive.compression_name = a->filter->name; - a->archive.compression_code = a->filter->code; return (ARCHIVE_OK); } @@ -600,7 +590,7 @@ choose_filters(struct archive_read *a) filter->archive = a; filter->upstream = a->filter; a->filter = filter; - r = (best_bidder->init)(a->filter); + r = (best_bidder->vtable->init)(a->filter); if (r != ARCHIVE_OK) { __archive_read_free_filters(a); return (ARCHIVE_FATAL); @@ -614,10 +604,9 @@ choose_filters(struct archive_read *a) int __archive_read_header(struct archive_read *a, struct archive_entry *entry) { - if (a->filter->read_header) - return a->filter->read_header(a->filter, entry); - else + if (!a->filter->vtable->read_header) return (ARCHIVE_OK); + return a->filter->vtable->read_header(a->filter, entry); } /* @@ -1006,8 +995,8 @@ close_filters(struct archive_read *a) /* Close each filter in the pipeline. */ while (f != NULL) { struct archive_read_filter *t = f->upstream; - if (!f->closed && f->close != NULL) { - int r1 = (f->close)(f); + if (!f->closed && f->vtable != NULL) { + int r1 = (f->vtable->close)(f); f->closed = 1; if (r1 < r) r = r1; @@ -1112,11 +1101,10 @@ _archive_read_free(struct archive *_a) /* Release the bidder objects. */ n = sizeof(a->bidders)/sizeof(a->bidders[0]); for (i = 0; i < n; i++) { - if (a->bidders[i].free != NULL) { - int r1 = (a->bidders[i].free)(&a->bidders[i]); - if (r1 < r) - r = r1; - } + if (a->bidders[i].vtable == NULL || + a->bidders[i].vtable->free == NULL) + continue; + (a->bidders[i].vtable->free)(&a->bidders[i]); } /* Release passphrase list. */ @@ -1241,19 +1229,35 @@ __archive_read_register_format(struct archive_read *a, * initialization functions. */ int -__archive_read_get_bidder(struct archive_read *a, - struct archive_read_filter_bidder **bidder) +__archive_read_register_bidder(struct archive_read *a, + void *bidder_data, + const char *name, + const struct archive_read_filter_bidder_vtable *vtable) { + struct archive_read_filter_bidder *bidder; int i, number_slots; + archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC, + ARCHIVE_STATE_NEW, "__archive_read_register_bidder"); + number_slots = sizeof(a->bidders) / sizeof(a->bidders[0]); for (i = 0; i < number_slots; i++) { - if (a->bidders[i].bid == NULL) { - memset(a->bidders + i, 0, sizeof(a->bidders[0])); - *bidder = (a->bidders + i); - return (ARCHIVE_OK); + if (a->bidders[i].vtable != NULL) + continue; + memset(a->bidders + i, 0, sizeof(a->bidders[0])); + bidder = (a->bidders + i); + bidder->data = bidder_data; + bidder->name = name; + bidder->vtable = vtable; + if (bidder->vtable->bid == NULL || bidder->vtable->init == NULL) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, + "Internal error: " + "no bid/init for filter bidder"); + return (ARCHIVE_FATAL); } + + return (ARCHIVE_OK); } archive_set_error(&a->archive, ENOMEM, @@ -1382,7 +1386,7 @@ __archive_read_filter_ahead(struct archive_read_filter *filter, *avail = 0; return (NULL); } - bytes_read = (filter->read)(filter, + bytes_read = (filter->vtable->read)(filter, &filter->client_buff); if (bytes_read < 0) { /* Read error. */ filter->client_total = filter->client_avail = 0; @@ -1561,8 +1565,8 @@ advance_file_pointer(struct archive_read_filter *filter, int64_t request) return (total_bytes_skipped); /* If there's an optimized skip function, use it. */ - if (filter->skip != NULL) { - bytes_skipped = (filter->skip)(filter, request); + if (filter->can_skip != 0) { + bytes_skipped = client_skip_proxy(filter, request); if (bytes_skipped < 0) { /* error */ filter->fatal = 1; return (bytes_skipped); @@ -1576,7 +1580,7 @@ advance_file_pointer(struct archive_read_filter *filter, int64_t request) /* Use ordinary reads as necessary to complete the request. */ for (;;) { - bytes_read = (filter->read)(filter, &filter->client_buff); + bytes_read = (filter->vtable->read)(filter, &filter->client_buff); if (bytes_read < 0) { filter->client_buff = NULL; filter->fatal = 1; @@ -1631,7 +1635,7 @@ __archive_read_filter_seek(struct archive_read_filter *filter, int64_t offset, if (filter->closed || filter->fatal) return (ARCHIVE_FATAL); - if (filter->seek == NULL) + if (filter->can_seek == 0) return (ARCHIVE_FAILED); client = &(filter->archive->client); diff --git a/src/libs/3rdparty/libarchive/archive_read_append_filter.c b/src/libs/3rdparty/libarchive/archive_read_append_filter.c index da7c55b9b..25dc4b2a2 100644 --- a/src/libs/3rdparty/libarchive/archive_read_append_filter.c +++ b/src/libs/3rdparty/libarchive/archive_read_append_filter.c @@ -135,7 +135,7 @@ archive_read_append_filter(struct archive *_a, int code) filter->archive = a; filter->upstream = a->filter; a->filter = filter; - r2 = (bidder->init)(a->filter); + r2 = (bidder->vtable->init)(a->filter); if (r2 != ARCHIVE_OK) { __archive_read_free_filters(a); return (ARCHIVE_FATAL); @@ -192,7 +192,7 @@ archive_read_append_filter_program_signature(struct archive *_a, filter->archive = a; filter->upstream = a->filter; a->filter = filter; - r = (bidder->init)(a->filter); + r = (bidder->vtable->init)(a->filter); if (r != ARCHIVE_OK) { __archive_read_free_filters(a); return (ARCHIVE_FATAL); diff --git a/src/libs/3rdparty/libarchive/archive_read_disk_entry_from_file.c b/src/libs/3rdparty/libarchive/archive_read_disk_entry_from_file.c index 9c9cf38ee..ab0270bc2 100644 --- a/src/libs/3rdparty/libarchive/archive_read_disk_entry_from_file.c +++ b/src/libs/3rdparty/libarchive/archive_read_disk_entry_from_file.c @@ -303,9 +303,11 @@ archive_read_disk_entry_from_file(struct archive *_a, if (r1 < r) r = r1; } - r1 = setup_sparse(a, entry, &fd); - if (r1 < r) - r = r1; + if ((a->flags & ARCHIVE_READDISK_NO_SPARSE) == 0) { + r1 = setup_sparse(a, entry, &fd); + if (r1 < r) + r = r1; + } /* If we opened the file earlier in this function, close it. */ if (initial_fd != fd) diff --git a/src/libs/3rdparty/libarchive/archive_read_disk_posix.c b/src/libs/3rdparty/libarchive/archive_read_disk_posix.c index 3ee6269ff..d0e1f35c8 100644 --- a/src/libs/3rdparty/libarchive/archive_read_disk_posix.c +++ b/src/libs/3rdparty/libarchive/archive_read_disk_posix.c @@ -369,22 +369,14 @@ static int open_on_current_dir(struct tree *, const char *, int); static int tree_dup(int); -static struct archive_vtable * -archive_read_disk_vtable(void) -{ - static struct archive_vtable av; - static int inited = 0; - - if (!inited) { - av.archive_free = _archive_read_free; - av.archive_close = _archive_read_close; - av.archive_read_data_block = _archive_read_data_block; - av.archive_read_next_header = _archive_read_next_header; - av.archive_read_next_header2 = _archive_read_next_header2; - inited = 1; - } - return (&av); -} +static const struct archive_vtable +archive_read_disk_vtable = { + .archive_free = _archive_read_free, + .archive_close = _archive_read_close, + .archive_read_data_block = _archive_read_data_block, + .archive_read_next_header = _archive_read_next_header, + .archive_read_next_header2 = _archive_read_next_header2, +}; const char * archive_read_disk_gname(struct archive *_a, la_int64_t gid) @@ -461,7 +453,7 @@ archive_read_disk_new(void) return (NULL); a->archive.magic = ARCHIVE_READ_DISK_MAGIC; a->archive.state = ARCHIVE_STATE_NEW; - a->archive.vtable = archive_read_disk_vtable(); + a->archive.vtable = &archive_read_disk_vtable; a->entry = archive_entry_new2(&a->archive); a->lookup_uname = trivial_lookup_uname; a->lookup_gname = trivial_lookup_gname; @@ -1290,7 +1282,7 @@ archive_read_disk_descend(struct archive *_a) ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, "archive_read_disk_descend"); - if (t->visit_type != TREE_REGULAR || !t->descend) + if (!archive_read_disk_can_descend(_a)) return (ARCHIVE_OK); /* diff --git a/src/libs/3rdparty/libarchive/archive_read_disk_windows.c b/src/libs/3rdparty/libarchive/archive_read_disk_windows.c index 877bc449a..ea32e2aac 100644 --- a/src/libs/3rdparty/libarchive/archive_read_disk_windows.c +++ b/src/libs/3rdparty/libarchive/archive_read_disk_windows.c @@ -449,22 +449,14 @@ entry_symlink_from_pathw(struct archive_entry *entry, const wchar_t *path) return; } -static struct archive_vtable * -archive_read_disk_vtable(void) -{ - static struct archive_vtable av; - static int inited = 0; - - if (!inited) { - av.archive_free = _archive_read_free; - av.archive_close = _archive_read_close; - av.archive_read_data_block = _archive_read_data_block; - av.archive_read_next_header = _archive_read_next_header; - av.archive_read_next_header2 = _archive_read_next_header2; - inited = 1; - } - return (&av); -} +static const struct archive_vtable +archive_read_disk_vtable = { + .archive_free = _archive_read_free, + .archive_close = _archive_read_close, + .archive_read_data_block = _archive_read_data_block, + .archive_read_next_header = _archive_read_next_header, + .archive_read_next_header2 = _archive_read_next_header2, +}; const char * archive_read_disk_gname(struct archive *_a, la_int64_t gid) @@ -541,7 +533,7 @@ archive_read_disk_new(void) return (NULL); a->archive.magic = ARCHIVE_READ_DISK_MAGIC; a->archive.state = ARCHIVE_STATE_NEW; - a->archive.vtable = archive_read_disk_vtable(); + a->archive.vtable = &archive_read_disk_vtable; a->entry = archive_entry_new2(&a->archive); a->lookup_uname = trivial_lookup_uname; a->lookup_gname = trivial_lookup_gname; @@ -1090,9 +1082,11 @@ next_entry(struct archive_read_disk *a, struct tree *t, } /* Find sparse data from the disk. */ - if (archive_entry_hardlink(entry) == NULL && - (st->dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0) - r = setup_sparse_from_disk(a, entry, t->entry_fh); + if ((a->flags & ARCHIVE_READDISK_NO_SPARSE) == 0) { + if (archive_entry_hardlink(entry) == NULL && + (st->dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0) + r = setup_sparse_from_disk(a, entry, t->entry_fh); + } } return (r); } @@ -1300,7 +1294,7 @@ archive_read_disk_descend(struct archive *_a) ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, "archive_read_disk_descend"); - if (t->visit_type != TREE_REGULAR || !t->descend) + if (!archive_read_disk_can_descend(_a)) return (ARCHIVE_OK); if (tree_current_is_physical_dir(t)) { @@ -2371,9 +2365,11 @@ archive_read_disk_entry_from_file(struct archive *_a, return (ARCHIVE_OK); } - r = setup_sparse_from_disk(a, entry, h); - if (fd < 0) - CloseHandle(h); + if ((a->flags & ARCHIVE_READDISK_NO_SPARSE) == 0) { + r = setup_sparse_from_disk(a, entry, h); + if (fd < 0) + CloseHandle(h); + } return (r); } diff --git a/src/libs/3rdparty/libarchive/archive_read_private.h b/src/libs/3rdparty/libarchive/archive_read_private.h index c842e6f09..383405d52 100644 --- a/src/libs/3rdparty/libarchive/archive_read_private.h +++ b/src/libs/3rdparty/libarchive/archive_read_private.h @@ -42,6 +42,16 @@ struct archive_read; struct archive_read_filter_bidder; struct archive_read_filter; +struct archive_read_filter_bidder_vtable { + /* Taste the upstream filter to see if we handle this. */ + int (*bid)(struct archive_read_filter_bidder *, + struct archive_read_filter *); + /* Initialize a newly-created filter. */ + int (*init)(struct archive_read_filter *); + /* Release the bidder's configuration data. */ + void (*free)(struct archive_read_filter_bidder *); +}; + /* * How bidding works for filters: * * The bid manager initializes the client-provided reader as the @@ -62,16 +72,16 @@ struct archive_read_filter_bidder { void *data; /* Name of the filter */ const char *name; - /* Taste the upstream filter to see if we handle this. */ - int (*bid)(struct archive_read_filter_bidder *, - struct archive_read_filter *); - /* Initialize a newly-created filter. */ - int (*init)(struct archive_read_filter *); - /* Set an option for the filter bidder. */ - int (*options)(struct archive_read_filter_bidder *, - const char *key, const char *value); - /* Release the bidder's configuration data. */ - int (*free)(struct archive_read_filter_bidder *); + const struct archive_read_filter_bidder_vtable *vtable; +}; + +struct archive_read_filter_vtable { + /* Return next block. */ + ssize_t (*read)(struct archive_read_filter *, const void **); + /* Close (just this filter) and free(self). */ + int (*close)(struct archive_read_filter *self); + /* Read any header metadata if available. */ + int (*read_header)(struct archive_read_filter *self, struct archive_entry *entry); }; /* @@ -86,25 +96,14 @@ struct archive_read_filter { struct archive_read_filter_bidder *bidder; /* My bidder. */ struct archive_read_filter *upstream; /* Who I read from. */ struct archive_read *archive; /* Associated archive. */ - /* Open a block for reading */ - int (*open)(struct archive_read_filter *self); - /* Return next block. */ - ssize_t (*read)(struct archive_read_filter *, const void **); - /* Skip forward this many bytes. */ - int64_t (*skip)(struct archive_read_filter *self, int64_t request); - /* Seek to an absolute location. */ - int64_t (*seek)(struct archive_read_filter *self, int64_t offset, int whence); - /* Close (just this filter) and free(self). */ - int (*close)(struct archive_read_filter *self); - /* Function that handles switching from reading one block to the next/prev */ - int (*sswitch)(struct archive_read_filter *self, unsigned int iindex); - /* Read any header metadata if available. */ - int (*read_header)(struct archive_read_filter *self, struct archive_entry *entry); + const struct archive_read_filter_vtable *vtable; /* My private data. */ void *data; const char *name; int code; + int can_skip; + int can_seek; /* Used by reblocking logic. */ char *buffer; @@ -242,8 +241,10 @@ int __archive_read_register_format(struct archive_read *a, int (*format_capabilities)(struct archive_read *), int (*has_encrypted_entries)(struct archive_read *)); -int __archive_read_get_bidder(struct archive_read *a, - struct archive_read_filter_bidder **bidder); +int __archive_read_register_bidder(struct archive_read *a, + void *bidder_data, + const char *name, + const struct archive_read_filter_bidder_vtable *vtable); const void *__archive_read_ahead(struct archive_read *, size_t, ssize_t *); const void *__archive_read_filter_ahead(struct archive_read_filter *, diff --git a/src/libs/3rdparty/libarchive/archive_read_set_options.c b/src/libs/3rdparty/libarchive/archive_read_set_options.c index 2e2eea690..2bd9b811e 100644 --- a/src/libs/3rdparty/libarchive/archive_read_set_options.c +++ b/src/libs/3rdparty/libarchive/archive_read_set_options.c @@ -112,37 +112,15 @@ static int archive_set_filter_option(struct archive *_a, const char *m, const char *o, const char *v) { - struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter *filter; - struct archive_read_filter_bidder *bidder; - int r, rv = ARCHIVE_WARN, matched_modules = 0; - - for (filter = a->filter; filter != NULL; filter = filter->upstream) { - bidder = filter->bidder; - if (bidder == NULL) - continue; - if (bidder->options == NULL) - /* This bidder does not support option */ - continue; - if (m != NULL) { - if (strcmp(filter->name, m) != 0) - continue; - ++matched_modules; - } + (void)_a; /* UNUSED */ + (void)o; /* UNUSED */ + (void)v; /* UNUSED */ - r = bidder->options(bidder, o, v); - - if (r == ARCHIVE_FATAL) - return (ARCHIVE_FATAL); - - if (r == ARCHIVE_OK) - rv = ARCHIVE_OK; - } /* If the filter name didn't match, return a special code for * _archive_set_option[s]. */ - if (m != NULL && matched_modules == 0) + if (m != NULL) return ARCHIVE_WARN - 1; - return (rv); + return ARCHIVE_WARN; } static int diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_bzip2.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_bzip2.c index 3885a7cf6..793d605c8 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_bzip2.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_bzip2.c @@ -70,7 +70,6 @@ static int bzip2_filter_close(struct archive_read_filter *); */ static int bzip2_reader_bid(struct archive_read_filter_bidder *, struct archive_read_filter *); static int bzip2_reader_init(struct archive_read_filter *); -static int bzip2_reader_free(struct archive_read_filter_bidder *); #if ARCHIVE_VERSION_NUMBER < 4000000 /* Deprecated; remove in libarchive 4.0 */ @@ -81,24 +80,21 @@ archive_read_support_compression_bzip2(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +bzip2_bidder_vtable = { + .bid = bzip2_reader_bid, + .init = bzip2_reader_init, +}; + int archive_read_support_filter_bzip2(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *reader; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_bzip2"); - if (__archive_read_get_bidder(a, &reader) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "bzip2", + &bzip2_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - reader->data = NULL; - reader->name = "bzip2"; - reader->bid = bzip2_reader_bid; - reader->init = bzip2_reader_init; - reader->options = NULL; - reader->free = bzip2_reader_free; #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR) return (ARCHIVE_OK); #else @@ -108,12 +104,6 @@ archive_read_support_filter_bzip2(struct archive *_a) #endif } -static int -bzip2_reader_free(struct archive_read_filter_bidder *self){ - (void)self; /* UNUSED */ - return (ARCHIVE_OK); -} - /* * Test whether we can handle this data. * @@ -183,6 +173,12 @@ bzip2_reader_init(struct archive_read_filter *self) #else +static const struct archive_read_filter_vtable +bzip2_reader_vtable = { + .read = bzip2_filter_read, + .close = bzip2_filter_close, +}; + /* * Setup the callbacks. */ @@ -209,9 +205,7 @@ bzip2_reader_init(struct archive_read_filter *self) self->data = state; state->out_block_size = out_block_size; state->out_block = out_block; - self->read = bzip2_filter_read; - self->skip = NULL; /* not supported */ - self->close = bzip2_filter_close; + self->vtable = &bzip2_reader_vtable; return (ARCHIVE_OK); } diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_compress.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_compress.c index e05132dbf..05b80a576 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_compress.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_compress.c @@ -133,7 +133,6 @@ struct private_data { static int compress_bidder_bid(struct archive_read_filter_bidder *, struct archive_read_filter *); static int compress_bidder_init(struct archive_read_filter *); -static int compress_bidder_free(struct archive_read_filter_bidder *); static ssize_t compress_filter_read(struct archive_read_filter *, const void **); static int compress_filter_close(struct archive_read_filter *); @@ -150,25 +149,19 @@ archive_read_support_compression_compress(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +compress_bidder_vtable = { + .bid = compress_bidder_bid, + .init = compress_bidder_init, +}; + int archive_read_support_filter_compress(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_compress"); - - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) - return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "compress (.Z)"; - bidder->bid = compress_bidder_bid; - bidder->init = compress_bidder_init; - bidder->options = NULL; - bidder->free = compress_bidder_free; - return (ARCHIVE_OK); + return __archive_read_register_bidder(a, NULL, "compress (.Z)", + &compress_bidder_vtable); } /* @@ -205,6 +198,12 @@ compress_bidder_bid(struct archive_read_filter_bidder *self, return (bits_checked); } +static const struct archive_read_filter_vtable +compress_reader_vtable = { + .read = compress_filter_read, + .close = compress_filter_close, +}; + /* * Setup the callbacks. */ @@ -233,9 +232,7 @@ compress_bidder_init(struct archive_read_filter *self) self->data = state; state->out_block_size = out_block_size; state->out_block = out_block; - self->read = compress_filter_read; - self->skip = NULL; /* not supported */ - self->close = compress_filter_close; + self->vtable = &compress_reader_vtable; /* XXX MOVE THE FOLLOWING OUT OF INIT() XXX */ @@ -306,16 +303,6 @@ compress_filter_read(struct archive_read_filter *self, const void **pblock) } /* - * Clean up the reader. - */ -static int -compress_bidder_free(struct archive_read_filter_bidder *self) -{ - self->data = NULL; - return (ARCHIVE_OK); -} - -/* * Close and release the filter. */ static int diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_grzip.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_grzip.c index 84c86aeb4..d4d1737cd 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_grzip.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_grzip.c @@ -54,30 +54,21 @@ static int grzip_bidder_bid(struct archive_read_filter_bidder *, static int grzip_bidder_init(struct archive_read_filter *); -static int -grzip_reader_free(struct archive_read_filter_bidder *self) -{ - (void)self; /* UNUSED */ - return (ARCHIVE_OK); -} +static const struct archive_read_filter_bidder_vtable +grzip_bidder_vtable = { + .bid = grzip_bidder_bid, + .init = grzip_bidder_init, +}; int archive_read_support_filter_grzip(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *reader; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_grzip"); - if (__archive_read_get_bidder(a, &reader) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, NULL, + &grzip_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - reader->data = NULL; - reader->bid = grzip_bidder_bid; - reader->init = grzip_bidder_init; - reader->options = NULL; - reader->free = grzip_reader_free; /* This filter always uses an external program. */ archive_set_error(_a, ARCHIVE_ERRNO_MISC, "Using external grzip program for grzip decompression"); diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_gzip.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_gzip.c index 9fa9e2b0d..4135a6361 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_gzip.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_gzip.c @@ -94,24 +94,21 @@ archive_read_support_compression_gzip(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +gzip_bidder_vtable = { + .bid = gzip_bidder_bid, + .init = gzip_bidder_init, +}; + int archive_read_support_filter_gzip(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_gzip"); - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "gzip", + &gzip_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "gzip"; - bidder->bid = gzip_bidder_bid; - bidder->init = gzip_bidder_init; - bidder->options = NULL; - bidder->free = NULL; /* No data, so no cleanup necessary. */ /* Signal the extent of gzip support with the return value here. */ #if HAVE_ZLIB_H return (ARCHIVE_OK); @@ -291,6 +288,15 @@ gzip_read_header(struct archive_read_filter *self, struct archive_entry *entry) return (ARCHIVE_OK); } +static const struct archive_read_filter_vtable +gzip_reader_vtable = { + .read = gzip_filter_read, + .close = gzip_filter_close, +#ifdef HAVE_ZLIB_H + .read_header = gzip_read_header, +#endif +}; + /* * Initialize the filter object. */ @@ -317,12 +323,7 @@ gzip_bidder_init(struct archive_read_filter *self) self->data = state; state->out_block_size = out_block_size; state->out_block = out_block; - self->read = gzip_filter_read; - self->skip = NULL; /* not supported */ - self->close = gzip_filter_close; -#ifdef HAVE_ZLIB_H - self->read_header = gzip_read_header; -#endif + self->vtable = &gzip_reader_vtable; state->in_stream = 0; /* We're not actually within a stream yet. */ diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_lrzip.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_lrzip.c index c82a8e2f1..a2389894f 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_lrzip.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_lrzip.c @@ -53,31 +53,21 @@ static int lrzip_bidder_bid(struct archive_read_filter_bidder *, static int lrzip_bidder_init(struct archive_read_filter *); -static int -lrzip_reader_free(struct archive_read_filter_bidder *self) -{ - (void)self; /* UNUSED */ - return (ARCHIVE_OK); -} +static const struct archive_read_filter_bidder_vtable +lrzip_bidder_vtable = { + .bid = lrzip_bidder_bid, + .init = lrzip_bidder_init, +}; int archive_read_support_filter_lrzip(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *reader; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_lrzip"); - if (__archive_read_get_bidder(a, &reader) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "lrzip", + &lrzip_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - reader->data = NULL; - reader->name = "lrzip"; - reader->bid = lrzip_bidder_bid; - reader->init = lrzip_bidder_init; - reader->options = NULL; - reader->free = lrzip_reader_free; /* This filter always uses an external program. */ archive_set_error(_a, ARCHIVE_ERRNO_MISC, "Using external lrzip program for lrzip decompression"); diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_lz4.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_lz4.c index 43ee6c2b7..ae0b08003 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_lz4.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_lz4.c @@ -99,7 +99,6 @@ static int lz4_filter_close(struct archive_read_filter *); */ static int lz4_reader_bid(struct archive_read_filter_bidder *, struct archive_read_filter *); static int lz4_reader_init(struct archive_read_filter *); -static int lz4_reader_free(struct archive_read_filter_bidder *); #if defined(HAVE_LIBLZ4) static ssize_t lz4_filter_read_default_stream(struct archive_read_filter *, const void **); @@ -107,24 +106,21 @@ static ssize_t lz4_filter_read_legacy_stream(struct archive_read_filter *, const void **); #endif +static const struct archive_read_filter_bidder_vtable +lz4_bidder_vtable = { + .bid = lz4_reader_bid, + .init = lz4_reader_init, +}; + int archive_read_support_filter_lz4(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *reader; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_lz4"); - if (__archive_read_get_bidder(a, &reader) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "lz4", + &lz4_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - reader->data = NULL; - reader->name = "lz4"; - reader->bid = lz4_reader_bid; - reader->init = lz4_reader_init; - reader->options = NULL; - reader->free = lz4_reader_free; #if defined(HAVE_LIBLZ4) return (ARCHIVE_OK); #else @@ -134,12 +130,6 @@ archive_read_support_filter_lz4(struct archive *_a) #endif } -static int -lz4_reader_free(struct archive_read_filter_bidder *self){ - (void)self; /* UNUSED */ - return (ARCHIVE_OK); -} - /* * Test whether we can handle this data. * @@ -218,6 +208,12 @@ lz4_reader_init(struct archive_read_filter *self) #else +static const struct archive_read_filter_vtable +lz4_reader_vtable = { + .read = lz4_filter_read, + .close = lz4_filter_close, +}; + /* * Setup the callbacks. */ @@ -238,9 +234,7 @@ lz4_reader_init(struct archive_read_filter *self) self->data = state; state->stage = SELECT_STREAM; - self->read = lz4_filter_read; - self->skip = NULL; /* not supported */ - self->close = lz4_filter_close; + self->vtable = &lz4_reader_vtable; return (ARCHIVE_OK); } diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_lzop.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_lzop.c index a1c392f4f..afd2d4d0c 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_lzop.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_lzop.c @@ -101,23 +101,21 @@ static int lzop_bidder_bid(struct archive_read_filter_bidder *, struct archive_read_filter *); static int lzop_bidder_init(struct archive_read_filter *); +static const struct archive_read_filter_bidder_vtable +lzop_bidder_vtable = { + .bid = lzop_bidder_bid, + .init = lzop_bidder_init, +}; + int archive_read_support_filter_lzop(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *reader; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_lzop"); - if (__archive_read_get_bidder(a, &reader) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, NULL, + &lzop_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - reader->data = NULL; - reader->bid = lzop_bidder_bid; - reader->init = lzop_bidder_init; - reader->options = NULL; - reader->free = NULL; /* Signal the extent of lzop support with the return value here. */ #if defined(HAVE_LZO_LZOCONF_H) && defined(HAVE_LZO_LZO1X_H) return (ARCHIVE_OK); @@ -171,6 +169,13 @@ lzop_bidder_init(struct archive_read_filter *self) return (r); } #else + +static const struct archive_read_filter_vtable +lzop_reader_vtable = { + .read = lzop_filter_read, + .close = lzop_filter_close +}; + /* * Initialize the filter object. */ @@ -190,9 +195,7 @@ lzop_bidder_init(struct archive_read_filter *self) } self->data = state; - self->read = lzop_filter_read; - self->skip = NULL; /* not supported */ - self->close = lzop_filter_close; + self->vtable = &lzop_reader_vtable; return (ARCHIVE_OK); } diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_program.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_program.c index bf5b6f2b3..885b2c205 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_program.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_program.c @@ -98,7 +98,7 @@ struct program_bidder { static int program_bidder_bid(struct archive_read_filter_bidder *, struct archive_read_filter *upstream); static int program_bidder_init(struct archive_read_filter *); -static int program_bidder_free(struct archive_read_filter_bidder *); +static void program_bidder_free(struct archive_read_filter_bidder *); /* * The actual filter needs to track input and output data. @@ -123,43 +123,21 @@ static ssize_t program_filter_read(struct archive_read_filter *, static int program_filter_close(struct archive_read_filter *); static void free_state(struct program_bidder *); -static int -set_bidder_signature(struct archive_read_filter_bidder *bidder, - struct program_bidder *state, const void *signature, size_t signature_len) -{ - - if (signature != NULL && signature_len > 0) { - state->signature_len = signature_len; - state->signature = malloc(signature_len); - memcpy(state->signature, signature, signature_len); - } - - /* - * Fill in the bidder object. - */ - bidder->data = state; - bidder->bid = program_bidder_bid; - bidder->init = program_bidder_init; - bidder->options = NULL; - bidder->free = program_bidder_free; - return (ARCHIVE_OK); -} +static const struct archive_read_filter_bidder_vtable +program_bidder_vtable = { + .bid = program_bidder_bid, + .init = program_bidder_init, + .free = program_bidder_free, +}; int archive_read_support_filter_program_signature(struct archive *_a, const char *cmd, const void *signature, size_t signature_len) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; struct program_bidder *state; /* - * Get a bidder object from the read core. - */ - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) - return (ARCHIVE_FATAL); - - /* * Allocate our private state. */ state = (struct program_bidder *)calloc(1, sizeof (*state)); @@ -169,20 +147,31 @@ archive_read_support_filter_program_signature(struct archive *_a, if (state->cmd == NULL) goto memerr; - return set_bidder_signature(bidder, state, signature, signature_len); + if (signature != NULL && signature_len > 0) { + state->signature_len = signature_len; + state->signature = malloc(signature_len); + memcpy(state->signature, signature, signature_len); + } + + if (__archive_read_register_bidder(a, state, NULL, + &program_bidder_vtable) != ARCHIVE_OK) { + free_state(state); + return (ARCHIVE_FATAL); + } + return (ARCHIVE_OK); + memerr: free_state(state); archive_set_error(_a, ENOMEM, "Can't allocate memory"); return (ARCHIVE_FATAL); } -static int +static void program_bidder_free(struct archive_read_filter_bidder *self) { struct program_bidder *state = (struct program_bidder *)self->data; free_state(state); - return (ARCHIVE_OK); } static void @@ -393,6 +382,12 @@ child_read(struct archive_read_filter *self, char *buf, size_t buf_len) } } +static const struct archive_read_filter_vtable +program_reader_vtable = { + .read = program_filter_read, + .close = program_filter_close, +}; + int __archive_read_program(struct archive_read_filter *self, const char *cmd) { @@ -439,9 +434,7 @@ __archive_read_program(struct archive_read_filter *self, const char *cmd) } self->data = state; - self->read = program_filter_read; - self->skip = NULL; - self->close = program_filter_close; + self->vtable = &program_reader_vtable; /* XXX Check that we can read at least one byte? */ return (ARCHIVE_OK); diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_rpm.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_rpm.c index ddd68392f..67a979cd7 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_rpm.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_rpm.c @@ -72,25 +72,19 @@ archive_read_support_compression_rpm(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +rpm_bidder_vtable = { + .bid = rpm_bidder_bid, + .init = rpm_bidder_init, +}; + int archive_read_support_filter_rpm(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_rpm"); - - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) - return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "rpm"; - bidder->bid = rpm_bidder_bid; - bidder->init = rpm_bidder_init; - bidder->options = NULL; - bidder->free = NULL; - return (ARCHIVE_OK); + return __archive_read_register_bidder(a, NULL, "rpm", + &rpm_bidder_vtable); } static int @@ -133,6 +127,12 @@ rpm_bidder_bid(struct archive_read_filter_bidder *self, return (bits_checked); } +static const struct archive_read_filter_vtable +rpm_reader_vtable = { + .read = rpm_filter_read, + .close = rpm_filter_close, +}; + static int rpm_bidder_init(struct archive_read_filter *self) { @@ -140,9 +140,6 @@ rpm_bidder_init(struct archive_read_filter *self) self->code = ARCHIVE_FILTER_RPM; self->name = "rpm"; - self->read = rpm_filter_read; - self->skip = NULL; /* not supported */ - self->close = rpm_filter_close; rpm = (struct rpm *)calloc(sizeof(*rpm), 1); if (rpm == NULL) { @@ -153,6 +150,7 @@ rpm_bidder_init(struct archive_read_filter *self) self->data = rpm; rpm->state = ST_LEAD; + self->vtable = &rpm_reader_vtable; return (ARCHIVE_OK); } diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_uu.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_uu.c index 689c18ce4..209b2a159 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_uu.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_uu.c @@ -76,25 +76,19 @@ archive_read_support_compression_uu(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +uudecode_bidder_vtable = { + .bid = uudecode_bidder_bid, + .init = uudecode_bidder_init, +}; + int archive_read_support_filter_uu(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_uu"); - - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) - return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "uu"; - bidder->bid = uudecode_bidder_bid; - bidder->init = uudecode_bidder_init; - bidder->options = NULL; - bidder->free = NULL; - return (ARCHIVE_OK); + return __archive_read_register_bidder(a, NULL, "uu", + &uudecode_bidder_vtable); } static const unsigned char ascii[256] = { @@ -357,6 +351,12 @@ uudecode_bidder_bid(struct archive_read_filter_bidder *self, return (0); } +static const struct archive_read_filter_vtable +uudecode_reader_vtable = { + .read = uudecode_filter_read, + .close = uudecode_filter_close, +}; + static int uudecode_bidder_init(struct archive_read_filter *self) { @@ -366,9 +366,6 @@ uudecode_bidder_init(struct archive_read_filter *self) self->code = ARCHIVE_FILTER_UU; self->name = "uu"; - self->read = uudecode_filter_read; - self->skip = NULL; /* not supported */ - self->close = uudecode_filter_close; uudecode = (struct uudecode *)calloc(sizeof(*uudecode), 1); out_buff = malloc(OUT_BUFF_SIZE); @@ -388,6 +385,7 @@ uudecode_bidder_init(struct archive_read_filter *self) uudecode->in_allocated = IN_BUFF_SIZE; uudecode->out_buff = out_buff; uudecode->state = ST_FIND_HEAD; + self->vtable = &uudecode_reader_vtable; return (ARCHIVE_OK); } diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_xz.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_xz.c index 11807cf67..32ae0be92 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_xz.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_xz.c @@ -108,24 +108,21 @@ archive_read_support_compression_xz(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +xz_bidder_vtable = { + .bid = xz_bidder_bid, + .init = xz_bidder_init, +}; + int archive_read_support_filter_xz(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_xz"); - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "xz", + &xz_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "xz"; - bidder->bid = xz_bidder_bid; - bidder->init = xz_bidder_init; - bidder->options = NULL; - bidder->free = NULL; #if HAVE_LZMA_H && HAVE_LIBLZMA return (ARCHIVE_OK); #else @@ -143,24 +140,21 @@ archive_read_support_compression_lzma(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +lzma_bidder_vtable = { + .bid = lzma_bidder_bid, + .init = lzma_bidder_init, +}; + int archive_read_support_filter_lzma(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_lzma"); - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "lzma", + &lzma_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "lzma"; - bidder->bid = lzma_bidder_bid; - bidder->init = lzma_bidder_init; - bidder->options = NULL; - bidder->free = NULL; #if HAVE_LZMA_H && HAVE_LIBLZMA return (ARCHIVE_OK); #else @@ -179,24 +173,21 @@ archive_read_support_compression_lzip(struct archive *a) } #endif +static const struct archive_read_filter_bidder_vtable +lzip_bidder_vtable = { + .bid = lzip_bidder_bid, + .init = lzip_bidder_init, +}; + int archive_read_support_filter_lzip(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_lzip"); - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "lzip", + &lzip_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "lzip"; - bidder->bid = lzip_bidder_bid; - bidder->init = lzip_bidder_init; - bidder->options = NULL; - bidder->free = NULL; #if HAVE_LZMA_H && HAVE_LIBLZMA return (ARCHIVE_OK); #else @@ -293,8 +284,8 @@ lzma_bidder_bid(struct archive_read_filter_bidder *self, /* Second through fifth bytes are dictionary size, stored in * little-endian order. The minimum dictionary size is * 1 << 12(4KiB) which the lzma of LZMA SDK uses with option - * -d12 and the maximum dictionary size is 1 << 27(128MiB) - * which the one uses with option -d27. + * -d12 and the maximum dictionary size is 1 << 29(512MiB) + * which the one uses with option -d29. * NOTE: A comment of LZMA SDK source code says this dictionary * range is from 1 << 12 to 1 << 30. */ dicsize = archive_le32dec(buffer+1); @@ -377,7 +368,7 @@ lzip_has_member(struct archive_read_filter *filter) /* Dictionary size. */ log2dic = buffer[5] & 0x1f; - if (log2dic < 12 || log2dic > 27) + if (log2dic < 12 || log2dic > 29) return (0); bits_checked += 8; @@ -470,6 +461,12 @@ set_error(struct archive_read_filter *self, int ret) } } +static const struct archive_read_filter_vtable +xz_lzma_reader_vtable = { + .read = xz_filter_read, + .close = xz_filter_close, +}; + /* * Setup the callbacks. */ @@ -494,9 +491,7 @@ xz_lzma_bidder_init(struct archive_read_filter *self) self->data = state; state->out_block_size = out_block_size; state->out_block = out_block; - self->read = xz_filter_read; - self->skip = NULL; /* not supported */ - self->close = xz_filter_close; + self->vtable = &xz_lzma_reader_vtable; state->stream.avail_in = 0; @@ -562,7 +557,7 @@ lzip_init(struct archive_read_filter *self) /* Get dictionary size. */ log2dic = h[5] & 0x1f; - if (log2dic < 12 || log2dic > 27) + if (log2dic < 12 || log2dic > 29) return (ARCHIVE_FATAL); dicsize = 1U << log2dic; if (log2dic > 12) diff --git a/src/libs/3rdparty/libarchive/archive_read_support_filter_zstd.c b/src/libs/3rdparty/libarchive/archive_read_support_filter_zstd.c index af7eeb7c1..39f25f1bf 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_filter_zstd.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_filter_zstd.c @@ -79,24 +79,21 @@ static int zstd_bidder_bid(struct archive_read_filter_bidder *, struct archive_read_filter *); static int zstd_bidder_init(struct archive_read_filter *); +static const struct archive_read_filter_bidder_vtable +zstd_bidder_vtable = { + .bid = zstd_bidder_bid, + .init = zstd_bidder_init, +}; + int archive_read_support_filter_zstd(struct archive *_a) { struct archive_read *a = (struct archive_read *)_a; - struct archive_read_filter_bidder *bidder; - - archive_check_magic(_a, ARCHIVE_READ_MAGIC, - ARCHIVE_STATE_NEW, "archive_read_support_filter_zstd"); - if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK) + if (__archive_read_register_bidder(a, NULL, "zstd", + &zstd_bidder_vtable) != ARCHIVE_OK) return (ARCHIVE_FATAL); - bidder->data = NULL; - bidder->name = "zstd"; - bidder->bid = zstd_bidder_bid; - bidder->init = zstd_bidder_init; - bidder->options = NULL; - bidder->free = NULL; #if HAVE_ZSTD_H && HAVE_LIBZSTD return (ARCHIVE_OK); #else @@ -160,6 +157,12 @@ zstd_bidder_init(struct archive_read_filter *self) #else +static const struct archive_read_filter_vtable +zstd_reader_vtable = { + .read = zstd_filter_read, + .close = zstd_filter_close, +}; + /* * Initialize the filter object */ @@ -192,9 +195,7 @@ zstd_bidder_init(struct archive_read_filter *self) state->out_block_size = out_block_size; state->out_block = out_block; state->dstream = dstream; - self->read = zstd_filter_read; - self->skip = NULL; /* not supported */ - self->close = zstd_filter_close; + self->vtable = &zstd_reader_vtable; state->eof = 0; state->in_frame = 0; diff --git a/src/libs/3rdparty/libarchive/archive_read_support_format_mtree.c b/src/libs/3rdparty/libarchive/archive_read_support_format_mtree.c index c87a15442..88bca76fb 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_format_mtree.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_format_mtree.c @@ -1629,11 +1629,11 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, || strcmp(key, "contents") == 0) { parse_escapes(val, NULL); archive_strcpy(&mtree->contents_name, val); - break; + return (ARCHIVE_OK); } if (strcmp(key, "cksum") == 0) - break; - __LA_FALLTHROUGH; + return (ARCHIVE_OK); + break; case 'd': if (strcmp(key, "device") == 0) { /* stat(2) st_rdev field, e.g. the major/minor IDs @@ -1647,65 +1647,64 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, archive_entry_set_rdev(entry, dev); return r; } - __LA_FALLTHROUGH; + break; case 'f': if (strcmp(key, "flags") == 0) { *parsed_kws |= MTREE_HAS_FFLAGS; archive_entry_copy_fflags_text(entry, val); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'g': if (strcmp(key, "gid") == 0) { *parsed_kws |= MTREE_HAS_GID; archive_entry_set_gid(entry, mtree_atol(&val, 10)); - break; + return (ARCHIVE_OK); } if (strcmp(key, "gname") == 0) { *parsed_kws |= MTREE_HAS_GNAME; archive_entry_copy_gname(entry, val); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'i': if (strcmp(key, "inode") == 0) { archive_entry_set_ino(entry, mtree_atol(&val, 10)); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'l': if (strcmp(key, "link") == 0) { + parse_escapes(val, NULL); archive_entry_copy_symlink(entry, val); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'm': if (strcmp(key, "md5") == 0 || strcmp(key, "md5digest") == 0) { return parse_digest(a, entry, val, ARCHIVE_ENTRY_DIGEST_MD5); } if (strcmp(key, "mode") == 0) { - if (val[0] >= '0' && val[0] <= '7') { - *parsed_kws |= MTREE_HAS_PERM; - archive_entry_set_perm(entry, - (mode_t)mtree_atol(&val, 8)); - } else { + if (val[0] < '0' || val[0] > '7') { archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, "Symbolic or non-octal mode \"%s\" unsupported", val); - return ARCHIVE_WARN; + return (ARCHIVE_WARN); } - break; + *parsed_kws |= MTREE_HAS_PERM; + archive_entry_set_perm(entry, (mode_t)mtree_atol(&val, 8)); + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'n': if (strcmp(key, "nlink") == 0) { *parsed_kws |= MTREE_HAS_NLINK; archive_entry_set_nlink(entry, (unsigned int)mtree_atol(&val, 10)); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'r': if (strcmp(key, "resdevice") == 0) { /* stat(2) st_dev field, e.g. the device ID where the @@ -1723,7 +1722,7 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, return parse_digest(a, entry, val, ARCHIVE_ENTRY_DIGEST_RMD160); } - __LA_FALLTHROUGH; + break; case 's': if (strcmp(key, "sha1") == 0 || strcmp(key, "sha1digest") == 0) { @@ -1747,9 +1746,9 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, } if (strcmp(key, "size") == 0) { archive_entry_set_size(entry, mtree_atol(&val, 10)); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 't': if (strcmp(key, "tags") == 0) { /* @@ -1757,7 +1756,7 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, * Ignore the tags for now, but the interface * should be extended to allow inclusion/exclusion. */ - break; + return (ARCHIVE_OK); } if (strcmp(key, "time") == 0) { int64_t m; @@ -1783,79 +1782,85 @@ parse_keyword(struct archive_read *a, struct mtree *mtree, else if (m < my_time_t_min) m = my_time_t_min; archive_entry_set_mtime(entry, (time_t)m, ns); - break; + return (ARCHIVE_OK); } if (strcmp(key, "type") == 0) { switch (val[0]) { case 'b': if (strcmp(val, "block") == 0) { - archive_entry_set_filetype(entry, AE_IFBLK); - break; + *parsed_kws |= MTREE_HAS_TYPE; + archive_entry_set_filetype(entry, + AE_IFBLK); + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'c': if (strcmp(val, "char") == 0) { + *parsed_kws |= MTREE_HAS_TYPE; archive_entry_set_filetype(entry, AE_IFCHR); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'd': if (strcmp(val, "dir") == 0) { + *parsed_kws |= MTREE_HAS_TYPE; archive_entry_set_filetype(entry, AE_IFDIR); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'f': if (strcmp(val, "fifo") == 0) { + *parsed_kws |= MTREE_HAS_TYPE; archive_entry_set_filetype(entry, AE_IFIFO); - break; + return (ARCHIVE_OK); } if (strcmp(val, "file") == 0) { + *parsed_kws |= MTREE_HAS_TYPE; archive_entry_set_filetype(entry, AE_IFREG); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; case 'l': if (strcmp(val, "link") == 0) { + *parsed_kws |= MTREE_HAS_TYPE; archive_entry_set_filetype(entry, AE_IFLNK); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; default: - archive_set_error(&a->archive, - ARCHIVE_ERRNO_FILE_FORMAT, - "Unrecognized file type \"%s\"; " - "assuming \"file\"", val); - archive_entry_set_filetype(entry, AE_IFREG); - return (ARCHIVE_WARN); + break; } - *parsed_kws |= MTREE_HAS_TYPE; - break; + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Unrecognized file type \"%s\"; " + "assuming \"file\"", val); + archive_entry_set_filetype(entry, AE_IFREG); + return (ARCHIVE_WARN); } - __LA_FALLTHROUGH; + break; case 'u': if (strcmp(key, "uid") == 0) { *parsed_kws |= MTREE_HAS_UID; archive_entry_set_uid(entry, mtree_atol(&val, 10)); - break; + return (ARCHIVE_OK); } if (strcmp(key, "uname") == 0) { *parsed_kws |= MTREE_HAS_UNAME; archive_entry_copy_uname(entry, val); - break; + return (ARCHIVE_OK); } - __LA_FALLTHROUGH; + break; default: - archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, - "Unrecognized key %s=%s", key, val); - return (ARCHIVE_WARN); + break; } - return (ARCHIVE_OK); + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Unrecognized key %s=%s", key, val); + return (ARCHIVE_WARN); } static int diff --git a/src/libs/3rdparty/libarchive/archive_read_support_format_rar.c b/src/libs/3rdparty/libarchive/archive_read_support_format_rar.c index c2666b2f4..893a280ff 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_format_rar.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_format_rar.c @@ -135,6 +135,16 @@ #define MAX_SYMBOL_LENGTH 0xF #define MAX_SYMBOLS 20 +/* Virtual Machine Properties */ +#define VM_MEMORY_SIZE 0x40000 +#define VM_MEMORY_MASK (VM_MEMORY_SIZE - 1) +#define PROGRAM_WORK_SIZE 0x3C000 +#define PROGRAM_GLOBAL_SIZE 0x2000 +#define PROGRAM_SYSTEM_GLOBAL_ADDRESS PROGRAM_WORK_SIZE +#define PROGRAM_SYSTEM_GLOBAL_SIZE 0x40 +#define PROGRAM_USER_GLOBAL_ADDRESS (PROGRAM_SYSTEM_GLOBAL_ADDRESS + PROGRAM_SYSTEM_GLOBAL_SIZE) +#define PROGRAM_USER_GLOBAL_SIZE (PROGRAM_GLOBAL_SIZE - PROGRAM_SYSTEM_GLOBAL_SIZE) + /* * Considering L1,L2 cache miss and a calling of write system-call, * the best size of the output buffer(uncompressed buffer) is 128K. @@ -213,6 +223,69 @@ struct data_block_offsets int64_t end_offset; }; +struct rar_program_code +{ + uint8_t *staticdata; + uint32_t staticdatalen; + uint8_t *globalbackup; + uint32_t globalbackuplen; + uint64_t fingerprint; + uint32_t usagecount; + uint32_t oldfilterlength; + struct rar_program_code *next; +}; + +struct rar_filter +{ + struct rar_program_code *prog; + uint32_t initialregisters[8]; + uint8_t *globaldata; + uint32_t globaldatalen; + size_t blockstartpos; + uint32_t blocklength; + uint32_t filteredblockaddress; + uint32_t filteredblocklength; + struct rar_filter *next; +}; + +struct memory_bit_reader +{ + const uint8_t *bytes; + size_t length; + size_t offset; + uint64_t bits; + int available; + int at_eof; +}; + +struct rar_virtual_machine +{ + uint32_t registers[8]; + uint8_t memory[VM_MEMORY_SIZE + sizeof(uint32_t)]; +}; + +struct rar_filters +{ + struct rar_virtual_machine *vm; + struct rar_program_code *progs; + struct rar_filter *stack; + int64_t filterstart; + uint32_t lastfilternum; + int64_t lastend; + uint8_t *bytes; + size_t bytes_ready; +}; + +struct audio_state +{ + int8_t weight[5]; + int16_t delta[4]; + int8_t lastdelta; + int error[11]; + int count; + uint8_t lastbyte; +}; + struct rar { /* Entries from main RAR header */ @@ -273,15 +346,16 @@ struct rar struct huffman_code lengthcode; unsigned char lengthtable[HUFFMAN_TABLE_SIZE]; struct lzss lzss; - char output_last_match; unsigned int lastlength; unsigned int lastoffset; unsigned int oldoffset[4]; unsigned int lastlowoffset; unsigned int numlowoffsetrepeats; - int64_t filterstart; char start_new_table; + /* Filters */ + struct rar_filters filters; + /* PPMd Variant H members */ char ppmd_valid; char ppmd_eod; @@ -343,13 +417,13 @@ static int read_symlink_stored(struct archive_read *, struct archive_entry *, static int read_data_stored(struct archive_read *, const void **, size_t *, int64_t *); static int read_data_compressed(struct archive_read *, const void **, size_t *, - int64_t *, size_t); + int64_t *, size_t); static int rar_br_preparation(struct archive_read *, struct rar_br *); static int parse_codes(struct archive_read *); static void free_codes(struct archive_read *); static int read_next_symbol(struct archive_read *, struct huffman_code *); static int create_code(struct archive_read *, struct huffman_code *, - unsigned char *, int, char); + unsigned char *, int, char); static int add_value(struct archive_read *, struct huffman_code *, int, int, int); static int new_node(struct huffman_code *); @@ -357,9 +431,29 @@ static int make_table(struct archive_read *, struct huffman_code *); static int make_table_recurse(struct archive_read *, struct huffman_code *, int, struct huffman_table_entry *, int, int); static int64_t expand(struct archive_read *, int64_t); -static int copy_from_lzss_window(struct archive_read *, const void **, - int64_t, int); +static int copy_from_lzss_window_to_unp(struct archive_read *, const void **, + int64_t, int); static const void *rar_read_ahead(struct archive_read *, size_t, ssize_t *); +static int parse_filter(struct archive_read *, const uint8_t *, uint16_t, + uint8_t); +static int run_filters(struct archive_read *); +static void clear_filters(struct rar_filters *); +static struct rar_filter *create_filter(struct rar_program_code *, + const uint8_t *, uint32_t, + uint32_t[8], size_t, uint32_t); +static void delete_filter(struct rar_filter *filter); +static struct rar_program_code *compile_program(const uint8_t *, size_t); +static void delete_program_code(struct rar_program_code *prog); +static uint32_t membr_next_rarvm_number(struct memory_bit_reader *br); +static inline uint32_t membr_bits(struct memory_bit_reader *br, int bits); +static int membr_fill(struct memory_bit_reader *br, int bits); +static int read_filter(struct archive_read *, int64_t *); +static int rar_decode_byte(struct archive_read*, uint8_t *); +static int execute_filter(struct archive_read*, struct rar_filter *, + struct rar_virtual_machine *, size_t); +static int copy_from_lzss_window(struct archive_read *, void *, int64_t, int); +static inline void vm_write_32(struct rar_virtual_machine*, size_t, uint32_t); +static inline uint32_t vm_read_32(struct rar_virtual_machine*, size_t); /* * Bit stream reader. @@ -1244,6 +1338,7 @@ archive_read_format_rar_cleanup(struct archive_read *a) rar = (struct rar *)(a->format->data); free_codes(a); + clear_filters(&rar->filters); free(rar->filename); free(rar->filename_save); free(rar->dbo); @@ -1662,6 +1757,7 @@ read_header(struct archive_read *a, struct archive_entry *entry, memset(rar->lengthtable, 0, sizeof(rar->lengthtable)); __archive_ppmd7_functions.Ppmd7_Free(&rar->ppmd7_context); rar->ppmd_valid = rar->ppmd_eod = 0; + rar->filters.filterstart = INT64_MAX; /* Don't set any archive entries for non-file header types */ if (head_type == NEWSUB_HEAD) @@ -1886,7 +1982,7 @@ read_data_stored(struct archive_read *a, const void **buff, size_t *size, static int read_data_compressed(struct archive_read *a, const void **buff, size_t *size, - int64_t *offset, size_t looper) + int64_t *offset, size_t looper) { if (looper++ > MAX_COMPRESS_DEPTH) return (ARCHIVE_FATAL); @@ -1901,6 +1997,33 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size, do { if (!rar->valid) return (ARCHIVE_FATAL); + + if (rar->filters.bytes_ready > 0) + { + /* Flush unp_buffer first */ + if (rar->unp_offset > 0) + { + *buff = rar->unp_buffer; + *size = rar->unp_offset; + rar->unp_offset = 0; + *offset = rar->offset_outgoing; + rar->offset_outgoing += *size; + } + else + { + *buff = rar->filters.bytes; + *size = rar->filters.bytes_ready; + + rar->offset += *size; + *offset = rar->offset_outgoing; + rar->offset_outgoing += *size; + + rar->filters.bytes_ready -= *size; + rar->filters.bytes += *size; + } + goto ending_block; + } + if (rar->ppmd_eod || (rar->dictionary_size && rar->offset >= rar->unp_size)) { @@ -1936,7 +2059,7 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size, bs = rar->unp_buffer_size - rar->unp_offset; else bs = (size_t)rar->bytes_uncopied; - ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); + ret = copy_from_lzss_window_to_unp(a, buff, rar->offset, (int)bs); if (ret != ARCHIVE_OK) return (ret); rar->offset += bs; @@ -1954,6 +2077,13 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size, continue; } + if (rar->filters.lastend == rar->filters.filterstart) + { + if (!run_filters(a)) + return (ARCHIVE_FATAL); + continue; + } + if (!rar->br.next_in && (ret = rar_br_preparation(a, &(rar->br))) < ARCHIVE_WARN) return (ret); @@ -2045,13 +2175,16 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size, { start = rar->offset; end = start + rar->dictionary_size; - rar->filterstart = INT64_MAX; + if (rar->filters.filterstart < end) { + end = rar->filters.filterstart; + } if ((actualend = expand(a, end)) < 0) return ((int)actualend); rar->bytes_uncopied = actualend - start; - if (rar->bytes_uncopied == 0) { + rar->filters.lastend = actualend; + if (rar->filters.lastend != rar->filters.filterstart && rar->bytes_uncopied == 0) { /* Broken RAR files cause this case. * NOTE: If this case were possible on a normal RAR file * we would find out where it was actually bad and @@ -2065,7 +2198,7 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size, bs = rar->unp_buffer_size - rar->unp_offset; else bs = (size_t)rar->bytes_uncopied; - ret = copy_from_lzss_window(a, buff, rar->offset, (int)bs); + ret = copy_from_lzss_window_to_unp(a, buff, rar->offset, (int)bs); if (ret != ARCHIVE_OK) return (ret); rar->offset += bs; @@ -2080,6 +2213,7 @@ read_data_compressed(struct archive_read *a, const void **buff, size_t *size, *size = rar->unp_buffer_size; *offset = rar->offset_outgoing; rar->offset_outgoing += *size; +ending_block: /* Calculate File CRC. */ rar->crc_calculated = crc32(rar->crc_calculated, *buff, (unsigned)*size); return ret; @@ -2739,25 +2873,19 @@ expand(struct archive_read *a, int64_t end) struct rar *rar = (struct rar *)(a->format->data); struct rar_br *br = &(rar->br); - if (rar->filterstart < end) - end = rar->filterstart; + if (rar->filters.filterstart < end) + end = rar->filters.filterstart; while (1) { - if (rar->output_last_match && - lzss_position(&rar->lzss) + rar->lastlength <= end) - { - lzss_emit_match(rar, rar->lastoffset, rar->lastlength); - rar->output_last_match = 0; - } + if(lzss_position(&rar->lzss) >= end) + return end; - if(rar->is_ppmd_block || rar->output_last_match || - lzss_position(&rar->lzss) >= end) + if(rar->is_ppmd_block) return lzss_position(&rar->lzss); if ((symbol = read_next_symbol(a, &rar->maincode)) < 0) return (ARCHIVE_FATAL); - rar->output_last_match = 0; if (symbol < 256) { @@ -2789,9 +2917,9 @@ expand(struct archive_read *a, int64_t end) } else if(symbol==257) { - archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, - "Parsing filters is unsupported."); - return (ARCHIVE_FAILED); + if (!read_filter(a, &end)) + return (ARCHIVE_FATAL); + continue; } else if(symbol==258) { @@ -2864,7 +2992,7 @@ expand(struct archive_read *a, int64_t end) goto truncated_data; offs += rar_br_bits(br, offsetbits[offssymbol] - 4) << 4; rar_br_consume(br, offsetbits[offssymbol] - 4); - } + } if(rar->numlowoffsetrepeats > 0) { @@ -2908,7 +3036,8 @@ expand(struct archive_read *a, int64_t end) rar->lastoffset = offs; rar->lastlength = len; - rar->output_last_match = 1; + + lzss_emit_match(rar, rar->lastoffset, rar->lastlength); } truncated_data: archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, @@ -2922,8 +3051,31 @@ bad_data: } static int -copy_from_lzss_window(struct archive_read *a, const void **buffer, - int64_t startpos, int length) +copy_from_lzss_window(struct archive_read *a, void *buffer, + int64_t startpos, int length) +{ + int windowoffs, firstpart; + struct rar *rar = (struct rar *)(a->format->data); + + windowoffs = lzss_offset_for_position(&rar->lzss, startpos); + firstpart = lzss_size(&rar->lzss) - windowoffs; + if (firstpart < 0) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Bad RAR file data"); + return (ARCHIVE_FATAL); + } + if (firstpart < length) { + memcpy(buffer, &rar->lzss.window[windowoffs], firstpart); + memcpy(buffer, &rar->lzss.window[0], length - firstpart); + } else { + memcpy(buffer, &rar->lzss.window[windowoffs], length); + } + return (ARCHIVE_OK); +} + +static int +copy_from_lzss_window_to_unp(struct archive_read *a, const void **buffer, + int64_t startpos, int length) { int windowoffs, firstpart; struct rar *rar = (struct rar *)(a->format->data); @@ -3003,3 +3155,599 @@ rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail) } return h; } + +static int +parse_filter(struct archive_read *a, const uint8_t *bytes, uint16_t length, uint8_t flags) +{ + struct rar *rar = (struct rar *)(a->format->data); + struct rar_filters *filters = &rar->filters; + + struct memory_bit_reader br = { 0 }; + struct rar_program_code *prog; + struct rar_filter *filter, **nextfilter; + + uint32_t numprogs, num, blocklength, globaldatalen; + uint8_t *globaldata; + size_t blockstartpos; + uint32_t registers[8] = { 0 }; + uint32_t i; + + br.bytes = bytes; + br.length = length; + + numprogs = 0; + for (prog = filters->progs; prog; prog = prog->next) + numprogs++; + + if ((flags & 0x80)) + { + num = membr_next_rarvm_number(&br); + if (num == 0) + { + delete_filter(filters->stack); + filters->stack = NULL; + delete_program_code(filters->progs); + filters->progs = NULL; + } + else + num--; + if (num > numprogs) { + return 0; + } + filters->lastfilternum = num; + } + else + num = filters->lastfilternum; + + prog = filters->progs; + for (i = 0; i < num; i++) + prog = prog->next; + if (prog) + prog->usagecount++; + + blockstartpos = membr_next_rarvm_number(&br) + (size_t)lzss_position(&rar->lzss); + if ((flags & 0x40)) + blockstartpos += 258; + if ((flags & 0x20)) + blocklength = membr_next_rarvm_number(&br); + else + blocklength = prog ? prog->oldfilterlength : 0; + + registers[3] = PROGRAM_SYSTEM_GLOBAL_ADDRESS; + registers[4] = blocklength; + registers[5] = prog ? prog->usagecount : 0; + registers[7] = VM_MEMORY_SIZE; + + if ((flags & 0x10)) + { + uint8_t mask = (uint8_t)membr_bits(&br, 7); + for (i = 0; i < 7; i++) + if ((mask & (1 << i))) + registers[i] = membr_next_rarvm_number(&br); + } + + if (!prog) + { + uint32_t len = membr_next_rarvm_number(&br); + uint8_t *bytecode; + struct rar_program_code **next; + + if (len == 0 || len > 0x10000) + return 0; + bytecode = malloc(len); + if (!bytecode) + return 0; + for (i = 0; i < len; i++) + bytecode[i] = (uint8_t)membr_bits(&br, 8); + prog = compile_program(bytecode, len); + if (!prog) { + free(bytecode); + return 0; + } + free(bytecode); + next = &filters->progs; + while (*next) + next = &(*next)->next; + *next = prog; + } + prog->oldfilterlength = blocklength; + + globaldata = NULL; + globaldatalen = 0; + if ((flags & 0x08)) + { + globaldatalen = membr_next_rarvm_number(&br); + if (globaldatalen > PROGRAM_USER_GLOBAL_SIZE) + return 0; + globaldata = malloc(globaldatalen + PROGRAM_SYSTEM_GLOBAL_SIZE); + if (!globaldata) + return 0; + for (i = 0; i < globaldatalen; i++) + globaldata[i + PROGRAM_SYSTEM_GLOBAL_SIZE] = (uint8_t)membr_bits(&br, 8); + } + + if (br.at_eof) + { + free(globaldata); + return 0; + } + + filter = create_filter(prog, globaldata, globaldatalen, registers, blockstartpos, blocklength); + free(globaldata); + if (!filter) + return 0; + + for (i = 0; i < 7; i++) + archive_le32enc(&filter->globaldata[i * 4], registers[i]); + archive_le32enc(&filter->globaldata[0x1C], blocklength); + archive_le32enc(&filter->globaldata[0x20], 0); + archive_le32enc(&filter->globaldata[0x2C], prog->usagecount); + + nextfilter = &filters->stack; + while (*nextfilter) + nextfilter = &(*nextfilter)->next; + *nextfilter = filter; + + if (!filters->stack->next) + filters->filterstart = blockstartpos; + + return 1; +} + +static struct rar_filter * +create_filter(struct rar_program_code *prog, const uint8_t *globaldata, uint32_t globaldatalen, uint32_t registers[8], size_t startpos, uint32_t length) +{ + struct rar_filter *filter; + + filter = calloc(1, sizeof(*filter)); + if (!filter) + return NULL; + filter->prog = prog; + filter->globaldatalen = globaldatalen > PROGRAM_SYSTEM_GLOBAL_SIZE ? globaldatalen : PROGRAM_SYSTEM_GLOBAL_SIZE; + filter->globaldata = calloc(1, filter->globaldatalen); + if (!filter->globaldata) + return NULL; + if (globaldata) + memcpy(filter->globaldata, globaldata, globaldatalen); + if (registers) + memcpy(filter->initialregisters, registers, sizeof(filter->initialregisters)); + filter->blockstartpos = startpos; + filter->blocklength = length; + + return filter; +} + +static int +run_filters(struct archive_read *a) +{ + struct rar *rar = (struct rar *)(a->format->data); + struct rar_filters *filters = &rar->filters; + struct rar_filter *filter = filters->stack; + size_t start = filters->filterstart; + size_t end = start + filter->blocklength; + uint32_t lastfilteraddress; + uint32_t lastfilterlength; + int ret; + + filters->filterstart = INT64_MAX; + end = (size_t)expand(a, end); + if (end != start + filter->blocklength) + return 0; + + if (!filters->vm) + { + filters->vm = calloc(1, sizeof(*filters->vm)); + if (!filters->vm) + return 0; + } + + ret = copy_from_lzss_window(a, filters->vm->memory, start, filter->blocklength); + if (ret != ARCHIVE_OK) + return 0; + if (!execute_filter(a, filter, filters->vm, rar->offset)) + return 0; + + lastfilteraddress = filter->filteredblockaddress; + lastfilterlength = filter->filteredblocklength; + filters->stack = filter->next; + filter->next = NULL; + delete_filter(filter); + + while ((filter = filters->stack) != NULL && (int64_t)filter->blockstartpos == filters->filterstart && filter->blocklength == lastfilterlength) + { + memmove(&filters->vm->memory[0], &filters->vm->memory[lastfilteraddress], lastfilterlength); + if (!execute_filter(a, filter, filters->vm, rar->offset)) + return 0; + + lastfilteraddress = filter->filteredblockaddress; + lastfilterlength = filter->filteredblocklength; + filters->stack = filter->next; + filter->next = NULL; + delete_filter(filter); + } + + if (filters->stack) + { + if (filters->stack->blockstartpos < end) + return 0; + filters->filterstart = filters->stack->blockstartpos; + } + + filters->lastend = end; + filters->bytes = &filters->vm->memory[lastfilteraddress]; + filters->bytes_ready = lastfilterlength; + + return 1; +} + +static struct rar_program_code * +compile_program(const uint8_t *bytes, size_t length) +{ + struct memory_bit_reader br = { 0 }; + struct rar_program_code *prog; + // uint32_t instrcount = 0; + uint8_t xor; + size_t i; + + xor = 0; + for (i = 1; i < length; i++) + xor ^= bytes[i]; + if (!length || xor != bytes[0]) + return NULL; + + br.bytes = bytes; + br.length = length; + br.offset = 1; + + prog = calloc(1, sizeof(*prog)); + if (!prog) + return NULL; + prog->fingerprint = crc32(0, bytes, length) | ((uint64_t)length << 32); + + if (membr_bits(&br, 1)) + { + prog->staticdatalen = membr_next_rarvm_number(&br) + 1; + prog->staticdata = malloc(prog->staticdatalen); + if (!prog->staticdata) + { + delete_program_code(prog); + return NULL; + } + for (i = 0; i < prog->staticdatalen; i++) + prog->staticdata[i] = (uint8_t)membr_bits(&br, 8); + } + + return prog; +} + +static void +delete_filter(struct rar_filter *filter) +{ + while (filter) + { + struct rar_filter *next = filter->next; + free(filter->globaldata); + free(filter); + filter = next; + } +} + +static void +clear_filters(struct rar_filters *filters) +{ + delete_filter(filters->stack); + delete_program_code(filters->progs); + free(filters->vm); +} + +static void +delete_program_code(struct rar_program_code *prog) +{ + while (prog) + { + struct rar_program_code *next = prog->next; + free(prog->staticdata); + free(prog->globalbackup); + free(prog); + prog = next; + } +} + +static uint32_t +membr_next_rarvm_number(struct memory_bit_reader *br) +{ + uint32_t val; + switch (membr_bits(br, 2)) + { + case 0: + return membr_bits(br, 4); + case 1: + val = membr_bits(br, 8); + if (val >= 16) + return val; + return 0xFFFFFF00 | (val << 4) | membr_bits(br, 4); + case 2: + return membr_bits(br, 16); + default: + return membr_bits(br, 32); + } +} + +static inline uint32_t +membr_bits(struct memory_bit_reader *br, int bits) +{ + if (bits > br->available && (br->at_eof || !membr_fill(br, bits))) + return 0; + return (uint32_t)((br->bits >> (br->available -= bits)) & (((uint64_t)1 << bits) - 1)); +} + +static int +membr_fill(struct memory_bit_reader *br, int bits) +{ + while (br->available < bits && br->offset < br->length) + { + br->bits = (br->bits << 8) | br->bytes[br->offset++]; + br->available += 8; + } + if (bits > br->available) + { + br->at_eof = 1; + return 0; + } + return 1; +} + +static int +read_filter(struct archive_read *a, int64_t *end) +{ + struct rar *rar = (struct rar *)(a->format->data); + uint8_t flags, val, *code; + uint16_t length, i; + + if (!rar_decode_byte(a, &flags)) + return 0; + length = (flags & 0x07) + 1; + if (length == 7) + { + if (!rar_decode_byte(a, &val)) + return 0; + length = val + 7; + } + else if (length == 8) + { + if (!rar_decode_byte(a, &val)) + return 0; + length = val << 8; + if (!rar_decode_byte(a, &val)) + return 0; + length |= val; + } + + code = malloc(length); + if (!code) + return 0; + for (i = 0; i < length; i++) + { + if (!rar_decode_byte(a, &code[i])) + { + free(code); + return 0; + } + } + if (!parse_filter(a, code, length, flags)) + { + free(code); + return 0; + } + free(code); + + if (rar->filters.filterstart < *end) + *end = rar->filters.filterstart; + + return 1; +} + +static int +execute_filter_delta(struct rar_filter *filter, struct rar_virtual_machine *vm) +{ + uint32_t length = filter->initialregisters[4]; + uint32_t numchannels = filter->initialregisters[0]; + uint8_t *src, *dst; + uint32_t i, idx; + + if (length > PROGRAM_WORK_SIZE / 2) + return 0; + + src = &vm->memory[0]; + dst = &vm->memory[length]; + for (i = 0; i < numchannels; i++) + { + uint8_t lastbyte = 0; + for (idx = i; idx < length; idx += numchannels) + lastbyte = dst[idx] = lastbyte - *src++; + } + + filter->filteredblockaddress = length; + filter->filteredblocklength = length; + + return 1; +} + +static int +execute_filter_e8(struct rar_filter *filter, struct rar_virtual_machine *vm, size_t pos, int e9also) +{ + uint32_t length = filter->initialregisters[4]; + uint32_t filesize = 0x1000000; + uint32_t i; + + if (length > PROGRAM_WORK_SIZE || length < 4) + return 0; + + for (i = 0; i <= length - 5; i++) + { + if (vm->memory[i] == 0xE8 || (e9also && vm->memory[i] == 0xE9)) + { + uint32_t currpos = (uint32_t)pos + i + 1; + int32_t address = (int32_t)vm_read_32(vm, i + 1); + if (address < 0 && currpos >= (uint32_t)-address) + vm_write_32(vm, i + 1, address + filesize); + else if (address >= 0 && (uint32_t)address < filesize) + vm_write_32(vm, i + 1, address - currpos); + i += 4; + } + } + + filter->filteredblockaddress = 0; + filter->filteredblocklength = length; + + return 1; +} + +static int +execute_filter_rgb(struct rar_filter *filter, struct rar_virtual_machine *vm) +{ + uint32_t stride = filter->initialregisters[0]; + uint32_t byteoffset = filter->initialregisters[1]; + uint32_t blocklength = filter->initialregisters[4]; + uint8_t *src, *dst; + uint32_t i, j; + + if (blocklength > PROGRAM_WORK_SIZE / 2 || stride > blocklength) + return 0; + + src = &vm->memory[0]; + dst = &vm->memory[blocklength]; + for (i = 0; i < 3; i++) { + uint8_t byte = 0; + uint8_t *prev = dst + i - stride; + for (j = i; j < blocklength; j += 3) + { + if (prev >= dst) + { + uint32_t delta1 = abs(prev[3] - prev[0]); + uint32_t delta2 = abs(byte - prev[0]); + uint32_t delta3 = abs(prev[3] - prev[0] + byte - prev[0]); + if (delta1 > delta2 || delta1 > delta3) + byte = delta2 <= delta3 ? prev[3] : prev[0]; + } + byte -= *src++; + dst[j] = byte; + prev += 3; + } + } + for (i = byteoffset; i < blocklength - 2; i += 3) + { + dst[i] += dst[i + 1]; + dst[i + 2] += dst[i + 1]; + } + + filter->filteredblockaddress = blocklength; + filter->filteredblocklength = blocklength; + + return 1; +} + +static int +execute_filter_audio(struct rar_filter *filter, struct rar_virtual_machine *vm) +{ + uint32_t length = filter->initialregisters[4]; + uint32_t numchannels = filter->initialregisters[0]; + uint8_t *src, *dst; + uint32_t i, j; + + if (length > PROGRAM_WORK_SIZE / 2) + return 0; + + src = &vm->memory[0]; + dst = &vm->memory[length]; + for (i = 0; i < numchannels; i++) + { + struct audio_state state; + memset(&state, 0, sizeof(state)); + for (j = i; j < length; j += numchannels) + { + int8_t delta = (int8_t)*src++; + uint8_t predbyte, byte; + int prederror; + state.delta[2] = state.delta[1]; + state.delta[1] = state.lastdelta - state.delta[0]; + state.delta[0] = state.lastdelta; + predbyte = ((8 * state.lastbyte + state.weight[0] * state.delta[0] + state.weight[1] * state.delta[1] + state.weight[2] * state.delta[2]) >> 3) & 0xFF; + byte = (predbyte - delta) & 0xFF; + prederror = delta << 3; + state.error[0] += abs(prederror); + state.error[1] += abs(prederror - state.delta[0]); state.error[2] += abs(prederror + state.delta[0]); + state.error[3] += abs(prederror - state.delta[1]); state.error[4] += abs(prederror + state.delta[1]); + state.error[5] += abs(prederror - state.delta[2]); state.error[6] += abs(prederror + state.delta[2]); + state.lastdelta = (int8_t)(byte - state.lastbyte); + dst[j] = state.lastbyte = byte; + if (!(state.count++ & 0x1F)) + { + uint8_t k, idx = 0; + for (k = 1; k < 7; k++) + { + if (state.error[k] < state.error[idx]) + idx = k; + } + memset(state.error, 0, sizeof(state.error)); + switch (idx) + { + case 1: if (state.weight[0] >= -16) state.weight[0]--; break; + case 2: if (state.weight[0] < 16) state.weight[0]++; break; + case 3: if (state.weight[1] >= -16) state.weight[1]--; break; + case 4: if (state.weight[1] < 16) state.weight[1]++; break; + case 5: if (state.weight[2] >= -16) state.weight[2]--; break; + case 6: if (state.weight[2] < 16) state.weight[2]++; break; + } + } + } + } + + filter->filteredblockaddress = length; + filter->filteredblocklength = length; + + return 1; +} + + +static int +execute_filter(struct archive_read *a, struct rar_filter *filter, struct rar_virtual_machine *vm, size_t pos) +{ + if (filter->prog->fingerprint == 0x1D0E06077D) + return execute_filter_delta(filter, vm); + if (filter->prog->fingerprint == 0x35AD576887) + return execute_filter_e8(filter, vm, pos, 0); + if (filter->prog->fingerprint == 0x393CD7E57E) + return execute_filter_e8(filter, vm, pos, 1); + if (filter->prog->fingerprint == 0x951C2C5DC8) + return execute_filter_rgb(filter, vm); + if (filter->prog->fingerprint == 0xD8BC85E701) + return execute_filter_audio(filter, vm); + + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, "No support for RAR VM program filter"); + return 0; +} + +static int +rar_decode_byte(struct archive_read *a, uint8_t *byte) +{ + struct rar *rar = (struct rar *)(a->format->data); + struct rar_br *br = &(rar->br); + if (!rar_br_read_ahead(a, br, 8)) + return 0; + *byte = (uint8_t)rar_br_bits(br, 8); + rar_br_consume(br, 8); + return 1; +} + +static inline void +vm_write_32(struct rar_virtual_machine* vm, size_t offset, uint32_t u32) +{ + archive_le32enc(vm->memory + offset, u32); +} + +static inline uint32_t +vm_read_32(struct rar_virtual_machine* vm, size_t offset) +{ + return archive_le32dec(vm->memory + offset); +} diff --git a/src/libs/3rdparty/libarchive/archive_read_support_format_rar5.c b/src/libs/3rdparty/libarchive/archive_read_support_format_rar5.c index 5d62d16ee..a3cfa72e7 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_format_rar5.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_format_rar5.c @@ -632,7 +632,7 @@ static int run_arm_filter(struct rar5* rar, struct filter_info* flt) { /* 0xEB = ARM's BL (branch + link) instruction. */ offset = read_filter_data(rar, (rar->cstate.solid_offset + flt->block_start + i) & - rar->cstate.window_mask) & 0x00ffffff; + (uint32_t)rar->cstate.window_mask) & 0x00ffffff; offset -= (uint32_t) ((i + flt->block_start) / 4); offset = (offset & 0x00ffffff) | 0xeb000000; @@ -1012,7 +1012,16 @@ static int read_var_sized(struct archive_read* a, size_t* pvalue, return ret; } -static int read_bits_32(struct rar5* rar, const uint8_t* p, uint32_t* value) { +static int read_bits_32(struct archive_read* a, struct rar5* rar, + const uint8_t* p, uint32_t* value) +{ + if(rar->bits.in_addr >= rar->cstate.cur_block_size) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_PROGRAMMER, + "Premature end of stream during extraction of data (#1)"); + return ARCHIVE_FATAL; + } + uint32_t bits = ((uint32_t) p[rar->bits.in_addr]) << 24; bits |= p[rar->bits.in_addr + 1] << 16; bits |= p[rar->bits.in_addr + 2] << 8; @@ -1023,7 +1032,16 @@ static int read_bits_32(struct rar5* rar, const uint8_t* p, uint32_t* value) { return ARCHIVE_OK; } -static int read_bits_16(struct rar5* rar, const uint8_t* p, uint16_t* value) { +static int read_bits_16(struct archive_read* a, struct rar5* rar, + const uint8_t* p, uint16_t* value) +{ + if(rar->bits.in_addr >= rar->cstate.cur_block_size) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_PROGRAMMER, + "Premature end of stream during extraction of data (#2)"); + return ARCHIVE_FATAL; + } + int bits = (int) ((uint32_t) p[rar->bits.in_addr]) << 16; bits |= (int) p[rar->bits.in_addr + 1] << 8; bits |= (int) p[rar->bits.in_addr + 2]; @@ -1039,8 +1057,8 @@ static void skip_bits(struct rar5* rar, int bits) { } /* n = up to 16 */ -static int read_consume_bits(struct rar5* rar, const uint8_t* p, int n, - int* value) +static int read_consume_bits(struct archive_read* a, struct rar5* rar, + const uint8_t* p, int n, int* value) { uint16_t v; int ret, num; @@ -1051,7 +1069,7 @@ static int read_consume_bits(struct rar5* rar, const uint8_t* p, int n, return ARCHIVE_FATAL; } - ret = read_bits_16(rar, p, &v); + ret = read_bits_16(a, rar, p, &v); if(ret != ARCHIVE_OK) return ret; @@ -1099,6 +1117,44 @@ static int bid_standard(struct archive_read* a) { return -1; } +static int bid_sfx(struct archive_read *a) +{ + const char *p; + + if ((p = __archive_read_ahead(a, 7, NULL)) == NULL) + return -1; + + if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) { + /* This is a PE file */ + char signature[sizeof(rar5_signature_xor)]; + ssize_t offset = 0x10000; + ssize_t window = 4096; + ssize_t bytes_avail; + + rar5_signature(signature); + + while (offset + window <= (1024 * 512)) { + const char *buff = __archive_read_ahead(a, offset + window, &bytes_avail); + if (buff == NULL) { + /* Remaining bytes are less than window. */ + window >>= 1; + if (window < 0x40) + return 0; + continue; + } + p = buff + offset; + while (p + 8 < buff + bytes_avail) { + if (memcmp(p, signature, sizeof(signature)) == 0) + return 30; + p += 0x10; + } + offset = p - buff; + } + } + + return 0; +} + static int rar5_bid(struct archive_read* a, int best_bid) { int my_bid; @@ -1109,6 +1165,10 @@ static int rar5_bid(struct archive_read* a, int best_bid) { if(my_bid > -1) { return my_bid; } + my_bid = bid_sfx(a); + if (my_bid > -1) { + return my_bid; + } return -1; } @@ -1712,14 +1772,29 @@ static int process_head_file(struct archive_read* a, struct rar5* rar, } } - /* If we're currently switching volumes, ignore the new definition of - * window_size. */ - if(rar->cstate.switch_multivolume == 0) { - /* Values up to 64M should fit into ssize_t on every - * architecture. */ - rar->cstate.window_size = (ssize_t) window_size; + if(rar->cstate.window_size < (ssize_t) window_size && + rar->cstate.window_buf) + { + /* If window_buf has been allocated before, reallocate it, so + * that its size will match new window_size. */ + + uint8_t* new_window_buf = + realloc(rar->cstate.window_buf, window_size); + + if(!new_window_buf) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, + "Not enough memory when trying to realloc the window " + "buffer."); + return ARCHIVE_FATAL; + } + + rar->cstate.window_buf = new_window_buf; } + /* Values up to 64M should fit into ssize_t on every + * architecture. */ + rar->cstate.window_size = (ssize_t) window_size; + if(rar->file.solid > 0 && rar->file.solid_window_size == 0) { /* Solid files have to have the same window_size across whole archive. Remember the window_size parameter @@ -2273,6 +2348,62 @@ static int skip_base_block(struct archive_read* a) { return ret; } +static int try_skip_sfx(struct archive_read *a) +{ + const char *p; + + if ((p = __archive_read_ahead(a, 7, NULL)) == NULL) + return ARCHIVE_EOF; + + if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) + { + char signature[sizeof(rar5_signature_xor)]; + const void *h; + const char *q; + size_t skip, total = 0; + ssize_t bytes, window = 4096; + + rar5_signature(signature); + + while (total + window <= (1024 * 512)) { + h = __archive_read_ahead(a, window, &bytes); + if (h == NULL) { + /* Remaining bytes are less than window. */ + window >>= 1; + if (window < 0x40) + goto fatal; + continue; + } + if (bytes < 0x40) + goto fatal; + p = h; + q = p + bytes; + + /* + * Scan ahead until we find something that looks + * like the RAR header. + */ + while (p + 8 < q) { + if (memcmp(p, signature, sizeof(signature)) == 0) { + skip = p - (const char *)h; + __archive_read_consume(a, skip); + return (ARCHIVE_OK); + } + p += 0x10; + } + skip = p - (const char *)h; + __archive_read_consume(a, skip); + total += skip; + } + } + + return ARCHIVE_OK; +fatal: + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Couldn't find out RAR header"); + return (ARCHIVE_FATAL); +} + static int rar5_read_header(struct archive_read *a, struct archive_entry *entry) { @@ -2281,6 +2412,8 @@ static int rar5_read_header(struct archive_read *a, if(rar->header_initialized == 0) { init_header(a); + if ((ret = try_skip_sfx(a)) < ARCHIVE_WARN) + return ret; rar->header_initialized = 1; } @@ -2425,13 +2558,13 @@ static int create_decode_tables(uint8_t* bit_length, static int decode_number(struct archive_read* a, struct decode_table* table, const uint8_t* p, uint16_t* num) { - int i, bits, dist; + int i, bits, dist, ret; uint16_t bitfield; uint32_t pos; struct rar5* rar = get_context(a); - if(ARCHIVE_OK != read_bits_16(rar, p, &bitfield)) { - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &bitfield))) { + return ret; } bitfield &= 0xfffe; @@ -2537,14 +2670,6 @@ static int parse_tables(struct archive_read* a, struct rar5* rar, for(i = 0; i < HUFF_TABLE_SIZE;) { uint16_t num; - if((rar->bits.in_addr + 6) >= rar->cstate.cur_block_size) { - /* Truncated data, can't continue. */ - archive_set_error(&a->archive, - ARCHIVE_ERRNO_FILE_FORMAT, - "Truncated data in huffman tables (#2)"); - return ARCHIVE_FATAL; - } - ret = decode_number(a, &rar->cstate.bd, p, &num); if(ret != ARCHIVE_OK) { archive_set_error(&a->archive, @@ -2561,8 +2686,8 @@ static int parse_tables(struct archive_read* a, struct rar5* rar, /* 16..17: repeat previous code */ uint16_t n; - if(ARCHIVE_OK != read_bits_16(rar, p, &n)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &n))) + return ret; if(num == 16) { n >>= 13; @@ -2590,8 +2715,8 @@ static int parse_tables(struct archive_read* a, struct rar5* rar, /* other codes: fill with zeroes `n` times */ uint16_t n; - if(ARCHIVE_OK != read_bits_16(rar, p, &n)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &n))) + return ret; if(num == 18) { n >>= 13; @@ -2707,22 +2832,22 @@ static int parse_block_header(struct archive_read* a, const uint8_t* p, } /* Convenience function used during filter processing. */ -static int parse_filter_data(struct rar5* rar, const uint8_t* p, - uint32_t* filter_data) +static int parse_filter_data(struct archive_read* a, struct rar5* rar, + const uint8_t* p, uint32_t* filter_data) { - int i, bytes; + int i, bytes, ret; uint32_t data = 0; - if(ARCHIVE_OK != read_consume_bits(rar, p, 2, &bytes)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_consume_bits(a, rar, p, 2, &bytes))) + return ret; bytes++; for(i = 0; i < bytes; i++) { uint16_t byte; - if(ARCHIVE_OK != read_bits_16(rar, p, &byte)) { - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &byte))) { + return ret; } /* Cast to uint32_t will ensure the shift operation will not @@ -2765,16 +2890,17 @@ static int parse_filter(struct archive_read* ar, const uint8_t* p) { uint16_t filter_type; struct filter_info* filt = NULL; struct rar5* rar = get_context(ar); + int ret; /* Read the parameters from the input stream. */ - if(ARCHIVE_OK != parse_filter_data(rar, p, &block_start)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = parse_filter_data(ar, rar, p, &block_start))) + return ret; - if(ARCHIVE_OK != parse_filter_data(rar, p, &block_length)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = parse_filter_data(ar, rar, p, &block_length))) + return ret; - if(ARCHIVE_OK != read_bits_16(rar, p, &filter_type)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_bits_16(ar, rar, p, &filter_type))) + return ret; filter_type >>= 13; skip_bits(rar, 3); @@ -2814,8 +2940,8 @@ static int parse_filter(struct archive_read* ar, const uint8_t* p) { if(filter_type == FILTER_DELTA) { int channels; - if(ARCHIVE_OK != read_consume_bits(rar, p, 5, &channels)) - return ARCHIVE_EOF; + if(ARCHIVE_OK != (ret = read_consume_bits(ar, rar, p, 5, &channels))) + return ret; filt->channels = channels + 1; } @@ -2823,10 +2949,11 @@ static int parse_filter(struct archive_read* ar, const uint8_t* p) { return ARCHIVE_OK; } -static int decode_code_length(struct rar5* rar, const uint8_t* p, - uint16_t code) +static int decode_code_length(struct archive_read* a, struct rar5* rar, + const uint8_t* p, uint16_t code) { int lbits, length = 2; + if(code < 8) { lbits = 0; length += code; @@ -2838,7 +2965,7 @@ static int decode_code_length(struct rar5* rar, const uint8_t* p, if(lbits > 0) { int add; - if(ARCHIVE_OK != read_consume_bits(rar, p, lbits, &add)) + if(ARCHIVE_OK != read_consume_bits(a, rar, p, lbits, &add)) return -1; length += add; @@ -2933,7 +3060,7 @@ static int do_uncompress_block(struct archive_read* a, const uint8_t* p) { continue; } else if(num >= 262) { uint16_t dist_slot; - int len = decode_code_length(rar, p, num - 262), + int len = decode_code_length(a, rar, p, num - 262), dbits, dist = 1; @@ -2975,12 +3102,12 @@ static int do_uncompress_block(struct archive_read* a, const uint8_t* p) { uint16_t low_dist; if(dbits > 4) { - if(ARCHIVE_OK != read_bits_32( - rar, p, &add)) { + if(ARCHIVE_OK != (ret = read_bits_32( + a, rar, p, &add))) { /* Return EOF if we * can't read more * data. */ - return ARCHIVE_EOF; + return ret; } skip_bits(rar, dbits - 4); @@ -3015,11 +3142,11 @@ static int do_uncompress_block(struct archive_read* a, const uint8_t* p) { /* dbits is one of [0,1,2,3] */ int add; - if(ARCHIVE_OK != read_consume_bits(rar, - p, dbits, &add)) { + if(ARCHIVE_OK != (ret = read_consume_bits(a, rar, + p, dbits, &add))) { /* Return EOF if we can't read * more data. */ - return ARCHIVE_EOF; + return ret; } dist += add; @@ -3076,7 +3203,11 @@ static int do_uncompress_block(struct archive_read* a, const uint8_t* p) { return ARCHIVE_FATAL; } - len = decode_code_length(rar, p, len_slot); + len = decode_code_length(a, rar, p, len_slot); + if (len == -1) { + return ARCHIVE_FATAL; + } + rar->cstate.last_len = len; if(ARCHIVE_OK != copy_string(a, len, dist)) @@ -3600,6 +3731,16 @@ static int do_uncompress_file(struct archive_read* a) { rar->cstate.initialized = 1; } + /* Don't allow extraction if window_size is invalid. */ + if(rar->cstate.window_size == 0) { + archive_set_error(&a->archive, + ARCHIVE_ERRNO_FILE_FORMAT, + "Invalid window size declaration in this file"); + + /* This should never happen in valid files. */ + return ARCHIVE_FATAL; + } + if(rar->cstate.all_filters_applied == 1) { /* We use while(1) here, but standard case allows for just 1 * iteration. The loop will iterate if process_block() didn't diff --git a/src/libs/3rdparty/libarchive/archive_read_support_format_tar.c b/src/libs/3rdparty/libarchive/archive_read_support_format_tar.c index 7e8febacf..bfdad7f87 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_format_tar.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_format_tar.c @@ -573,11 +573,15 @@ archive_read_format_tar_read_header(struct archive_read *a, l = wcslen(wp); if (l > 0 && wp[l - 1] == L'/') { archive_entry_set_filetype(entry, AE_IFDIR); + tar->entry_bytes_remaining = 0; + tar->entry_padding = 0; } } else if ((p = archive_entry_pathname(entry)) != NULL) { l = strlen(p); if (l > 0 && p[l - 1] == '/') { archive_entry_set_filetype(entry, AE_IFDIR); + tar->entry_bytes_remaining = 0; + tar->entry_padding = 0; } } } @@ -1396,6 +1400,7 @@ read_mac_metadata_blob(struct archive_read *a, struct tar *tar, struct archive_entry *entry, const void *h, size_t *unconsumed) { int64_t size; + size_t msize; const void *data; const char *p, *name; const wchar_t *wp, *wname; @@ -1434,6 +1439,11 @@ read_mac_metadata_blob(struct archive_read *a, struct tar *tar, /* Read the body as a Mac OS metadata blob. */ size = archive_entry_size(entry); + msize = (size_t)size; + if (size < 0 || (uintmax_t)msize != (uintmax_t)size) { + *unconsumed = 0; + return (ARCHIVE_FATAL); + } /* * TODO: Look beyond the body here to peek at the next header. @@ -1447,13 +1457,13 @@ read_mac_metadata_blob(struct archive_read *a, struct tar *tar, * Q: Is the above idea really possible? Even * when there are GNU or pax extension entries? */ - data = __archive_read_ahead(a, (size_t)size, NULL); + data = __archive_read_ahead(a, msize, NULL); if (data == NULL) { *unconsumed = 0; return (ARCHIVE_FATAL); } - archive_entry_copy_mac_metadata(entry, data, (size_t)size); - *unconsumed = (size_t)((size + 511) & ~ 511); + archive_entry_copy_mac_metadata(entry, data, msize); + *unconsumed = (msize + 511) & ~ 511; tar_flush_unconsumed(a, unconsumed); return (tar_read_header(a, tar, entry, unconsumed)); } diff --git a/src/libs/3rdparty/libarchive/archive_read_support_format_zip.c b/src/libs/3rdparty/libarchive/archive_read_support_format_zip.c index 21d41cc0f..38ada70b5 100644 --- a/src/libs/3rdparty/libarchive/archive_read_support_format_zip.c +++ b/src/libs/3rdparty/libarchive/archive_read_support_format_zip.c @@ -58,6 +58,9 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_format_zip.c 201102 #ifdef HAVE_LZMA_H #include <lzma.h> #endif +#ifdef HAVE_ZSTD_H +#include <zstd.h> +#endif #include "archive.h" #include "archive_digest_private.h" @@ -191,6 +194,11 @@ struct zip { char bzstream_valid; #endif +#if HAVE_ZSTD_H && HAVE_LIBZSTD + ZSTD_DStream *zstdstream; + char zstdstream_valid; +#endif + IByteIn zipx_ppmd_stream; ssize_t zipx_ppmd_read_compressed; CPpmd8 ppmd8; @@ -435,6 +443,7 @@ 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) */ + {93, "zstd"}, /* Zstandard (zstd) Compression */ {95, "xz"}, /* XZ compressed data */ {96, "jpeg"}, /* JPEG compressed data */ {97, "wav-pack"}, /* WavPack compressed data */ @@ -1144,7 +1153,8 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, (intmax_t)zip_entry->compressed_size); ret = ARCHIVE_WARN; } - if (zip_entry->uncompressed_size == 0) { + if (zip_entry->uncompressed_size == 0 || + zip_entry->uncompressed_size == 0xffffffff) { zip_entry->uncompressed_size = zip_entry_central_dir.uncompressed_size; } else if (zip_entry->uncompressed_size @@ -1186,7 +1196,7 @@ zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, { // symlink target string appeared to be compressed int status = ARCHIVE_FATAL; - const void *uncompressed_buffer; + const void *uncompressed_buffer = NULL; switch (zip->entry->compression) { @@ -2238,6 +2248,140 @@ zip_read_data_zipx_bzip2(struct archive_read *a, const void **buff, #endif +#if HAVE_ZSTD_H && HAVE_LIBZSTD +static int +zipx_zstd_init(struct archive_read *a, struct zip *zip) +{ + size_t r; + + /* Deallocate already existing Zstd decompression context if it + * exists. */ + if(zip->zstdstream_valid) { + ZSTD_freeDStream(zip->zstdstream); + zip->zstdstream_valid = 0; + } + + /* Allocate a new Zstd decompression context. */ + zip->zstdstream = ZSTD_createDStream(); + + r = ZSTD_initDStream(zip->zstdstream); + if (ZSTD_isError(r)) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Error initializing zstd decompressor: %s", + ZSTD_getErrorName(r)); + + return ARCHIVE_FAILED; + } + + /* Mark the zstdstream field to be released in cleanup phase. */ + zip->zstdstream_valid = 1; + + /* (Re)allocate the buffer that will contain decompressed bytes. */ + free(zip->uncompressed_buffer); + + zip->uncompressed_buffer_size = ZSTD_DStreamOutSize(); + zip->uncompressed_buffer = + (uint8_t*) malloc(zip->uncompressed_buffer_size); + if (zip->uncompressed_buffer == NULL) { + archive_set_error(&a->archive, ENOMEM, + "No memory for Zstd decompression"); + + return ARCHIVE_FATAL; + } + + /* Initialization done. */ + zip->decompress_init = 1; + return ARCHIVE_OK; +} + +static int +zip_read_data_zipx_zstd(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; + size_t ret; + uint64_t total_out; + ZSTD_outBuffer out; + ZSTD_inBuffer in; + + (void) offset; /* UNUSED */ + + /* Initialize decompression context if we're here for the first time. */ + if(!zip->decompress_init) { + r = zipx_zstd_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 zstd file body"); + return (ARCHIVE_FATAL); + } + + in_bytes = zipmin(zip->entry_bytes_remaining, bytes_avail); + if(in_bytes < 1) { + /* zstd doesn't complain when caller feeds avail_in == 0. + * It will actually return success in this case, which is + * undesirable. This is why we need to make this check + * manually. */ + archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, + "Truncated zstd file body"); + return (ARCHIVE_FATAL); + } + + /* Setup buffer boundaries */ + in.src = compressed_buff; + in.size = in_bytes; + in.pos = 0; + out = (ZSTD_outBuffer) { zip->uncompressed_buffer, zip->uncompressed_buffer_size, 0 }; + + /* Perform the decompression. */ + ret = ZSTD_decompressStream(zip->zstdstream, &out, &in); + if (ZSTD_isError(ret)) { + archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, + "Error during zstd decompression: %s", + ZSTD_getErrorName(ret)); + return (ARCHIVE_FATAL); + } + + /* Check end of the stream. */ + if (ret == 0) { + if ((in.pos == in.size) && (out.pos < out.size)) { + zip->end_of_entry = 1; + ZSTD_freeDStream(zip->zstdstream); + zip->zstdstream_valid = 0; + } + } + + /* Update the pointers so decompressor can continue decoding. */ + to_consume = in.pos; + __archive_read_consume(a, to_consume); + + total_out = out.pos; + + 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) @@ -2858,6 +3002,11 @@ archive_read_format_zip_read_data(struct archive_read *a, r = zip_read_data_zipx_xz(a, buff, size, offset); break; #endif +#if HAVE_ZSTD_H && HAVE_LIBZSTD + case 93: /* ZIPx Zstd compression. */ + r = zip_read_data_zipx_zstd(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); @@ -2948,6 +3097,12 @@ archive_read_format_zip_cleanup(struct archive_read *a) } #endif +#if HAVE_ZSTD_H && HAVE_LIBZSTD + if (zip->zstdstream_valid) { + ZSTD_freeDStream(zip->zstdstream); + } +#endif + free(zip->uncompressed_buffer); if (zip->ppmd8_valid) diff --git a/src/libs/3rdparty/libarchive/archive_string.c b/src/libs/3rdparty/libarchive/archive_string.c index 7460ded00..d7f2c46b2 100644 --- a/src/libs/3rdparty/libarchive/archive_string.c +++ b/src/libs/3rdparty/libarchive/archive_string.c @@ -745,7 +745,7 @@ archive_string_append_from_wcs_in_codepage(struct archive_string *as, dp = &defchar_used; count = WideCharToMultiByte(to_cp, 0, ws, wslen, as->s + as->length, - (int)as->buffer_length - as->length - 1, NULL, dp); + (int)as->buffer_length - (int)as->length - 1, NULL, dp); if (count == 0 && GetLastError() == ERROR_INSUFFICIENT_BUFFER) { /* Expand the MBS buffer and retry. */ diff --git a/src/libs/3rdparty/libarchive/archive_write.c b/src/libs/3rdparty/libarchive/archive_write.c index 38c14cba7..66592e826 100644 --- a/src/libs/3rdparty/libarchive/archive_write.c +++ b/src/libs/3rdparty/libarchive/archive_write.c @@ -60,8 +60,6 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_write.c 201099 2009-12-28 03:03: #include "archive_private.h" #include "archive_write_private.h" -static struct archive_vtable *archive_write_vtable(void); - static int _archive_filter_code(struct archive *, int); static const char *_archive_filter_name(struct archive *, int); static int64_t _archive_filter_bytes(struct archive *, int); @@ -79,26 +77,18 @@ struct archive_none { char *next; }; -static struct archive_vtable * -archive_write_vtable(void) -{ - static struct archive_vtable av; - static int inited = 0; - - if (!inited) { - av.archive_close = _archive_write_close; - av.archive_filter_bytes = _archive_filter_bytes; - av.archive_filter_code = _archive_filter_code; - av.archive_filter_name = _archive_filter_name; - av.archive_filter_count = _archive_write_filter_count; - av.archive_free = _archive_write_free; - av.archive_write_header = _archive_write_header; - av.archive_write_finish_entry = _archive_write_finish_entry; - av.archive_write_data = _archive_write_data; - inited = 1; - } - return (&av); -} +static const struct archive_vtable +archive_write_vtable = { + .archive_close = _archive_write_close, + .archive_filter_bytes = _archive_filter_bytes, + .archive_filter_code = _archive_filter_code, + .archive_filter_name = _archive_filter_name, + .archive_filter_count = _archive_write_filter_count, + .archive_free = _archive_write_free, + .archive_write_header = _archive_write_header, + .archive_write_finish_entry = _archive_write_finish_entry, + .archive_write_data = _archive_write_data, +}; /* * Allocate, initialize and return an archive object. @@ -114,7 +104,7 @@ archive_write_new(void) return (NULL); a->archive.magic = ARCHIVE_WRITE_MAGIC; a->archive.state = ARCHIVE_STATE_NEW; - a->archive.vtable = archive_write_vtable(); + a->archive.vtable = &archive_write_vtable; /* * The value 10240 here matches the traditional tar default, * but is otherwise arbitrary. diff --git a/src/libs/3rdparty/libarchive/archive_write_add_filter_xz.c b/src/libs/3rdparty/libarchive/archive_write_add_filter_xz.c index 9dd2c30e5..04bee90ef 100644 --- a/src/libs/3rdparty/libarchive/archive_write_add_filter_xz.c +++ b/src/libs/3rdparty/libarchive/archive_write_add_filter_xz.c @@ -251,13 +251,13 @@ archive_compressor_xz_init_stream(struct archive_write_filter *f, int ds, log2dic, wedges; /* Calculate a coded dictionary size */ - if (dict_size < (1 << 12) || dict_size > (1 << 27)) { + if (dict_size < (1 << 12) || dict_size > (1 << 29)) { archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, "Unacceptable dictionary size for lzip: %d", dict_size); return (ARCHIVE_FATAL); } - for (log2dic = 27; log2dic >= 12; log2dic--) { + for (log2dic = 29; log2dic >= 12; log2dic--) { if (dict_size & (1 << log2dic)) break; } diff --git a/src/libs/3rdparty/libarchive/archive_write_add_filter_zstd.c b/src/libs/3rdparty/libarchive/archive_write_add_filter_zstd.c index c74a35cde..e85b7669c 100644 --- a/src/libs/3rdparty/libarchive/archive_write_add_filter_zstd.c +++ b/src/libs/3rdparty/libarchive/archive_write_add_filter_zstd.c @@ -50,7 +50,8 @@ __FBSDID("$FreeBSD$"); struct private_data { int compression_level; -#if HAVE_ZSTD_H && HAVE_LIBZSTD + int threads; +#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR ZSTD_CStream *cstream; int64_t total_in; ZSTD_outBuffer out; @@ -76,7 +77,7 @@ static int archive_compressor_zstd_write(struct archive_write_filter *, const void *, size_t); static int archive_compressor_zstd_close(struct archive_write_filter *); static int archive_compressor_zstd_free(struct archive_write_filter *); -#if HAVE_ZSTD_H && HAVE_LIBZSTD +#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR static int drive_compressor(struct archive_write_filter *, struct private_data *, int, const void *, size_t); #endif @@ -107,7 +108,8 @@ archive_write_add_filter_zstd(struct archive *_a) f->code = ARCHIVE_FILTER_ZSTD; f->name = "zstd"; data->compression_level = CLEVEL_DEFAULT; -#if HAVE_ZSTD_H && HAVE_LIBZSTD + data->threads = 0; +#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR data->cstream = ZSTD_createCStream(); if (data->cstream == NULL) { free(data); @@ -134,7 +136,7 @@ static int archive_compressor_zstd_free(struct archive_write_filter *f) { struct private_data *data = (struct private_data *)f->data; -#if HAVE_ZSTD_H && HAVE_LIBZSTD +#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR ZSTD_freeCStream(data->cstream); free(data->out.dst); #else @@ -187,7 +189,7 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key, if (string_is_numeric(value) != ARCHIVE_OK) { return (ARCHIVE_WARN); } -#if HAVE_ZSTD_H && HAVE_LIBZSTD +#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR maximum = ZSTD_maxCLevel(); #if ZSTD_VERSION_NUMBER >= MINVER_MINCLEVEL if (ZSTD_versionNumber() >= MINVER_MINCLEVEL) { @@ -204,6 +206,20 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key, } data->compression_level = level; return (ARCHIVE_OK); + } else if (strcmp(key, "threads") == 0) { + int threads = atoi(value); + if (string_is_numeric(value) != ARCHIVE_OK) { + return (ARCHIVE_WARN); + } + + int minimum = 0; + + if (threads < minimum) { + return (ARCHIVE_WARN); + } + + data->threads = threads; + return (ARCHIVE_OK); } /* Note: The "warn" return is just to inform the options @@ -212,7 +228,7 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key, return (ARCHIVE_WARN); } -#if HAVE_ZSTD_H && HAVE_LIBZSTD +#if HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR /* * Setup callback. */ @@ -252,6 +268,8 @@ archive_compressor_zstd_open(struct archive_write_filter *f) return (ARCHIVE_FATAL); } + ZSTD_CCtx_setParameter(data->cstream, ZSTD_c_nbWorkers, data->threads); + return (ARCHIVE_OK); } @@ -335,7 +353,7 @@ drive_compressor(struct archive_write_filter *f, } } -#else /* HAVE_ZSTD_H && HAVE_LIBZSTD */ +#else /* HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR */ static int archive_compressor_zstd_open(struct archive_write_filter *f) @@ -366,6 +384,14 @@ archive_compressor_zstd_open(struct archive_write_filter *f) archive_strcat(&as, " --ultra"); } + if (data->threads != 0) { + struct archive_string as2; + archive_string_init(&as2); + archive_string_sprintf(&as2, " --threads=%d", data->threads); + archive_string_concat(&as, &as2); + archive_string_free(&as2); + } + f->write = archive_compressor_zstd_write; r = __archive_write_program_open(f, data->pdata, as.s); archive_string_free(&as); @@ -389,4 +415,4 @@ archive_compressor_zstd_close(struct archive_write_filter *f) return __archive_write_program_close(f, data->pdata); } -#endif /* HAVE_ZSTD_H && HAVE_LIBZSTD */ +#endif /* HAVE_ZSTD_H && HAVE_LIBZSTD_COMPRESSOR */ diff --git a/src/libs/3rdparty/libarchive/archive_write_disk_posix.c b/src/libs/3rdparty/libarchive/archive_write_disk_posix.c index fcd733aff..dd7eb9a5e 100644 --- a/src/libs/3rdparty/libarchive/archive_write_disk_posix.c +++ b/src/libs/3rdparty/libarchive/archive_write_disk_posix.c @@ -173,6 +173,7 @@ struct fixup_entry { struct fixup_entry *next; struct archive_acl acl; mode_t mode; + __LA_MODE_T filetype; int64_t atime; int64_t birthtime; int64_t mtime; @@ -357,6 +358,7 @@ struct archive_write_disk { static int la_opendirat(int, const char *); static int la_mktemp(struct archive_write_disk *); +static int la_verify_filetype(mode_t, __LA_MODE_T); static void fsobj_error(int *, struct archive_string *, int, const char *, const char *); static int check_symlinks_fsobj(char *, int *, struct archive_string *, @@ -396,8 +398,6 @@ static struct fixup_entry *sort_dir_list(struct fixup_entry *p); static ssize_t write_data_block(struct archive_write_disk *, const char *, size_t); -static struct archive_vtable *archive_write_disk_vtable(void); - static int _archive_write_disk_close(struct archive *); static int _archive_write_disk_free(struct archive *); static int _archive_write_disk_header(struct archive *, @@ -465,6 +465,39 @@ la_opendirat(int fd, const char *path) { } static int +la_verify_filetype(mode_t mode, __LA_MODE_T filetype) { + int ret = 0; + + switch (filetype) { + case AE_IFREG: + ret = (S_ISREG(mode)); + break; + case AE_IFDIR: + ret = (S_ISDIR(mode)); + break; + case AE_IFLNK: + ret = (S_ISLNK(mode)); + break; + case AE_IFSOCK: + ret = (S_ISSOCK(mode)); + break; + case AE_IFCHR: + ret = (S_ISCHR(mode)); + break; + case AE_IFBLK: + ret = (S_ISBLK(mode)); + break; + case AE_IFIFO: + ret = (S_ISFIFO(mode)); + break; + default: + break; + } + + return (ret); +} + +static int lazy_stat(struct archive_write_disk *a) { if (a->pst != NULL) { @@ -489,25 +522,16 @@ lazy_stat(struct archive_write_disk *a) return (ARCHIVE_WARN); } -static struct archive_vtable * -archive_write_disk_vtable(void) -{ - static struct archive_vtable av; - static int inited = 0; - - if (!inited) { - av.archive_close = _archive_write_disk_close; - av.archive_filter_bytes = _archive_write_disk_filter_bytes; - av.archive_free = _archive_write_disk_free; - av.archive_write_header = _archive_write_disk_header; - av.archive_write_finish_entry - = _archive_write_disk_finish_entry; - av.archive_write_data = _archive_write_disk_data; - av.archive_write_data_block = _archive_write_disk_data_block; - inited = 1; - } - return (&av); -} +static const struct archive_vtable +archive_write_disk_vtable = { + .archive_close = _archive_write_disk_close, + .archive_filter_bytes = _archive_write_disk_filter_bytes, + .archive_free = _archive_write_disk_free, + .archive_write_header = _archive_write_disk_header, + .archive_write_finish_entry = _archive_write_disk_finish_entry, + .archive_write_data = _archive_write_disk_data, + .archive_write_data_block = _archive_write_disk_data_block, +}; static int64_t _archive_write_disk_filter_bytes(struct archive *_a, int n) @@ -822,6 +846,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry) fe = current_fixup(a, archive_entry_pathname(entry)); if (fe == NULL) return (ARCHIVE_FATAL); + fe->filetype = archive_entry_filetype(entry); fe->fixup |= TODO_MODE_BASE; fe->mode = a->mode; } @@ -832,6 +857,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry) fe = current_fixup(a, archive_entry_pathname(entry)); if (fe == NULL) return (ARCHIVE_FATAL); + fe->filetype = archive_entry_filetype(entry); fe->mode = a->mode; fe->fixup |= TODO_TIMES; if (archive_entry_atime_is_set(entry)) { @@ -865,6 +891,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry) fe = current_fixup(a, archive_entry_pathname(entry)); if (fe == NULL) return (ARCHIVE_FATAL); + fe->filetype = archive_entry_filetype(entry); fe->fixup |= TODO_ACLS; archive_acl_copy(&fe->acl, archive_entry_acl(entry)); } @@ -877,6 +904,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry) fe = current_fixup(a, archive_entry_pathname(entry)); if (fe == NULL) return (ARCHIVE_FATAL); + fe->filetype = archive_entry_filetype(entry); fe->mac_metadata = malloc(metadata_size); if (fe->mac_metadata != NULL) { memcpy(fe->mac_metadata, metadata, @@ -891,6 +919,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry) fe = current_fixup(a, archive_entry_pathname(entry)); if (fe == NULL) return (ARCHIVE_FATAL); + fe->filetype = archive_entry_filetype(entry); fe->fixup |= TODO_FFLAGS; /* TODO: Complete this.. defer fflags from below. */ } @@ -1956,7 +1985,7 @@ archive_write_disk_new(void) a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC; /* We're ready to write a header immediately. */ a->archive.state = ARCHIVE_STATE_HEADER; - a->archive.vtable = archive_write_disk_vtable(); + a->archive.vtable = &archive_write_disk_vtable; a->start_time = time(NULL); /* Query and restore the umask. */ umask(a->user_umask = umask(0)); @@ -2462,7 +2491,8 @@ _archive_write_disk_close(struct archive *_a) struct archive_write_disk *a = (struct archive_write_disk *)_a; struct fixup_entry *next, *p; struct stat st; - int fd, ret; + char *c; + int fd, ret, openflags; archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC, ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, @@ -2475,24 +2505,70 @@ _archive_write_disk_close(struct archive *_a) while (p != NULL) { fd = -1; a->pst = NULL; /* Mark stat cache as out-of-date. */ - if (p->fixup & - (TODO_TIMES | TODO_MODE_BASE | TODO_ACLS | TODO_FFLAGS)) { - fd = open(p->name, - O_WRONLY | O_BINARY | O_NOFOLLOW | O_CLOEXEC); - if (fd == -1) { - /* If we cannot lstat, skip entry */ - if (lstat(p->name, &st) != 0) + + /* We must strip trailing slashes from the path to avoid + dereferencing symbolic links to directories */ + c = p->name; + while (*c != '\0') + c++; + while (c != p->name && *(c - 1) == '/') { + c--; + *c = '\0'; + } + + if (p->fixup == 0) + goto skip_fixup_entry; + else { + /* + * We need to verify if the type of the file + * we are going to open matches the file type + * of the fixup entry. + */ + openflags = O_BINARY | O_NOFOLLOW | O_RDONLY + | O_CLOEXEC; +#if defined(O_DIRECTORY) + if (p->filetype == AE_IFDIR) + openflags |= O_DIRECTORY; +#endif + fd = open(p->name, openflags); + +#if defined(O_DIRECTORY) + /* + * If we support O_DIRECTORY and open was + * successful we can skip the file type check + * for directories. For other file types + * we need to verify via fstat() or lstat() + */ + if (fd == -1 || p->filetype != AE_IFDIR) { +#if HAVE_FSTAT + if (fd > 0 && ( + fstat(fd, &st) != 0 || + la_verify_filetype(st.st_mode, + p->filetype) == 0)) { + goto skip_fixup_entry; + } else +#endif + if (lstat(p->name, &st) != 0 || + la_verify_filetype(st.st_mode, + p->filetype) == 0) { goto skip_fixup_entry; - /* - * If we deal with a symbolic link, mark - * it in the fixup mode to ensure no - * modifications are made to its target. - */ - if (S_ISLNK(st.st_mode)) { - p->mode &= ~S_IFMT; - p->mode |= S_IFLNK; } } +#else +#if HAVE_FSTAT + if (fd > 0 && ( + fstat(fd, &st) != 0 || + la_verify_filetype(st.st_mode, + p->filetype) == 0)) { + goto skip_fixup_entry; + } else +#endif + if (lstat(p->name, &st) != 0 || + la_verify_filetype(st.st_mode, + p->filetype) == 0) { + goto skip_fixup_entry; + } +#endif } if (p->fixup & TODO_TIMES) { set_times(a, fd, p->mode, p->name, @@ -2504,14 +2580,13 @@ _archive_write_disk_close(struct archive *_a) if (p->fixup & TODO_MODE_BASE) { #ifdef HAVE_FCHMOD if (fd >= 0) - fchmod(fd, p->mode); + fchmod(fd, p->mode & 07777); else #endif #ifdef HAVE_LCHMOD - lchmod(p->name, p->mode); + lchmod(p->name, p->mode & 07777); #else - if (!S_ISLNK(p->mode)) - chmod(p->name, p->mode); + chmod(p->name, p->mode & 07777); #endif } if (p->fixup & TODO_ACLS) @@ -2664,7 +2739,7 @@ new_fixup(struct archive_write_disk *a, const char *pathname) fe->next = a->fixup_list; a->fixup_list = fe; fe->fixup = 0; - fe->mode = 0; + fe->filetype = 0; fe->name = strdup(pathname); return (fe); } @@ -3787,6 +3862,7 @@ set_fflags(struct archive_write_disk *a) le = current_fixup(a, a->name); if (le == NULL) return (ARCHIVE_FATAL); + le->filetype = archive_entry_filetype(a->entry); le->fixup |= TODO_FFLAGS; le->fflags_set = set; /* Store the mode if it's not already there. */ diff --git a/src/libs/3rdparty/libarchive/archive_write_disk_windows.c b/src/libs/3rdparty/libarchive/archive_write_disk_windows.c index 0c600176c..1b12a299c 100644 --- a/src/libs/3rdparty/libarchive/archive_write_disk_windows.c +++ b/src/libs/3rdparty/libarchive/archive_write_disk_windows.c @@ -213,7 +213,7 @@ static int check_symlinks(struct archive_write_disk *); static int create_filesystem_object(struct archive_write_disk *); static struct fixup_entry *current_fixup(struct archive_write_disk *, const wchar_t *pathname); -static int cleanup_pathname(struct archive_write_disk *); +static int cleanup_pathname(struct archive_write_disk *, wchar_t *); static int create_dir(struct archive_write_disk *, wchar_t *); static int create_parent_dir(struct archive_write_disk *, wchar_t *); static int la_chmod(const wchar_t *, mode_t); @@ -238,8 +238,6 @@ static struct fixup_entry *sort_dir_list(struct fixup_entry *p); static ssize_t write_data_block(struct archive_write_disk *, const char *, size_t); -static struct archive_vtable *archive_write_disk_vtable(void); - static int _archive_write_disk_close(struct archive *); static int _archive_write_disk_free(struct archive *); static int _archive_write_disk_header(struct archive *, @@ -628,7 +626,7 @@ la_CreateSymbolicLinkW(const wchar_t *linkname, const wchar_t *target, static BOOLEAN (WINAPI *f)(LPCWSTR, LPCWSTR, DWORD); static int set; wchar_t *ttarget, *p; - int len; + size_t len; DWORD attrs = 0; DWORD flags = 0; DWORD newflags = 0; @@ -759,25 +757,16 @@ lazy_stat(struct archive_write_disk *a) return (ARCHIVE_WARN); } -static struct archive_vtable * -archive_write_disk_vtable(void) -{ - static struct archive_vtable av; - static int inited = 0; - - if (!inited) { - av.archive_close = _archive_write_disk_close; - av.archive_filter_bytes = _archive_write_disk_filter_bytes; - av.archive_free = _archive_write_disk_free; - av.archive_write_header = _archive_write_disk_header; - av.archive_write_finish_entry - = _archive_write_disk_finish_entry; - av.archive_write_data = _archive_write_disk_data; - av.archive_write_data_block = _archive_write_disk_data_block; - inited = 1; - } - return (&av); -} +static const struct archive_vtable +archive_write_disk_vtable = { + .archive_close = _archive_write_disk_close, + .archive_filter_bytes = _archive_write_disk_filter_bytes, + .archive_free = _archive_write_disk_free, + .archive_write_header = _archive_write_disk_header, + .archive_write_finish_entry = _archive_write_disk_finish_entry, + .archive_write_data = _archive_write_disk_data, + .archive_write_data_block = _archive_write_disk_data_block, +}; static int64_t _archive_write_disk_filter_bytes(struct archive *_a, int n) @@ -854,7 +843,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry) * dir restores; the dir restore logic otherwise gets messed * up by nonsense like "dir/.". */ - ret = cleanup_pathname(a); + ret = cleanup_pathname(a, a->name); if (ret != ARCHIVE_OK) return (ret); @@ -1373,7 +1362,7 @@ archive_write_disk_new(void) a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC; /* We're ready to write a header immediately. */ a->archive.state = ARCHIVE_STATE_HEADER; - a->archive.vtable = archive_write_disk_vtable(); + a->archive.vtable = &archive_write_disk_vtable; a->start_time = time(NULL); /* Query and restore the umask. */ umask(a->user_umask = umask(0)); @@ -1671,9 +1660,22 @@ create_filesystem_object(struct archive_write_disk *a) /* Since link(2) and symlink(2) don't handle modes, we're done here. */ linkname = archive_entry_hardlink_w(a->entry); if (linkname != NULL) { - wchar_t *linkfull, *namefull; - - linkfull = __la_win_permissive_name_w(linkname); + wchar_t *linksanitized, *linkfull, *namefull; + size_t l = (wcslen(linkname) + 1) * sizeof(wchar_t); + linksanitized = malloc(l); + if (linksanitized == NULL) { + archive_set_error(&a->archive, ENOMEM, + "Can't allocate memory for hardlink target"); + return (-1); + } + memcpy(linksanitized, linkname, l); + r = cleanup_pathname(a, linksanitized); + if (r != ARCHIVE_OK) { + free(linksanitized); + return (r); + } + linkfull = __la_win_permissive_name_w(linksanitized); + free(linksanitized); namefull = __la_win_permissive_name_w(a->name); if (linkfull == NULL || namefull == NULL) { errno = EINVAL; @@ -2184,12 +2186,12 @@ guidword(wchar_t *p, int n) * set) any '..' in the path. */ static int -cleanup_pathname(struct archive_write_disk *a) +cleanup_pathname(struct archive_write_disk *a, wchar_t *name) { wchar_t *dest, *src, *p, *top; wchar_t separator = L'\0'; - p = a->name; + p = name; if (*p == L'\0') { archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Invalid empty pathname"); @@ -2201,7 +2203,7 @@ cleanup_pathname(struct archive_write_disk *a) if (*p == L'/') *p = L'\\'; } - p = a->name; + p = name; /* Skip leading "\\.\" or "\\?\" or "\\?\UNC\" or * "\\?\Volume{GUID}\" diff --git a/src/libs/3rdparty/libarchive/archive_write_set_format_cpio.c b/src/libs/3rdparty/libarchive/archive_write_set_format_cpio.c index 29a7cada1..47152cc6a 100644 --- a/src/libs/3rdparty/libarchive/archive_write_set_format_cpio.c +++ b/src/libs/3rdparty/libarchive/archive_write_set_format_cpio.c @@ -1,3 +1,4 @@ +#include "archive_platform.h" #include "archive.h" /* diff --git a/src/libs/3rdparty/libarchive/archive_write_set_format_cpio_binary.c b/src/libs/3rdparty/libarchive/archive_write_set_format_cpio_binary.c index c1e2f65aa..d6ce35a7b 100644 --- a/src/libs/3rdparty/libarchive/archive_write_set_format_cpio_binary.c +++ b/src/libs/3rdparty/libarchive/archive_write_set_format_cpio_binary.c @@ -124,7 +124,7 @@ PACKED(struct cpio_binary_header { * ...but it feels a little better to do it like this: */ -static uint16_t swap16(uint16_t in) { +static uint16_t la_swap16(uint16_t in) { union { uint16_t s[2]; uint8_t c[4]; @@ -141,7 +141,7 @@ static uint16_t swap16(uint16_t in) { /* NOTREACHED */ } -static uint32_t swap32(uint32_t in) { +static uint32_t la_swap32(uint32_t in) { union { uint32_t l; uint16_t s[2]; @@ -156,8 +156,8 @@ static uint32_t swap32(uint32_t in) { U.s[1] = t; } else if (U.c[3]) { /* Big-endian */ U.l = in; - U.s[0] = swap16(U.s[0]); - U.s[1] = swap16(U.s[1]); + U.s[0] = la_swap16(U.s[0]); + U.s[1] = la_swap16(U.s[1]); } else { /* PDP-endian */ U.l = in; } @@ -426,8 +426,8 @@ write_header(struct archive_write *a, struct archive_entry *entry) /* Include trailing null */ pathlength = (int)len + 1; - h.h_magic = swap16(070707); - h.h_dev = swap16(archive_entry_dev(entry)); + h.h_magic = la_swap16(070707); + h.h_dev = la_swap16(archive_entry_dev(entry)); ino = synthesize_ino_value(cpio, entry); if (ino < 0) { @@ -441,7 +441,7 @@ write_header(struct archive_write *a, struct archive_entry *entry) ret_final = ARCHIVE_FATAL; goto exit_write_header; } - h.h_ino = swap16(ino); + h.h_ino = la_swap16((uint16_t)ino); h.h_mode = archive_entry_mode(entry); if (((h.h_mode & AE_IFMT) == AE_IFSOCK) || ((h.h_mode & AE_IFMT) == AE_IFIFO)) { @@ -460,20 +460,20 @@ write_header(struct archive_write *a, struct archive_entry *entry) /* we could turn off AE_IFREG here, but it does no harm, */ /* and allows v7 cpio to read the entry without confusion */ } - h.h_mode = swap16(h.h_mode); + h.h_mode = la_swap16(h.h_mode); - h.h_uid = swap16(archive_entry_uid(entry)); - h.h_gid = swap16(archive_entry_gid(entry)); - h.h_nlink = swap16(archive_entry_nlink(entry)); + h.h_uid = la_swap16((uint16_t)archive_entry_uid(entry)); + h.h_gid = la_swap16((uint16_t)archive_entry_gid(entry)); + h.h_nlink = la_swap16((uint16_t)archive_entry_nlink(entry)); if (archive_entry_filetype(entry) == AE_IFBLK || archive_entry_filetype(entry) == AE_IFCHR) - h.h_majmin = swap16(archive_entry_rdev(entry)); + h.h_majmin = la_swap16(archive_entry_rdev(entry)); else h.h_majmin = 0; - h.h_mtime = swap32(archive_entry_mtime(entry)); - h.h_namesize = swap16(pathlength); + h.h_mtime = la_swap32((uint32_t)archive_entry_mtime(entry)); + h.h_namesize = la_swap16(pathlength); /* Non-regular files don't store bodies. */ if (archive_entry_filetype(entry) != AE_IFREG) @@ -502,7 +502,7 @@ write_header(struct archive_write *a, struct archive_entry *entry) ret_final = ARCHIVE_FATAL; goto exit_write_header; } - h.h_filesize = swap32(strlen(p)); /* symlink */ + h.h_filesize = la_swap32((uint32_t)strlen(p)); /* symlink */ } else { if ((a->archive.archive_format == ARCHIVE_FORMAT_CPIO_PWB) && (archive_entry_size(entry) > 256*256*256-1)) { @@ -516,7 +516,7 @@ write_header(struct archive_write *a, struct archive_entry *entry) ret_final = ARCHIVE_FAILED; goto exit_write_header; } - h.h_filesize = swap32(archive_entry_size(entry)); /* file */ + h.h_filesize = la_swap32((uint32_t)archive_entry_size(entry)); /* file */ } ret = __archive_write_output(a, &h, HSIZE); diff --git a/src/libs/3rdparty/libarchive/archive_write_set_format_iso9660.c b/src/libs/3rdparty/libarchive/archive_write_set_format_iso9660.c index faabd28ea..58b7216a8 100644 --- a/src/libs/3rdparty/libarchive/archive_write_set_format_iso9660.c +++ b/src/libs/3rdparty/libarchive/archive_write_set_format_iso9660.c @@ -6802,6 +6802,7 @@ isoent_rr_move(struct archive_write *a) * This comparing rule is according to ISO9660 Standard 6.9.1 */ static int +__LA_LIBC_CC _compare_path_table(const void *v1, const void *v2) { const struct isoent *p1, *p2; @@ -6844,6 +6845,7 @@ _compare_path_table(const void *v1, const void *v2) } static int +__LA_LIBC_CC _compare_path_table_joliet(const void *v1, const void *v2) { const struct isoent *p1, *p2; diff --git a/src/libs/3rdparty/libarchive/archive_write_set_format_pax.c b/src/libs/3rdparty/libarchive/archive_write_set_format_pax.c index a2b271071..52911491f 100644 --- a/src/libs/3rdparty/libarchive/archive_write_set_format_pax.c +++ b/src/libs/3rdparty/libarchive/archive_write_set_format_pax.c @@ -1028,10 +1028,8 @@ archive_write_pax_header(struct archive_write *a, archive_string_init(&entry_name); archive_strcpy(&entry_name, archive_entry_pathname(entry_main)); - /* If file size is too large, add 'size' to pax extended attrs. */ + /* If file size is too large, we need pax extended attrs. */ if (archive_entry_size(entry_main) >= (((int64_t)1) << 33)) { - add_pax_attr_int(&(pax->pax_header), "size", - archive_entry_size(entry_main)); need_extension = 1; } @@ -1347,6 +1345,12 @@ archive_write_pax_header(struct archive_write *a, mapsize + pax->sparse_map_padding + sparse_total); } + /* If file size is too large, add 'size' to pax extended attrs. */ + if (archive_entry_size(entry_main) >= (((int64_t)1) << 33)) { + add_pax_attr_int(&(pax->pax_header), "size", + archive_entry_size(entry_main)); + } + /* Format 'ustar' header for main entry. * * The trouble with file size: If the reader can't understand diff --git a/src/libs/3rdparty/libarchive/archive_write_set_format_zip.c b/src/libs/3rdparty/libarchive/archive_write_set_format_zip.c index f4352d5a9..8c14a7027 100644 --- a/src/libs/3rdparty/libarchive/archive_write_set_format_zip.c +++ b/src/libs/3rdparty/libarchive/archive_write_set_format_zip.c @@ -740,12 +740,16 @@ archive_write_zip_header(struct archive_write *a, struct archive_entry *entry) /* We may know the size, but never the CRC. */ zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END; } else { - /* We don't know the size. In this case, we prefer - * deflate (it has a clear end-of-data marker which - * makes length-at-end more reliable) and will - * enable Zip64 extensions unless we're told not to. + /* We don't know the size. Use the default + * compression unless specified otherwise. + * We enable Zip64 extensions unless we're told not to. */ - zip->entry_compression = COMPRESSION_DEFAULT; + + zip->entry_compression = zip->requested_compression; + if(zip->entry_compression == COMPRESSION_UNSPECIFIED){ + zip->entry_compression = COMPRESSION_DEFAULT; + } + zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END; if ((zip->flags & ZIP_FLAG_AVOID_ZIP64) == 0) { zip->entry_uses_zip64 = 1; diff --git a/src/libs/3rdparty/libarchive/config_freebsd.h b/src/libs/3rdparty/libarchive/config_freebsd.h index ac651f00e..758621c4b 100644 --- a/src/libs/3rdparty/libarchive/config_freebsd.h +++ b/src/libs/3rdparty/libarchive/config_freebsd.h @@ -236,6 +236,14 @@ #define HAVE_ZLIB_H 1 #define TIME_WITH_SYS_TIME 1 +#if __FreeBSD_version >= 800505 +#define HAVE_LIBLZMA 1 +#define HAVE_LZMA_H 1 +#if __FreeBSD_version >= 1002504 +#define HAVE_LZMA_STREAM_ENCODER_MT 1 +#endif +#endif + #if __FreeBSD_version >= 1100056 #define HAVE_FUTIMENS 1 #define HAVE_UTIMENSAT 1 diff --git a/src/libs/3rdparty/libarchive/filter_fork_windows.c b/src/libs/3rdparty/libarchive/filter_fork_windows.c index 8d11179f3..0b963975b 100644 --- a/src/libs/3rdparty/libarchive/filter_fork_windows.c +++ b/src/libs/3rdparty/libarchive/filter_fork_windows.c @@ -31,6 +31,43 @@ #include "filter_fork.h" +/* There are some editions of Windows ("nano server," for example) that + * do not host user32.dll. If we want to keep running on those editions, + * we need to delay-load WaitForInputIdle. */ +static void * +la_GetFunctionUser32(const char *name) +{ + static HINSTANCE lib; + static int set; + if (!set) { + set = 1; + lib = LoadLibrary(TEXT("user32.dll")); + } + if (lib == NULL) { + return NULL; + } + return (void *)GetProcAddress(lib, name); +} + +static int +la_WaitForInputIdle(HANDLE hProcess, DWORD dwMilliseconds) +{ + static DWORD (WINAPI *f)(HANDLE, DWORD); + static int set; + + if (!set) { + set = 1; + f = la_GetFunctionUser32("WaitForInputIdle"); + } + + if (!f) { + /* An inability to wait for input idle is + * not _good_, but it is not catastrophic. */ + return WAIT_FAILED; + } + return (*f)(hProcess, dwMilliseconds); +} + int __archive_create_child(const char *cmd, int *child_stdin, int *child_stdout, HANDLE *out_child) @@ -149,7 +186,7 @@ __archive_create_child(const char *cmd, int *child_stdin, int *child_stdout, if (CreateProcessA(fullpath.s, cmdline.s, NULL, NULL, TRUE, 0, NULL, NULL, &staInfo, &childInfo) == 0) goto fail; - WaitForInputIdle(childInfo.hProcess, INFINITE); + la_WaitForInputIdle(childInfo.hProcess, INFINITE); CloseHandle(childInfo.hProcess); CloseHandle(childInfo.hThread); diff --git a/src/libs/3rdparty/libarchive/qt_attribution.json b/src/libs/3rdparty/libarchive/qt_attribution.json index b5d97b74c..122b2503e 100644 --- a/src/libs/3rdparty/libarchive/qt_attribution.json +++ b/src/libs/3rdparty/libarchive/qt_attribution.json @@ -5,7 +5,7 @@ "Description": "Multi-format archive and compression library.", "QtUsage": "Used for reading and writing archive files in Qt Installer Framework", "Homepage": "https://www.libarchive.org", - "Version": "3.5.2", + "Version": "3.6.0", "License": "BSD 2-clause \"Simplified\" License", "LicenseId": "BSD-2-Clause", "LicenseFile": "COPYING", |