switching back to high-level bz2 interface now that write has been simplified

diff --git a/bsdiff.c b/bsdiff.c
index 130fb5d..ffa47a1 100644 (file)
--- a/bsdiff.c
+++ b/bsdiff.c
@@ -376,90 +376,31 @@ int bsdiff(const uint8_t* old, int64_t oldsize, const uint8_t* new, int64_t news
 
 static int bz2_write(struct bsdiff_stream* stream, const void* buffer, int size)
 {
-       bz_stream* bz2;
-       FILE* pf;
-       int err;
-       char compress_buffer[4096];
+       int bz2err;
+       BZFILE* bz2;
 
-       bz2 = (bz_stream*)stream->opaque;
-       pf = (FILE*)bz2->opaque;
-
-       if (!bz2->state)
-       {
-               if (BZ_OK != BZ2_bzCompressInit(bz2, 9, 0, 0))
-                       return -1;
-       }
-
-       bz2->next_in = (char*)buffer;
-       bz2->avail_in = size;
-
-       for (;;)
-       {
-               bz2->next_out = compress_buffer;
-               bz2->avail_out = sizeof(compress_buffer);
-               if (BZ_RUN_OK != (err = BZ2_bzCompress(bz2, BZ_RUN)))
-                       return -1;
-
-               if (bz2->avail_out < sizeof(compress_buffer))
-               {
-                       const size_t written = sizeof(compress_buffer) - bz2->avail_out;
-                       if (written != fwrite(compress_buffer, 1, written, pf))
-                               return -1;
-               }
-
-               if (bz2->avail_in == 0)
-                       return 0;
-       }
-}
-
-static int bz2_finish(struct bsdiff_stream* stream)
-{
-       int err;
-       bz_stream* bz2;
-       FILE* pf;
-       char compress_buffer[4096];
-
-       bz2 = (bz_stream*)stream->opaque;
-       pf = (FILE*)bz2->opaque;
-
-       for (;;)
-       {
-               bz2->next_out = compress_buffer;
-               bz2->avail_out = sizeof(compress_buffer);
-
-               err = BZ2_bzCompress(bz2, BZ_FINISH);
-               if (BZ_FINISH_OK != err && BZ_STREAM_END != err)
-                       return -1;
-
-               if (bz2->avail_out < sizeof(compress_buffer))
-               {
-                       const size_t written = sizeof(compress_buffer) - bz2->avail_out;
-                       if (written != fwrite(compress_buffer, 1, written, pf))
-                               return -1;
-               }
-
-               if (BZ_STREAM_END == err)
-                       break;
-       }
+       bz2 = (BZFILE*)stream->opaque;
+       BZ2_bzWrite(&bz2err, bz2, (void*)buffer, size);
+       if (bz2err != BZ_STREAM_END && bz2err != BZ_OK)
+               return -1;
 
-       BZ2_bzCompressEnd(bz2);
        return 0;
 }
 
 int main(int argc,char *argv[])
 {
        int fd;
+       int bz2err;
        uint8_t *old,*new;
        off_t oldsize,newsize;
        uint8_t buf[8];
        FILE * pf;
        struct bsdiff_stream stream;
-       bz_stream bz2;
+       BZFILE* bz2;
 
        memset(&bz2, 0, sizeof(bz2));
        stream.malloc = malloc;
        stream.free = free;
-       stream.opaque = &bz2;
        stream.write = bz2_write;
 
        if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);
@@ -493,12 +434,17 @@ int main(int argc,char *argv[])
                fwrite(buf, sizeof(buf), 1, pf) != 1)
                err(1, "Failed to write header");
 
-       bz2.opaque = pf;
+
+       if (NULL == (bz2 = BZ2_bzWriteOpen(&bz2err, pf, 9, 0, 0)))
+               errx(1, "BZ2_bzWriteOpen, bz2err=%d", bz2err);
+
+       stream.opaque = bz2;
        if (bsdiff(old, oldsize, new, newsize, &stream))
                err(1, "bsdiff");
 
-       if (bz2_finish(&stream))
-               err(1, "stream.finish");
+       BZ2_bzWriteClose(&bz2err, bz2, 0, NULL, NULL);
+       if (bz2err != BZ_OK)
+               err(1, "BZ2_bzWriteClose, bz2err=%d", bz2err);
 
        if (fclose(pf))
                err(1, "fclose");

diff --git a/bspatch.c b/bspatch.c
index 1091050..9265a96 100644 (file)
--- a/bspatch.c
+++ b/bspatch.c
@@ -128,51 +128,18 @@ int bspatch(const struct bspatch_request req)
 #include <unistd.h>
 #include <fcntl.h>
 
-#define BUFFER_SIZE 4096
-struct bspatch_bz2_buffer
-{
-       FILE* pf;
-       bz_stream bz2;
-       char buffer[BUFFER_SIZE];
-};
-
-static int readcompress(const struct bspatch_stream* stream, void* buffer, int length)
+static int bz2_read(const struct bspatch_stream* stream, void* buffer, int length)
 {
        int n;
-       int ret;
-       struct bspatch_bz2_buffer* buf = (struct bspatch_bz2_buffer*)stream->opaque;
-       bz_stream* bz2 = &buf->bz2;
-
-       bz2->next_out = (char*)buffer;
-       bz2->avail_out = length;
-
-       for (;;)
-       {
-               if (bz2->avail_in == 0 && !feof(buf->pf) && bz2->avail_out > 0)
-               {
-                       n = fread(buf->buffer, 1, BUFFER_SIZE, buf->pf);
-                       if (ferror(buf->pf))
-                               return -1;
-
-                       bz2->next_in = buf->buffer;
-                       bz2->avail_in = n;
-               }
-
-               ret = BZ2_bzDecompress(bz2);
-               if (ret != BZ_OK && ret != BZ_STREAM_END)
-                       return -1;
-
-               if (ret == BZ_OK && feof(buf->pf) && bz2->avail_in == 0 && bz2->avail_out > 0)
-                       return -1;
+       int bz2err;
+       BZFILE* bz2;
 
-               if (ret == BZ_STREAM_END)
-                       return length - bz2->avail_out;
-               if (bz2->avail_out == 0)
-                       return length;
-       }
+       bz2 = (BZFILE*)stream->opaque;
+       n = BZ2_bzRead(&bz2err, bz2, buffer, length);
+       if (n == 0)
+               return -1;
 
-       // unreachable
-       return -1;
+       return n;
 }
 
 int main(int argc,char * argv[])
@@ -182,10 +149,8 @@ int main(int argc,char * argv[])
        int bz2err;
        uint8_t header[16];
        uint8_t *old;
+       BZFILE* bz2;
        struct bspatch_request req;
-       struct bspatch_bz2_buffer bz2;
-
-       memset(&bz2, 0, sizeof(bz2));
 
        if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);
 
@@ -219,18 +184,16 @@ int main(int argc,char * argv[])
        req.old = old;
        if((req.new=malloc(req.newsize+1))==NULL) err(1,NULL);
 
-       bz2.pf = f;
-       req.stream.opaque = &bz2;
-       req.stream.read = readcompress;
-
-       if (BZ_OK != (bz2err = BZ2_bzDecompressInit(&bz2.bz2, 0, 0)))
-               errx(1, "BZ2_bzDecompressInit, bz2err = %d", bz2err);
+       if (NULL == (bz2 = BZ2_bzReadOpen(&bz2err, f, 0, 0, NULL, 0)))
+               errx(1, "BZ2_bzReadOpen, bz2err=%d", bz2err);
 
+       req.stream.read = bz2_read;
+       req.stream.opaque = bz2;
        if (bspatch(req))
                err(1, "bspatch");
 
        /* Clean up the bzip2 reads */
-       BZ2_bzDecompressEnd(&bz2.bz2);
+       BZ2_bzReadClose(&bz2err, bz2);
        fclose(f);
 
        /* Write the new file */