Skip site navigation (1)Skip section navigation (2)
Date:      Wed, 20 May 2020 20:58:48 +0000 (UTC)
From:      Martin Matuska <mm@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org
Subject:   svn commit: r361294 - in head: contrib/libarchive contrib/libarchive/libarchive contrib/libarchive/libarchive/test contrib/libarchive/tar lib/libarchive/tests usr.bin/bsdcat usr.bin/cpio usr.bin/tar
Message-ID:  <202005202058.04KKwmMP077102@repo.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: mm
Date: Wed May 20 20:58:48 2020
New Revision: 361294
URL: https://svnweb.freebsd.org/changeset/base/361294

Log:
  MFV r361280:
  Update libarchive to 3.4.3
  
  Relevant vendor changes:
    PR #1352: support negative zstd compression levels
    PR #1359: improve zstd version checking
    PR #1348: support RHT.security.selinux from GNU tar
    PR #1357: support for archives compressed with pzstd
    PR #1367: fix issues in acl tests
    PR #1372: child handling cleanup
    PR #1378: fix memory leak from passphrase callback

Added:
  head/contrib/libarchive/libarchive/test/test_compat_zstd_2.tar.zst.uu
     - copied unchanged from r361280, vendor/libarchive/dist/libarchive/test/test_compat_zstd_2.tar.zst.uu
  head/contrib/libarchive/libarchive/test/test_read_pax_xattr_rht_security_selinux.c
     - copied unchanged from r361280, vendor/libarchive/dist/libarchive/test/test_read_pax_xattr_rht_security_selinux.c
  head/contrib/libarchive/libarchive/test/test_read_pax_xattr_rht_security_selinux.tar.uu
     - copied unchanged from r361280, vendor/libarchive/dist/libarchive/test/test_read_pax_xattr_rht_security_selinux.tar.uu
  head/contrib/libarchive/libarchive/test/test_read_pax_xattr_schily.c
     - copied unchanged from r361280, vendor/libarchive/dist/libarchive/test/test_read_pax_xattr_schily.c
  head/contrib/libarchive/libarchive/test/test_read_pax_xattr_schily.tar.uu
     - copied unchanged from r361280, vendor/libarchive/dist/libarchive/test/test_read_pax_xattr_schily.tar.uu
Deleted:
  head/contrib/libarchive/libarchive/test/test_read_pax_schily_xattr.c
  head/contrib/libarchive/libarchive/test/test_read_pax_schily_xattr.tar.uu
Modified:
  head/contrib/libarchive/NEWS
  head/contrib/libarchive/README.md
  head/contrib/libarchive/libarchive/archive.h
  head/contrib/libarchive/libarchive/archive_digest.c
  head/contrib/libarchive/libarchive/archive_entry.c
  head/contrib/libarchive/libarchive/archive_entry.h
  head/contrib/libarchive/libarchive/archive_entry_stat.3
  head/contrib/libarchive/libarchive/archive_read_add_passphrase.c
  head/contrib/libarchive/libarchive/archive_read_disk_posix.c
  head/contrib/libarchive/libarchive/archive_read_support_filter_program.c
  head/contrib/libarchive/libarchive/archive_read_support_filter_zstd.c
  head/contrib/libarchive/libarchive/archive_read_support_format_rar5.c
  head/contrib/libarchive/libarchive/archive_read_support_format_tar.c
  head/contrib/libarchive/libarchive/archive_write_add_filter_program.c
  head/contrib/libarchive/libarchive/archive_write_add_filter_zstd.c
  head/contrib/libarchive/libarchive/archive_write_set_options.3
  head/contrib/libarchive/libarchive/filter_fork.h
  head/contrib/libarchive/libarchive/filter_fork_posix.c
  head/contrib/libarchive/libarchive/test/test_acl_platform_nfs4.c
  head/contrib/libarchive/libarchive/test/test_acl_platform_posix1e.c
  head/contrib/libarchive/libarchive/test/test_compat_zstd.c
  head/contrib/libarchive/libarchive/test/test_write_filter_zstd.c
  head/contrib/libarchive/tar/bsdtar.1
  head/lib/libarchive/tests/Makefile
  head/usr.bin/bsdcat/Makefile
  head/usr.bin/cpio/Makefile
  head/usr.bin/tar/Makefile
Directory Properties:
  head/contrib/libarchive/   (props changed)

Modified: head/contrib/libarchive/NEWS
==============================================================================
--- head/contrib/libarchive/NEWS	Wed May 20 20:58:17 2020	(r361293)
+++ head/contrib/libarchive/NEWS	Wed May 20 20:58:48 2020	(r361294)
@@ -1,3 +1,9 @@
+May 20, 2020: libarchive 3.4.3 released
+
+Apr 30, 2020: Support for pzstd compressed files
+
+Apr 16, 2020: Support for RHT.security.selinux tar extended attribute
+
 Feb 11, 2020: libarchive 3.4.2 released
 
 Jan 23, 2020: Important fixes for writing XAR archives

Modified: head/contrib/libarchive/README.md
==============================================================================
--- head/contrib/libarchive/README.md	Wed May 20 20:58:17 2020	(r361293)
+++ head/contrib/libarchive/README.md	Wed May 20 20:58:48 2020	(r361294)
@@ -70,7 +70,7 @@ know about any errors or omissions you find.
 
 ## Supported Formats
 
-Currently, the library automatically detects and reads the following fomats:
+Currently, the library automatically detects and reads the following formats:
   * Old V7 tar archives
   * POSIX ustar
   * GNU tar format (including GNU long filenames, long link names, and sparse files)

Modified: head/contrib/libarchive/libarchive/archive.h
==============================================================================
--- head/contrib/libarchive/libarchive/archive.h	Wed May 20 20:58:17 2020	(r361293)
+++ head/contrib/libarchive/libarchive/archive.h	Wed May 20 20:58:48 2020	(r361294)
@@ -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 3004002
+#define	ARCHIVE_VERSION_NUMBER 3004003
 
 #include <sys/stat.h>
 #include <stddef.h>  /* for wchar_t */
@@ -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.4.2"
+#define	ARCHIVE_VERSION_ONLY_STRING "3.4.3"
 #define	ARCHIVE_VERSION_STRING "libarchive " ARCHIVE_VERSION_ONLY_STRING
 __LA_DECL const char *	archive_version_string(void);
 

Modified: head/contrib/libarchive/libarchive/archive_digest.c
==============================================================================
--- head/contrib/libarchive/libarchive/archive_digest.c	Wed May 20 20:58:17 2020	(r361293)
+++ head/contrib/libarchive/libarchive/archive_digest.c	Wed May 20 20:58:48 2020	(r361294)
@@ -109,14 +109,14 @@ win_crypto_Final(unsigned char *buf, size_t bufsize, D
 #if defined(ARCHIVE_CRYPTO_MD5_LIBC)
 
 static int
-__archive_libc_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   MD5Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   MD5Update(ctx, indata, insize);
@@ -124,7 +124,7 @@ __archive_libc_md5update(archive_md5_ctx *ctx, const v
 }
 
 static int
-__archive_libc_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   MD5Final(md, ctx);
   return (ARCHIVE_OK);
@@ -133,14 +133,14 @@ __archive_libc_md5final(archive_md5_ctx *ctx, void *md
 #elif defined(ARCHIVE_CRYPTO_MD5_LIBMD)
 
 static int
-__archive_libmd_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   MD5Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libmd_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   MD5Update(ctx, indata, insize);
@@ -148,7 +148,7 @@ __archive_libmd_md5update(archive_md5_ctx *ctx, const 
 }
 
 static int
-__archive_libmd_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   MD5Final(md, ctx);
   return (ARCHIVE_OK);
@@ -157,14 +157,14 @@ __archive_libmd_md5final(archive_md5_ctx *ctx, void *m
 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
 
 static int
-__archive_libsystem_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   CC_MD5_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libsystem_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   CC_MD5_Update(ctx, indata, insize);
@@ -172,7 +172,7 @@ __archive_libsystem_md5update(archive_md5_ctx *ctx, co
 }
 
 static int
-__archive_libsystem_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   CC_MD5_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -181,7 +181,7 @@ __archive_libsystem_md5final(archive_md5_ctx *ctx, voi
 #elif defined(ARCHIVE_CRYPTO_MD5_MBEDTLS)
 
 static int
-__archive_mbedtls_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   mbedtls_md5_init(ctx);
   if (mbedtls_md5_starts_ret(ctx) == 0)
@@ -191,7 +191,7 @@ __archive_mbedtls_md5init(archive_md5_ctx *ctx)
 }
 
 static int
-__archive_mbedtls_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   if (mbedtls_md5_update_ret(ctx, indata, insize) == 0)
@@ -201,7 +201,7 @@ __archive_mbedtls_md5update(archive_md5_ctx *ctx, cons
 }
 
 static int
-__archive_mbedtls_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   if (mbedtls_md5_finish_ret(ctx, md) == 0) {
     mbedtls_md5_free(ctx);
@@ -215,14 +215,14 @@ __archive_mbedtls_md5final(archive_md5_ctx *ctx, void 
 #elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
 
 static int
-__archive_nettle_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   md5_init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_nettle_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   md5_update(ctx, insize, indata);
@@ -230,7 +230,7 @@ __archive_nettle_md5update(archive_md5_ctx *ctx, const
 }
 
 static int
-__archive_nettle_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   md5_digest(ctx, MD5_DIGEST_SIZE, md);
   return (ARCHIVE_OK);
@@ -239,7 +239,7 @@ __archive_nettle_md5final(archive_md5_ctx *ctx, void *
 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
 
 static int
-__archive_openssl_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   if ((*ctx = EVP_MD_CTX_new()) == NULL)
 	return (ARCHIVE_FAILED);
@@ -248,7 +248,7 @@ __archive_openssl_md5init(archive_md5_ctx *ctx)
 }
 
 static int
-__archive_openssl_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   EVP_DigestUpdate(*ctx, indata, insize);
@@ -256,7 +256,7 @@ __archive_openssl_md5update(archive_md5_ctx *ctx, cons
 }
 
 static int
-__archive_openssl_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
    * this is meant to cope with that. Real fix is probably to fix
@@ -273,20 +273,20 @@ __archive_openssl_md5final(archive_md5_ctx *ctx, void 
 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
 
 static int
-__archive_windowsapi_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
   return (win_crypto_init(ctx, CALG_MD5));
 }
 
 static int
-__archive_windowsapi_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
   return (win_crypto_Update(ctx, indata, insize));
 }
 
 static int
-__archive_windowsapi_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
   return (win_crypto_Final(md, 16, ctx));
 }
@@ -294,14 +294,14 @@ __archive_windowsapi_md5final(archive_md5_ctx *ctx, vo
 #else
 
 static int
-__archive_stub_md5init(archive_md5_ctx *ctx)
+__archive_md5init(archive_md5_ctx *ctx)
 {
 	(void)ctx; /* UNUSED */
 	return (ARCHIVE_FAILED);
 }
 
 static int
-__archive_stub_md5update(archive_md5_ctx *ctx, const void *indata,
+__archive_md5update(archive_md5_ctx *ctx, const void *indata,
     size_t insize)
 {
 	(void)ctx; /* UNUSED */
@@ -311,7 +311,7 @@ __archive_stub_md5update(archive_md5_ctx *ctx, const v
 }
 
 static int
-__archive_stub_md5final(archive_md5_ctx *ctx, void *md)
+__archive_md5final(archive_md5_ctx *ctx, void *md)
 {
 	(void)ctx; /* UNUSED */
 	(void)md; /* UNUSED */
@@ -324,14 +324,14 @@ __archive_stub_md5final(archive_md5_ctx *ctx, void *md
 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
 
 static int
-__archive_libc_ripemd160init(archive_rmd160_ctx *ctx)
+__archive_ripemd160init(archive_rmd160_ctx *ctx)
 {
   RMD160Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
     size_t insize)
 {
   RMD160Update(ctx, indata, insize);
@@ -339,7 +339,7 @@ __archive_libc_ripemd160update(archive_rmd160_ctx *ctx
 }
 
 static int
-__archive_libc_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
 {
   RMD160Final(md, ctx);
   return (ARCHIVE_OK);
@@ -348,14 +348,14 @@ __archive_libc_ripemd160final(archive_rmd160_ctx *ctx,
 #elif defined(ARCHIVE_CRYPTO_RMD160_LIBMD)
 
 static int
-__archive_libmd_ripemd160init(archive_rmd160_ctx *ctx)
+__archive_ripemd160init(archive_rmd160_ctx *ctx)
 {
   RIPEMD160_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libmd_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
     size_t insize)
 {
   RIPEMD160_Update(ctx, indata, insize);
@@ -363,7 +363,7 @@ __archive_libmd_ripemd160update(archive_rmd160_ctx *ct
 }
 
 static int
-__archive_libmd_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
 {
   RIPEMD160_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -372,7 +372,7 @@ __archive_libmd_ripemd160final(archive_rmd160_ctx *ctx
 #elif defined(ARCHIVE_CRYPTO_RMD160_MBEDTLS)
 
 static int
-__archive_mbedtls_ripemd160init(archive_rmd160_ctx *ctx)
+__archive_ripemd160init(archive_rmd160_ctx *ctx)
 {
   mbedtls_ripemd160_init(ctx);
   if (mbedtls_ripemd160_starts_ret(ctx) == 0)
@@ -382,7 +382,7 @@ __archive_mbedtls_ripemd160init(archive_rmd160_ctx *ct
 }
 
 static int
-__archive_mbedtls_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
     size_t insize)
 {
   if (mbedtls_ripemd160_update_ret(ctx, indata, insize) == 0)
@@ -392,7 +392,7 @@ __archive_mbedtls_ripemd160update(archive_rmd160_ctx *
 }
 
 static int
-__archive_mbedtls_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
 {
   if (mbedtls_ripemd160_finish_ret(ctx, md) == 0) {
     mbedtls_ripemd160_free(ctx);
@@ -406,14 +406,14 @@ __archive_mbedtls_ripemd160final(archive_rmd160_ctx *c
 #elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
 
 static int
-__archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
+__archive_ripemd160init(archive_rmd160_ctx *ctx)
 {
   ripemd160_init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
     size_t insize)
 {
   ripemd160_update(ctx, insize, indata);
@@ -421,7 +421,7 @@ __archive_nettle_ripemd160update(archive_rmd160_ctx *c
 }
 
 static int
-__archive_nettle_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
 {
   ripemd160_digest(ctx, RIPEMD160_DIGEST_SIZE, md);
   return (ARCHIVE_OK);
@@ -430,7 +430,7 @@ __archive_nettle_ripemd160final(archive_rmd160_ctx *ct
 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
 
 static int
-__archive_openssl_ripemd160init(archive_rmd160_ctx *ctx)
+__archive_ripemd160init(archive_rmd160_ctx *ctx)
 {
   if ((*ctx = EVP_MD_CTX_new()) == NULL)
 	return (ARCHIVE_FAILED);
@@ -439,7 +439,7 @@ __archive_openssl_ripemd160init(archive_rmd160_ctx *ct
 }
 
 static int
-__archive_openssl_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
     size_t insize)
 {
   EVP_DigestUpdate(*ctx, indata, insize);
@@ -447,7 +447,7 @@ __archive_openssl_ripemd160update(archive_rmd160_ctx *
 }
 
 static int
-__archive_openssl_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
 {
   if (*ctx) {
     EVP_DigestFinal(*ctx, md, NULL);
@@ -460,14 +460,14 @@ __archive_openssl_ripemd160final(archive_rmd160_ctx *c
 #else
 
 static int
-__archive_stub_ripemd160init(archive_rmd160_ctx *ctx)
+__archive_ripemd160init(archive_rmd160_ctx *ctx)
 {
 	(void)ctx; /* UNUSED */
 	return (ARCHIVE_FAILED);
 }
 
 static int
-__archive_stub_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+__archive_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
     size_t insize)
 {
 	(void)ctx; /* UNUSED */
@@ -477,7 +477,7 @@ __archive_stub_ripemd160update(archive_rmd160_ctx *ctx
 }
 
 static int
-__archive_stub_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+__archive_ripemd160final(archive_rmd160_ctx *ctx, void *md)
 {
 	(void)ctx; /* UNUSED */
 	(void)md; /* UNUSED */
@@ -490,14 +490,14 @@ __archive_stub_ripemd160final(archive_rmd160_ctx *ctx,
 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC)
 
 static int
-__archive_libc_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   SHA1Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA1Update(ctx, indata, insize);
@@ -505,7 +505,7 @@ __archive_libc_sha1update(archive_sha1_ctx *ctx, const
 }
 
 static int
-__archive_libc_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   SHA1Final(md, ctx);
   return (ARCHIVE_OK);
@@ -514,14 +514,14 @@ __archive_libc_sha1final(archive_sha1_ctx *ctx, void *
 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBMD)
 
 static int
-__archive_libmd_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   SHA1_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libmd_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA1_Update(ctx, indata, insize);
@@ -529,7 +529,7 @@ __archive_libmd_sha1update(archive_sha1_ctx *ctx, cons
 }
 
 static int
-__archive_libmd_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   SHA1_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -538,14 +538,14 @@ __archive_libmd_sha1final(archive_sha1_ctx *ctx, void 
 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
 
 static int
-__archive_libsystem_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   CC_SHA1_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libsystem_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   CC_SHA1_Update(ctx, indata, insize);
@@ -553,7 +553,7 @@ __archive_libsystem_sha1update(archive_sha1_ctx *ctx, 
 }
 
 static int
-__archive_libsystem_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   CC_SHA1_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -562,7 +562,7 @@ __archive_libsystem_sha1final(archive_sha1_ctx *ctx, v
 #elif defined(ARCHIVE_CRYPTO_SHA1_MBEDTLS)
 
 static int
-__archive_mbedtls_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   mbedtls_sha1_init(ctx);
   if (mbedtls_sha1_starts_ret(ctx) == 0)
@@ -572,7 +572,7 @@ __archive_mbedtls_sha1init(archive_sha1_ctx *ctx)
 }
 
 static int
-__archive_mbedtls_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   if (mbedtls_sha1_update_ret(ctx, indata, insize) == 0)
@@ -582,7 +582,7 @@ __archive_mbedtls_sha1update(archive_sha1_ctx *ctx, co
 }
 
 static int
-__archive_mbedtls_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   if (mbedtls_sha1_finish_ret(ctx, md) == 0) {
     mbedtls_sha1_free(ctx);
@@ -596,14 +596,14 @@ __archive_mbedtls_sha1final(archive_sha1_ctx *ctx, voi
 #elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
 
 static int
-__archive_nettle_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   sha1_init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_nettle_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   sha1_update(ctx, insize, indata);
@@ -611,7 +611,7 @@ __archive_nettle_sha1update(archive_sha1_ctx *ctx, con
 }
 
 static int
-__archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
   return (ARCHIVE_OK);
@@ -620,7 +620,7 @@ __archive_nettle_sha1final(archive_sha1_ctx *ctx, void
 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
 
 static int
-__archive_openssl_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   if ((*ctx = EVP_MD_CTX_new()) == NULL)
 	return (ARCHIVE_FAILED);
@@ -629,7 +629,7 @@ __archive_openssl_sha1init(archive_sha1_ctx *ctx)
 }
 
 static int
-__archive_openssl_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   EVP_DigestUpdate(*ctx, indata, insize);
@@ -637,7 +637,7 @@ __archive_openssl_sha1update(archive_sha1_ctx *ctx, co
 }
 
 static int
-__archive_openssl_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   /* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
    * this is meant to cope with that. Real fix is probably to fix
@@ -654,20 +654,20 @@ __archive_openssl_sha1final(archive_sha1_ctx *ctx, voi
 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
 
 static int
-__archive_windowsapi_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
   return (win_crypto_init(ctx, CALG_SHA1));
 }
 
 static int
-__archive_windowsapi_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
   return (win_crypto_Update(ctx, indata, insize));
 }
 
 static int
-__archive_windowsapi_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
   return (win_crypto_Final(md, 20, ctx));
 }
@@ -675,14 +675,14 @@ __archive_windowsapi_sha1final(archive_sha1_ctx *ctx, 
 #else
 
 static int
-__archive_stub_sha1init(archive_sha1_ctx *ctx)
+__archive_sha1init(archive_sha1_ctx *ctx)
 {
 	(void)ctx; /* UNUSED */
 	return (ARCHIVE_FAILED);
 }
 
 static int
-__archive_stub_sha1update(archive_sha1_ctx *ctx, const void *indata,
+__archive_sha1update(archive_sha1_ctx *ctx, const void *indata,
     size_t insize)
 {
 	(void)ctx; /* UNUSED */
@@ -692,7 +692,7 @@ __archive_stub_sha1update(archive_sha1_ctx *ctx, const
 }
 
 static int
-__archive_stub_sha1final(archive_sha1_ctx *ctx, void *md)
+__archive_sha1final(archive_sha1_ctx *ctx, void *md)
 {
 	(void)ctx; /* UNUSED */
 	(void)md; /* UNUSED */
@@ -705,14 +705,14 @@ __archive_stub_sha1final(archive_sha1_ctx *ctx, void *
 #if defined(ARCHIVE_CRYPTO_SHA256_LIBC)
 
 static int
-__archive_libc_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   SHA256_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA256_Update(ctx, indata, insize);
@@ -720,7 +720,7 @@ __archive_libc_sha256update(archive_sha256_ctx *ctx, c
 }
 
 static int
-__archive_libc_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   SHA256_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -729,14 +729,14 @@ __archive_libc_sha256final(archive_sha256_ctx *ctx, vo
 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC2)
 
 static int
-__archive_libc2_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   SHA256Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc2_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA256Update(ctx, indata, insize);
@@ -744,7 +744,7 @@ __archive_libc2_sha256update(archive_sha256_ctx *ctx, 
 }
 
 static int
-__archive_libc2_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   SHA256Final(md, ctx);
   return (ARCHIVE_OK);
@@ -753,14 +753,14 @@ __archive_libc2_sha256final(archive_sha256_ctx *ctx, v
 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBC3)
 
 static int
-__archive_libc3_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   SHA256Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc3_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA256Update(ctx, indata, insize);
@@ -768,7 +768,7 @@ __archive_libc3_sha256update(archive_sha256_ctx *ctx, 
 }
 
 static int
-__archive_libc3_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   SHA256Final(md, ctx);
   return (ARCHIVE_OK);
@@ -777,14 +777,14 @@ __archive_libc3_sha256final(archive_sha256_ctx *ctx, v
 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBMD)
 
 static int
-__archive_libmd_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   SHA256_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libmd_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA256_Update(ctx, indata, insize);
@@ -792,7 +792,7 @@ __archive_libmd_sha256update(archive_sha256_ctx *ctx, 
 }
 
 static int
-__archive_libmd_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   SHA256_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -801,14 +801,14 @@ __archive_libmd_sha256final(archive_sha256_ctx *ctx, v
 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
 
 static int
-__archive_libsystem_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   CC_SHA256_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libsystem_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   CC_SHA256_Update(ctx, indata, insize);
@@ -816,7 +816,7 @@ __archive_libsystem_sha256update(archive_sha256_ctx *c
 }
 
 static int
-__archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   CC_SHA256_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -825,7 +825,7 @@ __archive_libsystem_sha256final(archive_sha256_ctx *ct
 #elif defined(ARCHIVE_CRYPTO_SHA256_MBEDTLS)
 
 static int
-__archive_mbedtls_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   mbedtls_sha256_init(ctx);
   if (mbedtls_sha256_starts_ret(ctx, 0) == 0)
@@ -835,7 +835,7 @@ __archive_mbedtls_sha256init(archive_sha256_ctx *ctx)
 }
 
 static int
-__archive_mbedtls_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   if (mbedtls_sha256_update_ret(ctx, indata, insize) == 0)
@@ -845,7 +845,7 @@ __archive_mbedtls_sha256update(archive_sha256_ctx *ctx
 }
 
 static int
-__archive_mbedtls_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   if (mbedtls_sha256_finish_ret(ctx, md) == 0) {
     mbedtls_sha256_free(ctx);
@@ -859,14 +859,14 @@ __archive_mbedtls_sha256final(archive_sha256_ctx *ctx,
 #elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
 
 static int
-__archive_nettle_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   sha256_init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   sha256_update(ctx, insize, indata);
@@ -874,7 +874,7 @@ __archive_nettle_sha256update(archive_sha256_ctx *ctx,
 }
 
 static int
-__archive_nettle_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
   return (ARCHIVE_OK);
@@ -883,7 +883,7 @@ __archive_nettle_sha256final(archive_sha256_ctx *ctx, 
 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
 
 static int
-__archive_openssl_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   if ((*ctx = EVP_MD_CTX_new()) == NULL)
 	return (ARCHIVE_FAILED);
@@ -892,7 +892,7 @@ __archive_openssl_sha256init(archive_sha256_ctx *ctx)
 }
 
 static int
-__archive_openssl_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   EVP_DigestUpdate(*ctx, indata, insize);
@@ -900,7 +900,7 @@ __archive_openssl_sha256update(archive_sha256_ctx *ctx
 }
 
 static int
-__archive_openssl_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   if (*ctx) {
     EVP_DigestFinal(*ctx, md, NULL);
@@ -913,20 +913,20 @@ __archive_openssl_sha256final(archive_sha256_ctx *ctx,
 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
 
 static int
-__archive_windowsapi_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
   return (win_crypto_init(ctx, CALG_SHA_256));
 }
 
 static int
-__archive_windowsapi_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
   return (win_crypto_Update(ctx, indata, insize));
 }
 
 static int
-__archive_windowsapi_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
   return (win_crypto_Final(md, 32, ctx));
 }
@@ -934,14 +934,14 @@ __archive_windowsapi_sha256final(archive_sha256_ctx *c
 #else
 
 static int
-__archive_stub_sha256init(archive_sha256_ctx *ctx)
+__archive_sha256init(archive_sha256_ctx *ctx)
 {
 	(void)ctx; /* UNUSED */
 	return (ARCHIVE_FAILED);
 }
 
 static int
-__archive_stub_sha256update(archive_sha256_ctx *ctx, const void *indata,
+__archive_sha256update(archive_sha256_ctx *ctx, const void *indata,
     size_t insize)
 {
 	(void)ctx; /* UNUSED */
@@ -951,7 +951,7 @@ __archive_stub_sha256update(archive_sha256_ctx *ctx, c
 }
 
 static int
-__archive_stub_sha256final(archive_sha256_ctx *ctx, void *md)
+__archive_sha256final(archive_sha256_ctx *ctx, void *md)
 {
 	(void)ctx; /* UNUSED */
 	(void)md; /* UNUSED */
@@ -964,14 +964,14 @@ __archive_stub_sha256final(archive_sha256_ctx *ctx, vo
 #if defined(ARCHIVE_CRYPTO_SHA384_LIBC)
 
 static int
-__archive_libc_sha384init(archive_sha384_ctx *ctx)
+__archive_sha384init(archive_sha384_ctx *ctx)
 {
   SHA384_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc_sha384update(archive_sha384_ctx *ctx, const void *indata,
+__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA384_Update(ctx, indata, insize);
@@ -979,7 +979,7 @@ __archive_libc_sha384update(archive_sha384_ctx *ctx, c
 }
 
 static int
-__archive_libc_sha384final(archive_sha384_ctx *ctx, void *md)
+__archive_sha384final(archive_sha384_ctx *ctx, void *md)
 {
   SHA384_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -988,14 +988,14 @@ __archive_libc_sha384final(archive_sha384_ctx *ctx, vo
 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC2)
 
 static int
-__archive_libc2_sha384init(archive_sha384_ctx *ctx)
+__archive_sha384init(archive_sha384_ctx *ctx)
 {
   SHA384Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc2_sha384update(archive_sha384_ctx *ctx, const void *indata,
+__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA384Update(ctx, indata, insize);
@@ -1003,7 +1003,7 @@ __archive_libc2_sha384update(archive_sha384_ctx *ctx, 
 }
 
 static int
-__archive_libc2_sha384final(archive_sha384_ctx *ctx, void *md)
+__archive_sha384final(archive_sha384_ctx *ctx, void *md)
 {
   SHA384Final(md, ctx);
   return (ARCHIVE_OK);
@@ -1012,14 +1012,14 @@ __archive_libc2_sha384final(archive_sha384_ctx *ctx, v
 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBC3)
 
 static int
-__archive_libc3_sha384init(archive_sha384_ctx *ctx)
+__archive_sha384init(archive_sha384_ctx *ctx)
 {
   SHA384Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libc3_sha384update(archive_sha384_ctx *ctx, const void *indata,
+__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
     size_t insize)
 {
   SHA384Update(ctx, indata, insize);
@@ -1027,7 +1027,7 @@ __archive_libc3_sha384update(archive_sha384_ctx *ctx, 
 }
 
 static int
-__archive_libc3_sha384final(archive_sha384_ctx *ctx, void *md)
+__archive_sha384final(archive_sha384_ctx *ctx, void *md)
 {
   SHA384Final(md, ctx);
   return (ARCHIVE_OK);
@@ -1036,14 +1036,14 @@ __archive_libc3_sha384final(archive_sha384_ctx *ctx, v
 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
 
 static int
-__archive_libsystem_sha384init(archive_sha384_ctx *ctx)
+__archive_sha384init(archive_sha384_ctx *ctx)
 {
   CC_SHA384_Init(ctx);
   return (ARCHIVE_OK);
 }
 
 static int
-__archive_libsystem_sha384update(archive_sha384_ctx *ctx, const void *indata,
+__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
     size_t insize)
 {
   CC_SHA384_Update(ctx, indata, insize);
@@ -1051,7 +1051,7 @@ __archive_libsystem_sha384update(archive_sha384_ctx *c
 }
 
 static int
-__archive_libsystem_sha384final(archive_sha384_ctx *ctx, void *md)
+__archive_sha384final(archive_sha384_ctx *ctx, void *md)
 {
   CC_SHA384_Final(md, ctx);
   return (ARCHIVE_OK);
@@ -1060,7 +1060,7 @@ __archive_libsystem_sha384final(archive_sha384_ctx *ct
 #elif defined(ARCHIVE_CRYPTO_SHA384_MBEDTLS)
 
 static int
-__archive_mbedtls_sha384init(archive_sha384_ctx *ctx)
+__archive_sha384init(archive_sha384_ctx *ctx)
 {
   mbedtls_sha512_init(ctx);
   if (mbedtls_sha512_starts_ret(ctx, 1) == 0)
@@ -1070,7 +1070,7 @@ __archive_mbedtls_sha384init(archive_sha384_ctx *ctx)
 }
 
 static int
-__archive_mbedtls_sha384update(archive_sha384_ctx *ctx, const void *indata,
+__archive_sha384update(archive_sha384_ctx *ctx, const void *indata,
     size_t insize)
 {

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202005202058.04KKwmMP077102>