Provide interface for in memory bspatch.
am: 716d569273
Change-Id: I5c89b2aa75e09e11e255303eb94ace9539e9ed1e
diff --git a/Android.mk b/Android.mk
index 12ee3e8..1073005 100644
--- a/Android.mk
+++ b/Android.mk
@@ -37,10 +37,12 @@
# "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_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_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)
diff --git a/Makefile b/Makefile
index fbfe56a..4214637 100644
--- a/Makefile
+++ b/Makefile
@@ -32,10 +32,12 @@
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 @@
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 @@
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
diff --git a/bspatch.cc b/bspatch.cc
index 550c6c7..693213a 100644
--- a/bspatch.cc
+++ b/bspatch.cc
@@ -46,15 +46,17 @@
#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,22 +81,28 @@
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,
+ 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))
+ if (!ReadBZ2(stream, buf, bytes_to_read))
return false;
if (!WriteAll(file, buf, bytes_to_read))
return false;
@@ -107,6 +115,18 @@
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) {
@@ -151,78 +171,23 @@
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];
+ std::unique_ptr<FileInterface> patch_file =
+ File::FOpen(patch_filename, O_RDONLY);
+ if (!patch_file)
+ err(1, "Error opening the patch filename %s", patch_filename);
+ uint64_t patch_size;
+ patch_file->GetSize(&patch_size);
+ std::vector<uint8_t> patch(patch_size);
+ if (!ReadAll(patch_file, patch.data(), patch_size))
+ errx(1, "Corrupt patch\n");
+ patch_file.reset();
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);
-
- // File format:
- // 0 8 "BSDIFF40"
- // 8 8 X
- // 16 8 Y
- // 24 8 sizeof(new_filename)
- // 32 X bzip2(control block)
- // 32+X Y bzip2(diff block)
- // 32+X+Y ??? bzip2(extra block)
- // with control block a set of triples (x,y,z) meaning "add x bytes
- // 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");
-
- // Read lengths from header.
- uint64_t oldsize, newsize;
- bzctrllen = ParseInt64(header + 8);
- bzdatalen = ParseInt64(header + 16);
- int64_t signed_newsize = ParseInt64(header + 24);
- newsize = signed_newsize;
- if ((bzctrllen < 0) || (bzdatalen < 0) || (signed_newsize < 0))
- errx(1, "Corrupt patch\n");
-
- // 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);
-
// 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");
+ err(1, "Error opening the old filename %s", old_filename);
std::vector<ex_t> parsed_old_extents;
if (using_extents) {
@@ -231,10 +196,6 @@
old_file.reset(new ExtentsFile(std::move(old_file), parsed_old_extents));
}
- 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);
@@ -251,10 +212,91 @@
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));
+ // 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);
+}
+
+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);
+}
+
+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"
+ // 8 8 X
+ // 16 8 Y
+ // 24 8 sizeof(new_filename)
+ // 32 X bzip2(control block)
+ // 32+X Y bzip2(diff block)
+ // 32+X+Y ??? bzip2(extra block)
+ // with control block a set of triples (x,y,z) meaning "add x bytes
+ // from oldfile to x bytes from the diff block; copy y bytes from the
+ // extra block; seek forwards in oldfile by z bytes".
+
+ // Check for appropriate magic.
+ if (memcmp(patch_data, "BSDIFF40", 8) != 0)
+ errx(1, "Corrupt patch\n");
+
+ // Read lengths from header.
+ uint64_t oldsize, newsize;
+ 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 ((ctrl_len < 0) || (data_len < 0) || (signed_newsize < 0) ||
+ (32 + ctrl_len + data_len > static_cast<int64_t>(patch_size)))
+ errx(1, "Corrupt patch\n");
+
+ 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)
+ errx(1, "failed to bzinit control stream (%d)\n", bz2err);
+
+ 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)
+ errx(1, "failed to bzinit diff stream (%d)\n", bz2err);
+
+ 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)
+ errx(1, "failed to bzinit extra stream (%d)\n", bz2err);
+
+ uint64_t old_file_pos = 0;
+
+ if (!old_file->GetSize(&oldsize))
+ err(1, "cannot obtain the size of old file");
+
// The oldpos can be negative, but the new pos is only incremented linearly.
int64_t oldpos = 0;
uint64_t newpos = 0;
@@ -263,7 +305,7 @@
int64_t i;
// Read control data.
for (i = 0; i <= 2; i++) {
- if (!ReadBZ2(cpfbz2, buf, 8))
+ if (!ReadBZ2(&cstream, buf, 8))
errx(1, "Corrupt patch\n");
ctrl[i] = ParseInt64(buf);
}
@@ -281,7 +323,7 @@
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(),
+ if (!ReadBZ2AndWriteAll(new_file, &dstream, -i, new_buf.data(),
new_buf.size()))
errx(1, "Error during ReadBZ2AndWriteAll()");
@@ -303,7 +345,7 @@
if (!read_bytes)
errx(1, "EOF reached while reading from input file");
// Read same amount of bytes from diff block
- if (!ReadBZ2(dpfbz2, new_buf.data(), read_bytes))
+ if (!ReadBZ2(&dstream, new_buf.data(), read_bytes))
errx(1, "Corrupt patch\n");
// new_buf already has data from diff block, adds old data to it.
for (size_t k = 0; k < read_bytes; k++)
@@ -320,7 +362,7 @@
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,
+ if (!ReadBZ2AndWriteAll(new_file, &dstream, oldpos - oldsize,
new_buf.data(), new_buf.size()))
errx(1, "Error during ReadBZ2AndWriteAll()");
}
@@ -330,7 +372,7 @@
errx(1, "Corrupt patch\n");
// Read extra block.
- if (!ReadBZ2AndWriteAll(new_file, epfbz2, ctrl[1], new_buf.data(),
+ if (!ReadBZ2AndWriteAll(new_file, &estream, ctrl[1], new_buf.data(),
new_buf.size()))
errx(1, "Error during ReadBZ2AndWriteAll()");
@@ -343,14 +385,12 @@
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);
+ err(1, "Error closing new file");
return 0;
}
diff --git a/bspatch.h b/bspatch.h
index 3de2874..2507879 100644
--- a/bspatch.h
+++ b/bspatch.h
@@ -5,6 +5,7 @@
#ifndef _BSDIFF_BSPATCH_H_
#define _BSDIFF_BSPATCH_H_
+#include <functional>
#include <memory>
#include <vector>
@@ -18,6 +19,17 @@
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);
diff --git a/buffer_file.cc b/buffer_file.cc
new file mode 100644
index 0000000..1e1c213
--- /dev/null
+++ b/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
diff --git a/buffer_file.h b/buffer_file.h
new file mode 100644
index 0000000..514225b
--- /dev/null
+++ b/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_
diff --git a/memory_file.cc b/memory_file.cc
index 59e2c7d..ec179b9 100644
--- a/memory_file.cc
+++ b/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;
}
diff --git a/memory_file.h b/memory_file.h
index 3e80b8a..2833649 100644
--- a/memory_file.h
+++ b/memory_file.h
@@ -6,7 +6,6 @@
#define _BSDIFF_MEMORY_FILE_H_
#include <memory>
-#include <vector>
#include "file_interface.h"
@@ -14,14 +13,12 @@
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 @@
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
diff --git a/sink_file.cc b/sink_file.cc
new file mode 100644
index 0000000..5cbd3bd
--- /dev/null
+++ b/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
diff --git a/sink_file.h b/sink_file.h
new file mode 100644
index 0000000..b2ce33f
--- /dev/null
+++ b/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_
