<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">? files/CHANGES
Index: Makefile
===================================================================
RCS file: /cvsroot/pkgsrc/security/netpgpverify/Makefile,v
retrieving revision 1.15
diff -u -r1.15 Makefile
--- Makefile	1 Sep 2015 19:38:42 -0000	1.15
+++ Makefile	2 Sep 2015 01:21:14 -0000
@@ -1,6 +1,6 @@
 # $NetBSD: Makefile,v 1.15 2015/09/01 19:38:42 agc Exp $
 
-DISTNAME=		netpgpverify-20150901
+DISTNAME=		netpgpverify-20150902
 CATEGORIES=		security
 MASTER_SITES=		# empty
 DISTFILES=		# empty
Index: files/bzlib.c
===================================================================
RCS file: /cvsroot/pkgsrc/security/netpgpverify/files/bzlib.c,v
retrieving revision 1.4
diff -u -r1.4 bzlib.c
--- files/bzlib.c	3 Feb 2015 21:13:17 -0000	1.4
+++ files/bzlib.c	2 Sep 2015 01:21:14 -0000
@@ -23,7 +23,7 @@
 /* CHANGES
    0.9.0    -- original version.
    0.9.0a/b -- no changes in this file.
-   0.9.0c   -- made zero-length BZ_FLUSH work correctly in bzCompress().
+   0.9.0c   -- made zero-length NETPGPV_BZ_FLUSH work correctly in bzCompress().
      fixed bzWrite/bzRead to ignore zero-length requests.
      fixed bzread to correctly handle read requests after EOF.
      wrong parameter order in call to bzDecompressInit in
@@ -60,7 +60,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, 
@@ -121,8 +121,8 @@
 
 
 /*---------------------------------------------------*/
-#ifndef BZ_NO_STDIO
-void BZ2_bz__AssertH__fail ( int errcode )
+#ifndef NETPGPV_BZ_NO_STDIO
+void NETPGPV_BZ2_bz__AssertH__fail ( int errcode )
 {
    fprintf(stderr, 
       "\n\nbzip2/libbzip2: internal error number %d.\n"
@@ -134,7 +134,7 @@
       "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) {
@@ -172,7 +172,7 @@
 
 /*---------------------------------------------------*/
 static
-int bz_config_ok ( void )
+int netpgpv_bz_config_ok ( void )
 {
    if (sizeof(int)   != 4) return 0;
    if (sizeof(short) != 2) return 0;
@@ -218,7 +218,7 @@
    if (zchh != zs-&gt;state_in_ch &amp;&amp;                 \
        zs-&gt;state_in_len == 1) {                   \
       UChar ch = (UChar)(zs-&gt;state_in_ch);        \
-      BZ_UPDATE_CRC( zs-&gt;blockCRC, ch );          \
+      NETPGPV_BZ_UPDATE_CRC( zs-&gt;blockCRC, ch );          \
       zs-&gt;inUse[zs-&gt;state_in_ch] = True;          \
       zs-&gt;block[zs-&gt;nblock] = (UChar)ch;          \
       zs-&gt;nblock++;                               \
@@ -245,27 +245,27 @@
 /*---------------------------------------------------*/
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompressInit) 
-                     ( bz_stream* strm, 
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzDecompressInit) 
+                     ( netpgpv_bz_stream* strm, 
                        int        verbosity,
                        int        small )
 {
    DState* s;
 
-   if (!bz_config_ok()) return BZ_CONFIG_ERROR;
+   if (!netpgpv_bz_config_ok()) return NETPGPV_BZ_CONFIG_ERROR;
 
-   if (strm == NULL) return BZ_PARAM_ERROR;
-   if (small != 0 &amp;&amp; small != 1) return BZ_PARAM_ERROR;
-   if (verbosity &lt; 0 || verbosity &gt; 4) return BZ_PARAM_ERROR;
+   if (strm == NULL) return NETPGPV_BZ_PARAM_ERROR;
+   if (small != 0 &amp;&amp; small != 1) return NETPGPV_BZ_PARAM_ERROR;
+   if (verbosity &lt; 0 || verbosity &gt; 4) return NETPGPV_BZ_PARAM_ERROR;
 
    if (strm-&gt;bzalloc == NULL) strm-&gt;bzalloc = default_bzalloc;
    if (strm-&gt;bzfree == NULL) strm-&gt;bzfree = default_bzfree;
 
-   s = BZALLOC( sizeof(DState) );
-   if (s == NULL) return BZ_MEM_ERROR;
+   s = NETPGPV_BZALLOC( sizeof(DState) );
+   if (s == NULL) return NETPGPV_BZ_MEM_ERROR;
    s-&gt;strm                  = strm;
    strm-&gt;state              = s;
-   s-&gt;state                 = BZ_X_MAGIC_1;
+   s-&gt;state                 = NETPGPV_BZ_X_MAGIC_1;
    s-&gt;bsLive                = 0;
    s-&gt;bsBuff                = 0;
    s-&gt;calculatedCombinedCRC = 0;
@@ -280,7 +280,7 @@
    s-&gt;currBlockNo           = 0;
    s-&gt;verbosity             = verbosity;
 
-   return BZ_OK;
+   return NETPGPV_BZ_OK;
 }
 
 
@@ -301,7 +301,7 @@
             if (s-&gt;strm-&gt;avail_out == 0) return False;
             if (s-&gt;state_out_len == 0) break;
             *( (UChar*)(s-&gt;strm-&gt;next_out) ) = s-&gt;state_out_ch;
-            BZ_UPDATE_CRC ( s-&gt;calculatedBlockCRC, s-&gt;state_out_ch );
+            NETPGPV_BZ_UPDATE_CRC ( s-&gt;calculatedBlockCRC, s-&gt;state_out_ch );
             s-&gt;state_out_len--;
             s-&gt;strm-&gt;next_out++;
             s-&gt;strm-&gt;avail_out--;
@@ -318,28 +318,28 @@
    
          s-&gt;state_out_len = 1;
          s-&gt;state_out_ch = s-&gt;k0;
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
          s-&gt;state_out_len = 2;
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
          s-&gt;state_out_len = 3;
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          s-&gt;state_out_len = ((Int32)k1) + 4;
-         BZ_GET_FAST(s-&gt;k0); BZ_RAND_UPD_MASK; 
-         s-&gt;k0 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_FAST(s-&gt;k0); NETPGPV_BZ_RAND_UPD_MASK; 
+         s-&gt;k0 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
       }
 
    } else {
@@ -369,7 +369,7 @@
                if (cs_avail_out == 0) goto return_notr;
                if (c_state_out_len == 1) break;
                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
-               BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
+               NETPGPV_BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
                c_state_out_len--;
                cs_next_out++;
                cs_avail_out--;
@@ -380,7 +380,7 @@
                   c_state_out_len = 1; goto return_notr;
                };
                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
-               BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
+               NETPGPV_BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
                cs_next_out++;
                cs_avail_out--;
             }
@@ -394,7 +394,7 @@
             c_state_out_len = 0; goto return_notr;
          };   
          c_state_out_ch = c_k0;
-         BZ_GET_FAST_C(k1); c_nblock_used++;
+         NETPGPV_BZ_GET_FAST_C(k1); c_nblock_used++;
          if (k1 != c_k0) { 
             c_k0 = k1; goto s_state_out_len_eq_one; 
          };
@@ -402,18 +402,18 @@
             goto s_state_out_len_eq_one;
    
          c_state_out_len = 2;
-         BZ_GET_FAST_C(k1); c_nblock_used++;
+         NETPGPV_BZ_GET_FAST_C(k1); c_nblock_used++;
          if (c_nblock_used == s_save_nblockPP) continue;
          if (k1 != c_k0) { c_k0 = k1; continue; };
    
          c_state_out_len = 3;
-         BZ_GET_FAST_C(k1); c_nblock_used++;
+         NETPGPV_BZ_GET_FAST_C(k1); c_nblock_used++;
          if (c_nblock_used == s_save_nblockPP) continue;
          if (k1 != c_k0) { c_k0 = k1; continue; };
    
-         BZ_GET_FAST_C(k1); c_nblock_used++;
+         NETPGPV_BZ_GET_FAST_C(k1); c_nblock_used++;
          c_state_out_len = ((Int32)k1) + 4;
-         BZ_GET_FAST_C(c_k0); c_nblock_used++;
+         NETPGPV_BZ_GET_FAST_C(c_k0); c_nblock_used++;
       }
 
       return_notr:
@@ -440,7 +440,7 @@
 
 
 /*---------------------------------------------------*/
-__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
+__inline__ Int32 NETPGPV_BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
 {
    Int32 nb, na, mid;
    nb = 0;
@@ -471,7 +471,7 @@
             if (s-&gt;strm-&gt;avail_out == 0) return False;
             if (s-&gt;state_out_len == 0) break;
             *( (UChar*)(s-&gt;strm-&gt;next_out) ) = s-&gt;state_out_ch;
-            BZ_UPDATE_CRC ( s-&gt;calculatedBlockCRC, s-&gt;state_out_ch );
+            NETPGPV_BZ_UPDATE_CRC ( s-&gt;calculatedBlockCRC, s-&gt;state_out_ch );
             s-&gt;state_out_len--;
             s-&gt;strm-&gt;next_out++;
             s-&gt;strm-&gt;avail_out--;
@@ -488,28 +488,28 @@
    
          s-&gt;state_out_len = 1;
          s-&gt;state_out_ch = s-&gt;k0;
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
          s-&gt;state_out_len = 2;
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
          s-&gt;state_out_len = 3;
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; 
-         k1 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; 
+         k1 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
          s-&gt;state_out_len = ((Int32)k1) + 4;
-         BZ_GET_SMALL(s-&gt;k0); BZ_RAND_UPD_MASK; 
-         s-&gt;k0 ^= BZ_RAND_MASK; s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(s-&gt;k0); NETPGPV_BZ_RAND_UPD_MASK; 
+         s-&gt;k0 ^= NETPGPV_BZ_RAND_MASK; s-&gt;nblock_used++;
       }
 
    } else {
@@ -520,7 +520,7 @@
             if (s-&gt;strm-&gt;avail_out == 0) return False;
             if (s-&gt;state_out_len == 0) break;
             *( (UChar*)(s-&gt;strm-&gt;next_out) ) = s-&gt;state_out_ch;
-            BZ_UPDATE_CRC ( s-&gt;calculatedBlockCRC, s-&gt;state_out_ch );
+            NETPGPV_BZ_UPDATE_CRC ( s-&gt;calculatedBlockCRC, s-&gt;state_out_ch );
             s-&gt;state_out_len--;
             s-&gt;strm-&gt;next_out++;
             s-&gt;strm-&gt;avail_out--;
@@ -537,23 +537,23 @@
    
          s-&gt;state_out_len = 1;
          s-&gt;state_out_ch = s-&gt;k0;
-         BZ_GET_SMALL(k1); s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
          s-&gt;state_out_len = 2;
-         BZ_GET_SMALL(k1); s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
          s-&gt;state_out_len = 3;
-         BZ_GET_SMALL(k1); s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); s-&gt;nblock_used++;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1) continue;
          if (k1 != s-&gt;k0) { s-&gt;k0 = k1; continue; };
    
-         BZ_GET_SMALL(k1); s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(k1); s-&gt;nblock_used++;
          s-&gt;state_out_len = ((Int32)k1) + 4;
-         BZ_GET_SMALL(s-&gt;k0); s-&gt;nblock_used++;
+         NETPGPV_BZ_GET_SMALL(s-&gt;k0); s-&gt;nblock_used++;
       }
 
    }
@@ -561,50 +561,50 @@
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzDecompress) ( netpgpv_bz_stream *strm )
 {
    Bool    corrupt;
    DState* s;
-   if (strm == NULL) return BZ_PARAM_ERROR;
+   if (strm == NULL) return NETPGPV_BZ_PARAM_ERROR;
    s = strm-&gt;state;
-   if (s == NULL) return BZ_PARAM_ERROR;
-   if (s-&gt;strm != strm) return BZ_PARAM_ERROR;
+   if (s == NULL) return NETPGPV_BZ_PARAM_ERROR;
+   if (s-&gt;strm != strm) return NETPGPV_BZ_PARAM_ERROR;
 
    while (True) {
-      if (s-&gt;state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
-      if (s-&gt;state == BZ_X_OUTPUT) {
+      if (s-&gt;state == NETPGPV_BZ_X_IDLE) return NETPGPV_BZ_SEQUENCE_ERROR;
+      if (s-&gt;state == NETPGPV_BZ_X_OUTPUT) {
          if (s-&gt;smallDecompress)
             corrupt = unRLE_obuf_to_output_SMALL ( s ); else
             corrupt = unRLE_obuf_to_output_FAST  ( s );
-         if (corrupt) return BZ_DATA_ERROR;
+         if (corrupt) return NETPGPV_BZ_DATA_ERROR;
          if (s-&gt;nblock_used == s-&gt;save_nblock+1 &amp;&amp; s-&gt;state_out_len == 0) {
-            BZ_FINALISE_CRC ( s-&gt;calculatedBlockCRC );
+            NETPGPV_BZ_FINALISE_CRC ( s-&gt;calculatedBlockCRC );
             if (s-&gt;verbosity &gt;= 3) 
                VPrintf2 ( " {0x%08x, 0x%08x}", s-&gt;storedBlockCRC, 
                           s-&gt;calculatedBlockCRC );
             if (s-&gt;verbosity &gt;= 2) VPrintf0 ( "]" );
             if (s-&gt;calculatedBlockCRC != s-&gt;storedBlockCRC)
-               return BZ_DATA_ERROR;
+               return NETPGPV_BZ_DATA_ERROR;
             s-&gt;calculatedCombinedCRC 
                = (s-&gt;calculatedCombinedCRC &lt;&lt; 1) | 
                     (s-&gt;calculatedCombinedCRC &gt;&gt; 31);
             s-&gt;calculatedCombinedCRC ^= s-&gt;calculatedBlockCRC;
-            s-&gt;state = BZ_X_BLKHDR_1;
+            s-&gt;state = NETPGPV_BZ_X_BLKHDR_1;
          } else {
-            return BZ_OK;
+            return NETPGPV_BZ_OK;
          }
       }
-      if (s-&gt;state &gt;= BZ_X_MAGIC_1) {
-         Int32 r = BZ2_decompress ( s );
-         if (r == BZ_STREAM_END) {
+      if (s-&gt;state &gt;= NETPGPV_BZ_X_MAGIC_1) {
+         Int32 r = NETPGPV_BZ2_decompress ( s );
+         if (r == NETPGPV_BZ_STREAM_END) {
             if (s-&gt;verbosity &gt;= 3)
                VPrintf2 ( "\n    combined CRCs: stored = 0x%08x, computed = 0x%08x", 
                           s-&gt;storedCombinedCRC, s-&gt;calculatedCombinedCRC );
             if (s-&gt;calculatedCombinedCRC != s-&gt;storedCombinedCRC)
-               return BZ_DATA_ERROR;
+               return NETPGPV_BZ_DATA_ERROR;
             return r;
          }
-         if (s-&gt;state != BZ_X_OUTPUT) return r;
+         if (s-&gt;state != NETPGPV_BZ_X_OUTPUT) return r;
       }
    }
 
@@ -615,31 +615,31 @@
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompressEnd)  ( bz_stream *strm )
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzDecompressEnd)  ( netpgpv_bz_stream *strm )
 {
    DState* s;
-   if (strm == NULL) return BZ_PARAM_ERROR;
+   if (strm == NULL) return NETPGPV_BZ_PARAM_ERROR;
    s = strm-&gt;state;
-   if (s == NULL) return BZ_PARAM_ERROR;
-   if (s-&gt;strm != strm) return BZ_PARAM_ERROR;
+   if (s == NULL) return NETPGPV_BZ_PARAM_ERROR;
+   if (s-&gt;strm != strm) return NETPGPV_BZ_PARAM_ERROR;
 
-   if (s-&gt;tt   != NULL) BZFREE(s-&gt;tt);
-   if (s-&gt;ll16 != NULL) BZFREE(s-&gt;ll16);
-   if (s-&gt;ll4  != NULL) BZFREE(s-&gt;ll4);
+   if (s-&gt;tt   != NULL) NETPGPV_BZFREE(s-&gt;tt);
+   if (s-&gt;ll16 != NULL) NETPGPV_BZFREE(s-&gt;ll16);
+   if (s-&gt;ll4  != NULL) NETPGPV_BZFREE(s-&gt;ll4);
 
-   BZFREE(strm-&gt;state);
+   NETPGPV_BZFREE(strm-&gt;state);
    strm-&gt;state = NULL;
 
-   return BZ_OK;
+   return NETPGPV_BZ_OK;
 }
 
 
-#ifndef BZ_NO_STDIO
+#ifndef NETPGPV_BZ_NO_STDIO
 /*---------------------------------------------------*/
 /*--- File I/O stuff                              ---*/
 /*---------------------------------------------------*/
 
-#define BZ_SETERR(eee)                    \
+#define NETPGPV_BZ_SETERR(eee)                    \
 {                                         \
    if (bzerror != NULL) *bzerror = eee;   \
    if (bzf != NULL) bzf-&gt;lastErr = eee;   \
@@ -648,14 +648,14 @@
 typedef 
    struct {
       FILE*     handle;
-      Char      buf[BZ_MAX_UNUSED];
+      Char      buf[NETPGPV_BZ_MAX_UNUSED];
       Int32     bufN;
       Bool      writing;
-      bz_stream strm;
+      netpgpv_bz_stream strm;
       Int32     lastErr;
       Bool      initialisedOk;
    }
-   bzFile;
+   netpgpv_bzFile;
 
 
 /*---------------------------------------------*/
@@ -669,7 +669,7 @@
 
 
 /*---------------------------------------------------*/
-BZFILE* BZ_API(BZ2_bzReadOpen) 
+NETPGPV_BZFILE* NETPGPV_BZ_API(NETPGPV_BZ2_bzReadOpen) 
                    ( int*  bzerror, 
                      FILE* f, 
                      int   verbosity,
@@ -677,30 +677,30 @@
                      void* unused,
                      int   nUnused )
 {
-   bzFile* bzf = NULL;
+   netpgpv_bzFile* bzf = NULL;
    int     ret;
 
    if (bzerror == NULL) {
 	return NULL;
    }
 
-   BZ_SETERR(BZ_OK);
+   NETPGPV_BZ_SETERR(NETPGPV_BZ_OK);
 
    if (f == NULL || 
        (small != 0 &amp;&amp; small != 1) ||
        (verbosity &lt; 0 || verbosity &gt; 4) ||
        (unused == NULL &amp;&amp; nUnused != 0) ||
-       (unused != NULL &amp;&amp; (nUnused &lt; 0 || nUnused &gt; BZ_MAX_UNUSED)))
-      { BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
+       (unused != NULL &amp;&amp; (nUnused &lt; 0 || nUnused &gt; NETPGPV_BZ_MAX_UNUSED)))
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_PARAM_ERROR); return NULL; };
 
    if (ferror(f))
-      { BZ_SETERR(BZ_IO_ERROR); return NULL; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_IO_ERROR); return NULL; };
 
-   bzf = malloc ( sizeof(bzFile) );
+   bzf = malloc ( sizeof(netpgpv_bzFile) );
    if (bzf == NULL) 
-      { BZ_SETERR(BZ_MEM_ERROR); return NULL; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_MEM_ERROR); return NULL; };
 
-   BZ_SETERR(BZ_OK);
+   NETPGPV_BZ_SETERR(NETPGPV_BZ_OK);
 
    bzf-&gt;initialisedOk = False;
    bzf-&gt;handle        = f;
@@ -716,9 +716,9 @@
       nUnused--;
    }
 
-   ret = BZ2_bzDecompressInit ( &amp;(bzf-&gt;strm), verbosity, small );
-   if (ret != BZ_OK)
-      { BZ_SETERR(ret); free(bzf); return NULL; };
+   ret = NETPGPV_BZ2_bzDecompressInit ( &amp;(bzf-&gt;strm), verbosity, small );
+   if (ret != NETPGPV_BZ_OK)
+      { NETPGPV_BZ_SETERR(ret); free(bzf); return NULL; };
 
    bzf-&gt;strm.avail_in = bzf-&gt;bufN;
    bzf-&gt;strm.next_in  = bzf-&gt;buf;
@@ -729,43 +729,43 @@
 
 
 /*---------------------------------------------------*/
-void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
+void NETPGPV_BZ_API(NETPGPV_BZ2_bzReadClose) ( int *bzerror, NETPGPV_BZFILE *b )
 {
-   bzFile* bzf = (bzFile*)b;
+   netpgpv_bzFile* bzf = (netpgpv_bzFile*)b;
 
-   BZ_SETERR(BZ_OK);
+   NETPGPV_BZ_SETERR(NETPGPV_BZ_OK);
    if (bzf == NULL)
-      { BZ_SETERR(BZ_OK); return; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_OK); return; };
 
    if (bzf-&gt;writing)
-      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_SEQUENCE_ERROR); return; };
 
    if (bzf-&gt;initialisedOk)
-      (void)BZ2_bzDecompressEnd ( &amp;(bzf-&gt;strm) );
+      (void)NETPGPV_BZ2_bzDecompressEnd ( &amp;(bzf-&gt;strm) );
    free ( bzf );
 }
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzRead) 
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzRead) 
            ( int*    bzerror, 
-             BZFILE* b, 
+             NETPGPV_BZFILE* b, 
              void*   buf, 
              int     len )
 {
    Int32   n, ret;
-   bzFile* bzf = (bzFile*)b;
+   netpgpv_bzFile* bzf = (netpgpv_bzFile*)b;
 
-   BZ_SETERR(BZ_OK);
+   NETPGPV_BZ_SETERR(NETPGPV_BZ_OK);
 
    if (bzf == NULL || buf == NULL || len &lt; 0)
-      { BZ_SETERR(BZ_PARAM_ERROR); return 0; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_PARAM_ERROR); return 0; };
 
    if (bzf-&gt;writing)
-      { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_SEQUENCE_ERROR); return 0; };
 
    if (len == 0)
-      { BZ_SETERR(BZ_OK); return 0; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_OK); return 0; };
 
    bzf-&gt;strm.avail_out = len;
    bzf-&gt;strm.next_out = buf;
@@ -773,32 +773,32 @@
    while (True) {
 
       if (ferror(bzf-&gt;handle)) 
-         { BZ_SETERR(BZ_IO_ERROR); return 0; };
+         { NETPGPV_BZ_SETERR(NETPGPV_BZ_IO_ERROR); return 0; };
 
       if (bzf-&gt;strm.avail_in == 0 &amp;&amp; !myfeof(bzf-&gt;handle)) {
          n = fread ( bzf-&gt;buf, sizeof(UChar), 
-                     BZ_MAX_UNUSED, bzf-&gt;handle );
+                     NETPGPV_BZ_MAX_UNUSED, bzf-&gt;handle );
          if (ferror(bzf-&gt;handle))
-            { BZ_SETERR(BZ_IO_ERROR); return 0; };
+            { NETPGPV_BZ_SETERR(NETPGPV_BZ_IO_ERROR); return 0; };
          bzf-&gt;bufN = n;
          bzf-&gt;strm.avail_in = bzf-&gt;bufN;
          bzf-&gt;strm.next_in = bzf-&gt;buf;
       }
 
-      ret = BZ2_bzDecompress ( &amp;(bzf-&gt;strm) );
+      ret = NETPGPV_BZ2_bzDecompress ( &amp;(bzf-&gt;strm) );
 
-      if (ret != BZ_OK &amp;&amp; ret != BZ_STREAM_END)
-         { BZ_SETERR(ret); return 0; };
+      if (ret != NETPGPV_BZ_OK &amp;&amp; ret != NETPGPV_BZ_STREAM_END)
+         { NETPGPV_BZ_SETERR(ret); return 0; };
 
-      if (ret == BZ_OK &amp;&amp; myfeof(bzf-&gt;handle) &amp;&amp; 
+      if (ret == NETPGPV_BZ_OK &amp;&amp; myfeof(bzf-&gt;handle) &amp;&amp; 
           bzf-&gt;strm.avail_in == 0 &amp;&amp; bzf-&gt;strm.avail_out &gt; 0)
-         { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
+         { NETPGPV_BZ_SETERR(NETPGPV_BZ_UNEXPECTED_EOF); return 0; };
 
-      if (ret == BZ_STREAM_END)
-         { BZ_SETERR(BZ_STREAM_END);
+      if (ret == NETPGPV_BZ_STREAM_END)
+         { NETPGPV_BZ_SETERR(NETPGPV_BZ_STREAM_END);
            return len - bzf-&gt;strm.avail_out; };
       if (bzf-&gt;strm.avail_out == 0)
-         { BZ_SETERR(BZ_OK); return len; };
+         { NETPGPV_BZ_SETERR(NETPGPV_BZ_OK); return len; };
       
    }
 
@@ -807,21 +807,21 @@
 
 
 /*---------------------------------------------------*/
-void BZ_API(BZ2_bzReadGetUnused) 
+void NETPGPV_BZ_API(NETPGPV_BZ2_bzReadGetUnused) 
                      ( int*    bzerror, 
-                       BZFILE* b, 
+                       NETPGPV_BZFILE* b, 
                        void**  unused, 
                        int*    nUnused )
 {
-   bzFile* bzf = (bzFile*)b;
+   netpgpv_bzFile* bzf = (netpgpv_bzFile*)b;
    if (bzf == NULL)
-      { BZ_SETERR(BZ_PARAM_ERROR); return; };
-   if (bzf-&gt;lastErr != BZ_STREAM_END)
-      { BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_PARAM_ERROR); return; };
+   if (bzf-&gt;lastErr != NETPGPV_BZ_STREAM_END)
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_SEQUENCE_ERROR); return; };
    if (unused == NULL || nUnused == NULL)
-      { BZ_SETERR(BZ_PARAM_ERROR); return; };
+      { NETPGPV_BZ_SETERR(NETPGPV_BZ_PARAM_ERROR); return; };
 
-   BZ_SETERR(BZ_OK);
+   NETPGPV_BZ_SETERR(NETPGPV_BZ_OK);
    *nUnused = bzf-&gt;strm.avail_in;
    *unused = bzf-&gt;strm.next_in;
 }
@@ -829,7 +829,7 @@
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzBuffToBuffDecompress) 
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzBuffToBuffDecompress) 
                            ( char*         dest, 
                              unsigned int* destLen,
                              char*         source, 
@@ -837,46 +837,46 @@
                              int           small,
                              int           verbosity )
 {
-   bz_stream strm;
+   netpgpv_bz_stream strm;
    int ret;
 
    if (dest == NULL || destLen == NULL || 
        source == NULL ||
        (small != 0 &amp;&amp; small != 1) ||
        verbosity &lt; 0 || verbosity &gt; 4) 
-          return BZ_PARAM_ERROR;
+          return NETPGPV_BZ_PARAM_ERROR;
 
    strm.bzalloc = NULL;
    strm.bzfree = NULL;
    strm.opaque = NULL;
-   ret = BZ2_bzDecompressInit ( &amp;strm, verbosity, small );
-   if (ret != BZ_OK) return ret;
+   ret = NETPGPV_BZ2_bzDecompressInit ( &amp;strm, verbosity, small );
+   if (ret != NETPGPV_BZ_OK) return ret;
 
    strm.next_in = source;
    strm.next_out = dest;
    strm.avail_in = sourceLen;
    strm.avail_out = *destLen;
 
-   ret = BZ2_bzDecompress ( &amp;strm );
-   if (ret == BZ_OK) goto output_overflow_or_eof;
-   if (ret != BZ_STREAM_END) goto errhandler;
+   ret = NETPGPV_BZ2_bzDecompress ( &amp;strm );
+   if (ret == NETPGPV_BZ_OK) goto output_overflow_or_eof;
+   if (ret != NETPGPV_BZ_STREAM_END) goto errhandler;
 
    /* normal termination */
    *destLen -= strm.avail_out;
-   BZ2_bzDecompressEnd ( &amp;strm );
-   return BZ_OK;
+   NETPGPV_BZ2_bzDecompressEnd ( &amp;strm );
+   return NETPGPV_BZ_OK;
 
    output_overflow_or_eof:
    if (strm.avail_out &gt; 0) {
-      BZ2_bzDecompressEnd ( &amp;strm );
-      return BZ_UNEXPECTED_EOF;
+      NETPGPV_BZ2_bzDecompressEnd ( &amp;strm );
+      return NETPGPV_BZ_UNEXPECTED_EOF;
    } else {
-      BZ2_bzDecompressEnd ( &amp;strm );
-      return BZ_OUTBUFF_FULL;
+      NETPGPV_BZ2_bzDecompressEnd ( &amp;strm );
+      return NETPGPV_BZ_OUTBUFF_FULL;
    };      
 
    errhandler:
-   BZ2_bzDecompressEnd ( &amp;strm );
+   NETPGPV_BZ2_bzDecompressEnd ( &amp;strm );
    return ret; 
 }
 
@@ -896,13 +896,13 @@
 /*--
    return version like "0.9.5d, 4-Sept-1999".
 --*/
-const char * BZ_API(BZ2_bzlibVersion)(void)
+const char * NETPGPV_BZ_API(NETPGPV_BZ2_bzlibVersion)(void)
 {
-   return BZ_VERSION;
+   return NETPGPV_BZ_VERSION;
 }
 
 
-#ifndef BZ_NO_STDIO
+#ifndef NETPGPV_BZ_NO_STDIO
 /*---------------------------------------------------*/
 
 #if defined(_WIN32) || defined(OS2) || defined(MSDOS)
@@ -913,19 +913,19 @@
 #   define SET_BINARY_MODE(file)
 #endif
 static
-BZFILE * bzopen_or_bzdopen
+NETPGPV_BZFILE * netpgpv_bzopen_or_bzdopen
                ( const char *path,   /* no use when bzdopen */
                  int fd,             /* no use when bzdopen */
                  const char *mode,
                  int open_mode)      /* bzopen: 0, bzdopen:1 */
 {
    int    bzerr;
-   char   unused[BZ_MAX_UNUSED];
+   char   unused[NETPGPV_BZ_MAX_UNUSED];
    int    blockSize100k = 9;
    int    writing       = 0;
    char   mode2[10]     = "";
    FILE   *fp           = NULL;
-   BZFILE *bzfp         = NULL;
+   NETPGPV_BZFILE *bzfp         = NULL;
    int    verbosity     = 0;
    int    smallMode     = 0;
    int    nUnused       = 0; 
@@ -943,7 +943,7 @@
          smallMode = 1; break;
       default:
          if (isdigit((unsigned char)(*mode))) {
-            blockSize100k = *mode-BZ_HDR_0;
+            blockSize100k = *mode-NETPGPV_BZ_HDR_0;
          }
       }
       mode++;
@@ -959,7 +959,7 @@
         fp = fopen(path,mode2);
       }
    } else {
-#ifdef BZ_STRICT_ANSI
+#ifdef NETPGPV_BZ_STRICT_ANSI
       fp = NULL;
 #else
       fp = fdopen(fd,mode2);
@@ -969,7 +969,7 @@
 
    if (writing) {
    } else {
-      bzfp = BZ2_bzReadOpen(&amp;bzerr,fp,verbosity,smallMode,
+      bzfp = NETPGPV_BZ2_bzReadOpen(&amp;bzerr,fp,verbosity,smallMode,
                             unused,nUnused);
    }
    if (bzfp == NULL) {
@@ -983,33 +983,33 @@
 /*---------------------------------------------------*/
 /*--
    open file for read or write.
-      ex) bzopen("file","w9")
+      ex) netpgpv_bzopen("file","w9")
       case path="" or NULL =&gt; use stdin or stdout.
 --*/
-BZFILE * BZ_API(BZ2_bzopen)
+NETPGPV_BZFILE * NETPGPV_BZ_API(NETPGPV_BZ2_bzopen)
                ( const char *path,
                  const char *mode )
 {
-   return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
+   return netpgpv_bzopen_or_bzdopen(path,-1,mode,/*netpgpv_bzopen*/0);
 }
 
 
 /*---------------------------------------------------*/
-BZFILE * BZ_API(BZ2_bzdopen)
+NETPGPV_BZFILE * NETPGPV_BZ_API(NETPGPV_BZ2_bzdopen)
                ( int fd,
                  const char *mode )
 {
-   return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
+   return netpgpv_bzopen_or_bzdopen(NULL,fd,mode,/*netpgpv_bzdopen*/1);
 }
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzread) (NETPGPV_BZFILE* b, void* buf, int len )
 {
    int bzerr, nread;
-   if (((bzFile*)b)-&gt;lastErr == BZ_STREAM_END) return 0;
-   nread = BZ2_bzRead(&amp;bzerr,b,buf,len);
-   if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
+   if (((netpgpv_bzFile*)b)-&gt;lastErr == NETPGPV_BZ_STREAM_END) return 0;
+   nread = NETPGPV_BZ2_bzRead(&amp;bzerr,b,buf,len);
+   if (bzerr == NETPGPV_BZ_OK || bzerr == NETPGPV_BZ_STREAM_END) {
       return nread;
    } else {
       return -1;
@@ -1018,7 +1018,7 @@
 
 
 /*---------------------------------------------------*/
-int BZ_API(BZ2_bzflush) (BZFILE *b)
+int NETPGPV_BZ_API(NETPGPV_BZ2_bzflush) (NETPGPV_BZFILE *b)
 {
 	USE_ARG(b);
    /* do nothing now... */
@@ -1027,16 +1027,16 @@
 
 
 /*---------------------------------------------------*/
-void BZ_API(BZ2_bzclose) (BZFILE* b)
+void NETPGPV_BZ_API(NETPGPV_BZ2_bzclose) (NETPGPV_BZFILE* b)
 {
    int bzerr;
    FILE *fp;
    
    if (b==NULL) {return;}
-   fp = ((bzFile *)b)-&gt;handle;
-   if(((bzFile*)b)-&gt;writing){
+   fp = ((netpgpv_bzFile *)b)-&gt;handle;
+   if(((netpgpv_bzFile*)b)-&gt;writing){
    }else{
-      BZ2_bzReadClose(&amp;bzerr,b);
+      NETPGPV_BZ2_bzReadClose(&amp;bzerr,b);
    }
    if(fp!=stdin &amp;&amp; fp!=stdout){
       fclose(fp);
@@ -1048,7 +1048,7 @@
 /*--
    return last error code 
 --*/
-static const char *bzerrorstrings[] = {
+static const char *netpgpv_bzerrorstrings[] = {
        "OK"
       ,"SEQUENCE_ERROR"
       ,"PARAM_ERROR"
@@ -1068,13 +1068,13 @@
 };
 
 
-const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
+const char * NETPGPV_BZ_API(NETPGPV_BZ2_bzerror) (NETPGPV_BZFILE *b, int *errnum)
 {
-   int err = ((bzFile *)b)-&gt;lastErr;
+   int err = ((netpgpv_bzFile *)b)-&gt;lastErr;
 
    if(err&gt;0) err = 0;
    *errnum = err;
-   return bzerrorstrings[err*-1];
+   return netpgpv_bzerrorstrings[err*-1];
 }
 #endif
 
@@ -1135,7 +1135,7 @@
          vvv = v;                                 \
          break;                                   \
       }                                           \
-      if (s-&gt;strm-&gt;avail_in == 0) RETURN(BZ_OK);  \
+      if (s-&gt;strm-&gt;avail_in == 0) RETURN(NETPGPV_BZ_OK);  \
       s-&gt;bsBuff                                   \
          = (s-&gt;bsBuff &lt;&lt; 8) |                     \
            ((UInt32)                              \
@@ -1160,8 +1160,8 @@
    if (groupPos == 0) {                           \
       groupNo++;                                  \
       if (groupNo &gt;= nSelectors)                  \
-         RETURN(BZ_DATA_ERROR);                   \
-      groupPos = BZ_G_SIZE;                       \
+         RETURN(NETPGPV_BZ_DATA_ERROR);                   \
+      groupPos = NETPGPV_BZ_G_SIZE;                       \
       gSel = s-&gt;selector[groupNo];                \
       gMinlen = s-&gt;minLens[gSel];                 \
       gLimit = &amp;(s-&gt;limit[gSel][0]);              \
@@ -1173,26 +1173,26 @@
    GET_BITS(label1, zvec, zn);                    \
    while (1) {                                    \
       if (zn &gt; 20 /* the longest code */)         \
-         RETURN(BZ_DATA_ERROR);                   \
+         RETURN(NETPGPV_BZ_DATA_ERROR);                   \
       if (zvec &lt;= gLimit[zn]) break;              \
       zn++;                                       \
       GET_BIT(label2, zj);                        \
       zvec = (zvec &lt;&lt; 1) | zj;                    \
    };                                             \
    if (zvec - gBase[zn] &lt; 0                       \
-       || zvec - gBase[zn] &gt;= BZ_MAX_ALPHA_SIZE)  \
-      RETURN(BZ_DATA_ERROR);                      \
+       || zvec - gBase[zn] &gt;= NETPGPV_BZ_MAX_ALPHA_SIZE)  \
+      RETURN(NETPGPV_BZ_DATA_ERROR);                      \
    lval = gPerm[zvec - gBase[zn]];                \
 }
 
 
 /*---------------------------------------------------*/
-Int32 BZ2_decompress ( DState* s )
+Int32 NETPGPV_BZ2_decompress ( DState* s )
 {
    UChar      uc;
    Int32      retVal;
    Int32      minLen, maxLen;
-   bz_stream* strm = s-&gt;strm;
+   netpgpv_bz_stream* strm = s-&gt;strm;
 
    /* stuff that needs to be saved/restored */
    Int32  i;
@@ -1220,7 +1220,7 @@
    Int32* gBase;
    Int32* gPerm;
 
-   if (s-&gt;state == BZ_X_MAGIC_1) {
+   if (s-&gt;state == NETPGPV_BZ_X_MAGIC_1) {
       /*initialise the save area*/
       s-&gt;save_i           = 0;
       s-&gt;save_j           = 0;
@@ -1274,82 +1274,82 @@
    gBase       = s-&gt;save_gBase;
    gPerm       = s-&gt;save_gPerm;
 
-   retVal = BZ_OK;
+   retVal = NETPGPV_BZ_OK;
 
    switch (s-&gt;state) {
 
-      GET_UCHAR(BZ_X_MAGIC_1, uc);
-      if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
+      GET_UCHAR(NETPGPV_BZ_X_MAGIC_1, uc);
+      if (uc != NETPGPV_BZ_HDR_B) RETURN(NETPGPV_BZ_DATA_ERROR_MAGIC);
 
-      GET_UCHAR(BZ_X_MAGIC_2, uc);
-      if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
+      GET_UCHAR(NETPGPV_BZ_X_MAGIC_2, uc);
+      if (uc != NETPGPV_BZ_HDR_Z) RETURN(NETPGPV_BZ_DATA_ERROR_MAGIC);
 
-      GET_UCHAR(BZ_X_MAGIC_3, uc)
-      if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
+      GET_UCHAR(NETPGPV_BZ_X_MAGIC_3, uc)
+      if (uc != NETPGPV_BZ_HDR_h) RETURN(NETPGPV_BZ_DATA_ERROR_MAGIC);
 
-      GET_BITS(BZ_X_MAGIC_4, s-&gt;blockSize100k, 8)
-      if (s-&gt;blockSize100k &lt; (BZ_HDR_0 + 1) || 
-          s-&gt;blockSize100k &gt; (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
-      s-&gt;blockSize100k -= BZ_HDR_0;
+      GET_BITS(NETPGPV_BZ_X_MAGIC_4, s-&gt;blockSize100k, 8)
+      if (s-&gt;blockSize100k &lt; (NETPGPV_BZ_HDR_0 + 1) || 
+          s-&gt;blockSize100k &gt; (NETPGPV_BZ_HDR_0 + 9)) RETURN(NETPGPV_BZ_DATA_ERROR_MAGIC);
+      s-&gt;blockSize100k -= NETPGPV_BZ_HDR_0;
 
       if (s-&gt;smallDecompress) {
-         s-&gt;ll16 = BZALLOC( s-&gt;blockSize100k * 100000 * sizeof(UInt16) );
-         s-&gt;ll4  = BZALLOC( 
+         s-&gt;ll16 = NETPGPV_BZALLOC( s-&gt;blockSize100k * 100000 * sizeof(UInt16) );
+         s-&gt;ll4  = NETPGPV_BZALLOC( 
                       ((1 + s-&gt;blockSize100k * 100000) &gt;&gt; 1) * sizeof(UChar) 
                    );
-         if (s-&gt;ll16 == NULL || s-&gt;ll4 == NULL) RETURN(BZ_MEM_ERROR);
+         if (s-&gt;ll16 == NULL || s-&gt;ll4 == NULL) RETURN(NETPGPV_BZ_MEM_ERROR);
       } else {
-         s-&gt;tt  = BZALLOC( s-&gt;blockSize100k * 100000 * sizeof(Int32) );
-         if (s-&gt;tt == NULL) RETURN(BZ_MEM_ERROR);
+         s-&gt;tt  = NETPGPV_BZALLOC( s-&gt;blockSize100k * 100000 * sizeof(Int32) );
+         if (s-&gt;tt == NULL) RETURN(NETPGPV_BZ_MEM_ERROR);
       }
 
-      GET_UCHAR(BZ_X_BLKHDR_1, uc);
+      GET_UCHAR(NETPGPV_BZ_X_BLKHDR_1, uc);
 
       if (uc == 0x17) goto endhdr_2;
-      if (uc != 0x31) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_BLKHDR_2, uc);
-      if (uc != 0x41) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_BLKHDR_3, uc);
-      if (uc != 0x59) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_BLKHDR_4, uc);
-      if (uc != 0x26) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_BLKHDR_5, uc);
-      if (uc != 0x53) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_BLKHDR_6, uc);
-      if (uc != 0x59) RETURN(BZ_DATA_ERROR);
+      if (uc != 0x31) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_BLKHDR_2, uc);
+      if (uc != 0x41) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_BLKHDR_3, uc);
+      if (uc != 0x59) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_BLKHDR_4, uc);
+      if (uc != 0x26) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_BLKHDR_5, uc);
+      if (uc != 0x53) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_BLKHDR_6, uc);
+      if (uc != 0x59) RETURN(NETPGPV_BZ_DATA_ERROR);
 
       s-&gt;currBlockNo++;
       if (s-&gt;verbosity &gt;= 2)
          VPrintf1 ( "\n    [%d: huff+mtf ", s-&gt;currBlockNo );
  
       s-&gt;storedBlockCRC = 0;
-      GET_UCHAR(BZ_X_BCRC_1, uc);
+      GET_UCHAR(NETPGPV_BZ_X_BCRC_1, uc);
       s-&gt;storedBlockCRC = (s-&gt;storedBlockCRC &lt;&lt; 8) | ((UInt32)uc);
-      GET_UCHAR(BZ_X_BCRC_2, uc);
+      GET_UCHAR(NETPGPV_BZ_X_BCRC_2, uc);
       s-&gt;storedBlockCRC = (s-&gt;storedBlockCRC &lt;&lt; 8) | ((UInt32)uc);
-      GET_UCHAR(BZ_X_BCRC_3, uc);
+      GET_UCHAR(NETPGPV_BZ_X_BCRC_3, uc);
       s-&gt;storedBlockCRC = (s-&gt;storedBlockCRC &lt;&lt; 8) | ((UInt32)uc);
-      GET_UCHAR(BZ_X_BCRC_4, uc);
+      GET_UCHAR(NETPGPV_BZ_X_BCRC_4, uc);
       s-&gt;storedBlockCRC = (s-&gt;storedBlockCRC &lt;&lt; 8) | ((UInt32)uc);
 
-      GET_BITS(BZ_X_RANDBIT, s-&gt;blockRandomised, 1);
+      GET_BITS(NETPGPV_BZ_X_RANDBIT, s-&gt;blockRandomised, 1);
 
       s-&gt;origPtr = 0;
-      GET_UCHAR(BZ_X_ORIGPTR_1, uc);
+      GET_UCHAR(NETPGPV_BZ_X_ORIGPTR_1, uc);
       s-&gt;origPtr = (s-&gt;origPtr &lt;&lt; 8) | ((Int32)uc);
-      GET_UCHAR(BZ_X_ORIGPTR_2, uc);
+      GET_UCHAR(NETPGPV_BZ_X_ORIGPTR_2, uc);
       s-&gt;origPtr = (s-&gt;origPtr &lt;&lt; 8) | ((Int32)uc);
-      GET_UCHAR(BZ_X_ORIGPTR_3, uc);
+      GET_UCHAR(NETPGPV_BZ_X_ORIGPTR_3, uc);
       s-&gt;origPtr = (s-&gt;origPtr &lt;&lt; 8) | ((Int32)uc);
 
       if (s-&gt;origPtr &lt; 0)
-         RETURN(BZ_DATA_ERROR);
+         RETURN(NETPGPV_BZ_DATA_ERROR);
       if (s-&gt;origPtr &gt; 10 + 100000*s-&gt;blockSize100k) 
-         RETURN(BZ_DATA_ERROR);
+         RETURN(NETPGPV_BZ_DATA_ERROR);
 
       /*--- Receive the mapping table ---*/
       for (i = 0; i &lt; 16; i++) {
-         GET_BIT(BZ_X_MAPPING_1, uc);
+         GET_BIT(NETPGPV_BZ_X_MAPPING_1, uc);
          if (uc == 1) 
             s-&gt;inUse16[i] = True; else 
             s-&gt;inUse16[i] = False;
@@ -1360,32 +1360,32 @@
       for (i = 0; i &lt; 16; i++)
          if (s-&gt;inUse16[i])
             for (j = 0; j &lt; 16; j++) {
-               GET_BIT(BZ_X_MAPPING_2, uc);
+               GET_BIT(NETPGPV_BZ_X_MAPPING_2, uc);
                if (uc == 1) s-&gt;inUse[i * 16 + j] = True;
             }
       makeMaps_d ( s );
-      if (s-&gt;nInUse == 0) RETURN(BZ_DATA_ERROR);
+      if (s-&gt;nInUse == 0) RETURN(NETPGPV_BZ_DATA_ERROR);
       alphaSize = s-&gt;nInUse+2;
 
       /*--- Now the selectors ---*/
-      GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
-      if (nGroups &lt; 2 || nGroups &gt; 6) RETURN(BZ_DATA_ERROR);
-      GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
-      if (nSelectors &lt; 1) RETURN(BZ_DATA_ERROR);
+      GET_BITS(NETPGPV_BZ_X_SELECTOR_1, nGroups, 3);
+      if (nGroups &lt; 2 || nGroups &gt; 6) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_BITS(NETPGPV_BZ_X_SELECTOR_2, nSelectors, 15);
+      if (nSelectors &lt; 1) RETURN(NETPGPV_BZ_DATA_ERROR);
       for (i = 0; i &lt; nSelectors; i++) {
          j = 0;
          while (True) {
-            GET_BIT(BZ_X_SELECTOR_3, uc);
+            GET_BIT(NETPGPV_BZ_X_SELECTOR_3, uc);
             if (uc == 0) break;
             j++;
-            if (j &gt;= nGroups) RETURN(BZ_DATA_ERROR);
+            if (j &gt;= nGroups) RETURN(NETPGPV_BZ_DATA_ERROR);
          }
          s-&gt;selectorMtf[i] = j;
       }
 
       /*--- Undo the MTF values for the selectors. ---*/
       {
-         UChar pos[BZ_N_GROUPS], tmp, v;
+         UChar pos[NETPGPV_BZ_N_GROUPS], tmp, v;
          for (v = 0; v &lt; nGroups; v++) pos[v] = v;
    
          for (i = 0; i &lt; nSelectors; i++) {
@@ -1399,13 +1399,13 @@
 
       /*--- Now the coding tables ---*/
       for (t = 0; t &lt; nGroups; t++) {
-         GET_BITS(BZ_X_CODING_1, curr, 5);
+         GET_BITS(NETPGPV_BZ_X_CODING_1, curr, 5);
          for (i = 0; i &lt; alphaSize; i++) {
             while (True) {
-               if (curr &lt; 1 || curr &gt; 20) RETURN(BZ_DATA_ERROR);
-               GET_BIT(BZ_X_CODING_2, uc);
+               if (curr &lt; 1 || curr &gt; 20) RETURN(NETPGPV_BZ_DATA_ERROR);
+               GET_BIT(NETPGPV_BZ_X_CODING_2, uc);
                if (uc == 0) break;
-               GET_BIT(BZ_X_CODING_3, uc);
+               GET_BIT(NETPGPV_BZ_X_CODING_3, uc);
                if (uc == 0) curr++; else curr--;
             }
             s-&gt;len[t][i] = curr;
@@ -1420,7 +1420,7 @@
             if (s-&gt;len[t][i] &gt; maxLen) maxLen = s-&gt;len[t][i];
             if (s-&gt;len[t][i] &lt; minLen) minLen = s-&gt;len[t][i];
          }
-         BZ2_hbCreateDecodeTables ( 
+         NETPGPV_BZ2_hbCreateDecodeTables ( 
             &amp;(s-&gt;limit[t][0]), 
             &amp;(s-&gt;base[t][0]), 
             &amp;(s-&gt;perm[t][0]), 
@@ -1454,13 +1454,13 @@
       /*-- end MTF init --*/
 
       nblock = 0;
-      GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
+      GET_MTF_VAL(NETPGPV_BZ_X_MTF_1, NETPGPV_BZ_X_MTF_2, nextSym);
 
       while (True) {
 
          if (nextSym == EOB) break;
 
-         if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
+         if (nextSym == NETPGPV_BZ_RUNA || nextSym == NETPGPV_BZ_RUNB) {
 
             es = -1;
             N = 1;
@@ -1471,13 +1471,13 @@
                   the initial RLE), viz, 900k, so bounding N at 2
                   million should guard against overflow without
                   rejecting any legitimate inputs. */
-               if (N &gt;= 2*1024*1024) RETURN(BZ_DATA_ERROR);
-               if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
-               if (nextSym == BZ_RUNB) es = es + (1+1) * N;
+               if (N &gt;= 2*1024*1024) RETURN(NETPGPV_BZ_DATA_ERROR);
+               if (nextSym == NETPGPV_BZ_RUNA) es = es + (0+1) * N; else
+               if (nextSym == NETPGPV_BZ_RUNB) es = es + (1+1) * N;
                N = N * 2;
-               GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
+               GET_MTF_VAL(NETPGPV_BZ_X_MTF_3, NETPGPV_BZ_X_MTF_4, nextSym);
             }
-               while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
+               while (nextSym == NETPGPV_BZ_RUNA || nextSym == NETPGPV_BZ_RUNB);
 
             es++;
             uc = s-&gt;seqToUnseq[ s-&gt;mtfa[s-&gt;mtfbase[0]] ];
@@ -1485,14 +1485,14 @@
 
             if (s-&gt;smallDecompress)
                while (es &gt; 0) {
-                  if (nblock &gt;= nblockMAX) RETURN(BZ_DATA_ERROR);
+                  if (nblock &gt;= nblockMAX) RETURN(NETPGPV_BZ_DATA_ERROR);
                   s-&gt;ll16[nblock] = (UInt16)uc;
                   nblock++;
                   es--;
                }
             else
                while (es &gt; 0) {
-                  if (nblock &gt;= nblockMAX) RETURN(BZ_DATA_ERROR);
+                  if (nblock &gt;= nblockMAX) RETURN(NETPGPV_BZ_DATA_ERROR);
                   s-&gt;tt[nblock] = (UInt32)uc;
                   nblock++;
                   es--;
@@ -1502,7 +1502,7 @@
 
          } else {
 
-            if (nblock &gt;= nblockMAX) RETURN(BZ_DATA_ERROR);
+            if (nblock &gt;= nblockMAX) RETURN(NETPGPV_BZ_DATA_ERROR);
 
             /*-- uc = MTF ( nextSym-1 ) --*/
             {
@@ -1564,7 +1564,7 @@
                s-&gt;tt[nblock]   = (UInt32)(s-&gt;seqToUnseq[uc]);
             nblock++;
 
-            GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
+            GET_MTF_VAL(NETPGPV_BZ_X_MTF_5, NETPGPV_BZ_X_MTF_6, nextSym);
             continue;
          }
       }
@@ -1573,13 +1573,13 @@
          check on s-&gt;origPtr.
       */
       if (s-&gt;origPtr &lt; 0 || s-&gt;origPtr &gt;= nblock)
-         RETURN(BZ_DATA_ERROR);
+         RETURN(NETPGPV_BZ_DATA_ERROR);
 
       /*-- Set up cftab to facilitate generation of T^(-1) --*/
       /* Check: unzftab entries in range. */
       for (i = 0; i &lt;= 255; i++) {
          if (s-&gt;unzftab[i] &lt; 0 || s-&gt;unzftab[i] &gt; nblock)
-            RETURN(BZ_DATA_ERROR);
+            RETURN(NETPGPV_BZ_DATA_ERROR);
       }
       /* Actually generate cftab. */
       s-&gt;cftab[0] = 0;
@@ -1589,20 +1589,20 @@
       for (i = 0; i &lt;= 256; i++) {
          if (s-&gt;cftab[i] &lt; 0 || s-&gt;cftab[i] &gt; nblock) {
             /* s-&gt;cftab[i] can legitimately be == nblock */
-            RETURN(BZ_DATA_ERROR);
+            RETURN(NETPGPV_BZ_DATA_ERROR);
          }
       }
       /* Check: cftab entries non-descending. */
       for (i = 1; i &lt;= 256; i++) {
          if (s-&gt;cftab[i-1] &gt; s-&gt;cftab[i]) {
-            RETURN(BZ_DATA_ERROR);
+            RETURN(NETPGPV_BZ_DATA_ERROR);
          }
       }
 
       s-&gt;state_out_len = 0;
       s-&gt;state_out_ch  = 0;
-      BZ_INITIALISE_CRC ( s-&gt;calculatedBlockCRC );
-      s-&gt;state = BZ_X_OUTPUT;
+      NETPGPV_BZ_INITIALISE_CRC ( s-&gt;calculatedBlockCRC );
+      s-&gt;state = NETPGPV_BZ_X_OUTPUT;
       if (s-&gt;verbosity &gt;= 2) VPrintf0 ( "rt+rld" );
 
       if (s-&gt;smallDecompress) {
@@ -1631,11 +1631,11 @@
          s-&gt;tPos = s-&gt;origPtr;
          s-&gt;nblock_used = 0;
          if (s-&gt;blockRandomised) {
-            BZ_RAND_INIT_MASK;
-            BZ_GET_SMALL(s-&gt;k0); s-&gt;nblock_used++;
-            BZ_RAND_UPD_MASK; s-&gt;k0 ^= BZ_RAND_MASK; 
+            NETPGPV_BZ_RAND_INIT_MASK;
+            NETPGPV_BZ_GET_SMALL(s-&gt;k0); s-&gt;nblock_used++;
+            NETPGPV_BZ_RAND_UPD_MASK; s-&gt;k0 ^= NETPGPV_BZ_RAND_MASK; 
          } else {
-            BZ_GET_SMALL(s-&gt;k0); s-&gt;nblock_used++;
+            NETPGPV_BZ_GET_SMALL(s-&gt;k0); s-&gt;nblock_used++;
          }
 
       } else {
@@ -1650,44 +1650,44 @@
          s-&gt;tPos = s-&gt;tt[s-&gt;origPtr] &gt;&gt; 8;
          s-&gt;nblock_used = 0;
          if (s-&gt;blockRandomised) {
-            BZ_RAND_INIT_MASK;
-            BZ_GET_FAST(s-&gt;k0); s-&gt;nblock_used++;
-            BZ_RAND_UPD_MASK; s-&gt;k0 ^= BZ_RAND_MASK; 
+            NETPGPV_BZ_RAND_INIT_MASK;
+            NETPGPV_BZ_GET_FAST(s-&gt;k0); s-&gt;nblock_used++;
+            NETPGPV_BZ_RAND_UPD_MASK; s-&gt;k0 ^= NETPGPV_BZ_RAND_MASK; 
          } else {
-            BZ_GET_FAST(s-&gt;k0); s-&gt;nblock_used++;
+            NETPGPV_BZ_GET_FAST(s-&gt;k0); s-&gt;nblock_used++;
          }
 
       }
 
-      RETURN(BZ_OK);
+      RETURN(NETPGPV_BZ_OK);
 
 
 
     endhdr_2:
 
-      GET_UCHAR(BZ_X_ENDHDR_2, uc);
-      if (uc != 0x72) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_ENDHDR_3, uc);
-      if (uc != 0x45) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_ENDHDR_4, uc);
-      if (uc != 0x38) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_ENDHDR_5, uc);
-      if (uc != 0x50) RETURN(BZ_DATA_ERROR);
-      GET_UCHAR(BZ_X_ENDHDR_6, uc);
-      if (uc != 0x90) RETURN(BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_ENDHDR_2, uc);
+      if (uc != 0x72) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_ENDHDR_3, uc);
+      if (uc != 0x45) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_ENDHDR_4, uc);
+      if (uc != 0x38) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_ENDHDR_5, uc);
+      if (uc != 0x50) RETURN(NETPGPV_BZ_DATA_ERROR);
+      GET_UCHAR(NETPGPV_BZ_X_ENDHDR_6, uc);
+      if (uc != 0x90) RETURN(NETPGPV_BZ_DATA_ERROR);
 
       s-&gt;storedCombinedCRC = 0;
-      GET_UCHAR(BZ_X_CCRC_1, uc);
+      GET_UCHAR(NETPGPV_BZ_X_CCRC_1, uc);
       s-&gt;storedCombinedCRC = (s-&gt;storedCombinedCRC &lt;&lt; 8) | ((UInt32)uc);
-      GET_UCHAR(BZ_X_CCRC_2, uc);
+      GET_UCHAR(NETPGPV_BZ_X_CCRC_2, uc);
       s-&gt;storedCombinedCRC = (s-&gt;storedCombinedCRC &lt;&lt; 8) | ((UInt32)uc);
-      GET_UCHAR(BZ_X_CCRC_3, uc);
+      GET_UCHAR(NETPGPV_BZ_X_CCRC_3, uc);
       s-&gt;storedCombinedCRC = (s-&gt;storedCombinedCRC &lt;&lt; 8) | ((UInt32)uc);
-      GET_UCHAR(BZ_X_CCRC_4, uc);
+      GET_UCHAR(NETPGPV_BZ_X_CCRC_4, uc);
       s-&gt;storedCombinedCRC = (s-&gt;storedCombinedCRC &lt;&lt; 8) | ((UInt32)uc);
 
-      s-&gt;state = BZ_X_IDLE;
-      RETURN(BZ_STREAM_END);
+      s-&gt;state = NETPGPV_BZ_X_IDLE;
+      RETURN(NETPGPV_BZ_STREAM_END);
 
       default: AssertH ( False, 4001 );
    }
@@ -1758,7 +1758,7 @@
   comp.compression FAQ.
 --*/
 
-UInt32 BZ2_crc32Table[256] = {
+UInt32 NETPGPV_BZ2_crc32Table[256] = {
 
    /*-- Ugly, innit? --*/
 
@@ -1894,7 +1894,7 @@
 
 
 /*---------------------------------------------------*/
-void BZ2_hbMakeCodeLengths ( UChar *len, 
+void NETPGPV_BZ2_hbMakeCodeLengths ( UChar *len, 
                              Int32 *freq,
                              Int32 alphaSize,
                              Int32 maxLen )
@@ -1906,9 +1906,9 @@
    Int32 nNodes, nHeap, n1, n2, i, j, k;
    Bool  tooLong;
 
-   Int32 heap   [ BZ_MAX_ALPHA_SIZE + 2 ];
-   Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
-   Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ]; 
+   Int32 heap   [ NETPGPV_BZ_MAX_ALPHA_SIZE + 2 ];
+   Int32 weight [ NETPGPV_BZ_MAX_ALPHA_SIZE * 2 ];
+   Int32 parent [ NETPGPV_BZ_MAX_ALPHA_SIZE * 2 ]; 
 
    for (i = 0; i &lt; alphaSize; i++)
       weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) &lt;&lt; 8;
@@ -1929,7 +1929,7 @@
          UPHEAP(nHeap);
       }
 
-      AssertH( nHeap &lt; (BZ_MAX_ALPHA_SIZE+2), 2001 );
+      AssertH( nHeap &lt; (NETPGPV_BZ_MAX_ALPHA_SIZE+2), 2001 );
    
       while (nHeap &gt; 1) {
          n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
@@ -1943,7 +1943,7 @@
          UPHEAP(nHeap);
       }
 
-      AssertH( nNodes &lt; (BZ_MAX_ALPHA_SIZE * 2), 2002 );
+      AssertH( nNodes &lt; (NETPGPV_BZ_MAX_ALPHA_SIZE * 2), 2002 );
 
       tooLong = False;
       for (i = 1; i &lt;= alphaSize; i++) {
@@ -1983,7 +1983,7 @@
 
 
 /*---------------------------------------------------*/
-void BZ2_hbAssignCodes ( Int32 *code,
+void NETPGPV_BZ2_hbAssignCodes ( Int32 *code,
                          UChar *length,
                          Int32 minLen,
                          Int32 maxLen,
@@ -2001,7 +2001,7 @@
 
 
 /*---------------------------------------------------*/
-void BZ2_hbCreateDecodeTables ( Int32 *limit,
+void NETPGPV_BZ2_hbCreateDecodeTables ( Int32 *limit,
                                 Int32 *base,
                                 Int32 *perm,
                                 UChar *length,
@@ -2016,12 +2016,12 @@
       for (j = 0; j &lt; alphaSize; j++)
          if (length[j] == i) { perm[pp] = j; pp++; };
 
-   for (i = 0; i &lt; BZ_MAX_CODE_LEN; i++) base[i] = 0;
+   for (i = 0; i &lt; NETPGPV_BZ_MAX_CODE_LEN; i++) base[i] = 0;
    for (i = 0; i &lt; alphaSize; i++) base[length[i]+1]++;
 
-   for (i = 1; i &lt; BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
+   for (i = 1; i &lt; NETPGPV_BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
 
-   for (i = 0; i &lt; BZ_MAX_CODE_LEN; i++) limit[i] = 0;
+   for (i = 0; i &lt; NETPGPV_BZ_MAX_CODE_LEN; i++) limit[i] = 0;
    vec = 0;
 
    for (i = minLen; i &lt;= maxLen; i++) {
Index: files/bzlib.h
===================================================================
RCS file: /cvsroot/pkgsrc/security/netpgpverify/files/bzlib.h,v
retrieving revision 1.1
diff -u -r1.1 bzlib.h
--- files/bzlib.h	16 Mar 2013 07:32:34 -0000	1.1
+++ files/bzlib.h	2 Sep 2015 01:21:14 -0000
@@ -28,24 +28,24 @@
 extern "C" {
 #endif
 
-#define BZ_RUN               0
-#define BZ_FLUSH             1
-#define BZ_FINISH            2
-
-#define BZ_OK                0
-#define BZ_RUN_OK            1
-#define BZ_FLUSH_OK          2
-#define BZ_FINISH_OK         3
-#define BZ_STREAM_END        4
-#define BZ_SEQUENCE_ERROR    (-1)
-#define BZ_PARAM_ERROR       (-2)
-#define BZ_MEM_ERROR         (-3)
-#define BZ_DATA_ERROR        (-4)
-#define BZ_DATA_ERROR_MAGIC  (-5)
-#define BZ_IO_ERROR          (-6)
-#define BZ_UNEXPECTED_EOF    (-7)
-#define BZ_OUTBUFF_FULL      (-8)
-#define BZ_CONFIG_ERROR      (-9)
+#define NETPGPV_BZ_RUN               0
+#define NETPGPV_BZ_FLUSH             1
+#define NETPGPV_BZ_FINISH            2
+
+#define NETPGPV_BZ_OK                0
+#define NETPGPV_BZ_RUN_OK            1
+#define NETPGPV_BZ_FLUSH_OK          2
+#define NETPGPV_BZ_FINISH_OK         3
+#define NETPGPV_BZ_STREAM_END        4
+#define NETPGPV_BZ_SEQUENCE_ERROR    (-1)
+#define NETPGPV_BZ_PARAM_ERROR       (-2)
+#define NETPGPV_BZ_MEM_ERROR         (-3)
+#define NETPGPV_BZ_DATA_ERROR        (-4)
+#define NETPGPV_BZ_DATA_ERROR_MAGIC  (-5)
+#define NETPGPV_BZ_IO_ERROR          (-6)
+#define NETPGPV_BZ_UNEXPECTED_EOF    (-7)
+#define NETPGPV_BZ_OUTBUFF_FULL      (-8)
+#define NETPGPV_BZ_CONFIG_ERROR      (-9)
 
 typedef 
    struct {
@@ -65,14 +65,14 @@
       void (*bzfree)(void *,void *);
       void *opaque;
    } 
-   bz_stream;
+   netpgpv_bz_stream;
 
 
-#ifndef BZ_IMPORT
-#define BZ_EXPORT
+#ifndef NETPGPV_BZ_IMPORT
+#define NETPGPV_BZ_EXPORT
 #endif
 
-#ifndef BZ_NO_STDIO
+#ifndef NETPGPV_BZ_NO_STDIO
 /* Need a definitition for FILE */
 #include &lt;stdio.h&gt;
 #endif
@@ -83,62 +83,62 @@
       /* windows.h define small to char */
 #      undef small
 #   endif
-#   ifdef BZ_EXPORT
-#   define BZ_API(func) WINAPI func
-#   define BZ_EXTERN extern
+#   ifdef NETPGPV_BZ_EXPORT
+#   define NETPGPV_BZ_API(func) WINAPI func
+#   define NETPGPV_BZ_EXTERN extern
 #   else
    /* import windows dll dynamically */
-#   define BZ_API(func) (WINAPI * func)
-#   define BZ_EXTERN
+#   define NETPGPV_BZ_API(func) (WINAPI * func)
+#   define NETPGPV_BZ_EXTERN
 #   endif
 #else
-#   define BZ_API(func) func
-#   define BZ_EXTERN extern
+#   define NETPGPV_BZ_API(func) func
+#   define NETPGPV_BZ_EXTERN extern
 #endif
 
 
 /*-- Core (low-level) library functions --*/
 
-BZ_EXTERN int BZ_API(BZ2_bzCompressInit) ( 
-      bz_stream* strm, 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzCompressInit) ( 
+      netpgpv_bz_stream* strm, 
       int        blockSize100k, 
       int        verbosity, 
       int        workFactor 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzCompress) ( 
-      bz_stream* strm, 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzCompress) ( 
+      netpgpv_bz_stream* strm, 
       int action 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) ( 
-      bz_stream* strm 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzCompressEnd) ( 
+      netpgpv_bz_stream* strm 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) ( 
-      bz_stream *strm, 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzDecompressInit) ( 
+      netpgpv_bz_stream *strm, 
       int       verbosity, 
       int       small
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzDecompress) ( 
-      bz_stream* strm 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzDecompress) ( 
+      netpgpv_bz_stream* strm 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) ( 
-      bz_stream *strm 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzDecompressEnd) ( 
+      netpgpv_bz_stream *strm 
    );
 
 
 
 /*-- High(er) level library functions --*/
 
-#ifndef BZ_NO_STDIO
-#define BZ_MAX_UNUSED 5000
+#ifndef NETPGPV_BZ_NO_STDIO
+#define NETPGPV_BZ_MAX_UNUSED 5000
 
-typedef void BZFILE;
+typedef void NETPGPV_BZFILE;
 
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( 
+NETPGPV_BZ_EXTERN NETPGPV_BZFILE* NETPGPV_BZ_API(NETPGPV_BZ2_bzReadOpen) ( 
       int*  bzerror,   
       FILE* f, 
       int   verbosity, 
@@ -147,26 +147,26 @@
       int   nUnused 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( 
+NETPGPV_BZ_EXTERN void NETPGPV_BZ_API(NETPGPV_BZ2_bzReadClose) ( 
       int*    bzerror, 
-      BZFILE* b 
+      NETPGPV_BZFILE* b 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( 
+NETPGPV_BZ_EXTERN void NETPGPV_BZ_API(NETPGPV_BZ2_bzReadGetUnused) ( 
       int*    bzerror, 
-      BZFILE* b, 
+      NETPGPV_BZFILE* b, 
       void**  unused,  
       int*    nUnused 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzRead) ( 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzRead) ( 
       int*    bzerror, 
-      BZFILE* b, 
+      NETPGPV_BZFILE* b, 
       void*   buf, 
       int     len 
    );
 
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) ( 
+NETPGPV_BZ_EXTERN NETPGPV_BZFILE* NETPGPV_BZ_API(NETPGPV_BZ2_bzWriteOpen) ( 
       int*  bzerror,      
       FILE* f, 
       int   blockSize100k, 
@@ -174,24 +174,24 @@
       int   workFactor 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzWrite) ( 
+NETPGPV_BZ_EXTERN void NETPGPV_BZ_API(NETPGPV_BZ2_bzWrite) ( 
       int*    bzerror, 
-      BZFILE* b, 
+      NETPGPV_BZFILE* b, 
       void*   buf, 
       int     len 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzWriteClose) ( 
+NETPGPV_BZ_EXTERN void NETPGPV_BZ_API(NETPGPV_BZ2_bzWriteClose) ( 
       int*          bzerror, 
-      BZFILE*       b, 
+      NETPGPV_BZFILE*       b, 
       int           abandon, 
       unsigned int* nbytes_in, 
       unsigned int* nbytes_out 
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) ( 
+NETPGPV_BZ_EXTERN void NETPGPV_BZ_API(NETPGPV_BZ2_bzWriteClose64) ( 
       int*          bzerror, 
-      BZFILE*       b, 
+      NETPGPV_BZFILE*       b, 
       int           abandon, 
       unsigned int* nbytes_in_lo32, 
       unsigned int* nbytes_in_hi32, 
@@ -203,7 +203,7 @@
 
 /*-- Utility functions --*/
 
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) ( 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzBuffToBuffCompress) ( 
       char*         dest, 
       unsigned int* destLen,
       char*         source, 
@@ -213,7 +213,7 @@
       int           workFactor 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) ( 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzBuffToBuffDecompress) ( 
       char*         dest, 
       unsigned int* destLen,
       char*         source, 
@@ -232,43 +232,43 @@
    If this code breaks, please contact both Yoshioka and me.
 --*/
 
-BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
+NETPGPV_BZ_EXTERN const char * NETPGPV_BZ_API(NETPGPV_BZ2_bzlibVersion) (
       void
    );
 
-#ifndef BZ_NO_STDIO
-BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
+#ifndef NETPGPV_BZ_NO_STDIO
+NETPGPV_BZ_EXTERN NETPGPV_BZFILE * NETPGPV_BZ_API(NETPGPV_BZ2_bzopen) (
       const char *path,
       const char *mode
    );
 
-BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
+NETPGPV_BZ_EXTERN NETPGPV_BZFILE * NETPGPV_BZ_API(NETPGPV_BZ2_bzdopen) (
       int        fd,
       const char *mode
    );
          
-BZ_EXTERN int BZ_API(BZ2_bzread) (
-      BZFILE* b, 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzread) (
+      NETPGPV_BZFILE* b, 
       void* buf, 
       int len 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzwrite) (
-      BZFILE* b, 
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzwrite) (
+      NETPGPV_BZFILE* b, 
       void*   buf, 
       int     len 
    );
 
-BZ_EXTERN int BZ_API(BZ2_bzflush) (
-      BZFILE* b
+NETPGPV_BZ_EXTERN int NETPGPV_BZ_API(NETPGPV_BZ2_bzflush) (
+      NETPGPV_BZFILE* b
    );
 
-BZ_EXTERN void BZ_API(BZ2_bzclose) (
-      BZFILE* b
+NETPGPV_BZ_EXTERN void NETPGPV_BZ_API(NETPGPV_BZ2_bzclose) (
+      NETPGPV_BZFILE* b
    );
 
-BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
-      BZFILE *b, 
+NETPGPV_BZ_EXTERN const char * NETPGPV_BZ_API(NETPGPV_BZ2_bzerror) (
+      NETPGPV_BZFILE *b, 
       int    *errnum
    );
 #endif
Index: files/bzlib_private.h
===================================================================
RCS file: /cvsroot/pkgsrc/security/netpgpverify/files/bzlib_private.h,v
retrieving revision 1.3
diff -u -r1.3 bzlib_private.h
--- files/bzlib_private.h	3 Feb 2015 21:13:17 -0000	1.3
+++ files/bzlib_private.h	2 Sep 2015 01:21:14 -0000
@@ -26,7 +26,7 @@
 
 #include &lt;stdlib.h&gt;
 
-#ifndef BZ_NO_STDIO
+#ifndef NETPGPV_BZ_NO_STDIO
 #include &lt;stdio.h&gt;
 #include &lt;ctype.h&gt;
 #include &lt;string.h&gt;
@@ -38,7 +38,7 @@
 
 /*-- General stuff. --*/
 
-#define BZ_VERSION  "1.0.6, 6-Sept-2010"
+#define NETPGPV_BZ_VERSION  "1.0.6, 6-Sept-2010"
 
 typedef char            Char;
 typedef unsigned char   Bool;
@@ -55,17 +55,17 @@
 #define __inline__  /* */
 #endif 
 
-#ifndef BZ_NO_STDIO
+#ifndef NETPGPV_BZ_NO_STDIO
 
 #ifndef __dead
 #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
+#if NETPGPV_BZ_DEBUG
 #define AssertD(cond,msg) \
    { if (!(cond)) {       \
       fprintf ( stderr,   \
@@ -91,9 +91,9 @@
 
 #else
 
-extern void bz_internal_error ( int errcode );
+extern void netpgpv_bz_internal_error ( int errcode );
 #define AssertH(cond,errcode) \
-   { if (!(cond)) bz_internal_error ( errcode ); }
+   { if (!(cond)) netpgpv_bz_internal_error ( errcode ); }
 #define AssertD(cond,msg)                do { } while (0)
 #define VPrintf0(zf)                     do { } while (0)
 #define VPrintf1(zf,za1)                 do { } while (0)
@@ -105,50 +105,50 @@
 #endif
 
 
-#define BZALLOC(nnn) (strm-&gt;bzalloc)(strm-&gt;opaque,(nnn),1)
-#define BZFREE(ppp)  (strm-&gt;bzfree)(strm-&gt;opaque,(ppp))
+#define NETPGPV_BZALLOC(nnn) (strm-&gt;bzalloc)(strm-&gt;opaque,(nnn),1)
+#define NETPGPV_BZFREE(ppp)  (strm-&gt;bzfree)(strm-&gt;opaque,(ppp))
 
 
 /*-- Header bytes. --*/
 
-#define BZ_HDR_B 0x42   /* 'B' */
-#define BZ_HDR_Z 0x5a   /* 'Z' */
-#define BZ_HDR_h 0x68   /* 'h' */
-#define BZ_HDR_0 0x30   /* '0' */
+#define NETPGPV_BZ_HDR_B 0x42   /* 'B' */
+#define NETPGPV_BZ_HDR_Z 0x5a   /* 'Z' */
+#define NETPGPV_BZ_HDR_h 0x68   /* 'h' */
+#define NETPGPV_BZ_HDR_0 0x30   /* '0' */
   
 /*-- Constants for the back end. --*/
 
-#define BZ_MAX_ALPHA_SIZE 258
-#define BZ_MAX_CODE_LEN    23
+#define NETPGPV_BZ_MAX_ALPHA_SIZE 258
+#define NETPGPV_BZ_MAX_CODE_LEN    23
 
-#define BZ_RUNA 0
-#define BZ_RUNB 1
+#define NETPGPV_BZ_RUNA 0
+#define NETPGPV_BZ_RUNB 1
 
-#define BZ_N_GROUPS 6
-#define BZ_G_SIZE   50
-#define BZ_N_ITERS  4
+#define NETPGPV_BZ_N_GROUPS 6
+#define NETPGPV_BZ_G_SIZE   50
+#define NETPGPV_BZ_N_ITERS  4
 
-#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
+#define NETPGPV_BZ_MAX_SELECTORS (2 + (900000 / NETPGPV_BZ_G_SIZE))
 
 
 
 /*-- Stuff for randomising repetitive blocks. --*/
 
-extern Int32 BZ2_rNums[512];
+extern Int32 NETPGPV_BZ2_rNums[512];
 
-#define BZ_RAND_DECLS                          \
+#define NETPGPV_BZ_RAND_DECLS                          \
    Int32 rNToGo;                               \
    Int32 rTPos                                 \
 
-#define BZ_RAND_INIT_MASK                      \
+#define NETPGPV_BZ_RAND_INIT_MASK                      \
    s-&gt;rNToGo = 0;                              \
    s-&gt;rTPos  = 0                               \
 
-#define BZ_RAND_MASK ((s-&gt;rNToGo == 1) ? 1 : 0)
+#define NETPGPV_BZ_RAND_MASK ((s-&gt;rNToGo == 1) ? 1 : 0)
 
-#define BZ_RAND_UPD_MASK                       \
+#define NETPGPV_BZ_RAND_UPD_MASK                       \
    if (s-&gt;rNToGo == 0) {                       \
-      s-&gt;rNToGo = BZ2_rNums[s-&gt;rTPos];         \
+      s-&gt;rNToGo = NETPGPV_BZ2_rNums[s-&gt;rTPos];         \
       s-&gt;rTPos++;                              \
       if (s-&gt;rTPos == 512) s-&gt;rTPos = 0;       \
    }                                           \
@@ -158,22 +158,22 @@
 
 /*-- Stuff for doing CRCs. --*/
 
-extern UInt32 BZ2_crc32Table[256];
+extern UInt32 NETPGPV_BZ2_crc32Table[256];
 
-#define BZ_INITIALISE_CRC(crcVar)              \
+#define NETPGPV_BZ_INITIALISE_CRC(crcVar)              \
 {                                              \
    crcVar = 0xffffffffL;                       \
 }
 
-#define BZ_FINALISE_CRC(crcVar)                \
+#define NETPGPV_BZ_FINALISE_CRC(crcVar)                \
 {                                              \
    crcVar = ~(crcVar);                         \
 }
 
-#define BZ_UPDATE_CRC(crcVar,cha)              \
+#define NETPGPV_BZ_UPDATE_CRC(crcVar,cha)              \
 {                                              \
    crcVar = (crcVar &lt;&lt; 8) ^                    \
-            BZ2_crc32Table[(crcVar &gt;&gt; 24) ^    \
+            NETPGPV_BZ2_crc32Table[(crcVar &gt;&gt; 24) ^    \
                            ((UChar)cha)];      \
 }
 
@@ -181,18 +181,18 @@
 
 /*-- States and modes for compression. --*/
 
-#define BZ_M_IDLE      1
-#define BZ_M_RUNNING   2
-#define BZ_M_FLUSHING  3
-#define BZ_M_FINISHING 4
-
-#define BZ_S_OUTPUT    1
-#define BZ_S_INPUT     2
-
-#define BZ_N_RADIX 2
-#define BZ_N_QSORT 12
-#define BZ_N_SHELL 18
-#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
+#define NETPGPV_BZ_M_IDLE      1
+#define NETPGPV_BZ_M_RUNNING   2
+#define NETPGPV_BZ_M_FLUSHING  3
+#define NETPGPV_BZ_M_FINISHING 4
+
+#define NETPGPV_BZ_S_OUTPUT    1
+#define NETPGPV_BZ_S_INPUT     2
+
+#define NETPGPV_BZ_N_RADIX 2
+#define NETPGPV_BZ_N_QSORT 12
+#define NETPGPV_BZ_N_SHELL 18
+#define NETPGPV_BZ_N_OVERSHOOT (NETPGPV_BZ_N_RADIX + NETPGPV_BZ_N_QSORT + NETPGPV_BZ_N_SHELL + 2)
 
 
 
@@ -201,8 +201,8 @@
 
 typedef
    struct {
-      /* pointer back to the struct bz_stream */
-      bz_stream* strm;
+      /* pointer back to the struct netpgpv_bz_stream */
+      netpgpv_bz_stream* strm;
 
       /* mode this stream is in, and whether inputting */
       /* or outputting data */
@@ -230,7 +230,7 @@
       /* run-length-encoding of the input */
       UInt32   state_in_ch;
       Int32    state_in_len;
-      BZ_RAND_DECLS;
+      NETPGPV_BZ_RAND_DECLS;
 
       /* input and output limits and current posns */
       Int32    nblock;
@@ -258,15 +258,15 @@
 
       /* stuff for coding the MTF values */
       Int32    nMTF;
-      Int32    mtfFreq    [BZ_MAX_ALPHA_SIZE];
-      UChar    selector   [BZ_MAX_SELECTORS];
-      UChar    selectorMtf[BZ_MAX_SELECTORS];
-
-      UChar    len     [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-      Int32    code    [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-      Int32    rfreq   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+      Int32    mtfFreq    [NETPGPV_BZ_MAX_ALPHA_SIZE];
+      UChar    selector   [NETPGPV_BZ_MAX_SELECTORS];
+      UChar    selectorMtf[NETPGPV_BZ_MAX_SELECTORS];
+
+      UChar    len     [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
+      Int32    code    [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
+      Int32    rfreq   [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
       /* second dimension: only 3 needed; 4 makes index calculations faster */
-      UInt32   len_pack[BZ_MAX_ALPHA_SIZE][4];
+      UInt32   len_pack[NETPGPV_BZ_MAX_ALPHA_SIZE][4];
 
    }
    EState;
@@ -276,68 +276,68 @@
 /*-- externs for compression. --*/
 
 extern void 
-BZ2_blockSort ( EState* );
+NETPGPV_BZ2_blockSort ( EState* );
 
 extern void 
-BZ2_compressBlock ( EState*, Bool );
+NETPGPV_BZ2_compressBlock ( EState*, Bool );
 
 extern void 
-BZ2_bsInitWrite ( EState* );
+NETPGPV_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 );
 
 
 
 /*-- states for decompression. --*/
 
-#define BZ_X_IDLE        1
-#define BZ_X_OUTPUT      2
+#define NETPGPV_BZ_X_IDLE        1
+#define NETPGPV_BZ_X_OUTPUT      2
 
-#define BZ_X_MAGIC_1     10
-#define BZ_X_MAGIC_2     11
-#define BZ_X_MAGIC_3     12
-#define BZ_X_MAGIC_4     13
-#define BZ_X_BLKHDR_1    14
-#define BZ_X_BLKHDR_2    15
-#define BZ_X_BLKHDR_3    16
-#define BZ_X_BLKHDR_4    17
-#define BZ_X_BLKHDR_5    18
-#define BZ_X_BLKHDR_6    19
-#define BZ_X_BCRC_1      20
-#define BZ_X_BCRC_2      21
-#define BZ_X_BCRC_3      22
-#define BZ_X_BCRC_4      23
-#define BZ_X_RANDBIT     24
-#define BZ_X_ORIGPTR_1   25
-#define BZ_X_ORIGPTR_2   26
-#define BZ_X_ORIGPTR_3   27
-#define BZ_X_MAPPING_1   28
-#define BZ_X_MAPPING_2   29
-#define BZ_X_SELECTOR_1  30
-#define BZ_X_SELECTOR_2  31
-#define BZ_X_SELECTOR_3  32
-#define BZ_X_CODING_1    33
-#define BZ_X_CODING_2    34
-#define BZ_X_CODING_3    35
-#define BZ_X_MTF_1       36
-#define BZ_X_MTF_2       37
-#define BZ_X_MTF_3       38
-#define BZ_X_MTF_4       39
-#define BZ_X_MTF_5       40
-#define BZ_X_MTF_6       41
-#define BZ_X_ENDHDR_2    42
-#define BZ_X_ENDHDR_3    43
-#define BZ_X_ENDHDR_4    44
-#define BZ_X_ENDHDR_5    45
-#define BZ_X_ENDHDR_6    46
-#define BZ_X_CCRC_1      47
-#define BZ_X_CCRC_2      48
-#define BZ_X_CCRC_3      49
-#define BZ_X_CCRC_4      50
+#define NETPGPV_BZ_X_MAGIC_1     10
+#define NETPGPV_BZ_X_MAGIC_2     11
+#define NETPGPV_BZ_X_MAGIC_3     12
+#define NETPGPV_BZ_X_MAGIC_4     13
+#define NETPGPV_BZ_X_BLKHDR_1    14
+#define NETPGPV_BZ_X_BLKHDR_2    15
+#define NETPGPV_BZ_X_BLKHDR_3    16
+#define NETPGPV_BZ_X_BLKHDR_4    17
+#define NETPGPV_BZ_X_BLKHDR_5    18
+#define NETPGPV_BZ_X_BLKHDR_6    19
+#define NETPGPV_BZ_X_BCRC_1      20
+#define NETPGPV_BZ_X_BCRC_2      21
+#define NETPGPV_BZ_X_BCRC_3      22
+#define NETPGPV_BZ_X_BCRC_4      23
+#define NETPGPV_BZ_X_RANDBIT     24
+#define NETPGPV_BZ_X_ORIGPTR_1   25
+#define NETPGPV_BZ_X_ORIGPTR_2   26
+#define NETPGPV_BZ_X_ORIGPTR_3   27
+#define NETPGPV_BZ_X_MAPPING_1   28
+#define NETPGPV_BZ_X_MAPPING_2   29
+#define NETPGPV_BZ_X_SELECTOR_1  30
+#define NETPGPV_BZ_X_SELECTOR_2  31
+#define NETPGPV_BZ_X_SELECTOR_3  32
+#define NETPGPV_BZ_X_CODING_1    33
+#define NETPGPV_BZ_X_CODING_2    34
+#define NETPGPV_BZ_X_CODING_3    35
+#define NETPGPV_BZ_X_MTF_1       36
+#define NETPGPV_BZ_X_MTF_2       37
+#define NETPGPV_BZ_X_MTF_3       38
+#define NETPGPV_BZ_X_MTF_4       39
+#define NETPGPV_BZ_X_MTF_5       40
+#define NETPGPV_BZ_X_MTF_6       41
+#define NETPGPV_BZ_X_ENDHDR_2    42
+#define NETPGPV_BZ_X_ENDHDR_3    43
+#define NETPGPV_BZ_X_ENDHDR_4    44
+#define NETPGPV_BZ_X_ENDHDR_5    45
+#define NETPGPV_BZ_X_ENDHDR_6    46
+#define NETPGPV_BZ_X_CCRC_1      47
+#define NETPGPV_BZ_X_CCRC_2      48
+#define NETPGPV_BZ_X_CCRC_3      49
+#define NETPGPV_BZ_X_CCRC_4      50
 
 
 
@@ -352,8 +352,8 @@
 
 typedef
    struct {
-      /* pointer back to the struct bz_stream */
-      bz_stream* strm;
+      /* pointer back to the struct netpgpv_bz_stream */
+      netpgpv_bz_stream* strm;
 
       /* state indicator for this stream */
       Int32    state;
@@ -362,7 +362,7 @@
       UChar    state_out_ch;
       Int32    state_out_len;
       Bool     blockRandomised;
-      BZ_RAND_DECLS;
+      NETPGPV_BZ_RAND_DECLS;
 
       /* the buffer for bit stream reading */
       UInt32   bsBuff;
@@ -405,14 +405,14 @@
       /* for decoding the MTF values */
       UChar    mtfa   [MTFA_SIZE];
       Int32    mtfbase[256 / MTFL_SIZE];
-      UChar    selector   [BZ_MAX_SELECTORS];
-      UChar    selectorMtf[BZ_MAX_SELECTORS];
-      UChar    len  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-
-      Int32    limit  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-      Int32    base   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-      Int32    perm   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-      Int32    minLens[BZ_N_GROUPS];
+      UChar    selector   [NETPGPV_BZ_MAX_SELECTORS];
+      UChar    selectorMtf[NETPGPV_BZ_MAX_SELECTORS];
+      UChar    len  [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
+
+      Int32    limit  [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
+      Int32    base   [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
+      Int32    perm   [NETPGPV_BZ_N_GROUPS][NETPGPV_BZ_MAX_ALPHA_SIZE];
+      Int32    minLens[NETPGPV_BZ_N_GROUPS];
 
       /* save area for scalars in the main decompress code */
       Int32    save_i;
@@ -447,14 +447,14 @@
 
 /*-- Macros for decompression. --*/
 
-#define BZ_GET_FAST(cccc)                     \
+#define NETPGPV_BZ_GET_FAST(cccc)                     \
     /* c_tPos is unsigned, hence test &lt; 0 is pointless. */ \
     if (s-&gt;tPos &gt;= (UInt32)100000 * (UInt32)s-&gt;blockSize100k) return True; \
     s-&gt;tPos = s-&gt;tt[s-&gt;tPos];                 \
     cccc = (UChar)(s-&gt;tPos &amp; 0xff);           \
     s-&gt;tPos &gt;&gt;= 8;
 
-#define BZ_GET_FAST_C(cccc)                   \
+#define NETPGPV_BZ_GET_FAST_C(cccc)                   \
     /* c_tPos is unsigned, hence test &lt; 0 is pointless. */ \
     if (c_tPos &gt;= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \
     c_tPos = c_tt[c_tPos];                    \
@@ -478,32 +478,32 @@
 #define GET_LL(i) \
    (((UInt32)s-&gt;ll16[i]) | (GET_LL4(i) &lt;&lt; 16))
 
-#define BZ_GET_SMALL(cccc)                            \
+#define NETPGPV_BZ_GET_SMALL(cccc)                            \
     /* c_tPos is unsigned, hence test &lt; 0 is pointless. */ \
     if (s-&gt;tPos &gt;= (UInt32)100000 * (UInt32)s-&gt;blockSize100k) return True; \
-    cccc = BZ2_indexIntoF ( s-&gt;tPos, s-&gt;cftab );    \
+    cccc = NETPGPV_BZ2_indexIntoF ( s-&gt;tPos, s-&gt;cftab );    \
     s-&gt;tPos = GET_LL(s-&gt;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 );
 
 
 #endif
 
 
-/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
+/*-- NETPGPV_BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
 
-#ifdef BZ_NO_STDIO
+#ifdef NETPGPV_BZ_NO_STDIO
 #ifndef NULL
 #define NULL 0
 #endif
Index: files/libverify.c
===================================================================
RCS file: /cvsroot/pkgsrc/security/netpgpverify/files/libverify.c,v
retrieving revision 1.12
diff -u -r1.12 libverify.c
--- files/libverify.c	1 Sep 2015 19:38:42 -0000	1.12
+++ files/libverify.c	2 Sep 2015 01:21:14 -0000
@@ -952,7 +952,7 @@
 read_compressed(pgpv_t *pgp, pgpv_compress_t *compressed, uint8_t *p, size_t len)
 {
 	pgpv_mem_t	*unzmem;
-	bz_stream	 bz;
+	netpgpv_bz_stream	 bz;
 	z_stream	 z;
 	int		 ok = 0;
 
@@ -1005,7 +1005,7 @@
 		ok = (inflateInit(&amp;z) == Z_OK);
 		break;
 	case BZIP2_COMPRESSION:
-		ok = (BZ2_bzDecompressInit(&amp;bz, 1, 0) == BZ_OK);
+		ok = (NETPGPV_BZ2_bzDecompressInit(&amp;bz, 1, 0) == NETPGPV_BZ_OK);
 		break;
 	}
 	if (!ok) {
@@ -1019,7 +1019,7 @@
 		unzmem-&gt;size = z.total_out;
 		break;
 	case BZIP2_COMPRESSION:
-		ok = (BZ2_bzDecompress(&amp;bz) == BZ_STREAM_END);
+		ok = (NETPGPV_BZ2_bzDecompress(&amp;bz) == NETPGPV_BZ_STREAM_END);
 		unzmem-&gt;size = ((uint64_t)bz.total_out_hi32 &lt;&lt; 32) | bz.total_out_lo32;
 		break;
 	}
Index: files/verify.h
===================================================================
RCS file: /cvsroot/pkgsrc/security/netpgpverify/files/verify.h,v
retrieving revision 1.14
diff -u -r1.14 verify.h
--- files/verify.h	1 Sep 2015 19:38:42 -0000	1.14
+++ files/verify.h	2 Sep 2015 01:21:14 -0000
@@ -23,9 +23,9 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef NETPGP_VERIFY_H_
-#define NETPGP_VERIFY_H_	20150901
+#define NETPGP_VERIFY_H_	20150902
 
-#define NETPGPVERIFY_VERSION	"netpgpverify portable 20150901"
+#define NETPGPVERIFY_VERSION	"netpgpverify portable 20150902"
 
 #include &lt;sys/types.h&gt;
 
</pre></body></html>