示例#1
0
static void openFile_bz2(struct FileHandle_bz2 *fp, const char *path)
{
  int err;
  fp->fp = fopen(path, "rb");
  if (fp->fp == NULL) openFileError(path);
  fp->bfp = BZ2_bzReadOpen(&err, fp->fp, 0, 0, NULL, 0);
}
示例#2
0
/* 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;
}
示例#3
0
NBBZip2::NBBZip2( QString archive, QString file ) {

	int error = 0;

	bz2FileName = QString( archive );
	if ( not file.isEmpty() ) {
		if ( QFileInfo( file ).isDir() ) {
			fileName = QDir( file ).filePath( QString( archive ) );
			fileName.chop( 4 );
		}

		else if ( QFileInfo( file ).exists() ) {
			QFile::rename( file, file + ".old" );
			fileName = QString( file );
		}

		else {
			fileName = QString( file );
		}
	}

	else {
		fileName = QString( archive );
		fileName.chop( 4 );
	}

	bzFile = fopen( qPrintable( bz2FileName ), "r" );
	bz2 = BZ2_bzReadOpen( &error, bzFile, 0, 0, NULL, 0 );
};
示例#4
0
void BzipInputStream::dopen(int fd, const char* mode)
{
	assert(0 == m_fp);

	int err;
#ifdef _MSC_VER
	m_cf = _fdopen(fd, mode);
#else
	m_cf = fdopen(fd, mode);
#endif
	if (0 == m_cf)
	{
		std::ostringstream oss;
		oss << "fd=" << fd << ", mode=" << mode;
		throw OpenFileException("<fd>", oss.str().c_str());
	}
	m_fp = BZ2_bzReadOpen(&err, m_cf
		, 0    // verbosity, 0 will not print msg
		, 0    // small
		, NULL // unused
		, 0    // nUnused
		);
	if (0 == m_fp)
	{
		std::ostringstream oss;
		oss << "fd=" << fd << ", mode=" << mode << ", err=" << strbzerr(err);
		throw OpenFileException("<fd>", oss.str().c_str());
	}
}
示例#5
0
文件: aflib.c 项目: nh13/BFAST
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;
}
示例#6
0
 void bz2streambuf::Open(FILE *f_)
 {
   f = f_;
   if (!write)
     bzfile = BZ2_bzReadOpen(&bzerror, f, 0, 0, NULL, 0);
   else
     bzfile = BZ2_bzWriteOpen(&bzerror, f, 5, 0, 0);
   error = (bzerror != BZ_OK);
 }
示例#7
0
bool Bz2::Open(const std::string &path, Bz2::OpenMode mode)
{
    m_errcode = BZ_OK;
    if (mode == Bz2::OPEN_WRITE) {
        m_fileStream = fopen(path.c_str(), "wb");
        m_bzFile = BZ2_bzReadOpen(&m_errcode, m_fileStream, 0, 0, nullptr, 0);
    }
    else {
        m_fileStream = fopen(path.c_str(), "rb");
        m_bzFile = BZ2_bzReadOpen(&m_errcode, m_fileStream, 0, 0, nullptr, 0);
    }
    
    if (m_errcode != BZ_OK) {
        this->Close();
        return false;
    }
    return true;
}
示例#8
0
struct Input *inputOpen(const char *name)
{
    const char *ext = strrchr(name, '.');
    struct Input *ctx = (struct Input *)malloc(sizeof(*ctx));

    if (!ctx)
        return NULL;

    memset(ctx, 0, sizeof(*ctx));

    ctx->name = (char *)malloc(strlen(name) + 1);
    if (ctx->name) strcpy(ctx->name, name);

    if (ext && !strcmp(ext, ".gz")) {
        ctx->fileHandle = (void *)gzopen(name, "rb");
        ctx->type = Input::gzipFile;
    } else if (ext && !strcmp(ext, ".bz2")) {
      int error = 0;
      ctx->systemHandle = fopen(name, "rb");
      if (!ctx->systemHandle) {
        fprintf(stderr, "error while opening file %s\n", name);
        exit(10);
      }

      ctx->fileHandle = (void *)BZ2_bzReadOpen(&error, ctx->systemHandle, 0, 0, NULL, 0);
      ctx->type = Input::bzip2File;

    } else {
        int *pfd = (int *)malloc(sizeof(int));
        if (pfd) {
            if (!strcmp(name, "-")) {
                *pfd = STDIN_FILENO;
            } else {
                int flags = O_RDONLY;
#ifdef O_LARGEFILE
                flags |= O_LARGEFILE;
#endif
                *pfd = open(name, flags);
                if (*pfd < 0) {
                    free(pfd);
                    pfd = NULL;
                }
            }
        }
        ctx->fileHandle = (void *)pfd;
        ctx->type = Input::plainFile;
    }
    if (!ctx->fileHandle) {
        fprintf(stderr, "error while opening file %s\n", name);
        exit(10);
    }
    ctx->buf_ptr = 0;
    ctx->buf_fill = 0;
    return ctx;
}
示例#9
0
文件: compression.c 项目: gdt/viking
/**
 * 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
}
示例#10
0
static void open_compressed_read(pcu_file* pf)
{
  int bzerror;
  int verbosity = 0;
  int small = 0;
  void* unused = NULL;
  int nUnused = 0;
  pf->bzf = BZ2_bzReadOpen(&bzerror, pf->f, verbosity, small, unused, nUnused);
  if (bzerror != BZ_OK)
    reel_fail("BZ2_bzReadOpen failed with code %d", bzerror);
}
示例#11
0
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);
}
示例#12
0
//----------------------------------------------------
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;
}
示例#13
0
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();
}
示例#14
0
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);
}
示例#15
0
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;
}
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;
}
示例#17
0
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);
}
示例#18
0
  CoinBzip2FileInput (const std::string &fileName):
    CoinGetslessFileInput (fileName), f_ (0), bzf_ (0)
  {
    int bzError = BZ_OK;
    readType_="bzlib";

    f_ = fopen (fileName.c_str (), "r");

    if (f_ != 0)
      bzf_ = BZ2_bzReadOpen (&bzError, f_, 0, 0, 0, 0);

    if (f_ == 0 || bzError != BZ_OK || bzf_ == 0)
      throw CoinError ("Could not open file for reading!",
		       "CoinBzip2FileInput",
		       "CoinBzip2FileInput");
  }
示例#19
0
void *
bopen (const char *filename, const char *mode)
{
  struct fhandle *f = &fhandle;
  f->file1 = fopen (filename, mode);
  if (! f->file1)
    return NULL;
  f->file2 = BZ2_bzReadOpen (&bzerror, f->file1, 0, 0, NULL, 0);
  if (bzerror != BZ_OK)
    {
      errno = bzerror;
      bclose (f);
      return NULL;
    }
  return f;
}
示例#20
0
NBBZip2::NBBZip2( QString archive, NBBZip2::Mode openmode, QString file ) {

	NBBZip2::Mode mode = openmode;
	int error = 0;

	switch( mode ) {
		case NBBZip2::READ : {
			bz2FileName = QString( archive );
			if ( not file.isEmpty() ) {
				if ( QFileInfo( file ).isDir() ) {
					fileName = QDir( file ).filePath( QString( archive ) );
					fileName.chop( 4 );
				}

				else if ( QFileInfo( file ).exists() ) {
					QFile::rename( file, file + ".old" );
					fileName = QString( file );
				}

				else {
					fileName = QString( file );
				}
			}

			else {
				fileName = QString( archive );
				fileName.chop( 4 );
			}

			bzFile = fopen( qPrintable( bz2FileName ), "r" );
			bz2 = BZ2_bzReadOpen( &error, bzFile, 0, 0, NULL, 0 );
			break;
		}

		case NBBZip2::WRITE : {
			bz2FileName = QString( archive );
			fileName = QString( file );

			bzFile = fopen( qPrintable( bz2FileName ), "w" );
			bz2 = BZ2_bzWriteOpen( &error, bzFile, 9, 0, 30 );
			break;
		}
	}
};
示例#21
0
文件: untar.c 项目: mwiebe/nsis-untgz
/* Initialize decompression library (if needed)
   0=success, nonzero means error during initialization
 */
int cm_init(gzFile in, int cm)
{
  infile = in; /* save gzFile for reading/cleanup */

  switch (cm)
  {
#ifdef ENABLE_BZ2
    case CM_BZ2:
      bzfile = BZ2_bzReadOpen(&bzerror, in, 0, 0, NULL, 0);
	return bzerror;
#endif
#ifdef ENABLE_LZMA
    case CM_LZMA:
      return lzma_init(in, &lzmaFile);
#endif
    default: /* CM_NONE, CM_GZ */
      return 0; /* success */
  }
}
示例#22
0
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);
}
示例#23
0
static struct gd_bzdata *_GD_Bzip2DoOpen(int dirfd, struct _gd_raw_file* file)
{
  int fd;
  struct gd_bzdata *ptr;

  dtrace("%i, %p", dirfd, file);

  if ((ptr = (struct gd_bzdata *)malloc(sizeof(struct gd_bzdata))) == NULL) {
    dreturn("%p", NULL);
    return NULL;
  }

  if ((fd = gd_OpenAt(file->D, dirfd, file->name, O_RDONLY, 0666)) == -1) {
    free(ptr);
    dreturn("%p", NULL);
    return NULL;
  }

  if ((ptr->stream = fdopen(fd, "rb")) == NULL) {
    close(fd);
    free(ptr);
    dreturn("%p", NULL);
    return NULL;
  }

  ptr->bzerror = ptr->stream_end = 0;
  ptr->bzfile = BZ2_bzReadOpen(&ptr->bzerror, ptr->stream, 0, 0, NULL, 0);

  if (ptr->bzfile == NULL || ptr->bzerror != BZ_OK) {
    fclose(ptr->stream);
    free(ptr);
    dreturn("%p", NULL);
    return NULL;
  }

  ptr->pos = ptr->end = 0;
  ptr->base = 0;

  dreturn("%p", ptr);
  return ptr;
}
示例#24
0
//----------------------------------------------------------------------------------
// Open the file
bool CFastqReader::OpenFiles()
{
	if(in || in_gzip || in_bzip2)
		return false;

	// Uncompressed file
	if(mode == m_plain)	
	{
		if((in = fopen(input_file_name.c_str(), "rb")) == NULL)
			return false;
	}
	// Gzip-compressed file
	else if(mode == m_gzip)
	{
		if((in_gzip = gzopen(input_file_name.c_str(), "rb")) == NULL)
			return false;
		gzbuffer(in_gzip, gzip_buffer_size);
	}
	// Bzip2-compressed file
	else if(mode == m_bzip2)
	{
		in = fopen(input_file_name.c_str(), "rb");
		if(!in)
			return false;
		setvbuf(in, NULL, _IOFBF, bzip2_buffer_size);
		if((in_bzip2 = BZ2_bzReadOpen(&bzerror, in, 0, 0, NULL, 0)) == NULL)
		{
			fclose(in);
			return false;
		}
	}
	
	// Reserve via PMM
	pmm_fastq->reserve(part);

	part_filled = 0;

	return true;
}
示例#25
0
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;
}
示例#26
0
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;
}
示例#27
0
文件: lbz.c 项目: eklitzke/lua-bz2
/* Binding to libbzip2's BZ2_bzReadOpen method */
int lbz_read_open(lua_State *L) {
	size_t len;
	const char *fname = lua_tolstring(L, 1, &len);
	FILE *f = fopen(fname, "rb");

	if (f == NULL)
		return luaL_error(L, "Failed to fopen %s", fname);

	int bzerror;
	lbz_state *state = (lbz_state *) lua_newuserdata(L, sizeof(lbz_state));
	state->bz_stream = BZ2_bzReadOpen(&bzerror, f, 0, 0, NULL, 0);
	state->f = f;

	lbz_buffer_init(state);

	luaL_getmetatable(L, LBZ_STATE_META);
	lua_setmetatable(L, -2);

	if (bzerror != BZ_OK)
		lua_pushnil(L);

	return 1;
}
示例#28
0
DumpReader::DumpReader(const std::string &dump)
 : m_dump(0), m_bz(0), m_dumpSize(0), m_bzStatus(BZ_OK)
{
	m_dump = fopen(dump.c_str(), "r");
	
	
	if (!m_dump) {
		throwErrno();
	}
	
	int status;
	
	m_bz = BZ2_bzReadOpen(&status, m_dump, 0, 0, 0, 0);
	
	if (status) {
		throw std::logic_error("bzip error");
	}
	
	if (fseek(m_dump, 0, SEEK_END) || 
		-1 == (m_dumpSize = ftell(m_dump)) ||
		fseek(m_dump, 0, SEEK_SET)) {
		throwErrno();
	}
}
示例#29
0
struct osm_planet *osm_planet_open(const char *filename)
{
    struct osm_planet *osf = calloc(1, sizeof(struct osm_planet));
    int bzerror;

    if( !(osf->fp = fopen(filename, "rb")))
    {
        fprintf(stderr, "osm_planet_open(): Unable to open file <%s>: %s\n", filename,
                strerror(errno));
        goto open_failed;
    }

    osf->bzfp = BZ2_bzReadOpen(&bzerror, osf->fp, 1, 0, NULL, 0);
    if(bzerror != BZ_OK)
    {
        fprintf(stderr, "osm_planet_open(): Unable to open compressed file with bzip2: %d\n", bzerror);
        goto open_failed;
    }

    pthread_mutex_init(&osf->drained_mutex, NULL);
    pthread_mutex_init(&osf->filled_mutex, NULL);
    pthread_cond_init(&osf->drained_signal, NULL);
    pthread_cond_init(&osf->filled_signal, NULL);

    if(pthread_create(&osf->file_read_thread, NULL, start_file_read_thread, osf) != 0)
    {
        fprintf(stderr, "osm_planet_open(): Unable to start file read thread\n");
        goto open_failed;
    }

    return osf;

open_failed:
    free(osf);
    return NULL;
}
示例#30
0
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);
}