// Attach to bzip2 file
bzfilebuf*
bzfilebuf::attach(int fd,
std::ios_base::openmode mode)
{
// Fail if file already open
if (this->is_open())
return NULL;
// Don't support simultaneous read/write access (yet)
if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
return NULL;
// Build mode string for bzdopen and check it [27.8.1.3.2]
char char_mode[6] = "\0\0\0\0\0";
if (!this->open_mode(mode, char_mode))
return NULL;
// Attempt to attach to file
if ((file = BZ2_bzdopen(fd, char_mode)) == NULL)
return NULL;
// On success, allocate internal buffer and set flags
this->enable_buffer();
io_mode = mode;
own_fd = false;
return this;
}
static void
decompress_bzip2(int fd_in, int fd_out, const char *desc)
{
char buffer[DPKG_BUFFER_SIZE];
BZFILE *bzfile = BZ2_bzdopen(fd_in, "r");
if (bzfile == NULL)
ohshit(_("%s: error binding input to bzip2 stream"), desc);
for (;;) {
int actualread, actualwrite;
actualread = BZ2_bzread(bzfile, buffer, sizeof(buffer));
if (actualread < 0) {
int bz_errnum = 0;
const char *errmsg = BZ2_bzerror(bzfile, &bz_errnum);
if (bz_errnum == BZ_IO_ERROR)
errmsg = strerror(errno);
ohshit(_("%s: internal bzip2 read error: '%s'"), desc,
errmsg);
}
if (actualread == 0) /* EOF. */
break;
actualwrite = fd_write(fd_out, buffer, actualread);
if (actualwrite != actualread)
ohshite(_("%s: internal bzip2 write error"), desc);
}
if (close(fd_out))
ohshite(_("%s: internal bzip2 write error"), desc);
}
static FD_t bzdFdopen(FD_t fd, int fdno, const char * fmode)
{
BZFILE *bzfile = BZ2_bzdopen(fdno, fmode);
if (bzfile == NULL)
return NULL;
fdSetFdno(fd, -1); /* XXX skip the fdio close */
fdPush(fd, bzdio, bzfile, fdno); /* Push bzdio onto stack */
return fd;
}
static void
compress_bzip2(int fd_in, int fd_out, struct compress_params *params, const char *desc)
{
char buffer[DPKG_BUFFER_SIZE];
char combuf[6];
int bz_errnum;
BZFILE *bzfile;
snprintf(combuf, sizeof(combuf), "w%d", params->level);
bzfile = BZ2_bzdopen(fd_out, combuf);
if (bzfile == NULL)
ohshit(_("%s: error binding output to bzip2 stream"), desc);
for (;;) {
int actualread, actualwrite;
actualread = fd_read(fd_in, buffer, sizeof(buffer));
if (actualread < 0)
ohshite(_("%s: internal bzip2 read error"), desc);
if (actualread == 0) /* EOF. */
break;
actualwrite = BZ2_bzwrite(bzfile, buffer, actualread);
if (actualwrite != actualread) {
const char *errmsg = BZ2_bzerror(bzfile, &bz_errnum);
if (bz_errnum == BZ_IO_ERROR)
errmsg = strerror(errno);
ohshit(_("%s: internal bzip2 write error: '%s'"), desc,
errmsg);
}
}
BZ2_bzWriteClose(&bz_errnum, bzfile, 0, NULL, NULL);
if (bz_errnum != BZ_OK) {
const char *errmsg = _("unexpected bzip2 error");
if (bz_errnum == BZ_IO_ERROR)
errmsg = strerror(errno);
ohshit(_("%s: internal bzip2 write error: '%s'"), desc,
errmsg);
}
/* Because BZ2_bzWriteClose has done a fflush on the file handle,
* doing a close on the file descriptor associated with it should
* be safe™. */
if (close(fd_out))
ohshite(_("%s: internal bzip2 write error"), desc);
}
static FD_t bzdFdopen(FD_t fd, const char * fmode)
{
int fdno;
BZFILE *bzfile;
if (fd == NULL || fmode == NULL) return NULL;
fdno = fdFileno(fd);
fdSetFdno(fd, -1); /* XXX skip the fdio close */
if (fdno < 0) return NULL;
bzfile = BZ2_bzdopen(fdno, fmode);
if (bzfile == NULL) return NULL;
fdPush(fd, bzdio, bzfile, fdno); /* Push bzdio onto stack */
return fdLink(fd);
}
static inline FILE *mybzfdopen(int fd, const char *mode)
{
BZFILE *bzf = BZ2_bzdopen(fd, mode);
return cookieopen(bzf, mode, cookie_bzread, cookie_bzwrite, cookie_bzclose);
}
bool BZ2File::open(CStrRef filename, CStrRef mode) {
assert(m_bzFile == nullptr);
return m_innerFile->open(filename, mode) &&
(m_bzFile = BZ2_bzdopen(dup(m_innerFile->fd()), mode.data()));
}
int main(int argc,char *argv[])
{
int decompress = 0;
int level = 9;
char *fn_r = NULL;
char *fn_w = NULL;
#ifdef _WIN32
if(BZ2DLLLoadLibrary()<0){
fprintf(stderr,"Loading of %s failed. Giving up.\n", BZ2_LIBNAME);
exit(1);
}
printf("Loading of %s succeeded. Library version is %s.\n",
BZ2_LIBNAME, BZ2_bzlibVersion() );
#endif
while(++argv,--argc){
if(**argv =='-' || **argv=='/'){
char *p;
for(p=*argv+1;*p;p++){
if(*p=='d'){
decompress = 1;
}else if('1'<=*p && *p<='9'){
level = *p - '0';
}else{
usage();
exit(1);
}
}
}else{
break;
}
}
if(argc>=1){
fn_r = *argv;
argc--;argv++;
}else{
fn_r = NULL;
}
if(argc>=1){
fn_w = *argv;
argc--;argv++;
}else{
fn_w = NULL;
}
{
int len;
char buff[0x1000];
char mode[10];
if(decompress){
BZFILE *BZ2fp_r = NULL;
FILE *fp_w = NULL;
if(fn_w){
if((fp_w = fopen(fn_w,"wb"))==NULL){
printf("can't open [%s]\n",fn_w);
perror("reason:");
exit(1);
}
}else{
fp_w = stdout;
}
if((fn_r == NULL && (BZ2fp_r = BZ2_bzdopen(fileno(stdin),"rb"))==NULL)
|| (fn_r != NULL && (BZ2fp_r = BZ2_bzopen(fn_r,"rb"))==NULL)){
printf("can't bz2openstream\n");
exit(1);
}
while((len=BZ2_bzread(BZ2fp_r,buff,0x1000))>0){
fwrite(buff,1,len,fp_w);
}
BZ2_bzclose(BZ2fp_r);
if(fp_w != stdout) fclose(fp_w);
}else{
BZFILE *BZ2fp_w = NULL;
FILE *fp_r = NULL;
if(fn_r){
if((fp_r = fopen(fn_r,"rb"))==NULL){
printf("can't open [%s]\n",fn_r);
perror("reason:");
exit(1);
}
}else{
fp_r = stdin;
}
mode[0]='w';
mode[1] = '0' + level;
mode[2] = '\0';
if((fn_w == NULL && (BZ2fp_w = BZ2_bzdopen(fileno(stdout),mode))==NULL)
|| (fn_w !=NULL && (BZ2fp_w = BZ2_bzopen(fn_w,mode))==NULL)){
printf("can't bz2openstream\n");
exit(1);
}
while((len=fread(buff,1,0x1000,fp_r))>0){
BZ2_bzwrite(BZ2fp_w,buff,len);
}
BZ2_bzclose(BZ2fp_w);
if(fp_r!=stdin)fclose(fp_r);
}
}
#ifdef _WIN32
BZ2DLLFreeLibrary();
#endif
return 0;
}
bool BZ2File::open(const String& filename, const String& mode) {
assert(m_bzFile == nullptr);
return m_innerFile->open(filename, mode) &&
(m_bzFile = BZ2_bzdopen(dup(m_innerFile->fd()), mode.data()));
}
/*
* Opens a file for processing.
*/
struct file *
grep_open(const char *path)
{
struct file *f;
f = grep_malloc(sizeof *f);
memset(f, 0, sizeof *f);
if (path == NULL) {
/* Processing stdin implies --line-buffered. */
lbflag = true;
f->fd = STDIN_FILENO;
} else if ((f->fd = open(path, O_RDONLY)) == -1)
goto error1;
if (filebehave == FILE_MMAP) {
struct stat st;
if ((fstat(f->fd, &st) == -1) || (st.st_size > OFF_MAX) ||
(!S_ISREG(st.st_mode)))
filebehave = FILE_STDIO;
else {
int flags = MAP_PRIVATE | MAP_NOCORE | MAP_NOSYNC;
#ifdef MAP_PREFAULT_READ
flags |= MAP_PREFAULT_READ;
#endif
fsiz = st.st_size;
buffer = mmap(NULL, fsiz, PROT_READ, flags,
f->fd, (off_t)0);
if (buffer == MAP_FAILED)
filebehave = FILE_STDIO;
else {
bufrem = st.st_size;
bufpos = buffer;
madvise(buffer, st.st_size, MADV_SEQUENTIAL);
}
}
}
if ((buffer == NULL) || (buffer == MAP_FAILED))
buffer = grep_malloc(MAXBUFSIZ);
if (filebehave == FILE_GZIP &&
(gzbufdesc = gzdopen(f->fd, "r")) == NULL)
goto error2;
#ifndef WITHOUT_BZIP2
if (filebehave == FILE_BZIP &&
(bzbufdesc = BZ2_bzdopen(f->fd, "r")) == NULL)
goto error2;
#endif
/* Fill read buffer, also catches errors early */
if (bufrem == 0 && grep_refill(f) != 0)
goto error2;
/* Check for binary stuff, if necessary */
if (binbehave != BINFILE_TEXT && memchr(bufpos, '\0', bufrem) != NULL)
f->binary = true;
return (f);
error2:
close(f->fd);
error1:
free(f);
return (NULL);
}
