Merge changes from topic 'use_bspatch_from_external/bsdiff'

* changes:
  Remove bspatch_recovery.
  Add another overload of bspatch().
  bspatch: convert all err() and errx() calls to returns.
  Provide interface for in memory bspatch.

Android.mk

@@ -37,10 +37,12 @@ bsdiff_src_files := \
 # "bspatch" program.
 bspatch_src_files := \
     bspatch.cc \
+    buffer_file.cc \
     extents.cc \
     extents_file.cc \
     file.cc \
-    memory_file.cc
+    memory_file.cc \
+    sink_file.cc
 
 # Unit test files.
 bsdiff_common_unittests := \
@@ -57,6 +59,7 @@ LOCAL_MODULE := libbspatch
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_SRC_FILES := $(bspatch_src_files)
 LOCAL_CFLAGS := $(bsdiff_common_cflags)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
 LOCAL_STATIC_LIBRARIES := $(bsdiff_common_static_libs)
 include $(BUILD_STATIC_LIBRARY)
 
@@ -76,6 +79,7 @@ LOCAL_MODULE := libbspatch
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_SRC_FILES := $(bspatch_src_files)
 LOCAL_CFLAGS := $(bsdiff_common_cflags)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
 LOCAL_STATIC_LIBRARIES := $(bsdiff_common_static_libs)
 include $(BUILD_HOST_STATIC_LIBRARY)
 
@@ -100,20 +104,6 @@ LOCAL_STATIC_LIBRARIES := \
     $(bsdiff_common_static_libs)
 include $(BUILD_EXECUTABLE)
 
-# bspatch used in recovery by update_engine_sideload.
-include $(CLEAR_VARS)
-LOCAL_MODULE := bspatch_recovery
-LOCAL_MODULE_STEM := bspatch
-LOCAL_FORCE_STATIC_EXECUTABLE := true
-LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin
-LOCAL_CPP_EXTENSION := .cc
-LOCAL_SRC_FILES := bspatch_main.cc
-LOCAL_CFLAGS := $(bsdiff_common_cflags)
-LOCAL_STATIC_LIBRARIES := \
-    libbspatch \
-    $(bsdiff_common_static_libs)
-include $(BUILD_EXECUTABLE)
-
 # Host executables.
 
 include $(CLEAR_VARS)

Makefile

@@ -32,10 +32,12 @@ BSDIFF_OBJS = \
 BSPATCH_LIBS = -lbz2
 BSPATCH_OBJS = \
   bspatch.o \
+  buffer_file.o \
   extents.o \
   extents_file.o \
   file.o \
-  memory_file.o
+  memory_file.o \
+  sink_file.o
 
 UNITTEST_LIBS = -lgmock -lgtest -lpthread
 UNITTEST_OBJS = \
@@ -66,6 +68,7 @@ bspatch.o: bspatch.cc bspatch.h extents.h extents_file.h file_interface.h \
  file.h
 bspatch_main.o: bspatch_main.cc bspatch.h
 bspatch_unittest.o: bspatch_unittest.cc bspatch.h test_utils.h
+buffer_file.o: buffer_file.cc buffer_file.h file_interface.h bspatch.h
 extents.o: extents.cc extents.h extents_file.h file_interface.h
 extents_file.o: extents_file.cc extents_file.h file_interface.h
 extents_file_unittest.o: extents_file_unittest.cc extents_file.h \
@@ -74,6 +77,7 @@ extents_unittest.o: extents_unittest.cc extents.h extents_file.h \
  file_interface.h
 file.o: file.cc file.h file_interface.h
 memory_file.o: memory_file.cc memory_file.h file_interface.h
+sink_file.o: sink_file.cc sink_file.h file_interface.h
 testrunner.o: testrunner.cc
 test_utils.o: test_utils.cc test_utils.h
 

bspatch.cc

@@ -31,7 +31,6 @@ __FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59:
 #include "bspatch.h"
 
 #include <bzlib.h>
-#include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
@@ -46,15 +45,17 @@ __FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59:
 #include <limits>
 #include <vector>
 
+#include "buffer_file.h"
 #include "extents.h"
 #include "extents_file.h"
 #include "file.h"
 #include "file_interface.h"
 #include "memory_file.h"
+#include "sink_file.h"
 
 namespace {
 
-int64_t ParseInt64(u_char* buf) {
+int64_t ParseInt64(const u_char* buf) {
   int64_t y;
 
   y = buf[7] & 0x7F;
@@ -79,34 +80,56 @@ int64_t ParseInt64(u_char* buf) {
   return y;
 }
 
-bool ReadBZ2(BZFILE* pfbz2, uint8_t* data, size_t size) {
-  int bz2err;
-  size_t lenread = BZ2_bzRead(&bz2err, pfbz2, data, size);
-  if (lenread < size || (bz2err != BZ_OK && bz2err != BZ_STREAM_END))
-    return false;
+bool ReadBZ2(bz_stream* stream, uint8_t* data, size_t size) {
+  stream->next_out = (char*)data;
+  while (size > 0) {
+    unsigned int read_size = std::min(
+        static_cast<size_t>(std::numeric_limits<unsigned int>::max()), size);
+    stream->avail_out = read_size;
+    int bz2err = BZ2_bzDecompress(stream);
+    if (bz2err != BZ_OK && bz2err != BZ_STREAM_END)
+      return false;
+    size -= read_size - stream->avail_out;
+  }
   return true;
 }
 
-bool ReadBZ2AndWriteAll(const std::unique_ptr<bsdiff::FileInterface>& file,
-                        BZFILE* pfbz2,
-                        size_t size,
-                        uint8_t* buf,
-                        size_t buf_size) {
+int ReadBZ2AndWriteAll(const std::unique_ptr<bsdiff::FileInterface>& file,
+                       bz_stream* stream,
+                       size_t size,
+                       uint8_t* buf,
+                       size_t buf_size) {
   while (size > 0) {
     size_t bytes_to_read = std::min(size, buf_size);
-    if (!ReadBZ2(pfbz2, buf, bytes_to_read))
-      return false;
-    if (!WriteAll(file, buf, bytes_to_read))
-      return false;
+    if (!ReadBZ2(stream, buf, bytes_to_read)) {
+      fprintf(stderr, "Failed to read bzip stream.\n");
+      return 2;
+    }
+    if (!WriteAll(file, buf, bytes_to_read)) {
+      perror("WriteAll() failed");
+      return 1;
+    }
     size -= bytes_to_read;
   }
-  return true;
+  return 0;
 }
 
 }  // namespace
 
 namespace bsdiff {
 
+bool ReadAll(const std::unique_ptr<FileInterface>& file,
+             uint8_t* data,
+             size_t size) {
+  size_t offset = 0, read;
+  while (offset < size) {
+    if (!file->Read(data + offset, size - offset, &read) || read == 0)
+      return false;
+    offset += read;
+  }
+  return true;
+}
+
 bool WriteAll(const std::unique_ptr<FileInterface>& file,
               const uint8_t* data,
               size_t size) {
@@ -127,10 +150,15 @@ bool IsOverlapping(const char* old_filename,
   if (stat(new_filename, &new_stat) == -1) {
     if (errno == ENOENT)
       return false;
-    err(1, "Error stat the new filename %s", new_filename);
+    fprintf(stderr, "Error stat the new file %s: %s\n", new_filename,
+            strerror(errno));
+    return true;
+  }
+  if (stat(old_filename, &old_stat) == -1) {
+    fprintf(stderr, "Error stat the old file %s: %s\n", old_filename,
+            strerror(errno));
+    return true;
   }
-  if (stat(old_filename, &old_stat) == -1)
-    err(1, "Error stat the old filename %s", old_filename);
 
   if (old_stat.st_dev != new_stat.st_dev || old_stat.st_ino != new_stat.st_ino)
     return false;
@@ -147,22 +175,116 @@ bool IsOverlapping(const char* old_filename,
   return false;
 }
 
-int bspatch(
-    const char* old_filename, const char* new_filename,
-    const char* patch_filename,
-    const char* old_extents, const char* new_extents) {
-  FILE* f, *cpf, *dpf, *epf;
-  BZFILE* cpfbz2, *dpfbz2, *epfbz2;
-  int bz2err;
-  ssize_t bzctrllen, bzdatalen;
-  u_char header[32], buf[8];
-  off_t ctrl[3];
+// Patch |old_filename| with |patch_filename| and save it to |new_filename|.
+// |old_extents| and |new_extents| are comma-separated lists of "offset:length"
+// extents of |old_filename| and |new_filename|.
+// Returns 0 on success, 1 on I/O error and 2 on data error.
+int bspatch(const char* old_filename,
+            const char* new_filename,
+            const char* patch_filename,
+            const char* old_extents,
+            const char* new_extents) {
+  std::unique_ptr<FileInterface> patch_file =
+      File::FOpen(patch_filename, O_RDONLY);
+  if (!patch_file) {
+    fprintf(stderr, "Error opening the patch file %s: %s\n", patch_filename,
+            strerror(errno));
+    return 1;
+  }
+  uint64_t patch_size;
+  patch_file->GetSize(&patch_size);
+  std::vector<uint8_t> patch(patch_size);
+  if (!ReadAll(patch_file, patch.data(), patch_size)) {
+    fprintf(stderr, "Error reading the patch file %s: %s\n", patch_filename,
+            strerror(errno));
+    return 1;
+  }
+  patch_file.reset();
 
+  return bspatch(old_filename, new_filename, patch.data(), patch_size,
+                 old_extents, new_extents);
+}
+
+// Patch |old_filename| with |patch_data| and save it to |new_filename|.
+// |old_extents| and |new_extents| are comma-separated lists of "offset:length"
+// extents of |old_filename| and |new_filename|.
+// Returns 0 on success, 1 on I/O error and 2 on data error.
+int bspatch(const char* old_filename,
+            const char* new_filename,
+            const uint8_t* patch_data,
+            size_t patch_size,
+            const char* old_extents,
+            const char* new_extents) {
   int using_extents = (old_extents != NULL || new_extents != NULL);
 
-  // Open patch file.
-  if ((f = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
+  // Open input file for reading.
+  std::unique_ptr<FileInterface> old_file = File::FOpen(old_filename, O_RDONLY);
+  if (!old_file) {
+    fprintf(stderr, "Error opening the old file %s: %s\n", old_filename,
+            strerror(errno));
+    return 1;
+  }
+
+  std::vector<ex_t> parsed_old_extents;
+  if (using_extents) {
+    if (!ParseExtentStr(old_extents, &parsed_old_extents)) {
+      fprintf(stderr, "Error parsing the old extents\n");
+      return 2;
+    }
+    old_file.reset(new ExtentsFile(std::move(old_file), parsed_old_extents));
+  }
+
+  // Open output file for writing.
+  std::unique_ptr<FileInterface> new_file =
+      File::FOpen(new_filename, O_CREAT | O_WRONLY);
+  if (!new_file) {
+    fprintf(stderr, "Error opening the new file %s: %s\n", new_filename,
+            strerror(errno));
+    return 1;
+  }
+
+  std::vector<ex_t> parsed_new_extents;
+  if (using_extents) {
+    if (!ParseExtentStr(new_extents, &parsed_new_extents)) {
+      fprintf(stderr, "Error parsing the new extents\n");
+      return 2;
+    }
+    new_file.reset(new ExtentsFile(std::move(new_file), parsed_new_extents));
+  }
+
+  if (IsOverlapping(old_filename, new_filename, parsed_old_extents,
+                    parsed_new_extents)) {
+    // New and old file is overlapping, we can not stream output to new file,
+    // cache it in a buffer and write to the file at the end.
+    uint64_t newsize = ParseInt64(patch_data + 24);
+    new_file.reset(new BufferFile(std::move(new_file), newsize));
+  }
+
+  return bspatch(old_file, new_file, patch_data, patch_size);
+}
+
+// Patch |old_data| with |patch_data| and save it by calling sink function.
+// Returns 0 on success, 1 on I/O error and 2 on data error.
+int bspatch(const uint8_t* old_data,
+            size_t old_size,
+            const uint8_t* patch_data,
+            size_t patch_size,
+            const sink_func& sink) {
+  std::unique_ptr<FileInterface> old_file(new MemoryFile(old_data, old_size));
+  std::unique_ptr<FileInterface> new_file(new SinkFile(sink));
+
+  return bspatch(old_file, new_file, patch_data, patch_size);
+}
+
+// Patch |old_file| with |patch_data| and save it to |new_file|.
+// Returns 0 on success, 1 on I/O error and 2 on data error.
+int bspatch(const std::unique_ptr<FileInterface>& old_file,
+            const std::unique_ptr<FileInterface>& new_file,
+            const uint8_t* patch_data,
+            size_t patch_size) {
+  int bz2err;
+  u_char buf[8];
+  off_t ctrl[3];
 
   // File format:
   //   0       8    "BSDIFF40"
@@ -176,83 +298,62 @@ int bspatch(
   // from oldfile to x bytes from the diff block; copy y bytes from the
   // extra block; seek forwards in oldfile by z bytes".
 
-  // Read header.
-  if (fread(header, 1, 32, f) < 32) {
-    if (feof(f))
-      errx(1, "Corrupt patch\n");
-    err(1, "fread(%s)", patch_filename);
-  }
-
   // Check for appropriate magic.
-  if (memcmp(header, "BSDIFF40", 8) != 0)
-    errx(1, "Corrupt patch\n");
+  if (memcmp(patch_data, "BSDIFF40", 8) != 0) {
+    fprintf(stderr, "Not a bsdiff patch.\n");
+    return 2;
+  }
 
   // Read lengths from header.
   uint64_t oldsize, newsize;
-  bzctrllen = ParseInt64(header + 8);
-  bzdatalen = ParseInt64(header + 16);
-  int64_t signed_newsize = ParseInt64(header + 24);
+  int64_t ctrl_len = ParseInt64(patch_data + 8);
+  int64_t data_len = ParseInt64(patch_data + 16);
+  int64_t signed_newsize = ParseInt64(patch_data + 24);
   newsize = signed_newsize;
-  if ((bzctrllen < 0) || (bzdatalen < 0) || (signed_newsize < 0))
-    errx(1, "Corrupt patch\n");
+  if ((ctrl_len < 0) || (data_len < 0) || (signed_newsize < 0) ||
+      (32 + ctrl_len + data_len > static_cast<int64_t>(patch_size))) {
+    fprintf(stderr, "Corrupt patch.\n");
+    return 2;
+  }
 
-  // Close patch file and re-open it via libbzip2 at the right places.
-  if (fclose(f))
-    err(1, "fclose(%s)", patch_filename);
-  if ((cpf = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-  if (fseek(cpf, 32, SEEK_SET))
-    err(1, "fseeko(%s, %lld)", patch_filename, (long long)32);
-  if ((cpfbz2 = BZ2_bzReadOpen(&bz2err, cpf, 0, 0, NULL, 0)) == NULL)
-    errx(1, "BZ2_bzReadOpen, bz2err = %d", bz2err);
-  if ((dpf = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-  if (fseek(dpf, 32 + bzctrllen, SEEK_SET))
-    err(1, "fseeko(%s, %lld)", patch_filename, (long long)(32 + bzctrllen));
-  if ((dpfbz2 = BZ2_bzReadOpen(&bz2err, dpf, 0, 0, NULL, 0)) == NULL)
-    errx(1, "BZ2_bzReadOpen, bz2err = %d", bz2err);
-  if ((epf = fopen(patch_filename, "r")) == NULL)
-    err(1, "fopen(%s)", patch_filename);
-  if (fseek(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))
-    err(1, "fseeko(%s, %lld)", patch_filename,
-        (long long)(32 + bzctrllen + bzdatalen));
-  if ((epfbz2 = BZ2_bzReadOpen(&bz2err, epf, 0, 0, NULL, 0)) == NULL)
-    errx(1, "BZ2_bzReadOpen, bz2err = %d", bz2err);
+  bz_stream cstream;
+  cstream.next_in = (char*)patch_data + 32;
+  cstream.avail_in = ctrl_len;
+  cstream.bzalloc = nullptr;
+  cstream.bzfree = nullptr;
+  cstream.opaque = nullptr;
+  if ((bz2err = BZ2_bzDecompressInit(&cstream, 0, 0)) != BZ_OK) {
+    fprintf(stderr, "Failed to bzinit control stream (%d)\n", bz2err);
+    return 2;
+  }
 
-  // Open input file for reading.
-  std::unique_ptr<FileInterface> old_file = File::FOpen(old_filename, O_RDONLY);
-  if (!old_file)
-    err(1, "Error opening the old filename");
+  bz_stream dstream;
+  dstream.next_in = (char*)patch_data + 32 + ctrl_len;
+  dstream.avail_in = data_len;
+  dstream.bzalloc = nullptr;
+  dstream.bzfree = nullptr;
+  dstream.opaque = nullptr;
+  if ((bz2err = BZ2_bzDecompressInit(&dstream, 0, 0)) != BZ_OK) {
+    fprintf(stderr, "Failed to bzinit diff stream (%d)\n", bz2err);
+    return 2;
+  }
 
-  std::vector<ex_t> parsed_old_extents;
-  if (using_extents) {
-    if (!ParseExtentStr(old_extents, &parsed_old_extents))
-      errx(1, "Error parsing the old extents");
-    old_file.reset(new ExtentsFile(std::move(old_file), parsed_old_extents));
+  bz_stream estream;
+  estream.next_in = (char*)patch_data + 32 + ctrl_len + data_len;
+  estream.avail_in = patch_size - (32 + ctrl_len + data_len);
+  estream.bzalloc = nullptr;
+  estream.bzfree = nullptr;
+  estream.opaque = nullptr;
+  if ((bz2err = BZ2_bzDecompressInit(&estream, 0, 0)) != BZ_OK) {
+    fprintf(stderr, "Failed to bzinit extra stream (%d)\n", bz2err);
+    return 2;
   }
 
-  if (!old_file->GetSize(&oldsize))
-    err(1, "cannot obtain the size of %s", old_filename);
   uint64_t old_file_pos = 0;
 
-  // Open output file for writing.
-  std::unique_ptr<FileInterface> new_file =
-      File::FOpen(new_filename, O_CREAT | O_WRONLY);
-  if (!new_file)
-    err(1, "Error opening the new filename %s", new_filename);
-
-  std::vector<ex_t> parsed_new_extents;
-  if (using_extents) {
-    if (!ParseExtentStr(new_extents, &parsed_new_extents))
-      errx(1, "Error parsing the new extents");
-    new_file.reset(new ExtentsFile(std::move(new_file), parsed_new_extents));
-  }
-
-  if (IsOverlapping(old_filename, new_filename, parsed_old_extents,
-                    parsed_new_extents)) {
-    // New and old file is overlapping, we can not stream output to new file,
-    // cache it in the memory and write to the file at the end.
-    new_file.reset(new MemoryFile(std::move(new_file), newsize));
+  if (!old_file->GetSize(&oldsize)) {
+    fprintf(stderr, "Cannot obtain the size of old file.\n");
+    return 1;
   }
 
   // The oldpos can be negative, but the new pos is only incremented linearly.
@@ -263,34 +364,44 @@ int bspatch(
     int64_t i;
     // Read control data.
     for (i = 0; i <= 2; i++) {
-      if (!ReadBZ2(cpfbz2, buf, 8))
-        errx(1, "Corrupt patch\n");
+      if (!ReadBZ2(&cstream, buf, 8)) {
+        fprintf(stderr, "Failed to read control stream.\n");
+        return 2;
+      }
       ctrl[i] = ParseInt64(buf);
     }
 
     // Sanity-check.
-    if (ctrl[0] < 0 || ctrl[1] < 0)
-      errx(1, "Corrupt patch\n");
+    if (ctrl[0] < 0 || ctrl[1] < 0) {
+      fprintf(stderr, "Corrupt patch.\n");
+      return 2;
+    }
 
     // Sanity-check.
-    if (newpos + ctrl[0] > newsize)
-      errx(1, "Corrupt patch\n");
+    if (newpos + ctrl[0] > newsize) {
+      fprintf(stderr, "Corrupt patch.\n");
+      return 2;
+    }
 
+    int ret = 0;
     // Add old data to diff string. It is enough to fseek once, at
     // the beginning of the sequence, to avoid unnecessary overhead.
     if ((i = oldpos) < 0) {
       // Write diff block directly to new file without adding old data,
       // because we will skip part where |oldpos| < 0.
-      if (!ReadBZ2AndWriteAll(new_file, dpfbz2, -i, new_buf.data(),
-                              new_buf.size()))
-        errx(1, "Error during ReadBZ2AndWriteAll()");
-
+      ret = ReadBZ2AndWriteAll(new_file, &dstream, -i, new_buf.data(),
+                               new_buf.size());
+      if (ret)
+        return ret;
       i = 0;
     }
 
     // We just checked that |i| is not negative.
-    if (static_cast<uint64_t>(i) != old_file_pos && !old_file->Seek(i))
-      err(1, "error seeking input file to offset %" PRId64, i);
+    if (static_cast<uint64_t>(i) != old_file_pos && !old_file->Seek(i)) {
+      fprintf(stderr, "Error seeking input file to offset %" PRId64 ": %s\n", i,
+              strerror(errno));
+      return 1;
+    }
     if ((old_file_pos = oldpos + ctrl[0]) > oldsize)
       old_file_pos = oldsize;
 
@@ -298,18 +409,26 @@ int bspatch(
     while (chunk_size > 0) {
       size_t read_bytes;
       size_t bytes_to_read = std::min(chunk_size, old_buf.size());
-      if (!old_file->Read(old_buf.data(), bytes_to_read, &read_bytes))
-        err(1, "error reading from input file");
-      if (!read_bytes)
-        errx(1, "EOF reached while reading from input file");
+      if (!old_file->Read(old_buf.data(), bytes_to_read, &read_bytes)) {
+        perror("Error reading from input file");
+        return 1;
+      }
+      if (!read_bytes) {
+        fprintf(stderr, "EOF reached while reading from input file.\n");
+        return 2;
+      }
       // Read same amount of bytes from diff block
-      if (!ReadBZ2(dpfbz2, new_buf.data(), read_bytes))
-        errx(1, "Corrupt patch\n");
+      if (!ReadBZ2(&dstream, new_buf.data(), read_bytes)) {
+        fprintf(stderr, "Failed to read diff stream.\n");
+        return 2;
+      }
       // new_buf already has data from diff block, adds old data to it.
       for (size_t k = 0; k < read_bytes; k++)
         new_buf[k] += old_buf[k];
-      if (!WriteAll(new_file, new_buf.data(), read_bytes))
-        err(1, "Error writing new file.");
+      if (!WriteAll(new_file, new_buf.data(), read_bytes)) {
+        perror("Error writing to new file");
+        return 1;
+      }
       chunk_size -= read_bytes;
     }
 
@@ -320,19 +439,23 @@ int bspatch(
     if (oldpos > static_cast<int64_t>(oldsize)) {
       // Write diff block directly to new file without adding old data,
       // because we skipped part where |oldpos| > oldsize.
-      if (!ReadBZ2AndWriteAll(new_file, dpfbz2, oldpos - oldsize,
-                              new_buf.data(), new_buf.size()))
-        errx(1, "Error during ReadBZ2AndWriteAll()");
+      ret = ReadBZ2AndWriteAll(new_file, &dstream, oldpos - oldsize,
+                               new_buf.data(), new_buf.size());
+      if (ret)
+        return ret;
     }
 
     // Sanity-check.
-    if (newpos + ctrl[1] > newsize)
-      errx(1, "Corrupt patch\n");
+    if (newpos + ctrl[1] > newsize) {
+      fprintf(stderr, "Corrupt patch.\n");
+      return 2;
+    }
 
     // Read extra block.
-    if (!ReadBZ2AndWriteAll(new_file, epfbz2, ctrl[1], new_buf.data(),
-                            new_buf.size()))
-      errx(1, "Error during ReadBZ2AndWriteAll()");
+    ret = ReadBZ2AndWriteAll(new_file, &estream, ctrl[1], new_buf.data(),
+                             new_buf.size());
+    if (ret)
+      return ret;
 
     // Adjust pointers.
     newpos += ctrl[1];
@@ -343,14 +466,14 @@ int bspatch(
   old_file->Close();
 
   // Clean up the bzip2 reads.
-  BZ2_bzReadClose(&bz2err, cpfbz2);
-  BZ2_bzReadClose(&bz2err, dpfbz2);
-  BZ2_bzReadClose(&bz2err, epfbz2);
-  if (fclose(cpf) || fclose(dpf) || fclose(epf))
-    err(1, "fclose(%s)", patch_filename);
+  BZ2_bzDecompressEnd(&cstream);
+  BZ2_bzDecompressEnd(&dstream);
+  BZ2_bzDecompressEnd(&estream);
 
-  if (!new_file->Close())
-    err(1, "Error closing new file %s", new_filename);
+  if (!new_file->Close()) {
+    perror("Error closing new file");
+    return 1;
+  }
 
   return 0;
 }

bspatch.h

@@ -5,6 +5,7 @@
 #ifndef _BSDIFF_BSPATCH_H_
 #define _BSDIFF_BSPATCH_H_
 
+#include <functional>
 #include <memory>
 #include <vector>
 
@@ -18,6 +19,24 @@ int bspatch(const char* old_filename,
             const char* old_extents,
             const char* new_extents);
 
+int bspatch(const char* old_filename,
+            const char* new_filename,
+            const uint8_t* patch_data,
+            size_t patch_size,
+            const char* old_extents,
+            const char* new_extents);
+
+int bspatch(const uint8_t* old_data,
+            size_t old_size,
+            const uint8_t* patch_data,
+            size_t patch_size,
+            const std::function<size_t(const uint8_t*, size_t)>& sink);
+
+int bspatch(const std::unique_ptr<FileInterface>& old_file,
+            const std::unique_ptr<FileInterface>& new_file,
+            const uint8_t* patch_data,
+            size_t patch_size);
+
 bool WriteAll(const std::unique_ptr<FileInterface>& file,
               const uint8_t* data,
               size_t size);

buffer_file.cc

@@ -0,0 +1,49 @@
+// Copyright 2016 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "buffer_file.h"
+
+#include "bspatch.h"
+
+namespace bsdiff {
+
+BufferFile::BufferFile(std::unique_ptr<FileInterface> file, size_t size)
+    : file_(std::move(file)) {
+  buffer_.reserve(size);
+}
+
+BufferFile::~BufferFile() {
+  Close();
+}
+
+bool BufferFile::Read(void* buf, size_t count, size_t* bytes_read) {
+  return false;
+}
+
+bool BufferFile::Write(const void* buf, size_t count, size_t* bytes_written) {
+  const uint8_t* data = static_cast<const uint8_t*>(buf);
+  buffer_.insert(buffer_.end(), data, data + count);
+  *bytes_written = count;
+  return true;
+}
+
+bool BufferFile::Seek(off_t pos) {
+  return false;
+}
+
+bool BufferFile::Close() {
+  if (!WriteAll(file_, buffer_.data(), buffer_.size()))
+    return false;
+  // Prevent writing |buffer_| to |file_| again if Close() is called more than
+  // once.
+  buffer_.clear();
+  return file_->Close();
+}
+
+bool BufferFile::GetSize(uint64_t* size) {
+  *size = buffer_.size();
+  return true;
+}
+
+}  // namespace bsdiff

buffer_file.h

@@ -0,0 +1,41 @@
+// Copyright 2016 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef _BSDIFF_BUFFER_FILE_H_
+#define _BSDIFF_BUFFER_FILE_H_
+
+#include <memory>
+#include <vector>
+
+#include "file_interface.h"
+
+namespace bsdiff {
+
+class BufferFile : public FileInterface {
+ public:
+  // Creates a write only BufferFile based on the underlying |file| passed.
+  // The BufferFile will cache all the write in a buffer and write everything
+  // to |file| at once upon closing. Read and Seek are not supported.
+  // |size| should be the estimated total file size, it is used to reserve
+  // buffer space.
+  BufferFile(std::unique_ptr<FileInterface> file, size_t size);
+
+  ~BufferFile() override;
+
+  // FileInterface overrides.
+  bool Read(void* buf, size_t count, size_t* bytes_read) override;
+  bool Write(const void* buf, size_t count, size_t* bytes_written) override;
+  bool Seek(off_t pos) override;
+  bool Close() override;
+  bool GetSize(uint64_t* size) override;
+
+ private:
+  // The underlying FileInterace instance.
+  std::unique_ptr<FileInterface> file_ = nullptr;
+  std::vector<uint8_t> buffer_;
+};
+
+}  // namespace bsdiff
+
+#endif  // _BSDIFF_BUFFER_FILE_H_

memory_file.cc

@@ -4,45 +4,39 @@
 
 #include "memory_file.h"
 
-#include "bspatch.h"
+#include <algorithm>
+#include <string.h>
 
 namespace bsdiff {
 
-MemoryFile::MemoryFile(std::unique_ptr<FileInterface> file, size_t size)
-    : file_(std::move(file)) {
-  buffer_.reserve(size);
-}
-
-MemoryFile::~MemoryFile() {
-  Close();
-}
+MemoryFile::MemoryFile(const uint8_t* data, size_t size)
+    : data_(data), size_(size) {}
 
 bool MemoryFile::Read(void* buf, size_t count, size_t* bytes_read) {
-  return false;
-}
-
-bool MemoryFile::Write(const void* buf, size_t count, size_t* bytes_written) {
-  const uint8_t* data = static_cast<const uint8_t*>(buf);
-  buffer_.insert(buffer_.end(), data, data + count);
-  *bytes_written = count;
+  count = std::min(count, static_cast<size_t>(size_ - offset_));
+  memcpy(buf, data_ + offset_, count);
+  offset_ += count;
+  *bytes_read = count;
   return true;
 }
 
-bool MemoryFile::Seek(off_t pos) {
+bool MemoryFile::Write(const void* buf, size_t count, size_t* bytes_written) {
   return false;
 }
 
-bool MemoryFile::Close() {
-  if (!WriteAll(file_, buffer_.data(), buffer_.size()))
+bool MemoryFile::Seek(off_t pos) {
+  if (pos > static_cast<off_t>(size_) || pos < 0)
     return false;
-  // Prevent writing |buffer_| to |file_| again if Close() is called more than
-  // once.
-  buffer_.clear();
-  return file_->Close();
+  offset_ = pos;
+  return true;
+}
+
+bool MemoryFile::Close() {
+  return true;
 }
 
 bool MemoryFile::GetSize(uint64_t* size) {
-  *size = buffer_.size();
+  *size = size_;
   return true;
 }
 

memory_file.h

@@ -6,7 +6,6 @@
 #define _BSDIFF_MEMORY_FILE_H_
 
 #include <memory>
-#include <vector>
 
 #include "file_interface.h"
 
@@ -14,14 +13,12 @@ namespace bsdiff {
 
 class MemoryFile : public FileInterface {
  public:
-  // Creates a MemoryFile based on the underlying |file| passed. The MemoryFile
-  // will cache all the write in memory and write it to to |file| when it's
-  // closed. MemoryFile does not support read and seek.
-  // |size| should be the estimated total file size, it is used to reserve
-  // buffer space.
-  MemoryFile(std::unique_ptr<FileInterface> file, size_t size);
+  // Creates a read only MemoryFile based on the underlying |data| passed.
+  // The MemoryFile will use data starting from |data| with length of |size| as
+  // the file content. Write is not supported.
+  MemoryFile(const uint8_t* data, size_t size);
 
-  ~MemoryFile() override;
+  ~MemoryFile() = default;
 
   // FileInterface overrides.
   bool Read(void* buf, size_t count, size_t* bytes_read) override;
@@ -31,10 +28,9 @@ class MemoryFile : public FileInterface {
   bool GetSize(uint64_t* size) override;
 
  private:
-  // The underlying FileInterace instance.
-  std::unique_ptr<FileInterface> file_;
-
-  std::vector<uint8_t> buffer_;
+  const uint8_t* data_ = nullptr;
+  size_t size_ = 0;
+  off_t offset_ = 0;
 };
 
 }  // namespace bsdiff

sink_file.cc

@@ -0,0 +1,33 @@
+// Copyright 2016 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "sink_file.h"
+
+namespace bsdiff {
+
+SinkFile::SinkFile(const sink_func& sink)
+    : sink_(sink) {}
+
+bool SinkFile::Read(void* buf, size_t count, size_t* bytes_read) {
+  return false;
+}
+
+bool SinkFile::Write(const void* buf, size_t count, size_t* bytes_written) {
+  *bytes_written = sink_(static_cast<const uint8_t*>(buf), count);
+  return true;
+}
+
+bool SinkFile::Seek(off_t pos) {
+  return false;
+}
+
+bool SinkFile::Close() {
+  return true;
+}
+
+bool SinkFile::GetSize(uint64_t* size) {
+  return false;
+}
+
+}  // namespace bsdiff

sink_file.h

@@ -0,0 +1,41 @@
+// Copyright 2016 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef _BSDIFF_SINK_FILE_H_
+#define _BSDIFF_SINK_FILE_H_
+
+#include <stdint.h>
+
+#include <functional>
+
+#include "file_interface.h"
+
+using sink_func = std::function<size_t(const uint8_t*, size_t)>;
+
+namespace bsdiff {
+
+class SinkFile : public FileInterface {
+ public:
+  // Creates a SinkFile based on the underlying |sink| function passed.
+  // The SinkFile will call |sink| function upon write.
+  // Read, Seek and GetSize are not supported.
+  explicit SinkFile(const sink_func& sink);
+
+  ~SinkFile() = default;
+
+  // FileInterface overrides.
+  bool Read(void* buf, size_t count, size_t* bytes_read) override;
+  bool Write(const void* buf, size_t count, size_t* bytes_written) override;
+  bool Seek(off_t pos) override;
+  bool Close() override;
+  bool GetSize(uint64_t* size) override;
+
+ private:
+  // The sink() function used to write data.
+  const sink_func& sink_;
+};
+
+}  // namespace bsdiff
+
+#endif  // _BSDIFF_SINK_FILE_H_