pkgsrc-Changes archive

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

CVS commit: pkgsrc/security/netpgpverify/files



Module Name:    pkgsrc
Committed By:   agc
Date:           Sun May  3 23:49:04 UTC 2020

Modified Files:
        pkgsrc/security/netpgpverify/files: Makefile.bsd b64.c b64.h bzlib.c
            bzlib.h bzlib_private.h libverify.c rsa.c rsa.h verify.h zlib.c
            zlib.h

Log Message:
Update netpgpverify and libnetpgpverify to version 20200503

ensure all exported functions use a unique prfix, so that they don't
conflict with symbols (both data and text) in libcrypto. this works for
statically linked binaries and libraries, rather then the version map which
only works for dynalically-linked.


To generate a diff of this commit:
cvs rdiff -u -r1.12 -r1.13 pkgsrc/security/netpgpverify/files/Makefile.bsd
cvs rdiff -u -r1.1 -r1.2 pkgsrc/security/netpgpverify/files/b64.c \
    pkgsrc/security/netpgpverify/files/b64.h \
    pkgsrc/security/netpgpverify/files/bzlib.h \
    pkgsrc/security/netpgpverify/files/zlib.h
cvs rdiff -u -r1.5 -r1.6 pkgsrc/security/netpgpverify/files/bzlib.c
cvs rdiff -u -r1.3 -r1.4 pkgsrc/security/netpgpverify/files/bzlib_private.h
cvs rdiff -u -r1.28 -r1.29 pkgsrc/security/netpgpverify/files/libverify.c
cvs rdiff -u -r1.4 -r1.5 pkgsrc/security/netpgpverify/files/rsa.c
cvs rdiff -u -r1.2 -r1.3 pkgsrc/security/netpgpverify/files/rsa.h \
    pkgsrc/security/netpgpverify/files/zlib.c
cvs rdiff -u -r1.41 -r1.42 pkgsrc/security/netpgpverify/files/verify.h

Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

Modified files:

Index: pkgsrc/security/netpgpverify/files/Makefile.bsd
diff -u pkgsrc/security/netpgpverify/files/Makefile.bsd:1.12 pkgsrc/security/netpgpverify/files/Makefile.bsd:1.13
--- pkgsrc/security/netpgpverify/files/Makefile.bsd:1.12        Thu Jun 30 21:19:59 2016
+++ pkgsrc/security/netpgpverify/files/Makefile.bsd     Sun May  3 23:49:04 2020
@@ -1,4 +1,4 @@
-# $NetBSD: Makefile.bsd,v 1.12 2016/06/30 21:19:59 agc Exp $
+# $NetBSD: Makefile.bsd,v 1.13 2020/05/03 23:49:04 agc Exp $
 
 PROG=netpgpverify
 
@@ -12,6 +12,11 @@ SRCS+= md5c.c rmd160.c sha1.c sha2.c
 
 CPPFLAGS+=-I.
 
+CPPFLAGS.bzlib.c+=     -Wno-error=implicit-fallthrough
+CPPFLAGS.zlib.c+=      -Wno-error=implicit-fallthrough
+
+LDFLAGS+=-Wl,--version-script=${.CURDIR}/verify.map
+
 .ifndef PRODUCTION
 CPPFLAGS+=-g -O0
 LDFLAGS+=-g -O0

Index: pkgsrc/security/netpgpverify/files/b64.c
diff -u pkgsrc/security/netpgpverify/files/b64.c:1.1 pkgsrc/security/netpgpverify/files/b64.c:1.2
--- pkgsrc/security/netpgpverify/files/b64.c:1.1        Sat Mar 16 07:32:34 2013
+++ pkgsrc/security/netpgpverify/files/b64.c    Sun May  3 23:49:04 2020
@@ -235,7 +235,7 @@ encodeblock(uint8_t *wordin, uint8_t *wo
 ** base64 encode a stream adding padding and line breaks as per spec.
 */
 int 
-b64encode(const char *in, const size_t insize, void *vp, size_t outsize, int linesize)
+netpgpv_b64encode(const char *in, const size_t insize, void *vp, size_t outsize, int linesize)
 {
        const char      *inp;
        unsigned         i;
@@ -299,7 +299,7 @@ decodeblock(uint8_t wordin[4], uint8_t w
 ** decode a base64 encoded stream discarding padding, line breaks and noise
 */
 int
-b64decode(const char *in, const size_t insize, void *vp, size_t outsize)
+netpgpv_b64decode(const char *in, const size_t insize, void *vp, size_t outsize)
 {
        const char      *inp;
        unsigned         wordlen;
@@ -349,7 +349,7 @@ b64decode(const char *in, const size_t i
 
 /* return the encoded size for n bytes input */
 int
-b64_encsize(unsigned n)
+netpgpv_b64_encsize(unsigned n)
 {
        return ((4 * n) / 3) + 4;
 }
Index: pkgsrc/security/netpgpverify/files/b64.h
diff -u pkgsrc/security/netpgpverify/files/b64.h:1.1 pkgsrc/security/netpgpverify/files/b64.h:1.2
--- pkgsrc/security/netpgpverify/files/b64.h:1.1        Sat Mar 16 07:32:34 2013
+++ pkgsrc/security/netpgpverify/files/b64.h    Sun May  3 23:49:04 2020
@@ -25,8 +25,8 @@
 #ifndef B64_H_
 #define B64_H_ 20091223
 
-int b64encode(const char */*in*/, const size_t /*insize*/, void */*vp*/, size_t /*outsize*/, int /*linesize*/);
-int b64decode(const char */*in*/, const size_t /*insize*/, void */*vp*/, size_t /*outsize*/);
-int b64_encsize(unsigned /*n*/);
+int netpgpv_b64encode(const char */*in*/, const size_t /*insize*/, void */*vp*/, size_t /*outsize*/, int /*linesize*/);
+int netpgpv_b64decode(const char */*in*/, const size_t /*insize*/, void */*vp*/, size_t /*outsize*/);
+int netpgpv_b64_encsize(unsigned /*n*/);
 
 #endif
Index: pkgsrc/security/netpgpverify/files/bzlib.h
diff -u pkgsrc/security/netpgpverify/files/bzlib.h:1.1 pkgsrc/security/netpgpverify/files/bzlib.h:1.2
--- pkgsrc/security/netpgpverify/files/bzlib.h:1.1      Sat Mar 16 07:32:34 2013
+++ pkgsrc/security/netpgpverify/files/bzlib.h  Sun May  3 23:49:04 2020
@@ -1,4 +1,4 @@
-/*     $NetBSD: bzlib.h,v 1.1 2013/03/16 07:32:34 agc Exp $    */
+/*     $NetBSD: bzlib.h,v 1.2 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -115,17 +115,17 @@ BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) 
       bz_stream* strm 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) ( 
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzDecompressInit) ( 
       bz_stream *strm, 
       int       verbosity, 
       int       small
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzDecompress) ( 
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzDecompress) ( 
       bz_stream* strm 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) ( 
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzDecompressEnd) ( 
       bz_stream *strm 
    );
 
@@ -138,7 +138,7 @@ BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd
 
 typedef void BZFILE;
 
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( 
+BZ_EXTERN BZFILE* BZ_API(netpgpv_BZ2_bzReadOpen) ( 
       int*  bzerror,   
       FILE* f, 
       int   verbosity, 
@@ -147,19 +147,19 @@ BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen)
       int   nUnused 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( 
+BZ_EXTERN void BZ_API(netpgpv_BZ2_bzReadClose) ( 
       int*    bzerror, 
       BZFILE* b 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( 
+BZ_EXTERN void BZ_API(netpgpv_BZ2_bzReadGetUnused) ( 
       int*    bzerror, 
       BZFILE* b, 
       void**  unused,  
       int*    nUnused 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzRead) ( 
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzRead) ( 
       int*    bzerror, 
       BZFILE* b, 
       void*   buf, 
@@ -213,7 +213,7 @@ BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCom
       int           workFactor 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) ( 
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzBuffToBuffDecompress) ( 
       char*         dest, 
       unsigned int* destLen,
       char*         source, 
@@ -232,22 +232,22 @@ BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDec
    If this code breaks, please contact both Yoshioka and me.
 --*/
 
-BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
+BZ_EXTERN const char * BZ_API(netpgpv_BZ2_bzlibVersion) (
       void
    );
 
 #ifndef BZ_NO_STDIO
-BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
+BZ_EXTERN BZFILE * BZ_API(netpgpv_BZ2_bzopen) (
       const char *path,
       const char *mode
    );
 
-BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
+BZ_EXTERN BZFILE * BZ_API(netpgpv_BZ2_bzdopen) (
       int        fd,
       const char *mode
    );
          
-BZ_EXTERN int BZ_API(BZ2_bzread) (
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzread) (
       BZFILE* b, 
       void* buf, 
       int len 
@@ -259,15 +259,15 @@ BZ_EXTERN int BZ_API(BZ2_bzwrite) (
       int     len 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzflush) (
+BZ_EXTERN int BZ_API(netpgpv_BZ2_bzflush) (
       BZFILE* b
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzclose) (
+BZ_EXTERN void BZ_API(netpgpv_BZ2_bzclose) (
       BZFILE* b
    );
 
-BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
+BZ_EXTERN const char * BZ_API(netpgpv_BZ2_bzerror) (
       BZFILE *b, 
       int    *errnum
    );
Index: pkgsrc/security/netpgpverify/files/zlib.h
diff -u pkgsrc/security/netpgpverify/files/zlib.h:1.1 pkgsrc/security/netpgpverify/files/zlib.h:1.2
--- pkgsrc/security/netpgpverify/files/zlib.h:1.1       Sat Mar 16 07:32:35 2013
+++ pkgsrc/security/netpgpverify/files/zlib.h   Sun May  3 23:49:04 2020
@@ -1,4 +1,4 @@
-/*     $NetBSD: zlib.h,v 1.1 2013/03/16 07:32:35 agc Exp $     */
+/*     $NetBSD: zlib.h,v 1.2 2020/05/03 23:49:04 agc Exp $     */
 
 /* zlib.h -- interface of the 'zlib' general purpose compression library
   version 1.2.3, July 18th, 2005
@@ -35,7 +35,7 @@
 
 #include "config.h"
 
-/*     $NetBSD: zlib.h,v 1.1 2013/03/16 07:32:35 agc Exp $     */
+/*     $NetBSD: zlib.h,v 1.2 2020/05/03 23:49:04 agc Exp $     */
 
 /* zconf.h -- configuration of the zlib compression library
  * Copyright (C) 1995-2005 Jean-loup Gailly.
@@ -49,55 +49,58 @@
 
 #include <sys/types.h>
 
+/* we don't want these colliding with anything else out there */
+#define        Z_PREFIX        1
+
 /*
  * If you *really* need a unique prefix for all types and library functions,
  * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
  */
 #ifdef Z_PREFIX
-#  define deflateInit_          z_deflateInit_
-#  define deflate               z_deflate
-#  define deflateEnd            z_deflateEnd
-#  define inflateInit_          z_inflateInit_
-#  define inflate               z_inflate
-#  define inflateEnd            z_inflateEnd
-#  define deflateInit2_         z_deflateInit2_
-#  define deflateSetDictionary  z_deflateSetDictionary
-#  define deflateCopy           z_deflateCopy
-#  define deflateReset          z_deflateReset
-#  define deflateParams         z_deflateParams
-#  define deflateBound          z_deflateBound
-#  define deflatePrime          z_deflatePrime
-#  define inflateInit2_         z_inflateInit2_
-#  define inflateSetDictionary  z_inflateSetDictionary
-#  define inflateSync           z_inflateSync
-#  define inflateSyncPoint      z_inflateSyncPoint
-#  define inflateCopy           z_inflateCopy
-#  define inflateReset          z_inflateReset
-#  define inflateBack           z_inflateBack
-#  define inflateBackEnd        z_inflateBackEnd
-#  define compress              z_compress
-#  define compress2             z_compress2
-#  define compressBound         z_compressBound
-#  define uncompress            z_uncompress
-#  define adler32               z_adler32
-#  define crc32                 z_crc32
-#  define get_crc_table         z_get_crc_table
-#  define zError                z_zError
-
-#  define alloc_func            z_alloc_func
-#  define free_func             z_free_func
-#  define in_func               z_in_func
-#  define out_func              z_out_func
-#  define Byte                  z_Byte
-#  define uInt                  z_uInt
-#  define uLong                 z_uLong
-#  define Bytef                 z_Bytef
-#  define charf                 z_charf
-#  define intf                  z_intf
-#  define uIntf                 z_uIntf
-#  define uLongf                z_uLongf
-#  define voidpf                z_voidpf
-#  define voidp                 z_voidp
+#  define deflateInit_          netpgpv_z_deflateInit_
+#  define deflate               netpgpv_z_deflate
+#  define deflateEnd            netpgpv_z_deflateEnd
+#  define inflateInit_          netpgpv_z_inflateInit_
+#  define inflate               netpgpv_z_inflate
+#  define inflateEnd            netpgpv_z_inflateEnd
+#  define deflateInit2_         netpgpv_z_deflateInit2_
+#  define deflateSetDictionary  netpgpv_z_deflateSetDictionary
+#  define deflateCopy           netpgpv_z_deflateCopy
+#  define deflateReset          netpgpv_z_deflateReset
+#  define deflateParams         netpgpv_z_deflateParams
+#  define deflateBound          netpgpv_z_deflateBound
+#  define deflatePrime          netpgpv_z_deflatePrime
+#  define inflateInit2_         netpgpv_z_inflateInit2_
+#  define inflateSetDictionary  netpgpv_z_inflateSetDictionary
+#  define inflateSync           netpgpv_z_inflateSync
+#  define inflateSyncPoint      netpgpv_z_inflateSyncPoint
+#  define inflateCopy           netpgpv_z_inflateCopy
+#  define inflateReset          netpgpv_z_inflateReset
+#  define inflateBack           netpgpv_z_inflateBack
+#  define inflateBackEnd        netpgpv_z_inflateBackEnd
+#  define compress              netpgpv_z_compress
+#  define compress2             netpgpv_z_compress2
+#  define compressBound         netpgpv_z_compressBound
+#  define uncompress            netpgpv_z_uncompress
+#  define adler32               netpgpv_z_adler32
+#  define crc32                 netpgpv_z_crc32
+#  define get_crc_table         netpgpv_z_get_crc_table
+#  define zError                netpgpv_z_zError
+
+#  define alloc_func            netpgpv_z_alloc_func
+#  define free_func             netpgpv_z_free_func
+#  define in_func               netpgpv_z_in_func
+#  define out_func              netpgpv_z_out_func
+#  define Byte                  netpgpv_z_Byte
+#  define uInt                  netpgpv_z_uInt
+#  define uLong                 netpgpv_z_uLong
+#  define Bytef                 netpgpv_z_Bytef
+#  define charf                 netpgpv_z_charf
+#  define intf                  netpgpv_z_intf
+#  define uIntf                 netpgpv_z_uIntf
+#  define uLongf                netpgpv_z_uLongf
+#  define voidpf                netpgpv_z_voidpf
+#  define voidp                 netpgpv_z_voidp
 #endif
 
 #if defined(__MSDOS__) && !defined(MSDOS)
@@ -1138,7 +1141,7 @@ ZEXTERN int ZEXPORT inflateReset OF((z_s
    stream state was inconsistent (such as zalloc or state being NULL).
 */
 
-ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+ZEXTERN int ZEXPORT netpgpv_inflatePrime OF((z_streamp strm,
                                      int bits,
                                      int value));
 /*
@@ -1150,15 +1153,15 @@ ZEXTERN int ZEXPORT inflatePrime OF((z_s
   inflateReset().  bits must be less than or equal to 16, and that many of the
   least significant bits of value will be inserted in the input.
 
-      inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+      netpgpv_inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
    stream state was inconsistent.
 */
 
-ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+ZEXTERN int ZEXPORT netpgpv_inflateGetHeader OF((z_streamp strm,
                                          gz_headerp head));
 /*
-      inflateGetHeader() requests that gzip header information be stored in the
-   provided gz_header structure.  inflateGetHeader() may be called after
+      netpgpv_inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  netpgpv_inflateGetHeader() may be called after
    inflateInit2() or inflateReset(), and before the first call of inflate().
    As inflate() processes the gzip stream, head->done is zero until the header
    is completed, at which time head->done is set to one.  If a zlib stream is
@@ -1184,13 +1187,13 @@ ZEXTERN int ZEXPORT inflateGetHeader OF(
    allocated memory, then the application will need to save those pointers
    elsewhere so that they can be eventually freed.
 
-      If inflateGetHeader is not used, then the header information is simply
+      If netpgpv_inflateGetHeader is not used, then the header information is simply
    discarded.  The header is always checked for validity, including the header
    CRC if present.  inflateReset() will reset the process to discard the header
-   information.  The application would need to call inflateGetHeader() again to
+   information.  The application would need to call netpgpv_inflateGetHeader() again to
    retrieve the header from the next gzip stream.
 
-      inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+      netpgpv_inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
    stream state was inconsistent.
 */
 

Index: pkgsrc/security/netpgpverify/files/bzlib.c
diff -u pkgsrc/security/netpgpverify/files/bzlib.c:1.5 pkgsrc/security/netpgpverify/files/bzlib.c:1.6
--- pkgsrc/security/netpgpverify/files/bzlib.c:1.5      Fri Feb 19 22:41:50 2016
+++ pkgsrc/security/netpgpverify/files/bzlib.c  Sun May  3 23:49:04 2020
@@ -1,4 +1,4 @@
-/*     $NetBSD: bzlib.c,v 1.5 2016/02/19 22:41:50 agc Exp $    */
+/*     $NetBSD: bzlib.c,v 1.6 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -39,7 +39,7 @@
 #define        USE_ARG(x)      /*LINTED*/(void)&(x)
 #endif
 
-/*     $NetBSD: bzlib.c,v 1.5 2016/02/19 22:41:50 agc Exp $    */
+/*     $NetBSD: bzlib.c,v 1.6 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -64,7 +64,7 @@
 
 
 /*---------------------------------------------*/
-Int32 BZ2_rNums[512] = { 
+Int32 netpgpv_BZ2_rNums[512] = { 
    619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 
    985, 724, 205, 454, 863, 491, 741, 242, 949, 214, 
    733, 859, 335, 708, 621, 574, 73, 654, 730, 472, 
@@ -126,7 +126,7 @@ Int32 BZ2_rNums[512] = { 
 
 /*---------------------------------------------------*/
 #ifndef BZ_NO_STDIO
-void BZ2_bz__AssertH__fail ( int errcode )
+void netpgpv_BZ2_bz__AssertH__fail ( int errcode )
 {
    fprintf(stderr, 
       "\n\nbzip2/libbzip2: internal error number %d.\n"
@@ -138,7 +138,7 @@ void BZ2_bz__AssertH__fail ( int errcode
       "timely and accurate bug reports eventually lead to higher\n"
       "quality software.  Thanks.  Julian Seward, 10 December 2007.\n\n",
       errcode,
-      BZ2_bzlibVersion()
+      netpgpv_BZ2_bzlibVersion()
    );
 
    if (errcode == 1007) {
@@ -249,7 +249,7 @@ void default_bzfree ( void* opaque, void
 /*---------------------------------------------------*/
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompressInit) 
+int BZ_API(netpgpv_BZ2_bzDecompressInit) 
                      ( bz_stream* strm, 
                        int        verbosity,
                        int        small )
@@ -444,7 +444,7 @@ Bool unRLE_obuf_to_output_FAST ( DState*
 
 
 /*---------------------------------------------------*/
-__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
+__inline__ Int32 netpgpv_BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
 {
    Int32 nb, na, mid;
    nb = 0;
@@ -565,7 +565,7 @@ Bool unRLE_obuf_to_output_SMALL ( DState
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
+int BZ_API(netpgpv_BZ2_bzDecompress) ( bz_stream *strm )
 {
    Bool    corrupt;
    DState* s;
@@ -599,7 +599,7 @@ int BZ_API(BZ2_bzDecompress) ( bz_stream
          }
       }
       if (s->state >= BZ_X_MAGIC_1) {
-         Int32 r = BZ2_decompress ( s );
+         Int32 r = netpgpv_BZ2_decompress ( s );
          if (r == BZ_STREAM_END) {
             if (s->verbosity >= 3)
                VPrintf2 ( "\n    combined CRCs: stored = 0x%08x, computed = 0x%08x", 
@@ -619,7 +619,7 @@ int BZ_API(BZ2_bzDecompress) ( bz_stream
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompressEnd)  ( bz_stream *strm )
+int BZ_API(netpgpv_BZ2_bzDecompressEnd)  ( bz_stream *strm )
 {
    DState* s;
    if (strm == NULL) return BZ_PARAM_ERROR;
@@ -673,7 +673,7 @@ static Bool myfeof ( FILE* f )
 
 
 /*---------------------------------------------------*/
-BZFILE* BZ_API(BZ2_bzReadOpen) 
+BZFILE* BZ_API(netpgpv_BZ2_bzReadOpen) 
                    ( int*  bzerror, 
                      FILE* f, 
                      int   verbosity,
@@ -720,7 +720,7 @@ BZFILE* BZ_API(BZ2_bzReadOpen) 
       nUnused--;
    }
 
-   ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
+   ret = netpgpv_BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
    if (ret != BZ_OK)
       { BZ_SETERR(ret); free(bzf); return NULL; };
 
@@ -733,7 +733,7 @@ BZFILE* BZ_API(BZ2_bzReadOpen) 
 
 
 /*---------------------------------------------------*/
-void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
+void BZ_API(netpgpv_BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
 {
    bzFile* bzf = (bzFile*)b;
 
@@ -745,13 +745,13 @@ void BZ_API(BZ2_bzReadClose) ( int *bzer
       { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
 
    if (bzf->initialisedOk)
-      (void)BZ2_bzDecompressEnd ( &(bzf->strm) );
+      (void)netpgpv_BZ2_bzDecompressEnd ( &(bzf->strm) );
    free ( bzf );
 }
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzRead) 
+int BZ_API(netpgpv_BZ2_bzRead) 
            ( int*    bzerror, 
              BZFILE* b, 
              void*   buf, 
@@ -789,7 +789,7 @@ int BZ_API(BZ2_bzRead) 
          bzf->strm.next_in = bzf->buf;
       }
 
-      ret = BZ2_bzDecompress ( &(bzf->strm) );
+      ret = netpgpv_BZ2_bzDecompress ( &(bzf->strm) );
 
       if (ret != BZ_OK && ret != BZ_STREAM_END)
          { BZ_SETERR(ret); return 0; };
@@ -811,7 +811,7 @@ int BZ_API(BZ2_bzRead) 
 
 
 /*---------------------------------------------------*/
-void BZ_API(BZ2_bzReadGetUnused) 
+void BZ_API(netpgpv_BZ2_bzReadGetUnused) 
                      ( int*    bzerror, 
                        BZFILE* b, 
                        void**  unused, 
@@ -833,7 +833,7 @@ void BZ_API(BZ2_bzReadGetUnused) 
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzBuffToBuffDecompress) 
+int BZ_API(netpgpv_BZ2_bzBuffToBuffDecompress) 
                            ( char*         dest, 
                              unsigned int* destLen,
                              char*         source, 
@@ -853,7 +853,7 @@ int BZ_API(BZ2_bzBuffToBuffDecompress) 
    strm.bzalloc = NULL;
    strm.bzfree = NULL;
    strm.opaque = NULL;
-   ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
+   ret = netpgpv_BZ2_bzDecompressInit ( &strm, verbosity, small );
    if (ret != BZ_OK) return ret;
 
    strm.next_in = source;
@@ -861,26 +861,26 @@ int BZ_API(BZ2_bzBuffToBuffDecompress) 
    strm.avail_in = sourceLen;
    strm.avail_out = *destLen;
 
-   ret = BZ2_bzDecompress ( &strm );
+   ret = netpgpv_BZ2_bzDecompress ( &strm );
    if (ret == BZ_OK) goto output_overflow_or_eof;
    if (ret != BZ_STREAM_END) goto errhandler;
 
    /* normal termination */
    *destLen -= strm.avail_out;
-   BZ2_bzDecompressEnd ( &strm );
+   netpgpv_BZ2_bzDecompressEnd ( &strm );
    return BZ_OK;
 
    output_overflow_or_eof:
    if (strm.avail_out > 0) {
-      BZ2_bzDecompressEnd ( &strm );
+      netpgpv_BZ2_bzDecompressEnd ( &strm );
       return BZ_UNEXPECTED_EOF;
    } else {
-      BZ2_bzDecompressEnd ( &strm );
+      netpgpv_BZ2_bzDecompressEnd ( &strm );
       return BZ_OUTBUFF_FULL;
    };      
 
    errhandler:
-   BZ2_bzDecompressEnd ( &strm );
+   netpgpv_BZ2_bzDecompressEnd ( &strm );
    return ret; 
 }
 
@@ -900,7 +900,7 @@ int BZ_API(BZ2_bzBuffToBuffDecompress) 
 /*--
    return version like "0.9.5d, 4-Sept-1999".
 --*/
-const char * BZ_API(BZ2_bzlibVersion)(void)
+const char * BZ_API(netpgpv_BZ2_bzlibVersion)(void)
 {
    return BZ_VERSION;
 }
@@ -973,7 +973,7 @@ BZFILE * bzopen_or_bzdopen
 
    if (writing) {
    } else {
-      bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
+      bzfp = netpgpv_BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
                             unused,nUnused);
    }
    if (bzfp == NULL) {
@@ -990,7 +990,7 @@ BZFILE * bzopen_or_bzdopen
       ex) bzopen("file","w9")
       case path="" or NULL => use stdin or stdout.
 --*/
-BZFILE * BZ_API(BZ2_bzopen)
+BZFILE * BZ_API(netpgpv_BZ2_bzopen)
                ( const char *path,
                  const char *mode )
 {
@@ -999,7 +999,7 @@ BZFILE * BZ_API(BZ2_bzopen)
 
 
 /*---------------------------------------------------*/
-BZFILE * BZ_API(BZ2_bzdopen)
+BZFILE * BZ_API(netpgpv_BZ2_bzdopen)
                ( int fd,
                  const char *mode )
 {
@@ -1008,11 +1008,11 @@ BZFILE * BZ_API(BZ2_bzdopen)
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
+int BZ_API(netpgpv_BZ2_bzread) (BZFILE* b, void* buf, int len )
 {
    int bzerr, nread;
    if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
-   nread = BZ2_bzRead(&bzerr,b,buf,len);
+   nread = netpgpv_BZ2_bzRead(&bzerr,b,buf,len);
    if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
       return nread;
    } else {
@@ -1022,7 +1022,7 @@ int BZ_API(BZ2_bzread) (BZFILE* b, void*
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzflush) (BZFILE *b)
+int BZ_API(netpgpv_BZ2_bzflush) (BZFILE *b)
 {
        USE_ARG(b);
    /* do nothing now... */
@@ -1031,7 +1031,7 @@ int BZ_API(BZ2_bzflush) (BZFILE *b)
 
 
 /*---------------------------------------------------*/
-void BZ_API(BZ2_bzclose) (BZFILE* b)
+void BZ_API(netpgpv_BZ2_bzclose) (BZFILE* b)
 {
    int bzerr;
    FILE *fp;
@@ -1040,7 +1040,7 @@ void BZ_API(BZ2_bzclose) (BZFILE* b)
    fp = ((bzFile *)b)->handle;
    if(((bzFile*)b)->writing){
    }else{
-      BZ2_bzReadClose(&bzerr,b);
+      netpgpv_BZ2_bzReadClose(&bzerr,b);
    }
    if(fp!=stdin && fp!=stdout){
       fclose(fp);
@@ -1072,7 +1072,7 @@ static const char *bzerrorstrings[] = {
 };
 
 
-const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
+const char * BZ_API(netpgpv_BZ2_bzerror) (BZFILE *b, int *errnum)
 {
    int err = ((bzFile *)b)->lastErr;
 
@@ -1086,7 +1086,7 @@ const char * BZ_API(BZ2_bzerror) (BZFILE
 /*-------------------------------------------------------------*/
 /*--- end                                           bzlib.c ---*/
 /*-------------------------------------------------------------*/
-/*     $NetBSD: bzlib.c,v 1.5 2016/02/19 22:41:50 agc Exp $    */
+/*     $NetBSD: bzlib.c,v 1.6 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -1191,7 +1191,7 @@ void makeMaps_d ( DState* s )
 
 
 /*---------------------------------------------------*/
-Int32 BZ2_decompress ( DState* s )
+Int32 netpgpv_BZ2_decompress ( DState* s )
 {
    UChar      uc;
    Int32      retVal;
@@ -1424,7 +1424,7 @@ Int32 BZ2_decompress ( DState* s )
             if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
             if (s->len[t][i] < minLen) minLen = s->len[t][i];
          }
-         BZ2_hbCreateDecodeTables ( 
+         netpgpv_BZ2_hbCreateDecodeTables ( 
             &(s->limit[t][0]), 
             &(s->base[t][0]), 
             &(s->perm[t][0]), 
@@ -1732,7 +1732,7 @@ Int32 BZ2_decompress ( DState* s )
 /*-------------------------------------------------------------*/
 /*--- end                                      decompress.c ---*/
 /*-------------------------------------------------------------*/
-/*     $NetBSD: bzlib.c,v 1.5 2016/02/19 22:41:50 agc Exp $    */
+/*     $NetBSD: bzlib.c,v 1.6 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -1762,7 +1762,7 @@ Int32 BZ2_decompress ( DState* s )
   comp.compression FAQ.
 --*/
 
-UInt32 BZ2_crc32Table[256] = {
+UInt32 netpgpv_BZ2_crc32Table[256] = {
 
    /*-- Ugly, innit? --*/
 
@@ -1836,7 +1836,7 @@ UInt32 BZ2_crc32Table[256] = {
 /*-------------------------------------------------------------*/
 /*--- end                                        crctable.c ---*/
 /*-------------------------------------------------------------*/
-/*     $NetBSD: bzlib.c,v 1.5 2016/02/19 22:41:50 agc Exp $    */
+/*     $NetBSD: bzlib.c,v 1.6 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -1898,7 +1898,7 @@ UInt32 BZ2_crc32Table[256] = {
 
 
 /*---------------------------------------------------*/
-void BZ2_hbMakeCodeLengths ( UChar *len, 
+void netpgpv_BZ2_hbMakeCodeLengths ( UChar *len, 
                              Int32 *freq,
                              Int32 alphaSize,
                              Int32 maxLen )
@@ -1987,7 +1987,7 @@ void BZ2_hbMakeCodeLengths ( UChar *len,
 
 
 /*---------------------------------------------------*/
-void BZ2_hbAssignCodes ( Int32 *code,
+void netpgpv_BZ2_hbAssignCodes ( Int32 *code,
                          UChar *length,
                          Int32 minLen,
                          Int32 maxLen,
@@ -2005,7 +2005,7 @@ void BZ2_hbAssignCodes ( Int32 *code,
 
 
 /*---------------------------------------------------*/
-void BZ2_hbCreateDecodeTables ( Int32 *limit,
+void netpgpv_BZ2_hbCreateDecodeTables ( Int32 *limit,
                                 Int32 *base,
                                 Int32 *perm,
                                 UChar *length,

Index: pkgsrc/security/netpgpverify/files/bzlib_private.h
diff -u pkgsrc/security/netpgpverify/files/bzlib_private.h:1.3 pkgsrc/security/netpgpverify/files/bzlib_private.h:1.4
--- pkgsrc/security/netpgpverify/files/bzlib_private.h:1.3      Tue Feb  3 21:13:17 2015
+++ pkgsrc/security/netpgpverify/files/bzlib_private.h  Sun May  3 23:49:04 2020
@@ -1,4 +1,4 @@
-/*     $NetBSD: bzlib_private.h,v 1.3 2015/02/03 21:13:17 agc Exp $    */
+/*     $NetBSD: bzlib_private.h,v 1.4 2020/05/03 23:49:04 agc Exp $    */
 
 
 /*-------------------------------------------------------------*/
@@ -61,9 +61,9 @@ typedef unsigned short  UInt16;
 #define __dead
 #endif
 
-void BZ2_bz__AssertH__fail ( int errcode ) __dead;
+void netpgpv_BZ2_bz__AssertH__fail ( int errcode ) __dead;
 #define AssertH(cond,errcode) \
-   { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); }
+   { if (!(cond)) netpgpv_BZ2_bz__AssertH__fail ( errcode ); }
 
 #if BZ_DEBUG
 #define AssertD(cond,msg) \
@@ -134,7 +134,7 @@ extern void bz_internal_error ( int errc
 
 /*-- Stuff for randomising repetitive blocks. --*/
 
-extern Int32 BZ2_rNums[512];
+extern Int32 netpgpv_BZ2_rNums[512];
 
 #define BZ_RAND_DECLS                          \
    Int32 rNToGo;                               \
@@ -148,7 +148,7 @@ extern Int32 BZ2_rNums[512];
 
 #define BZ_RAND_UPD_MASK                       \
    if (s->rNToGo == 0) {                       \
-      s->rNToGo = BZ2_rNums[s->rTPos];         \
+      s->rNToGo = netpgpv_BZ2_rNums[s->rTPos];         \
       s->rTPos++;                              \
       if (s->rTPos == 512) s->rTPos = 0;       \
    }                                           \
@@ -158,7 +158,7 @@ extern Int32 BZ2_rNums[512];
 
 /*-- Stuff for doing CRCs. --*/
 
-extern UInt32 BZ2_crc32Table[256];
+extern UInt32 netpgpv_BZ2_crc32Table[256];
 
 #define BZ_INITIALISE_CRC(crcVar)              \
 {                                              \
@@ -173,7 +173,7 @@ extern UInt32 BZ2_crc32Table[256];
 #define BZ_UPDATE_CRC(crcVar,cha)              \
 {                                              \
    crcVar = (crcVar << 8) ^                    \
-            BZ2_crc32Table[(crcVar >> 24) ^    \
+            netpgpv_BZ2_crc32Table[(crcVar >> 24) ^    \
                            ((UChar)cha)];      \
 }
 
@@ -285,10 +285,10 @@ extern void 
 BZ2_bsInitWrite ( EState* );
 
 extern void 
-BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
+netpgpv_BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
 
 extern void 
-BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
+netpgpv_BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
 
 
 
@@ -481,20 +481,20 @@ typedef
 #define BZ_GET_SMALL(cccc)                            \
     /* c_tPos is unsigned, hence test < 0 is pointless. */ \
     if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
-    cccc = BZ2_indexIntoF ( s->tPos, s->cftab );    \
+    cccc = netpgpv_BZ2_indexIntoF ( s->tPos, s->cftab );    \
     s->tPos = GET_LL(s->tPos);
 
 
 /*-- externs for decompression. --*/
 
 extern Int32 
-BZ2_indexIntoF ( Int32, Int32* );
+netpgpv_BZ2_indexIntoF ( Int32, Int32* );
 
 extern Int32 
-BZ2_decompress ( DState* );
+netpgpv_BZ2_decompress ( DState* );
 
 extern void 
-BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
+netpgpv_BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
                            Int32,  Int32, Int32 );
 
 

Index: pkgsrc/security/netpgpverify/files/libverify.c
diff -u pkgsrc/security/netpgpverify/files/libverify.c:1.28 pkgsrc/security/netpgpverify/files/libverify.c:1.29
--- pkgsrc/security/netpgpverify/files/libverify.c:1.28 Sun Mar 11 04:52:03 2018
+++ pkgsrc/security/netpgpverify/files/libverify.c      Sun May  3 23:49:04 2020
@@ -1316,7 +1316,7 @@ read_compressed(pgpv_t *pgp, pgpv_compre
                ok = (inflateInit(&z) == Z_OK);
                break;
        case BZIP2_COMPRESSION:
-               ok = (BZ2_bzDecompressInit(&bz, 1, 0) == BZ_OK);
+               ok = (netpgpv_BZ2_bzDecompressInit(&bz, 1, 0) == BZ_OK);
                break;
        }
        if (!ok) {
@@ -1330,7 +1330,7 @@ read_compressed(pgpv_t *pgp, pgpv_compre
                unzmem->size = z.total_out;
                break;
        case BZIP2_COMPRESSION:
-               ok = (BZ2_bzDecompress(&bz) == BZ_STREAM_END);
+               ok = (netpgpv_BZ2_bzDecompress(&bz) == BZ_STREAM_END);
                unzmem->size = ((uint64_t)bz.total_out_hi32 << 32) | bz.total_out_lo32;
                break;
        }
@@ -1881,7 +1881,7 @@ rsa_padding_check_none(uint8_t *to, int 
 
 /* check against the exponent/moudulo operation */
 static int
-lowlevel_rsa_public_check(const uint8_t *encbuf, int enclen, uint8_t *dec, const rsa_pubkey_t *rsa)
+lowlevel_rsa_public_check(const uint8_t *encbuf, int enclen, uint8_t *dec, const netpgpv_rsa_pubkey_t *rsa)
 {
        uint8_t         *decbuf;
        PGPV_BIGNUM             *decbn;
@@ -1947,10 +1947,10 @@ err:
 
 /* verify */
 static int
-rsa_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, RSA *rsa, int padding)
+rsa_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, NETPGPV_RSA *rsa, int padding)
 {
-       rsa_pubkey_t    pub;
-       int             ret;
+       netpgpv_rsa_pubkey_t    pub;
+       int                     ret;
 
        if (enc == NULL || dec == NULL || rsa == NULL) {
                return 0;
@@ -1985,7 +1985,7 @@ estimate_primarykey_size(pgpv_primarykey
 static int 
 pgpv_rsa_public_decrypt(uint8_t *out, const uint8_t *in, size_t length, const pgpv_pubkey_t *pubkey)
 {
-       RSA            *orsa;
+       NETPGPV_RSA    *orsa;
        int             n;
 
        if ((orsa = calloc(1, sizeof(*orsa))) == NULL) {
@@ -1993,7 +1993,7 @@ pgpv_rsa_public_decrypt(uint8_t *out, co
        }
        orsa->n = pubkey->bn[RSA_N].bn;
        orsa->e = pubkey->bn[RSA_E].bn;
-       n = rsa_public_decrypt((int)length, in, out, orsa, RSA_NO_PADDING);
+       n = rsa_public_decrypt((int)length, in, out, orsa, NETPGPV_RSA_NO_PADDING);
        orsa->n = orsa->e = NULL;
        free(orsa);
        return n;
@@ -2313,7 +2313,7 @@ read_ascii_armor(pgpv_cursor_t *cursor, 
                        (size_t)(p - mem->mem));
                return 0;
        }
-       binsigsize = b64decode((char *)p, (size_t)(sigend - p), binsig, sizeof(binsig));
+       binsigsize = netpgpv_b64decode((char *)p, (size_t)(sigend - p), binsig, sizeof(binsig));
 
        read_binary_memory(cursor->pgp, "signature", cons_onepass, 15);
        ARRAY_APPEND(cursor->pgp->pkts, litdata);
@@ -2738,8 +2738,8 @@ read_ssh_file(pgpv_t *pgp, pgpv_primaryk
                memset(&userid, 0x0, sizeof(userid));
                (void) gethostname(hostname, sizeof(hostname));
                if (strlen(space + 1) - 1 == 0) {
-                       (void) snprintf(owner, sizeof(owner), "<root@%s>",
-                                       hostname);
+                       (void) snprintf(owner, sizeof(owner), "<root@%.*s>",
+                                       240, hostname);
                } else {
                        (void) snprintf(owner, sizeof(owner), "<%.*s>",
                                (int)strlen(space + 1) - 1,

Index: pkgsrc/security/netpgpverify/files/rsa.c
diff -u pkgsrc/security/netpgpverify/files/rsa.c:1.4 pkgsrc/security/netpgpverify/files/rsa.c:1.5
--- pkgsrc/security/netpgpverify/files/rsa.c:1.4        Fri Sep 25 15:46:58 2015
+++ pkgsrc/security/netpgpverify/files/rsa.c    Sun May  3 23:49:04 2020
@@ -61,7 +61,7 @@ rsa_padding_check_none(uint8_t *to, int 
 }
 
 static int
-lowlevel_rsa_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa)
+lowlevel_rsa_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, NETPGPV_RSA *rsa)
 {
        PGPV_BIGNUM     *decbn;
        PGPV_BIGNUM     *signedbn;
@@ -100,7 +100,7 @@ err:
 }
 
 static int
-lowlevel_rsa_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa)
+lowlevel_rsa_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, NETPGPV_RSA *rsa)
 {
        PGPV_BIGNUM     *decbn;
        PGPV_BIGNUM     *encbn;
@@ -143,7 +143,7 @@ err:
 }
 
 static int
-lowlevel_rsa_private_decrypt(int enclen, const unsigned char *encbuf, unsigned char *to, RSA *rsa)
+lowlevel_rsa_private_decrypt(int enclen, const unsigned char *encbuf, unsigned char *to, NETPGPV_RSA *rsa)
 {
        PGPV_BIGNUM     *encbn;
        PGPV_BIGNUM     *decbn;
@@ -185,7 +185,7 @@ err:
 }
 
 static int
-lowlevel_rsa_public_decrypt(const uint8_t *encbuf, int enclen, uint8_t *dec, const rsa_pubkey_t *rsa)
+lowlevel_rsa_public_decrypt(const uint8_t *encbuf, int enclen, uint8_t *dec, const netpgpv_rsa_pubkey_t *rsa)
 {
        uint8_t         *decbuf;
        PGPV_BIGNUM             *decbn;
@@ -404,7 +404,7 @@ cleanup:
 #define DSA_MAX_MODULUS_BITS   10000
 
 static int
-dsa_do_verify(const unsigned char *calculated, int dgst_len, const dsasig_t *sig, mpi_dsa_t *dsa)
+dsa_do_verify(const unsigned char *calculated, int dgst_len, const netpgpv_dsasig_t *sig, netpgpv_mpi_dsa_t *dsa)
 {
        PGPV_BIGNUM              *M;
        PGPV_BIGNUM              *W;
@@ -491,24 +491,26 @@ err:
 /*************************************************************************/
 
 int
-RSA_size(const RSA *rsa)
+netpgpv_RSA_size(const NETPGPV_RSA *rsa)
 {
        return (rsa == NULL) ? 0 : PGPV_BN_num_bits(rsa->n);
 }
 
 int
-DSA_size(const DSA *dsa)
+netpgpv_DSA_size(const NETPGPV_DSA *dsa)
 {
        return (dsa == NULL) ? 0 : PGPV_BN_num_bits(dsa->p);
 }
 
 unsigned 
-dsa_verify(const signature_t *signature, const dsa_pubkey_t *pubdsa, const uint8_t *calculated, size_t hash_length)
-{
-       mpi_dsa_t       odsa;
-       dsasig_t        osig;
-       unsigned        qlen;
-       int             ret;
+netpgpv_dsa_verify(const signature_t *signature,
+       const netpgpv_dsa_pubkey_t *pubdsa, const uint8_t *calculated,
+       size_t hash_length)
+{
+       netpgpv_mpi_dsa_t       odsa;
+       netpgpv_dsasig_t        osig;
+       unsigned                qlen;
+       int                  ret;
 
        if (signature == NULL || pubdsa == NULL || calculated == NULL) {
                return -1;
@@ -539,14 +541,14 @@ dsa_verify(const signature_t *signature,
        return (unsigned)ret;
 }
 
-RSA *
-RSA_new(void)
+NETPGPV_RSA *
+netpgpv_RSA_new(void)
 {
-       return netpgp_allocate(1, sizeof(RSA));
+       return netpgp_allocate(1, sizeof(NETPGPV_RSA));
 }
 
 void
-RSA_free(RSA *rsa)
+netpgpv_RSA_free(NETPGPV_RSA *rsa)
 {
        if (rsa) {
                netpgp_deallocate(rsa, sizeof(*rsa));
@@ -554,7 +556,7 @@ RSA_free(RSA *rsa)
 }
 
 int
-RSA_check_key(RSA *rsa)
+netpgpv_RSA_check_key(NETPGPV_RSA *rsa)
 {
        PGPV_BIGNUM     *calcn;
        int      ret;
@@ -580,8 +582,8 @@ errout:
        return ret;
 }
 
-RSA *
-RSA_generate_key(int num, unsigned long e, void (*callback)(int,int,void *), void *cb_arg)
+NETPGPV_RSA *
+netpgpv_RSA_generate_key(int num, unsigned long e, void (*callback)(int,int,void *), void *cb_arg)
 {
        /* STUBBED */
        USE_ARG(num);
@@ -589,12 +591,12 @@ RSA_generate_key(int num, unsigned long 
        USE_ARG(callback);
        USE_ARG(cb_arg);
        printf("RSA_generate_key stubbed\n");
-       return RSA_new();
+       return netpgpv_RSA_new();
 }
 
 /* encrypt */
 int
-RSA_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa, int padding)
+netpgpv_RSA_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, NETPGPV_RSA *rsa, int padding)
 {
        USE_ARG(padding);
        if (plain == NULL || encbuf == NULL || rsa == NULL) {
@@ -605,7 +607,7 @@ RSA_public_encrypt(int plainc, const uns
 
 /* decrypt */
 int
-RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding)
+netpgpv_RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to, NETPGPV_RSA *rsa, int padding)
 {
        USE_ARG(padding);
        if (from == NULL || to == NULL || rsa == NULL) {
@@ -616,7 +618,7 @@ RSA_private_decrypt(int flen, const unsi
 
 /* sign */
 int
-RSA_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa, int padding)
+netpgpv_RSA_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, NETPGPV_RSA *rsa, int padding)
 {
        USE_ARG(padding);
        if (plain == NULL || encbuf == NULL || rsa == NULL) {
@@ -627,10 +629,10 @@ RSA_private_encrypt(int plainc, const un
 
 /* verify */
 int
-RSA_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, RSA *rsa, int padding)
+netpgpv_RSA_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, NETPGPV_RSA *rsa, int padding)
 {
-       rsa_pubkey_t    pub;
-       int             ret;
+       netpgpv_rsa_pubkey_t    pub;
+       int                     ret;
 
        if (enc == NULL || dec == NULL || rsa == NULL) {
                return 0;
@@ -647,47 +649,47 @@ RSA_public_decrypt(int enclen, const uns
 
 /***********************************************************************/
 
-DSA *
-DSA_new(void)
+NETPGPV_DSA *
+netpgpv_DSA_new(void)
 {
-       return netpgp_allocate(1, sizeof(DSA));
+       return netpgp_allocate(1, sizeof(NETPGPV_DSA));
 }
 
 void
-DSA_free(DSA *dsa)
+netpgpv_DSA_free(NETPGPV_DSA *dsa)
 {
        if (dsa) {
                netpgp_deallocate(dsa, sizeof(*dsa));
        }
 }
 
-DSA_SIG *
-DSA_SIG_new(void)
+NETPGPV_DSA_SIG *
+netpgpv_DSA_SIG_new(void)
 {
-       return netpgp_allocate(1, sizeof(DSA_SIG));
+       return netpgp_allocate(1, sizeof(NETPGPV_DSA_SIG));
 }
 
 void
-DSA_SIG_free(DSA_SIG *sig)
+netpgpv_DSA_SIG_free(NETPGPV_DSA_SIG *sig)
 {
        if (sig) {
                netpgp_deallocate(sig, sizeof(*sig));
        }
 }
 
-DSA_SIG *
-DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
+NETPGPV_DSA_SIG *
+netpgpv_DSA_do_sign(const unsigned char *dgst, int dlen, NETPGPV_DSA *dsa)
 {
        /* STUBBED */
        USE_ARG(dgst);
        USE_ARG(dlen);
        USE_ARG(dsa);
        printf("DSA_do_sign stubbed\n");
-       return DSA_SIG_new();
+       return netpgpv_DSA_SIG_new();
 }
 
 int
-DSA_do_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa)
+netpgpv_DSA_do_verify(const unsigned char *dgst, int dgst_len, NETPGPV_DSA_SIG *sig, NETPGPV_DSA *dsa)
 {
        if (dgst == NULL || dgst_len == 0 || sig == NULL || dsa == NULL) {
                return -1;

Index: pkgsrc/security/netpgpverify/files/rsa.h
diff -u pkgsrc/security/netpgpverify/files/rsa.h:1.2 pkgsrc/security/netpgpverify/files/rsa.h:1.3
--- pkgsrc/security/netpgpverify/files/rsa.h:1.2        Tue Sep  1 19:38:42 2015
+++ pkgsrc/security/netpgpverify/files/rsa.h    Sun May  3 23:49:04 2020
@@ -39,12 +39,12 @@
 
 __BEGIN_DECLS
 
-typedef struct rsa_pubkey_t {
+typedef struct netpgpv_rsa_pubkey_t {
        PGPV_BIGNUM             *n;     /* RSA public modulus n */
        PGPV_BIGNUM             *e;     /* RSA public encryption exponent e */
-} rsa_pubkey_t;
+} netpgpv_rsa_pubkey_t;
 
-typedef struct mpi_rsa_t {
+typedef struct netpgpv_mpi_rsa_t {
        int              f1;    /* openssl pad */
        long             f2;    /* openssl version */
        const void      *f3;    /* openssl method */
@@ -57,18 +57,18 @@ typedef struct mpi_rsa_t {
        PGPV_BIGNUM             *dmp1;
        PGPV_BIGNUM             *dmq1;
        PGPV_BIGNUM             *iqmp;
-} mpi_rsa_t;
+} netpgpv_mpi_rsa_t;
 
-#define RSA    mpi_rsa_t
+#define NETPGPV_RSA    netpgpv_mpi_rsa_t
 
-typedef struct dsa_pubkey_t {
+typedef struct netpgpv_dsa_pubkey_t {
        PGPV_BIGNUM             *p;     /* DSA public modulus n */
        PGPV_BIGNUM             *q;     /* DSA public encryption exponent e */
        PGPV_BIGNUM             *g;
        PGPV_BIGNUM             *y;
-} dsa_pubkey_t;
+} netpgpv_dsa_pubkey_t;
 
-typedef struct mpi_dsa_t {
+typedef struct netpgpv_mpi_dsa_t {
        PGPV_BIGNUM             *p;
        PGPV_BIGNUM             *q;
        PGPV_BIGNUM             *g;
@@ -76,29 +76,29 @@ typedef struct mpi_dsa_t {
        PGPV_BIGNUM             *x;
        PGPV_BIGNUM             *pub_key;
        PGPV_BIGNUM             *priv_key;
-} mpi_dsa_t;
+} netpgpv_mpi_dsa_t;
 
-#define DSA    mpi_dsa_t
+#define NETPGPV_DSA    netpgpv_mpi_dsa_t
 
-typedef struct rsasig_t {
+typedef struct netpgpv_rsasig_t {
        PGPV_BIGNUM             *sig;                   /* mpi which is actual signature */
-} rsasig_t;
+} netpgpv_rsasig_t;
 
-typedef struct dsasig_t {
+typedef struct netpgpv_dsasig_t {
        PGPV_BIGNUM             *r;                     /* mpi which is actual signature */
        PGPV_BIGNUM             *s;                     /* mpi which is actual signature */
-} dsasig_t;
+} netpgpv_dsasig_t;
 
-#define DSA_SIG                dsasig_t
+#define NETPGPV_DSA_SIG                netpgpv_dsasig_t
 
 /* misc defs */
-#define RSA_NO_PADDING                 3
+#define NETPGPV_RSA_NO_PADDING         3
 
 #define SIGNETBSD_ID_SIZE              8
 #define SIGNETBSD_NAME_SIZE            128
 
-#define RSA_PUBKEY_ALG                 1
-#define DSA_PUBKEY_ALG                 17
+#define NETPGPV_RSA_PUBKEY_ALG         1
+#define NETPGPV_DSA_PUBKEY_ALG         17
 
 /* the public part of the key */
 typedef struct pubkey_t {
@@ -109,8 +109,8 @@ typedef struct pubkey_t {
        int64_t         expiry;                 /* expiration time of the key */
        uint32_t        validity;               /* validity in days */
        uint32_t        alg;                    /* pubkey algorithm - rsa/dss etc */
-       rsa_pubkey_t    rsa;                    /* specific RSA keys */
-       dsa_pubkey_t    dsa;                    /* specific DSA keys */
+       netpgpv_rsa_pubkey_t    rsa;                    /* specific RSA keys */
+       netpgpv_dsa_pubkey_t    dsa;                    /* specific DSA keys */
 } pubkey_t;
 
 /* signature details (for a specific file) */
@@ -122,33 +122,42 @@ typedef struct signature_t {
        uint8_t          id[SIGNETBSD_ID_SIZE]; /* binary id */
        uint32_t         key_alg;               /* public key algorithm number */
        uint32_t         hash_alg;              /* hashing algorithm number */
-       rsasig_t         rsa;                   /* RSA signature */
-       dsasig_t         dsa;                   /* DSA signature */
+       netpgpv_rsasig_t         rsa;                   /* RSA signature */
+       netpgpv_dsasig_t         dsa;                   /* DSA signature */
        size_t           v4_hashlen;            /* length of hashed info */
        uint8_t         *v4_hashed;             /* hashed info */
        uint8_t          hash2[2];              /* high 2 bytes of hashed value - for quick test */
        pubkey_t        *signer;                /* pubkey of signer */
 } signature_t;
 
-unsigned dsa_verify(const signature_t */*sig*/, const dsa_pubkey_t */*pubdsa*/, const uint8_t */*calc*/, size_t /*hashlen*/);
-
-RSA *RSA_new(void);
-int RSA_size(const RSA */*rsa*/);
-void RSA_free(RSA */*rsa*/);
-int RSA_check_key(RSA */*rsa*/);
-RSA *RSA_generate_key(int /*num*/, unsigned long /*e*/, void (*callback)(int,int,void *), void */*cb_arg*/);
-int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
-int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
-int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
-int RSA_public_decrypt(int flen, const uint8_t *from, uint8_t *to, RSA *rsa, int padding);
-
-DSA *DSA_new(void);
-int DSA_size(const DSA */*rsa*/);
-void DSA_free(DSA */*dsa*/);
-DSA_SIG *DSA_SIG_new(void);
-void DSA_SIG_free(DSA_SIG */*sig*/);
-int DSA_do_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa);
-DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa);
+unsigned netpgpv_dsa_verify(const signature_t */*sig*/,
+       const netpgpv_dsa_pubkey_t */*pubdsa*/, const uint8_t */*calc*/,
+       size_t /*hashlen*/);
+
+NETPGPV_RSA *netpgpv_RSA_new(void);
+int netpgpv_RSA_size(const NETPGPV_RSA */*rsa*/);
+void netpgpv_RSA_free(NETPGPV_RSA */*rsa*/);
+int netpgpv_RSA_check_key(NETPGPV_RSA */*rsa*/);
+NETPGPV_RSA *netpgpv_RSA_generate_key(int /*num*/, unsigned long /*e*/,
+       void (*callback)(int,int,void *), void */*cb_arg*/);
+int netpgpv_RSA_public_encrypt(int /*flen*/, const unsigned char */*from*/,
+       unsigned char */*to*/, NETPGPV_RSA */*rsa*/, int /*padding*/);
+int netpgpv_RSA_private_decrypt(int /*flen*/, const unsigned char */*from*/,
+       unsigned char */*to*/, NETPGPV_RSA */*rsa*/, int /*padding*/);
+int netpgpv_RSA_private_encrypt(int /*flen*/, const unsigned char */*from*/,
+       unsigned char */*to*/, NETPGPV_RSA */*rsa*/, int /*padding*/);
+int netpgpv_RSA_public_decrypt(int /*flen*/, const uint8_t */*from*/,
+       uint8_t */*to*/, NETPGPV_RSA */*rsa*/, int /*padding*/);
+
+NETPGPV_DSA *netpgpv_DSA_new(void);
+int netpgpv_DSA_size(const NETPGPV_DSA */*rsa*/);
+void netpgpv_DSA_free(NETPGPV_DSA */*dsa*/);
+NETPGPV_DSA_SIG *netpgpv_DSA_SIG_new(void);
+void netpgpv_DSA_SIG_free(NETPGPV_DSA_SIG */*sig*/);
+int netpgpv_DSA_do_verify(const unsigned char */*dgst*/, int /*dgst_len*/,
+       NETPGPV_DSA_SIG */*sig*/, NETPGPV_DSA */*dsa*/);
+NETPGPV_DSA_SIG *netpgpv_DSA_do_sign(const unsigned char */*dgst*/,
+       int /*dlen*/, NETPGPV_DSA */*dsa*/);
 
 __END_DECLS
 
Index: pkgsrc/security/netpgpverify/files/zlib.c
diff -u pkgsrc/security/netpgpverify/files/zlib.c:1.2 pkgsrc/security/netpgpverify/files/zlib.c:1.3
--- pkgsrc/security/netpgpverify/files/zlib.c:1.2       Tue Feb  3 21:13:17 2015
+++ pkgsrc/security/netpgpverify/files/zlib.c   Sun May  3 23:49:04 2020
@@ -1,4 +1,4 @@
-/*     $NetBSD: zlib.c,v 1.2 2015/02/03 21:13:17 agc Exp $     */
+/*     $NetBSD: zlib.c,v 1.3 2020/05/03 23:49:04 agc Exp $     */
 
 /* inflate.c -- zlib decompression
  * Copyright (C) 1995-2005 Mark Adler
@@ -34,23 +34,23 @@
  * - Fix bug in reuse of allocated window after inflateReset()
  * - Remove bit fields--back to byte structure for speed
  * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
- * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Change post-increments to pre-increments in netpgpv_inflate_fast(), PPC biased?
  * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
- * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Make MATCH copy in inflate() much faster for when netpgpv_inflate_fast() not used
  * - Use local copies of stream next and avail values, as well as local bit
- *   buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *   buffer and bit count in inflate()--for speed when netpgpv_inflate_fast() not used
  *
  * 1.2.beta4    1 Jan 2003
- * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Split ptr - 257 statements in netpgpv_inflate_table() to avoid compiler warnings
  * - Move a comment on output buffer sizes from inffast.c to inflate.c
- * - Add comments in inffast.c to introduce the inflate_fast() routine
- * - Rearrange window copies in inflate_fast() for speed and simplification
- * - Unroll last copy for window match in inflate_fast()
- * - Use local copies of window variables in inflate_fast() for speed
- * - Pull out common write == 0 case for speed in inflate_fast()
- * - Make op and len in inflate_fast() unsigned for consistency
- * - Add FAR to lcode and dcode declarations in inflate_fast()
- * - Simplified bad distance check in inflate_fast()
+ * - Add comments in inffast.c to introduce the netpgpv_inflate_fast() routine
+ * - Rearrange window copies in netpgpv_inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in netpgpv_inflate_fast()
+ * - Use local copies of window variables in netpgpv_inflate_fast() for speed
+ * - Pull out common write == 0 case for speed in netpgpv_inflate_fast()
+ * - Make op and len in netpgpv_inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in netpgpv_inflate_fast()
+ * - Simplified bad distance check in netpgpv_inflate_fast()
  * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
  *   source file infback.c to provide a call-back interface to inflate for
  *   programs like gzip and unzip -- uses window as output buffer to avoid
@@ -237,14 +237,14 @@ struct inflate_state {
     code codes[ENOUGH];         /* space for code tables */
 };
 
-voidpf zcalloc(voidpf /*opaque*/, unsigned /*items*/, unsigned /*size*/);
-void zcfree (voidpf /*opaque*/, voidpf /*ptr*/);
-int inflate_table(codetype /*type*/, unsigned short FAR */*lens*/, unsigned /*codes*/,
+voidpf netpgpv_zcalloc(voidpf /*opaque*/, unsigned /*items*/, unsigned /*size*/);
+void netpgpv_zcfree (voidpf /*opaque*/, voidpf /*ptr*/);
+int netpgpv_inflate_table(codetype /*type*/, unsigned short FAR */*lens*/, unsigned /*codes*/,
        code FAR * FAR */*table*/, unsigned FAR */*bits*/, unsigned short FAR */*work*/);
-void inflate_fast(z_streamp /*strm*/, unsigned /*start*/);
+void netpgpv_inflate_fast(z_streamp /*strm*/, unsigned /*start*/);
 
 voidpf
-zcalloc (voidpf opaque, unsigned items, unsigned size)
+netpgpv_zcalloc (voidpf opaque, unsigned items, unsigned size)
 {
     if (opaque) items += size - size; /* make compiler happy */
     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
@@ -252,7 +252,7 @@ zcalloc (voidpf opaque, unsigned items, 
 }
 
 void
-zcfree (voidpf opaque, voidpf ptr)
+netpgpv_zcfree (voidpf opaque, voidpf ptr)
 {
     free(ptr);
     if (opaque) return; /* make compiler happy */
@@ -291,7 +291,7 @@ int ZEXPORT inflateReset(z_streamp strm)
     return Z_OK;
 }
 
-int ZEXPORT inflatePrime(z_streamp strm, int bits, int value)
+int ZEXPORT netpgpv_inflatePrime(z_streamp strm, int bits, int value)
 {
     struct inflate_state FAR *state;
 
@@ -314,10 +314,10 @@ int ZEXPORT inflateInit2_(z_streamp strm
     if (strm == Z_NULL) return Z_STREAM_ERROR;
     strm->msg = Z_NULL;                 /* in case we return an error */
     if (strm->zalloc == (alloc_func)0) {
-        strm->zalloc = zcalloc;
+        strm->zalloc = netpgpv_zcalloc;
         strm->opaque = (voidpf)0;
     }
-    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    if (strm->zfree == (free_func)0) strm->zfree = netpgpv_zcfree;
     state = (struct inflate_state FAR *)
             ZALLOC(strm, 1, sizeof(struct inflate_state));
     if (state == Z_NULL) return Z_MEM_ERROR;
@@ -361,7 +361,7 @@ int ZEXPORT inflateInit_( z_streamp strm
 local void
 fixedtables(struct inflate_state FAR *state)
 {
-/*     $NetBSD: zlib.c,v 1.2 2015/02/03 21:13:17 agc Exp $     */
+/*     $NetBSD: zlib.c,v 1.3 2020/05/03 23:49:04 agc Exp $     */
 
     /* inffixed.h -- table for decoding fixed codes
      * Generated automatically by makefixed().
@@ -762,7 +762,7 @@ adler32(uLong adler, const Bytef *buf, u
    longest code or if it is less than the shortest code.
  */
 int
-inflate_table(codetype type, unsigned short FAR *lens, unsigned codes,
+netpgpv_inflate_table(codetype type, unsigned short FAR *lens, unsigned codes,
        code FAR * FAR *table, unsigned FAR *bits, unsigned short FAR *work)
 {
     unsigned len;               /* a code's length in bits */
@@ -1106,12 +1106,12 @@ inflate_table(codetype type, unsigned sh
       checking for available input while decoding.
 
     - The maximum bytes that a single length/distance pair can output is 258
-      bytes, which is the maximum length that can be coded.  inflate_fast()
+      bytes, which is the maximum length that can be coded.  netpgpv_inflate_fast()
       requires strm->avail_out >= 258 for each loop to avoid checking for
       output space.
  */
 void
-inflate_fast(z_streamp strm, unsigned start)
+netpgpv_inflate_fast(z_streamp strm, unsigned start)
 /* inflate()'s starting value for strm->avail_out */
 {
     struct inflate_state FAR *state;
@@ -1748,7 +1748,7 @@ inflate(z_streamp strm, int flush)
             state->next = state->codes;
             state->lencode = (code const FAR *)(state->next);
             state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+            ret = netpgpv_inflate_table(CODES, state->lens, 19, &(state->next),
                                 &(state->lenbits), state->work);
             if (ret) {
                 strm->msg = __UNCONST("invalid code lengths set");
@@ -1814,7 +1814,7 @@ inflate(z_streamp strm, int flush)
             state->next = state->codes;
             state->lencode = (code const FAR *)(state->next);
             state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+            ret = netpgpv_inflate_table(LENS, state->lens, state->nlen, &(state->next),
                                 &(state->lenbits), state->work);
             if (ret) {
                 strm->msg = __UNCONST("invalid literal/lengths set");
@@ -1823,7 +1823,7 @@ inflate(z_streamp strm, int flush)
             }
             state->distcode = (code const FAR *)(state->next);
             state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+            ret = netpgpv_inflate_table(DISTS, state->lens + state->nlen, state->ndist,
                             &(state->next), &(state->distbits), state->work);
             if (ret) {
                 strm->msg = __UNCONST("invalid distances set");
@@ -1835,7 +1835,7 @@ inflate(z_streamp strm, int flush)
         case LEN:
             if (have >= 6 && left >= 258) {
                 RESTORE();
-                inflate_fast(strm, out);
+                netpgpv_inflate_fast(strm, out);
                 LOAD();
                 break;
             }
@@ -2092,7 +2092,7 @@ inflateSetDictionary(z_streamp strm, con
 }
 
 int ZEXPORT
-inflateGetHeader(z_streamp strm, gz_headerp head)
+netpgpv_inflateGetHeader(z_streamp strm, gz_headerp head)
 {
     struct inflate_state FAR *state;
 

Index: pkgsrc/security/netpgpverify/files/verify.h
diff -u pkgsrc/security/netpgpverify/files/verify.h:1.41 pkgsrc/security/netpgpverify/files/verify.h:1.42
--- pkgsrc/security/netpgpverify/files/verify.h:1.41    Thu Oct  3 20:18:13 2019
+++ pkgsrc/security/netpgpverify/files/verify.h Sun May  3 23:49:04 2020
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2012-2019 Alistair Crooks <agc%NetBSD.org@localhost>
+ * Copyright (c) 2012-2020 Alistair Crooks <agc%NetBSD.org@localhost>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -23,9 +23,9 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef NETPGP_VERIFY_H_
-#define NETPGP_VERIFY_H_       20191003
+#define NETPGP_VERIFY_H_       20200503
 
-#define NETPGPVERIFY_VERSION   "netpgpverify portable 20191003"
+#define NETPGPVERIFY_VERSION   "netpgpverify portable 20200503"
 
 #include <sys/types.h>
 



Home | Main Index | Thread Index | Old Index