? 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->state_in_ch && \ zs->state_in_len == 1) { \ UChar ch = (UChar)(zs->state_in_ch); \ - BZ_UPDATE_CRC( zs->blockCRC, ch ); \ + NETPGPV_BZ_UPDATE_CRC( zs->blockCRC, ch ); \ zs->inUse[zs->state_in_ch] = True; \ zs->block[zs->nblock] = (UChar)ch; \ zs->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 && small != 1) return BZ_PARAM_ERROR; - if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR; + if (strm == NULL) return NETPGPV_BZ_PARAM_ERROR; + if (small != 0 && small != 1) return NETPGPV_BZ_PARAM_ERROR; + if (verbosity < 0 || verbosity > 4) return NETPGPV_BZ_PARAM_ERROR; if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; if (strm->bzfree == NULL) strm->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->strm = strm; strm->state = s; - s->state = BZ_X_MAGIC_1; + s->state = NETPGPV_BZ_X_MAGIC_1; s->bsLive = 0; s->bsBuff = 0; s->calculatedCombinedCRC = 0; @@ -280,7 +280,7 @@ s->currBlockNo = 0; s->verbosity = verbosity; - return BZ_OK; + return NETPGPV_BZ_OK; } @@ -301,7 +301,7 @@ if (s->strm->avail_out == 0) return False; if (s->state_out_len == 0) break; *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; - BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + NETPGPV_BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); s->state_out_len--; s->strm->next_out++; s->strm->avail_out--; @@ -318,28 +318,28 @@ s->state_out_len = 1; s->state_out_ch = s->k0; - BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; s->state_out_len = 2; - BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; s->state_out_len = 3; - BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; - BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_FAST(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; s->state_out_len = ((Int32)k1) + 4; - BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK; - s->k0 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_FAST(s->k0); NETPGPV_BZ_RAND_UPD_MASK; + s->k0 ^= NETPGPV_BZ_RAND_MASK; s->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->strm->avail_out == 0) return False; if (s->state_out_len == 0) break; *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; - BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + NETPGPV_BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); s->state_out_len--; s->strm->next_out++; s->strm->avail_out--; @@ -488,28 +488,28 @@ s->state_out_len = 1; s->state_out_ch = s->k0; - BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; s->state_out_len = 2; - BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; s->state_out_len = 3; - BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; - BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; - k1 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); NETPGPV_BZ_RAND_UPD_MASK; + k1 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; s->state_out_len = ((Int32)k1) + 4; - BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK; - s->k0 ^= BZ_RAND_MASK; s->nblock_used++; + NETPGPV_BZ_GET_SMALL(s->k0); NETPGPV_BZ_RAND_UPD_MASK; + s->k0 ^= NETPGPV_BZ_RAND_MASK; s->nblock_used++; } } else { @@ -520,7 +520,7 @@ if (s->strm->avail_out == 0) return False; if (s->state_out_len == 0) break; *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; - BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + NETPGPV_BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); s->state_out_len--; s->strm->next_out++; s->strm->avail_out--; @@ -537,23 +537,23 @@ s->state_out_len = 1; s->state_out_ch = s->k0; - BZ_GET_SMALL(k1); s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; s->state_out_len = 2; - BZ_GET_SMALL(k1); s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; s->state_out_len = 3; - BZ_GET_SMALL(k1); s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); s->nblock_used++; if (s->nblock_used == s->save_nblock+1) continue; if (k1 != s->k0) { s->k0 = k1; continue; }; - BZ_GET_SMALL(k1); s->nblock_used++; + NETPGPV_BZ_GET_SMALL(k1); s->nblock_used++; s->state_out_len = ((Int32)k1) + 4; - BZ_GET_SMALL(s->k0); s->nblock_used++; + NETPGPV_BZ_GET_SMALL(s->k0); s->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->state; - if (s == NULL) return BZ_PARAM_ERROR; - if (s->strm != strm) return BZ_PARAM_ERROR; + if (s == NULL) return NETPGPV_BZ_PARAM_ERROR; + if (s->strm != strm) return NETPGPV_BZ_PARAM_ERROR; while (True) { - if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR; - if (s->state == BZ_X_OUTPUT) { + if (s->state == NETPGPV_BZ_X_IDLE) return NETPGPV_BZ_SEQUENCE_ERROR; + if (s->state == NETPGPV_BZ_X_OUTPUT) { if (s->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->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { - BZ_FINALISE_CRC ( s->calculatedBlockCRC ); + NETPGPV_BZ_FINALISE_CRC ( s->calculatedBlockCRC ); if (s->verbosity >= 3) VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC, s->calculatedBlockCRC ); if (s->verbosity >= 2) VPrintf0 ( "]" ); if (s->calculatedBlockCRC != s->storedBlockCRC) - return BZ_DATA_ERROR; + return NETPGPV_BZ_DATA_ERROR; s->calculatedCombinedCRC = (s->calculatedCombinedCRC << 1) | (s->calculatedCombinedCRC >> 31); s->calculatedCombinedCRC ^= s->calculatedBlockCRC; - s->state = BZ_X_BLKHDR_1; + s->state = NETPGPV_BZ_X_BLKHDR_1; } else { - return BZ_OK; + return NETPGPV_BZ_OK; } } - if (s->state >= BZ_X_MAGIC_1) { - Int32 r = BZ2_decompress ( s ); - if (r == BZ_STREAM_END) { + if (s->state >= NETPGPV_BZ_X_MAGIC_1) { + Int32 r = NETPGPV_BZ2_decompress ( s ); + if (r == NETPGPV_BZ_STREAM_END) { if (s->verbosity >= 3) VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x", s->storedCombinedCRC, s->calculatedCombinedCRC ); if (s->calculatedCombinedCRC != s->storedCombinedCRC) - return BZ_DATA_ERROR; + return NETPGPV_BZ_DATA_ERROR; return r; } - if (s->state != BZ_X_OUTPUT) return r; + if (s->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->state; - if (s == NULL) return BZ_PARAM_ERROR; - if (s->strm != strm) return BZ_PARAM_ERROR; + if (s == NULL) return NETPGPV_BZ_PARAM_ERROR; + if (s->strm != strm) return NETPGPV_BZ_PARAM_ERROR; - if (s->tt != NULL) BZFREE(s->tt); - if (s->ll16 != NULL) BZFREE(s->ll16); - if (s->ll4 != NULL) BZFREE(s->ll4); + if (s->tt != NULL) NETPGPV_BZFREE(s->tt); + if (s->ll16 != NULL) NETPGPV_BZFREE(s->ll16); + if (s->ll4 != NULL) NETPGPV_BZFREE(s->ll4); - BZFREE(strm->state); + NETPGPV_BZFREE(strm->state); strm->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->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 && small != 1) || (verbosity < 0 || verbosity > 4) || (unused == NULL && nUnused != 0) || - (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED))) - { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; + (unused != NULL && (nUnused < 0 || nUnused > 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->initialisedOk = False; bzf->handle = f; @@ -716,9 +716,9 @@ nUnused--; } - ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small ); - if (ret != BZ_OK) - { BZ_SETERR(ret); free(bzf); return NULL; }; + ret = NETPGPV_BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small ); + if (ret != NETPGPV_BZ_OK) + { NETPGPV_BZ_SETERR(ret); free(bzf); return NULL; }; bzf->strm.avail_in = bzf->bufN; bzf->strm.next_in = bzf->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->writing) - { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + { NETPGPV_BZ_SETERR(NETPGPV_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 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 < 0) - { BZ_SETERR(BZ_PARAM_ERROR); return 0; }; + { NETPGPV_BZ_SETERR(NETPGPV_BZ_PARAM_ERROR); return 0; }; if (bzf->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->strm.avail_out = len; bzf->strm.next_out = buf; @@ -773,32 +773,32 @@ while (True) { if (ferror(bzf->handle)) - { BZ_SETERR(BZ_IO_ERROR); return 0; }; + { NETPGPV_BZ_SETERR(NETPGPV_BZ_IO_ERROR); return 0; }; if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) { n = fread ( bzf->buf, sizeof(UChar), - BZ_MAX_UNUSED, bzf->handle ); + NETPGPV_BZ_MAX_UNUSED, bzf->handle ); if (ferror(bzf->handle)) - { BZ_SETERR(BZ_IO_ERROR); return 0; }; + { NETPGPV_BZ_SETERR(NETPGPV_BZ_IO_ERROR); return 0; }; bzf->bufN = n; bzf->strm.avail_in = bzf->bufN; 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; }; + if (ret != NETPGPV_BZ_OK && ret != NETPGPV_BZ_STREAM_END) + { NETPGPV_BZ_SETERR(ret); return 0; }; - if (ret == BZ_OK && myfeof(bzf->handle) && + if (ret == NETPGPV_BZ_OK && myfeof(bzf->handle) && bzf->strm.avail_in == 0 && bzf->strm.avail_out > 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->strm.avail_out; }; if (bzf->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->lastErr != BZ_STREAM_END) - { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + { NETPGPV_BZ_SETERR(NETPGPV_BZ_PARAM_ERROR); return; }; + if (bzf->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->strm.avail_in; *unused = bzf->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 && small != 1) || verbosity < 0 || verbosity > 4) - return BZ_PARAM_ERROR; + return NETPGPV_BZ_PARAM_ERROR; strm.bzalloc = NULL; strm.bzfree = NULL; strm.opaque = NULL; - ret = BZ2_bzDecompressInit ( &strm, verbosity, small ); - if (ret != BZ_OK) return ret; + ret = NETPGPV_BZ2_bzDecompressInit ( &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 ( &strm ); - if (ret == BZ_OK) goto output_overflow_or_eof; - if (ret != BZ_STREAM_END) goto errhandler; + ret = NETPGPV_BZ2_bzDecompress ( &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 ( &strm ); - return BZ_OK; + NETPGPV_BZ2_bzDecompressEnd ( &strm ); + return NETPGPV_BZ_OK; output_overflow_or_eof: if (strm.avail_out > 0) { - BZ2_bzDecompressEnd ( &strm ); - return BZ_UNEXPECTED_EOF; + NETPGPV_BZ2_bzDecompressEnd ( &strm ); + return NETPGPV_BZ_UNEXPECTED_EOF; } else { - BZ2_bzDecompressEnd ( &strm ); - return BZ_OUTBUFF_FULL; + NETPGPV_BZ2_bzDecompressEnd ( &strm ); + return NETPGPV_BZ_OUTBUFF_FULL; }; errhandler: - BZ2_bzDecompressEnd ( &strm ); + NETPGPV_BZ2_bzDecompressEnd ( &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(&bzerr,fp,verbosity,smallMode, + bzfp = NETPGPV_BZ2_bzReadOpen(&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 => 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)->lastErr == BZ_STREAM_END) return 0; - nread = BZ2_bzRead(&bzerr,b,buf,len); - if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) { + if (((netpgpv_bzFile*)b)->lastErr == NETPGPV_BZ_STREAM_END) return 0; + nread = NETPGPV_BZ2_bzRead(&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)->handle; - if(((bzFile*)b)->writing){ + fp = ((netpgpv_bzFile *)b)->handle; + if(((netpgpv_bzFile*)b)->writing){ }else{ - BZ2_bzReadClose(&bzerr,b); + NETPGPV_BZ2_bzReadClose(&bzerr,b); } if(fp!=stdin && 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)->lastErr; + int err = ((netpgpv_bzFile *)b)->lastErr; if(err>0) err = 0; *errnum = err; - return bzerrorstrings[err*-1]; + return netpgpv_bzerrorstrings[err*-1]; } #endif @@ -1135,7 +1135,7 @@ vvv = v; \ break; \ } \ - if (s->strm->avail_in == 0) RETURN(BZ_OK); \ + if (s->strm->avail_in == 0) RETURN(NETPGPV_BZ_OK); \ s->bsBuff \ = (s->bsBuff << 8) | \ ((UInt32) \ @@ -1160,8 +1160,8 @@ if (groupPos == 0) { \ groupNo++; \ if (groupNo >= nSelectors) \ - RETURN(BZ_DATA_ERROR); \ - groupPos = BZ_G_SIZE; \ + RETURN(NETPGPV_BZ_DATA_ERROR); \ + groupPos = NETPGPV_BZ_G_SIZE; \ gSel = s->selector[groupNo]; \ gMinlen = s->minLens[gSel]; \ gLimit = &(s->limit[gSel][0]); \ @@ -1173,26 +1173,26 @@ GET_BITS(label1, zvec, zn); \ while (1) { \ if (zn > 20 /* the longest code */) \ - RETURN(BZ_DATA_ERROR); \ + RETURN(NETPGPV_BZ_DATA_ERROR); \ if (zvec <= gLimit[zn]) break; \ zn++; \ GET_BIT(label2, zj); \ zvec = (zvec << 1) | zj; \ }; \ if (zvec - gBase[zn] < 0 \ - || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \ - RETURN(BZ_DATA_ERROR); \ + || zvec - gBase[zn] >= 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->strm; + netpgpv_bz_stream* strm = s->strm; /* stuff that needs to be saved/restored */ Int32 i; @@ -1220,7 +1220,7 @@ Int32* gBase; Int32* gPerm; - if (s->state == BZ_X_MAGIC_1) { + if (s->state == NETPGPV_BZ_X_MAGIC_1) { /*initialise the save area*/ s->save_i = 0; s->save_j = 0; @@ -1274,82 +1274,82 @@ gBase = s->save_gBase; gPerm = s->save_gPerm; - retVal = BZ_OK; + retVal = NETPGPV_BZ_OK; switch (s->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->blockSize100k, 8) - if (s->blockSize100k < (BZ_HDR_0 + 1) || - s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC); - s->blockSize100k -= BZ_HDR_0; + GET_BITS(NETPGPV_BZ_X_MAGIC_4, s->blockSize100k, 8) + if (s->blockSize100k < (NETPGPV_BZ_HDR_0 + 1) || + s->blockSize100k > (NETPGPV_BZ_HDR_0 + 9)) RETURN(NETPGPV_BZ_DATA_ERROR_MAGIC); + s->blockSize100k -= NETPGPV_BZ_HDR_0; if (s->smallDecompress) { - s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) ); - s->ll4 = BZALLOC( + s->ll16 = NETPGPV_BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) ); + s->ll4 = NETPGPV_BZALLOC( ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) ); - if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR); + if (s->ll16 == NULL || s->ll4 == NULL) RETURN(NETPGPV_BZ_MEM_ERROR); } else { - s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); - if (s->tt == NULL) RETURN(BZ_MEM_ERROR); + s->tt = NETPGPV_BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); + if (s->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->currBlockNo++; if (s->verbosity >= 2) VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo ); s->storedBlockCRC = 0; - GET_UCHAR(BZ_X_BCRC_1, uc); + GET_UCHAR(NETPGPV_BZ_X_BCRC_1, uc); s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); - GET_UCHAR(BZ_X_BCRC_2, uc); + GET_UCHAR(NETPGPV_BZ_X_BCRC_2, uc); s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); - GET_UCHAR(BZ_X_BCRC_3, uc); + GET_UCHAR(NETPGPV_BZ_X_BCRC_3, uc); s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); - GET_UCHAR(BZ_X_BCRC_4, uc); + GET_UCHAR(NETPGPV_BZ_X_BCRC_4, uc); s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); - GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1); + GET_BITS(NETPGPV_BZ_X_RANDBIT, s->blockRandomised, 1); s->origPtr = 0; - GET_UCHAR(BZ_X_ORIGPTR_1, uc); + GET_UCHAR(NETPGPV_BZ_X_ORIGPTR_1, uc); s->origPtr = (s->origPtr << 8) | ((Int32)uc); - GET_UCHAR(BZ_X_ORIGPTR_2, uc); + GET_UCHAR(NETPGPV_BZ_X_ORIGPTR_2, uc); s->origPtr = (s->origPtr << 8) | ((Int32)uc); - GET_UCHAR(BZ_X_ORIGPTR_3, uc); + GET_UCHAR(NETPGPV_BZ_X_ORIGPTR_3, uc); s->origPtr = (s->origPtr << 8) | ((Int32)uc); if (s->origPtr < 0) - RETURN(BZ_DATA_ERROR); + RETURN(NETPGPV_BZ_DATA_ERROR); if (s->origPtr > 10 + 100000*s->blockSize100k) - RETURN(BZ_DATA_ERROR); + RETURN(NETPGPV_BZ_DATA_ERROR); /*--- Receive the mapping table ---*/ for (i = 0; i < 16; i++) { - GET_BIT(BZ_X_MAPPING_1, uc); + GET_BIT(NETPGPV_BZ_X_MAPPING_1, uc); if (uc == 1) s->inUse16[i] = True; else s->inUse16[i] = False; @@ -1360,32 +1360,32 @@ for (i = 0; i < 16; i++) if (s->inUse16[i]) for (j = 0; j < 16; j++) { - GET_BIT(BZ_X_MAPPING_2, uc); + GET_BIT(NETPGPV_BZ_X_MAPPING_2, uc); if (uc == 1) s->inUse[i * 16 + j] = True; } makeMaps_d ( s ); - if (s->nInUse == 0) RETURN(BZ_DATA_ERROR); + if (s->nInUse == 0) RETURN(NETPGPV_BZ_DATA_ERROR); alphaSize = s->nInUse+2; /*--- Now the selectors ---*/ - GET_BITS(BZ_X_SELECTOR_1, nGroups, 3); - if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR); - GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15); - if (nSelectors < 1) RETURN(BZ_DATA_ERROR); + GET_BITS(NETPGPV_BZ_X_SELECTOR_1, nGroups, 3); + if (nGroups < 2 || nGroups > 6) RETURN(NETPGPV_BZ_DATA_ERROR); + GET_BITS(NETPGPV_BZ_X_SELECTOR_2, nSelectors, 15); + if (nSelectors < 1) RETURN(NETPGPV_BZ_DATA_ERROR); for (i = 0; i < 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 >= nGroups) RETURN(BZ_DATA_ERROR); + if (j >= nGroups) RETURN(NETPGPV_BZ_DATA_ERROR); } s->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 < nGroups; v++) pos[v] = v; for (i = 0; i < nSelectors; i++) { @@ -1399,13 +1399,13 @@ /*--- Now the coding tables ---*/ for (t = 0; t < nGroups; t++) { - GET_BITS(BZ_X_CODING_1, curr, 5); + GET_BITS(NETPGPV_BZ_X_CODING_1, curr, 5); for (i = 0; i < alphaSize; i++) { while (True) { - if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR); - GET_BIT(BZ_X_CODING_2, uc); + if (curr < 1 || curr > 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->len[t][i] = curr; @@ -1420,7 +1420,7 @@ 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]), @@ -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 >= 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 >= 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->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; @@ -1485,14 +1485,14 @@ if (s->smallDecompress) while (es > 0) { - if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + if (nblock >= nblockMAX) RETURN(NETPGPV_BZ_DATA_ERROR); s->ll16[nblock] = (UInt16)uc; nblock++; es--; } else while (es > 0) { - if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + if (nblock >= nblockMAX) RETURN(NETPGPV_BZ_DATA_ERROR); s->tt[nblock] = (UInt32)uc; nblock++; es--; @@ -1502,7 +1502,7 @@ } else { - if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + if (nblock >= nblockMAX) RETURN(NETPGPV_BZ_DATA_ERROR); /*-- uc = MTF ( nextSym-1 ) --*/ { @@ -1564,7 +1564,7 @@ s->tt[nblock] = (UInt32)(s->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->origPtr. */ if (s->origPtr < 0 || s->origPtr >= 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 <= 255; i++) { if (s->unzftab[i] < 0 || s->unzftab[i] > nblock) - RETURN(BZ_DATA_ERROR); + RETURN(NETPGPV_BZ_DATA_ERROR); } /* Actually generate cftab. */ s->cftab[0] = 0; @@ -1589,20 +1589,20 @@ for (i = 0; i <= 256; i++) { if (s->cftab[i] < 0 || s->cftab[i] > nblock) { /* s->cftab[i] can legitimately be == nblock */ - RETURN(BZ_DATA_ERROR); + RETURN(NETPGPV_BZ_DATA_ERROR); } } /* Check: cftab entries non-descending. */ for (i = 1; i <= 256; i++) { if (s->cftab[i-1] > s->cftab[i]) { - RETURN(BZ_DATA_ERROR); + RETURN(NETPGPV_BZ_DATA_ERROR); } } s->state_out_len = 0; s->state_out_ch = 0; - BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); - s->state = BZ_X_OUTPUT; + NETPGPV_BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); + s->state = NETPGPV_BZ_X_OUTPUT; if (s->verbosity >= 2) VPrintf0 ( "rt+rld" ); if (s->smallDecompress) { @@ -1631,11 +1631,11 @@ s->tPos = s->origPtr; s->nblock_used = 0; if (s->blockRandomised) { - BZ_RAND_INIT_MASK; - BZ_GET_SMALL(s->k0); s->nblock_used++; - BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; + NETPGPV_BZ_RAND_INIT_MASK; + NETPGPV_BZ_GET_SMALL(s->k0); s->nblock_used++; + NETPGPV_BZ_RAND_UPD_MASK; s->k0 ^= NETPGPV_BZ_RAND_MASK; } else { - BZ_GET_SMALL(s->k0); s->nblock_used++; + NETPGPV_BZ_GET_SMALL(s->k0); s->nblock_used++; } } else { @@ -1650,44 +1650,44 @@ s->tPos = s->tt[s->origPtr] >> 8; s->nblock_used = 0; if (s->blockRandomised) { - BZ_RAND_INIT_MASK; - BZ_GET_FAST(s->k0); s->nblock_used++; - BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; + NETPGPV_BZ_RAND_INIT_MASK; + NETPGPV_BZ_GET_FAST(s->k0); s->nblock_used++; + NETPGPV_BZ_RAND_UPD_MASK; s->k0 ^= NETPGPV_BZ_RAND_MASK; } else { - BZ_GET_FAST(s->k0); s->nblock_used++; + NETPGPV_BZ_GET_FAST(s->k0); s->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->storedCombinedCRC = 0; - GET_UCHAR(BZ_X_CCRC_1, uc); + GET_UCHAR(NETPGPV_BZ_X_CCRC_1, uc); s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); - GET_UCHAR(BZ_X_CCRC_2, uc); + GET_UCHAR(NETPGPV_BZ_X_CCRC_2, uc); s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); - GET_UCHAR(BZ_X_CCRC_3, uc); + GET_UCHAR(NETPGPV_BZ_X_CCRC_3, uc); s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); - GET_UCHAR(BZ_X_CCRC_4, uc); + GET_UCHAR(NETPGPV_BZ_X_CCRC_4, uc); s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); - s->state = BZ_X_IDLE; - RETURN(BZ_STREAM_END); + s->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 < alphaSize; i++) weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8; @@ -1929,7 +1929,7 @@ UPHEAP(nHeap); } - AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 ); + AssertH( nHeap < (NETPGPV_BZ_MAX_ALPHA_SIZE+2), 2001 ); while (nHeap > 1) { n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1); @@ -1943,7 +1943,7 @@ UPHEAP(nHeap); } - AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 ); + AssertH( nNodes < (NETPGPV_BZ_MAX_ALPHA_SIZE * 2), 2002 ); tooLong = False; for (i = 1; i <= 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 < alphaSize; j++) if (length[j] == i) { perm[pp] = j; pp++; }; - for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0; + for (i = 0; i < NETPGPV_BZ_MAX_CODE_LEN; i++) base[i] = 0; for (i = 0; i < alphaSize; i++) base[length[i]+1]++; - for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1]; + for (i = 1; i < NETPGPV_BZ_MAX_CODE_LEN; i++) base[i] += base[i-1]; - for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0; + for (i = 0; i < NETPGPV_BZ_MAX_CODE_LEN; i++) limit[i] = 0; vec = 0; for (i = minLen; i <= 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 #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 -#ifndef BZ_NO_STDIO +#ifndef NETPGPV_BZ_NO_STDIO #include #include #include @@ -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->bzalloc)(strm->opaque,(nnn),1) -#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp)) +#define NETPGPV_BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1) +#define NETPGPV_BZFREE(ppp) (strm->bzfree)(strm->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->rNToGo = 0; \ s->rTPos = 0 \ -#define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0) +#define NETPGPV_BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0) -#define BZ_RAND_UPD_MASK \ +#define NETPGPV_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,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 << 8) ^ \ - BZ2_crc32Table[(crcVar >> 24) ^ \ + NETPGPV_BZ2_crc32Table[(crcVar >> 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 < 0 is pointless. */ \ if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \ s->tPos = s->tt[s->tPos]; \ cccc = (UChar)(s->tPos & 0xff); \ s->tPos >>= 8; -#define BZ_GET_FAST_C(cccc) \ +#define NETPGPV_BZ_GET_FAST_C(cccc) \ /* c_tPos is unsigned, hence test < 0 is pointless. */ \ if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \ c_tPos = c_tt[c_tPos]; \ @@ -478,32 +478,32 @@ #define GET_LL(i) \ (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16)) -#define BZ_GET_SMALL(cccc) \ +#define NETPGPV_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 ); #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(&z) == Z_OK); break; case BZIP2_COMPRESSION: - ok = (BZ2_bzDecompressInit(&bz, 1, 0) == BZ_OK); + ok = (NETPGPV_BZ2_bzDecompressInit(&bz, 1, 0) == NETPGPV_BZ_OK); break; } if (!ok) { @@ -1019,7 +1019,7 @@ unzmem->size = z.total_out; break; case BZIP2_COMPRESSION: - ok = (BZ2_bzDecompress(&bz) == BZ_STREAM_END); + ok = (NETPGPV_BZ2_bzDecompress(&bz) == NETPGPV_BZ_STREAM_END); unzmem->size = ((uint64_t)bz.total_out_hi32 << 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