/** * uncompress_bzip2: * @name: The name of the file to attempt to decompress * * Returns: The name of the uncompressed file (in a temporary location) or NULL * free the returned name after use. * * Also see: http://www.bzip.org/1.0.5/bzip2-manual-1.0.5.html */ gchar* uncompress_bzip2 ( gchar *name ) { #ifdef HAVE_BZLIB_H FILE *ff = g_fopen ( name, "r" ); if ( !ff ) return NULL; int bzerror; BZFILE* bf = BZ2_bzReadOpen ( &bzerror, ff, 0, 0, NULL, 0 ); // This should take care of the bz2 file header if ( bzerror != BZ_OK ) { BZ2_bzReadClose ( &bzerror, bf ); // handle error return NULL; } GFileIOStream *gios; GError *error = NULL; GFile *gf = g_file_new_tmp ( "vik-bz2-tmp.XXXXXX", &gios, &error ); gchar *tmpname = g_file_get_path (gf); GOutputStream *gos = g_io_stream_get_output_stream ( G_IO_STREAM(gios) ); // Process in arbitary sized chunks char buf[4096]; bzerror = BZ_OK; int nBuf; // Now process the actual compression data while ( bzerror == BZ_OK ) { nBuf = BZ2_bzRead ( &bzerror, bf, buf, 4096 ); if ( bzerror == BZ_OK || bzerror == BZ_STREAM_END) { // do something with buf[0 .. nBuf-1] if ( g_output_stream_write ( gos, buf, nBuf, NULL, &error ) < 0 ) { g_critical ( "Couldn't write bz2 tmp %s file due to %s", tmpname, error->message ); g_error_free (error); BZ2_bzReadClose ( &bzerror, bf ); goto end; } } } if ( bzerror != BZ_STREAM_END ) { BZ2_bzReadClose ( &bzerror, bf ); // handle error... goto end; } else { BZ2_bzReadClose ( &bzerror, bf ); g_output_stream_close ( gos, NULL, &error ); } end: return tmpname; #else return NULL; #endif }
//---------------------------------------------------- int zu_seek(ZUFILE *f, long offset, int whence) { int res = 0; int bzerror=BZ_OK; if (whence == SEEK_END) { return -1; // TODO } switch(f->type) { //SEEK_SET, SEEK_CUR case ZU_COMPRESS_NONE : res = fseek((FILE*)(f->zfile), offset, whence); f->pos = ftell((FILE*)(f->zfile)); break; case ZU_COMPRESS_GZIP : if (whence == SEEK_SET) { res = gzseek((gzFile)(f->zfile), offset, whence); } else { // !!! BUG with SEEK_CUR in ZLIB !!! int p1 = gztell((gzFile)(f->zfile)); res = gzseek((gzFile)(f->zfile), p1+offset, SEEK_SET); } f->pos = gztell((gzFile)(f->zfile)); if (res >= 0) res = 0; break; #ifndef __ANDROID__ case ZU_COMPRESS_BZIP : if (whence==SEEK_SET && offset >= f->pos) { res = zu_bzSeekForward(f, offset-f->pos); } else if (whence==SEEK_CUR) { res = zu_bzSeekForward(f, offset); } else { // BAD : reopen file BZ2_bzReadClose (&bzerror,(BZFILE*)(f->zfile)); bzerror=BZ_OK; rewind(f->faux); f->pos = 0; f->zfile = (void *) BZ2_bzReadOpen(&bzerror,f->faux,0,0,NULL,0); if (bzerror != BZ_OK) { BZ2_bzReadClose (&bzerror,(BZFILE*)(f->zfile)); fclose(f->faux); f->zfile = NULL; f->ok = 0; } res = zu_bzSeekForward(f, offset); } break; #endif } return res; }
VISIBILITY_ENABLE #include "ttyrec.h" VISIBILITY_DISABLE #include "stream.h" #include "error.h" #include "gettext.h" #define ERRORMSG(x) do if (write(fd,(x),strlen(x))) {} while(0) #define BUFFER_SIZE 32768 #if (defined HAVE_LIBBZ2) || (defined SHIPPED_LIBBZ2) static void read_bz2(int f, int fd, const char *arg) { BZFILE* b; int nBuf; char buf[BUFFER_SIZE]; int bzerror; b = BZ2_bzReadOpen(&bzerror, fdopen(f,"rb"), 0, 0, NULL, 0); if (bzerror != BZ_OK) { BZ2_bzReadClose(&bzerror, b); // error ERRORMSG(_("Invalid/corrupt .bz2 file.\n")); close(fd); return; } bzerror = BZ_OK; while (bzerror == BZ_OK) { nBuf = BZ2_bzRead(&bzerror, b, buf, BUFFER_SIZE); if (write(fd, buf, nBuf)!=nBuf) { BZ2_bzReadClose(&bzerror, b); close(fd); return; } } if (bzerror != BZ_STREAM_END) { BZ2_bzReadClose(&bzerror, b); // error ERRORMSG("\033[0m"); ERRORMSG(_("bzip2: Error during decompression.\n")); } else BZ2_bzReadClose(&bzerror, b); close(fd); }
bool QTarBZip2Decompressor::decompressToFiles() { QString root = mPathSrc + QDir::separator() + mArchiveFileName; const std::string tbz2Filename = root.toStdString(); const std::string extractTo = mPathDest.toStdString(); FILE *tbz2File = fopen(tbz2Filename.c_str(), "rb"); int bzError; const int BUF_SIZE = 10000; // char* buf = new char[BUF_SIZE]; boost::scoped_array< char > buf ( new char[BUF_SIZE] ); BZFILE *pBz = BZ2_bzReadOpen(&bzError, tbz2File, 0, 0, 0, 0); if ( bzError != BZ_OK ) { qDebug() << "bzError != BZ_OK"; BZ2_bzReadClose( &bzError, pBz ); //delete[] buf; return false; } const QString tarFilename = root.section( ".bz2", 0, 0 ); QFile tbz2FileTmp( tarFilename ); if( !tbz2FileTmp.open( QIODevice::WriteOnly ) ) { BZ2_bzReadClose( &bzError, pBz ); //delete[] buf; return false; } bzError = BZ_OK; while ( bzError == BZ_OK ) { ssize_t bytesRead = BZ2_bzRead ( &bzError, pBz, buf.get(), BUF_SIZE ); if ( bzError == BZ_OK ) // fwrite (buf , 1 , bytesRead , tbz2FileTmp ); tbz2FileTmp.write( buf.get(), bytesRead ); } BZ2_bzReadClose ( &bzError, pBz ); const std::string tarFilename2 = tarFilename.toStdString(); TAR *pTar; tar_open(&pTar, const_cast< char* > ( tarFilename2.c_str() ), NULL, O_RDONLY, 0644, TAR_GNU); tar_extract_all( pTar, const_cast< char* > ( extractTo.c_str() ) ); close(tar_fd(pTar)); QFile::remove( tarFilename ); //delete[] buf; return true; }
bool MANFrame::Decompress(const wxString& filename, const wxString& tmpfile) { // open file FILE* f = fopen(filename.mb_str(), "rb"); if (!f) { return false; } // open BZIP2 stream int bzerror; BZFILE* bz = BZ2_bzReadOpen(&bzerror, f, 0, 0, 0L, 0); if (!bz || bzerror != BZ_OK) { fclose(f); return false; } // open output file FILE* fo = fopen(tmpfile.mb_str(), "wb"); if (!fo) { fclose(f); return false; } // read stream writing to uncompressed file char buffer[2048]; while (bzerror != BZ_STREAM_END) { int read_bytes = BZ2_bzRead(&bzerror, bz, buffer, 2048); if (bzerror != BZ_OK && bzerror != BZ_STREAM_END) { BZ2_bzReadClose(&bzerror, bz); fclose(fo); fclose(f); return false; } fwrite(buffer, read_bytes, 1, fo); } BZ2_bzReadClose(&bzerror, bz); fclose(fo); fclose(f); return true; }
/* tries to re-open the bz stream at the next stream start. returns 0 on success, -1 on failure. */ int bzReOpen(struct Input *ctx, int *error) { /* for copying out the last unused part of the block which has an EOS token in it. needed for re-initialising the next stream. */ unsigned char unused[BZ_MAX_UNUSED]; void *unused_tmp_ptr = NULL; int nUnused, i; BZ2_bzReadGetUnused(error, (BZFILE *)(ctx->fileHandle), &unused_tmp_ptr, &nUnused); if (*error != BZ_OK) return -1; /* when bzReadClose is called the unused buffer is deallocated, so it needs to be copied somewhere safe first. */ for (i = 0; i < nUnused; ++i) unused[i] = ((unsigned char *)unused_tmp_ptr)[i]; BZ2_bzReadClose(error, (BZFILE *)(ctx->fileHandle)); if (*error != BZ_OK) return -1; /* reassign the file handle */ ctx->fileHandle = BZ2_bzReadOpen(error, ctx->systemHandle, 0, 0, unused, nUnused); if (ctx->fileHandle == NULL || *error != BZ_OK) return -1; return 0; }
int osm_planet_close(struct osm_planet *osf) { int bzerror; /* Signal to file read thread and wait for it to exit */ osf->exit_now = 1; pthread_join(osf->file_read_thread, NULL); pthread_detach(osf->file_read_thread); pthread_mutex_destroy(&osf->drained_mutex); pthread_mutex_destroy(&osf->filled_mutex); pthread_cond_destroy(&osf->drained_signal); pthread_cond_destroy(&osf->filled_signal); BZ2_bzReadClose(&bzerror, osf->bzfp); if(bzerror != BZ_OK) { fprintf(stderr, "osm_planet_close(): Error closing compressed file with bzip2: %d\n", bzerror); return 1; } if(fclose(osf->fp) != 0) { fprintf(stderr, "osm_planet_close(): Error closing file\n"); return 1; } free(osf->recvbuff); free(osf); return 0; }
/* properly cleanup any resources decompression library allocated */ void cm_cleanup(int cm) { switch (cm) { #ifdef ENABLE_BZ2 case CM_BZ2: BZ2_bzReadClose(&bzerror, bzfile); break; #endif #ifdef ENABLE_LZMA case CM_LZMA: lzma_cleanup(lzmaFile); break; #endif default: /* CM_NONE, CM_GZ */ break; } /* close the input stream */ if (gzclose(infile) != Z_OK) { PrintMessage(_T("failed gzclose")); /* return -1; */ } }
bool NBBZip2::extract() { int error; // Reading from the bz2 file opened std::ofstream ofile( qPrintable( fileName ), std::ofstream::binary ); while ( true ) { char buffer[ MAX_READ_SIZE ] = { "\x00" }; int charsRead = BZ2_bzRead( &error, bz2, buffer, MAX_READ_SIZE ); ofile.write( buffer, charsRead ); if ( error == BZ_OK ) continue; else break; } if ( error != BZ_STREAM_END ) return false; // Close the file BZ2_bzReadClose( &error, bz2 ); if ( error != BZ_OK ) return false; fclose( bzFile ); return true; };
static void close_compressed_read(pcu_file* pf) { int bzerror; BZ2_bzReadClose(&bzerror, pf->bzf); if (bzerror != BZ_OK) reel_fail("BZ2_readClose failed with code %d", bzerror); }
//---------------------------------------------------- int zu_close(ZUFILE *f) { int bzerror=BZ_OK; if (f) { f->ok = 0; f->pos = 0; free(f->fname); if (f->zfile!=NULL) { switch(f->type) { case ZU_COMPRESS_NONE : fclose((FILE*)(f->zfile)); break; case ZU_COMPRESS_GZIP : gzclose((gzFile)(f->zfile)); break; case ZU_COMPRESS_BZIP : BZ2_bzReadClose (&bzerror,(BZFILE*)(f->zfile)); if (f->faux) { fclose(f->faux); } break; } } } return 0; }
void BZ2Stream::stopRead() { BZ2_bzReadClose(&bzerror_, bzfile_); switch (bzerror_) { case BZ_IO_ERROR: throw BagIOException("BZ_IO_ERROR"); } }
/* * POST: Closes the gt_input_file * RETURN VALUE: Returns zero on success and error code */ gt_status gt_input_file_close(gt_input_file* const input_file) { GT_INPUT_FILE_CHECK(input_file); gt_status status = GT_INPUT_FILE_OK; #ifdef HAVE_BZLIB int bzerr; #endif switch (input_file->file_type) { case REGULAR_FILE: gt_free(input_file->file_buffer); if (fclose(input_file->file)) status = GT_INPUT_FILE_CLOSE_ERR; break; case GZIPPED_FILE: gt_free(input_file->file_buffer); #ifdef HAVE_ZLIB if (gzclose((gzFile)input_file->file)) status = GT_INPUT_FILE_CLOSE_ERR; #endif break; case BZIPPED_FILE: gt_free(input_file->file_buffer); #ifdef HAVE_BZLIB BZ2_bzReadClose(&bzerr,input_file->file); if (bzerr!=BZ_OK) status = GT_INPUT_FILE_CLOSE_ERR; #endif break; case MAPPED_FILE: gt_cond_error(munmap(input_file->file,input_file->file_size)==-1,SYS_UNMAP); if (close(input_file->fildes)) status = GT_INPUT_FILE_CLOSE_ERR; break; case STREAM: gt_free(input_file->file_buffer); break; } gt_free(input_file); return status; }
// xmlInputCloseCallback static int bz2_file_close(void *bzfile) { int bzerror; BZ2_bzReadClose(&bzerror, ((struct bz2_file *)bzfile)->file); fclose(((struct bz2_file *)bzfile)->f); free(bzfile); return bzerror == BZ_OK ? 0 : -1; }
int cfr_close(CFRFILE *stream) { /**************************/ // Analog to 'fclose'. int retval = -1; if (stream == NULL) return(-1); if (stream->closed) { errno = EBADF; return(EOF); } switch (stream->format) { case 1: // uncompressed { retval = fclose((FILE *)(stream->data1)); stream->error1 = retval; return(retval); } break; #ifndef DONT_HAVE_BZ2 case 2: // bzip2 { BZFILE * bzin; int bzerror; bzerror = BZ_OK; bzin = (BZFILE *) (stream->data2); BZ2_bzReadClose( &bzerror, bzin); if (bzerror != BZ_OK) { stream->error2 = bzerror; stream->error1 = fclose((FILE *)(stream->data1)); return(-1); } retval = fclose((FILE *)(stream->data1)); stream->error1 = retval; return(retval); } break; #endif #ifndef DONT_HAVE_GZ case 3: // gzip { if(stream->data2!=NULL) { retval=gzclose(stream->data2); } stream->error2 = retval; return(retval); } break; #endif default: // this is an internal error, no diag yet. fprintf(stderr,"illegal format '%d' in cfr_close!\n",stream->format); exit(1); } free(stream); return(retval); }
size_t AFILE_afread(void *ptr, size_t size, size_t count, AFILE *afp) { #ifndef DISABLE_BZLIB int32_t nbuf=0, i; void *unused_tmp_void=NULL; char *unused_tmp=NULL; #endif switch(afp->c) { case AFILE_NO_COMPRESSION: return fread(ptr, size, count, afp->fp); #ifndef DISABLE_BZLIB case AFILE_BZ2_COMPRESSION: while(0 == nbuf && !(BZ_STREAM_END == afp->bzerror && 0 == afp->n_unused && feof(afp->fp))) { nbuf = BZ2_bzRead(&afp->bzerror, afp->bz2, ptr, size*count); if(BZ_OK == afp->bzerror) { // return # of bytes return nbuf; } else if(BZ_STREAM_END == afp->bzerror) { // Get unused BZ2_bzReadGetUnused(&afp->bzerror, afp->bz2, &unused_tmp_void, &afp->n_unused); if(BZ_OK != afp->bzerror) AFILE_print_error("Could not BZ2_bzReadGetUnused"); unused_tmp = (char*)unused_tmp_void; for(i=0;i<afp->n_unused;i++) { afp->unused[i] = unused_tmp[i]; } // Close BZ2_bzReadClose(&afp->bzerror, afp->bz2); if(BZ_OK != afp->bzerror) AFILE_print_error("Could not BZ2_bzReadClose"); afp->bzerror = BZ_STREAM_END; // set to the stream end for next call to this function // Open again if necessary if(0 == afp->n_unused && feof(afp->fp)) { return nbuf; } else { afp->bz2 = BZ2_bzReadOpen(&afp->bzerror, afp->fp, 0, 0, afp->unused, afp->n_unused); if(NULL == afp->bz2) AFILE_print_error("Could not open file"); } } else { fprintf(stderr, "nbuf = %d\n", nbuf); fprintf(stderr, "afp->bzerror = %d\n", afp->bzerror); AFILE_print_error("Could not read"); } } return nbuf; #endif case AFILE_GZ_COMPRESSION: return gzread(afp->gz, ptr, size*count); break; default: AFILE_print_error("Could not recognize compresssion\n"); break; } return 0; }
virtual ~CoinBzip2FileInput () { int bzError = BZ_OK; if (bzf_ != 0) BZ2_bzReadClose (&bzError, bzf_); if (f_ != 0) fclose (f_); }
int bclose (void *file) { struct fhandle *f = (struct fhandle *) file; BZ2_bzReadClose (&bzerror, (BZFILE *) f->file2); fclose (f->file1); f->file2 = NULL; f->file1 = NULL; return 0; }
void lbz_perform_close(lbz_state *state, int keep_extra_buf) { int bzerror; if(!keep_extra_buf) lbz_buffer_free(state); if(!state->bz_stream) return; BZ2_bzReadClose(&bzerror, state->bz_stream); fclose(state->f); state->bz_stream = NULL; state->f = NULL; }
off64_t _GD_Bzip2Seek(struct _gd_raw_file* file, off64_t count, gd_type_t data_type, unsigned int mode __gd_unused) { struct gd_bzdata *ptr = (struct gd_bzdata *)file->edata; dtrace("%p, %lli, 0x%X, <unused>", file, (long long)count, data_type); count *= GD_SIZE(data_type); if (ptr->base > count) { /* a backwards seek -- reopen the file */ ptr->bzerror = 0; BZ2_bzReadClose(&ptr->bzerror, ptr->bzfile); ptr->bzfile = BZ2_bzReadOpen(&ptr->bzerror, ptr->stream, 0, 0, NULL, 0); if (ptr->bzfile == NULL || ptr->bzerror != BZ_OK) { fclose(ptr->stream); dreturn("%i", -1); return -1; } ptr->pos = ptr->end = 0; ptr->base = ptr->stream_end = 0; } /* seek forward the slow way */ while (ptr->base + ptr->end < count) { int n; ptr->bzerror = 0; n = BZ2_bzRead(&ptr->bzerror, ptr->bzfile, ptr->data, GD_BZIP_BUFFER_SIZE); if (ptr->bzerror == BZ_OK || ptr->bzerror == BZ_STREAM_END) { ptr->base += ptr->end; ptr->end = n; } else { dreturn("%i", -1); return -1; } /* eof */ if (ptr->bzerror != BZ_OK) { ptr->stream_end = 1; break; } } ptr->pos = (ptr->bzerror == BZ_STREAM_END && count >= ptr->base + ptr->end) ? ptr->end : count - ptr->base; dreturn("%lli", (long long)((ptr->base + ptr->pos) / GD_SIZE(data_type))); return (ptr->base + ptr->pos) / GD_SIZE(data_type); }
void BZ2Stream::startRead() { bzfile_ = BZ2_bzReadOpen(&bzerror_, getFilePointer(), verbosity_, 0, getUnused(), getUnusedLength()); switch (bzerror_) { case BZ_OK: break; default: { BZ2_bzReadClose(&bzerror_, bzfile_); throw BagException("Error opening file for reading compressed stream"); } } clearUnused(); }
int fsReadCompressed(FILESYSTEM_FILE *f, void *data, int len) { BZFILE *bzf; int err, back; void *buf; if (!f) return -1; if (!(bzf = BZ2_bzReadOpen(&err, f->fp, 0, 0, NULL, 0))) return -1; BZ2_bzRead(&err, bzf, data, len); if (err != BZ_STREAM_END) { BZ2_bzReadClose(&err, bzf); return -1; } BZ2_bzReadGetUnused(&err, bzf, &buf, &back); fseek(f->fp, back * -1, SEEK_CUR); f->pos = ftell(f->fp) - f->offset; BZ2_bzReadClose(&err, bzf); return 0; }
void DumpReader::close() { if (m_bz) { MonitorBlock sync(this); int ignore; if (m_bz) BZ2_bzReadClose(&ignore, m_bz); m_bz = 0; if (m_dump) fclose(m_dump); m_dump = 0; sync.notifyAll(); } }
static void read_bz2(int f, int fd, char *arg) { BZFILE* b; int nBuf; char buf[BUFFER_SIZE]; int bzerror; b = BZ2_bzReadOpen ( &bzerror, fdopen(f,"rb"), 0, 0, NULL, 0 ); if (bzerror != BZ_OK) { BZ2_bzReadClose ( &bzerror, b ); // error ERRORMSG(_("Invalid/corrupt .bz2 file.\n")); close(fd); return; } bzerror = BZ_OK; while (bzerror == BZ_OK) { nBuf = BZ2_bzRead ( &bzerror, b, buf, BUFFER_SIZE); if (write(fd, buf, nBuf)!=nBuf) { BZ2_bzReadClose ( &bzerror, b ); close(fd); return; } } if (bzerror != BZ_STREAM_END) { BZ2_bzReadClose ( &bzerror, b ); // error ERRORMSG("\033[0m"); ERRORMSG(_("bzip2: Error during decompression.\n")); } else { BZ2_bzReadClose ( &bzerror, b ); } close(fd); }
extern char get_header_tar_bz2(archive_handle_t *archive_handle) { BZ2_bzReadOpen(archive_handle->src_fd, NULL, 0); archive_handle->read = read_bz2; archive_handle->seek = seek_by_char; archive_handle->offset = 0; while (get_header_tar(archive_handle) == EXIT_SUCCESS); /* Cleanup */ BZ2_bzReadClose(); /* Can only do one tar.bz2 per archive */ return(EXIT_FAILURE); }
void BzipInputStream::close() { assert(m_fp); assert(m_cf); int err; BZ2_bzReadClose(&err, m_fp); ::fclose(m_cf); m_fp = 0; m_cf = 0; if (BZ_OK != err) { std::ostringstream oss; oss << "BZ2_bzReadClose err=" << strbzerr(err) << ", in " << BOOST_CURRENT_FUNCTION; throw OpenFileException("<fd>", oss.str().c_str()); } }
void bz2streambuf::Close() { if (bzfile) { if (sync() != 0) error = true; if (!write) BZ2_bzReadClose(&bzerror, bzfile); else { unsigned int nbytes_in, nbytes_out; BZ2_bzWriteClose(&bzerror, bzfile, error ? 1 : 0, &nbytes_in, &nbytes_out); } bzfile = NULL; } }
void ExtractFile(int id, char *fs) { FILE *out; uint i, s; char fn[256] = "bcpxtract\\\0"; char *min, *mout, *ws; uint os, sws; int be; BZFILE *bz; if(!file) return; strcat_s(fn, 255, fs); out = fopen(fn, "wb"); if(!out) return; fseek(file, fent[id].offset, SEEK_SET); s = fent[id].endos - fent[id].offset; switch(fent[id].form) { case 1: // Uncompressed for(i = 0; i < s; i++) fputc(fgetc(file), out); break; case 2: // Zero-sized file break; case 3: // bzip2-compressed file mout = malloc(fent[id].size); bz = BZ2_bzReadOpen(&be, file, 0, 0, NULL, 0); if(be != BZ_OK) fErr(-822, "Failed to initialize bzip2 decompression."); BZ2_bzRead(&be, bz, mout, fent[id].size); if((be != BZ_OK) && (be != BZ_STREAM_END)) fErr(-872, "Failed to decompress bzip2 file."); BZ2_bzReadClose(&be, bz); fwrite(mout, fent[id].size, 1, out); free(mout); break; case 4: // LZRW3-compressed file ws = (char*)malloc(MEM_REQ); min = (char*)malloc(s); mout = (char*)malloc(os = fent[id].size); fread(min, s, 1, file); compress(COMPRESS_ACTION_DECOMPRESS, ws, min, s, mout, &os); if(fent[id].size != os) MessageBox(hwnd, "The decompressed sizes in the file table and from the decompression algorithm are different.", title, 48); fwrite(mout, fent[id].size, 1, out); free(ws); free(min); free(mout); break; } fclose(out); }
static struct bz2_file *bz2_fd_open(int fd) { struct bz2_file *b = NULL; FILE* f; int bzerror; f = fdopen (fd, "r" ); if (f) { b = malloc(sizeof(struct bz2_file)); b->f = f; b->file = BZ2_bzReadOpen(&bzerror, f, 0, 0, NULL, 0); b->eof = false; if (bzerror != BZ_OK) { oscap_seterr(OSCAP_EFAMILY_OSCAP, "Could not build BZ2FILE from %s: %s", BZ2_bzerror(b->file, &bzerror)); BZ2_bzReadClose(&bzerror, b->file); free(b); b = NULL; } } return b; }
bool Bz2::Close() { m_errcode = BZ_OK; if (m_bzFile) { if (m_mode == Bz2::OPEN_WRITE) { BZ2_bzWriteClose(&m_errcode, m_bzFile, 0, nullptr, nullptr); } else { BZ2_bzReadClose(&m_errcode, m_bzFile); } m_bzFile = nullptr; } if (m_fileStream) { fclose(m_fileStream); m_fileStream = nullptr; } if (m_errcode != BZ_OK) { return false; } return true; }