2 files changed, 185 insertions, 39 deletions

diff --git a/libsparse/include/sparse/sparse.h b/libsparse/include/sparse/sparse.h
index 1b91ead5c..3d5fb0c53 100644
--- a/libsparse/include/sparse/sparse.h
+++ b/libsparse/include/sparse/sparse.h
@@ -246,9 +246,24 @@ int sparse_file_foreach_chunk(struct sparse_file *s, bool sparse, bool crc,
 int sparse_file_read(struct sparse_file *s, int fd, bool sparse, bool crc);
 
 /**
- * sparse_file_import - import an existing sparse file
+ * sparse_file_read_buf - read a buffer into a sparse file cookie
  *
  * @s - sparse file cookie
+ * @buf - buffer to read from
+ * @crc - verify the crc of a file in the Android sparse file format
+ *
+ * Reads a buffer into a sparse file cookie. The buffer must remain
+ * valid until the sparse file cookie is freed. If crc is true, the
+ * crc of the sparse file will be verified.
+ *
+ * Returns 0 on success, negative errno on error.
+ */
+int sparse_file_read_buf(struct sparse_file *s, char *buf, bool crc);
+
+/**
+ * sparse_file_import - import an existing sparse file
+ *
+ * @fd - file descriptor to read from
  * @verbose - print verbose errors while reading the sparse file
  * @crc - verify the crc of a file in the Android sparse file format
  *
@@ -261,6 +276,21 @@ int sparse_file_read(struct sparse_file *s, int fd, bool sparse, bool crc);
 struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc);
 
 /**
+ * sparse_file_import_buf - import an existing sparse file from a buffer
+ *
+ * @buf - buffer to read from
+ * @verbose - print verbose errors while reading the sparse file
+ * @crc - verify the crc of a file in the Android sparse file format
+ *
+ * Reads existing sparse file data into a sparse file cookie, recreating the same
+ * sparse cookie that was used to write it.  If verbose is true, prints verbose
+ * errors when the sparse file is formatted incorrectly.
+ *
+ * Returns a new sparse file cookie on success, NULL on error.
+ */
+struct sparse_file *sparse_file_import_buf(char* buf, bool verbose, bool crc);
+
+/**
  * sparse_file_import_auto - import an existing sparse or normal file
  *
  * @fd - file descriptor to read from
diff --git a/libsparse/sparse_read.cpp b/libsparse/sparse_read.cpp
index 437963527..d6a68b3c7 100644
--- a/libsparse/sparse_read.cpp
+++ b/libsparse/sparse_read.cpp
@@ -58,6 +58,114 @@ static std::string ErrorString(int err)
         return android::base::StringPrintf("Unknown error %d", err);
 }
 
+class SparseFileSource {
+public:
+        /* Seeks the source ahead by the given offset. */
+        virtual void Seek(int64_t offset) = 0;
+
+        /* Return the current offset. */
+        virtual int64_t GetOffset() = 0;
+
+        /* Set the current offset. Return 0 if successful. */
+        virtual int SetOffset(int64_t offset) = 0;
+
+        /* Adds the given length from the current offset of the source to the file at the given
+         * block. Return 0 if successful. */
+        virtual int AddToSparseFile(struct sparse_file *s, int64_t len, unsigned int block) = 0;
+
+        /* Get data of fixed size from the current offset and seek len bytes.
+         * Return 0 if successful. */
+        virtual int ReadValue(void *ptr, int len) = 0;
+
+        /* Find the crc32 of the next len bytes and seek ahead len bytes. Return 0 if successful. */
+        virtual int GetCrc32(uint32_t *crc32, int64_t len) = 0;
+
+        virtual ~SparseFileSource() {};
+};
+
+class SparseFileFdSource : public SparseFileSource {
+private:
+        int fd;
+public:
+        SparseFileFdSource(int fd) : fd(fd) {}
+        ~SparseFileFdSource() override {}
+
+        void Seek(int64_t off) override {
+                lseek64(fd, off, SEEK_CUR);
+        }
+
+        int64_t GetOffset() override {
+                return lseek64(fd, 0, SEEK_CUR);
+        }
+
+        int SetOffset(int64_t offset) override {
+                return lseek64(fd, offset, SEEK_SET) == offset ? 0 : -errno;
+        }
+
+        int AddToSparseFile(struct sparse_file *s, int64_t len, unsigned int block) override {
+                return sparse_file_add_fd(s, fd, GetOffset(), len, block);
+        }
+
+        int ReadValue(void *ptr, int len) override {
+                return read_all(fd, ptr, len);
+        }
+
+        int GetCrc32(uint32_t *crc32, int64_t len) override {
+                int chunk;
+                int ret;
+                while (len) {
+                        chunk = std::min(len, COPY_BUF_SIZE);
+                        ret = read_all(fd, copybuf, chunk);
+                        if (ret < 0) {
+                                return ret;
+                        }
+                        *crc32 = sparse_crc32(*crc32, copybuf, chunk);
+                        len -= chunk;
+                }
+                return 0;
+        }
+};
+
+class SparseFileBufSource : public SparseFileSource {
+private:
+        char *buf;
+        int64_t offset;
+public:
+        SparseFileBufSource(char *buf) : buf(buf), offset(0) {}
+        ~SparseFileBufSource() override {}
+
+        void Seek(int64_t off) override {
+                buf += off;
+                offset += off;
+        }
+
+        int64_t GetOffset() override {
+                return offset;
+        }
+
+        int SetOffset(int64_t off) override {
+                buf += off - offset;
+                offset = off;
+                return 0;
+        }
+
+        int AddToSparseFile(struct sparse_file *s, int64_t len, unsigned int block) override {
+                return sparse_file_add_data(s, buf, len, block);
+        }
+
+        int ReadValue(void *ptr, int len) override {
+                memcpy(ptr, buf, len);
+                Seek(len);
+                return 0;
+        }
+
+        int GetCrc32(uint32_t *crc32, int64_t len) override {
+                *crc32 = sparse_crc32(*crc32, buf, len);
+                Seek(len);
+                return 0;
+        }
+};
+
 static void verbose_error(bool verbose, int err, const char *fmt, ...)
 {
         if (!verbose) return;
@@ -74,11 +182,10 @@ static void verbose_error(bool verbose, int err, const char *fmt, ...)
 }
 
 static int process_raw_chunk(struct sparse_file *s, unsigned int chunk_size,
-                int fd, int64_t offset, unsigned int blocks, unsigned int block,
+                SparseFileSource *source, unsigned int blocks, unsigned int block,
                 uint32_t *crc32)
 {
         int ret;
-        int chunk;
         int64_t len = blocks * s->block_size;
 
         if (chunk_size % s->block_size != 0) {
@@ -89,30 +196,25 @@ static int process_raw_chunk(struct sparse_file *s, unsigned int chunk_size,
                 return -EINVAL;
         }
 
-        ret = sparse_file_add_fd(s, fd, offset, len, block);
+        ret = source->AddToSparseFile(s, len, block);
         if (ret < 0) {
                 return ret;
         }
 
         if (crc32) {
-                while (len) {
-                        chunk = std::min(len, COPY_BUF_SIZE);
-                        ret = read_all(fd, copybuf, chunk);
-                        if (ret < 0) {
-                                return ret;
-                        }
-                        *crc32 = sparse_crc32(*crc32, copybuf, chunk);
-                        len -= chunk;
+                ret = source->GetCrc32(crc32, len);
+                if (ret < 0) {
+                        return ret;
                 }
         } else {
-                lseek64(fd, len, SEEK_CUR);
+                source->Seek(len);
         }
 
         return 0;
 }
 
 static int process_fill_chunk(struct sparse_file *s, unsigned int chunk_size,
-                int fd, unsigned int blocks, unsigned int block, uint32_t *crc32)
+                SparseFileSource *source, unsigned int blocks, unsigned int block, uint32_t *crc32)
 {
         int ret;
         int chunk;
@@ -125,7 +227,7 @@ static int process_fill_chunk(struct sparse_file *s, unsigned int chunk_size,
                 return -EINVAL;
         }
 
-        ret = read_all(fd, &fill_val, sizeof(fill_val));
+        ret = source->ReadValue(&fill_val, sizeof(fill_val));
         if (ret < 0) {
                 return ret;
         }
@@ -153,7 +255,7 @@ static int process_fill_chunk(struct sparse_file *s, unsigned int chunk_size,
 }
 
 static int process_skip_chunk(struct sparse_file *s, unsigned int chunk_size,
-                int fd __unused, unsigned int blocks,
+                SparseFileSource *source __unused, unsigned int blocks,
                 unsigned int block __unused, uint32_t *crc32)
 {
         if (chunk_size != 0) {
@@ -161,7 +263,7 @@ static int process_skip_chunk(struct sparse_file *s, unsigned int chunk_size,
         }
 
         if (crc32) {
-                int64_t len = (int64_t)blocks * s->block_size;
+                int64_t len = (int64_t)blocks * s->block_size;
                 memset(copybuf, 0, COPY_BUF_SIZE);
 
                 while (len) {
@@ -174,16 +276,15 @@ static int process_skip_chunk(struct sparse_file *s, unsigned int chunk_size,
         return 0;
 }
 
-static int process_crc32_chunk(int fd, unsigned int chunk_size, uint32_t *crc32)
+static int process_crc32_chunk(SparseFileSource *source, unsigned int chunk_size, uint32_t *crc32)
 {
         uint32_t file_crc32;
-        int ret;
 
         if (chunk_size != sizeof(file_crc32)) {
                 return -EINVAL;
         }
 
-        ret = read_all(fd, &file_crc32, sizeof(file_crc32));
+        int ret = source->ReadValue(&file_crc32, sizeof(file_crc32));
         if (ret < 0) {
                 return ret;
         }
@@ -195,18 +296,19 @@ static int process_crc32_chunk(int fd, unsigned int chunk_size, uint32_t *crc32)
         return 0;
 }
 
-static int process_chunk(struct sparse_file *s, int fd, off64_t offset,
+static int process_chunk(struct sparse_file *s, SparseFileSource *source,
                 unsigned int chunk_hdr_sz, chunk_header_t *chunk_header,
                 unsigned int cur_block, uint32_t *crc_ptr)
 {
         int ret;
         unsigned int chunk_data_size;
+        int64_t offset = source->GetOffset();
 
         chunk_data_size = chunk_header->total_sz - chunk_hdr_sz;
 
         switch (chunk_header->chunk_type) {
                 case CHUNK_TYPE_RAW:
-                        ret = process_raw_chunk(s, chunk_data_size, fd, offset,
+                        ret = process_raw_chunk(s, chunk_data_size, source,
                                         chunk_header->chunk_sz, cur_block, crc_ptr);
                         if (ret < 0) {
                                 verbose_error(s->verbose, ret, "data block at %" PRId64, offset);
@@ -214,7 +316,7 @@ static int process_chunk(struct sparse_file *s, int fd, off64_t offset,
                         }
                         return chunk_header->chunk_sz;
                 case CHUNK_TYPE_FILL:
-                        ret = process_fill_chunk(s, chunk_data_size, fd,
+                        ret = process_fill_chunk(s, chunk_data_size, source,
                                         chunk_header->chunk_sz, cur_block, crc_ptr);
                         if (ret < 0) {
                                 verbose_error(s->verbose, ret, "fill block at %" PRId64, offset);
@@ -222,7 +324,7 @@ static int process_chunk(struct sparse_file *s, int fd, off64_t offset,
                         }
                         return chunk_header->chunk_sz;
                 case CHUNK_TYPE_DONT_CARE:
-                        ret = process_skip_chunk(s, chunk_data_size, fd,
+                        ret = process_skip_chunk(s, chunk_data_size, source,
                                         chunk_header->chunk_sz, cur_block, crc_ptr);
                         if (chunk_data_size != 0) {
                                 if (ret < 0) {
@@ -232,7 +334,7 @@ static int process_chunk(struct sparse_file *s, int fd, off64_t offset,
                         }
                         return chunk_header->chunk_sz;
                 case CHUNK_TYPE_CRC32:
-                        ret = process_crc32_chunk(fd, chunk_data_size, crc_ptr);
+                        ret = process_crc32_chunk(source, chunk_data_size, crc_ptr);
                         if (ret < 0) {
                                 verbose_error(s->verbose, -EINVAL, "crc block at %" PRId64,
                                                 offset);
@@ -247,7 +349,7 @@ static int process_chunk(struct sparse_file *s, int fd, off64_t offset,
         return 0;
 }
 
-static int sparse_file_read_sparse(struct sparse_file *s, int fd, bool crc)
+static int sparse_file_read_sparse(struct sparse_file *s, SparseFileSource *source, bool crc)
 {
         int ret;
         unsigned int i;
@@ -256,7 +358,6 @@ static int sparse_file_read_sparse(struct sparse_file *s, int fd, bool crc)
         uint32_t crc32 = 0;
         uint32_t *crc_ptr = 0;
         unsigned int cur_block = 0;
-        off64_t offset;
 
         if (!copybuf) {
                 copybuf = (char *)malloc(COPY_BUF_SIZE);
@@ -270,7 +371,7 @@ static int sparse_file_read_sparse(struct sparse_file *s, int fd, bool crc)
                 crc_ptr = &crc32;
         }
 
-        ret = read_all(fd, &sparse_header, sizeof(sparse_header));
+        ret = source->ReadValue(&sparse_header, sizeof(sparse_header));
         if (ret < 0) {
                 return ret;
         }
@@ -295,11 +396,11 @@ static int sparse_file_read_sparse(struct sparse_file *s, int fd, bool crc)
                 /* Skip the remaining bytes in a header that is longer than
                  * we expected.
                  */
-                lseek64(fd, sparse_header.file_hdr_sz - SPARSE_HEADER_LEN, SEEK_CUR);
+                source->Seek(sparse_header.file_hdr_sz - SPARSE_HEADER_LEN);
         }
 
         for (i = 0; i < sparse_header.total_chunks; i++) {
-                ret = read_all(fd, &chunk_header, sizeof(chunk_header));
+                ret = source->ReadValue(&chunk_header, sizeof(chunk_header));
                 if (ret < 0) {
                         return ret;
                 }
@@ -308,12 +409,10 @@ static int sparse_file_read_sparse(struct sparse_file *s, int fd, bool crc)
                         /* Skip the remaining bytes in a header that is longer than
                          * we expected.
                          */
-                        lseek64(fd, sparse_header.chunk_hdr_sz - CHUNK_HEADER_LEN, SEEK_CUR);
+                        source->Seek(sparse_header.chunk_hdr_sz - CHUNK_HEADER_LEN);
                 }
 
-                offset = lseek64(fd, 0, SEEK_CUR);
-
-                ret = process_chunk(s, fd, offset, sparse_header.chunk_hdr_sz, &chunk_header,
+                ret = process_chunk(s, source, sparse_header.chunk_hdr_sz, &chunk_header,
                                 cur_block, crc_ptr);
                 if (ret < 0) {
                         return ret;
@@ -388,20 +487,27 @@ int sparse_file_read(struct sparse_file *s, int fd, bool sparse, bool crc)
         }
 
         if (sparse) {
-                return sparse_file_read_sparse(s, fd, crc);
+                SparseFileFdSource source(fd);
+                return sparse_file_read_sparse(s, &source, crc);
         } else {
                 return sparse_file_read_normal(s, fd);
         }
 }
 
-struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc)
+int sparse_file_read_buf(struct sparse_file *s, char *buf, bool crc)
+{
+        SparseFileBufSource source(buf);
+        return sparse_file_read_sparse(s, &source, crc);
+}
+
+static struct sparse_file *sparse_file_import_source(SparseFileSource *source, bool verbose, bool crc)
 {
         int ret;
         sparse_header_t sparse_header;
         int64_t len;
         struct sparse_file *s;
 
-        ret = read_all(fd, &sparse_header, sizeof(sparse_header));
+        ret = source->ReadValue(&sparse_header, sizeof(sparse_header));
         if (ret < 0) {
                 verbose_error(verbose, ret, "header");
                 return NULL;
@@ -432,7 +538,7 @@ struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc)
                 return NULL;
         }
 
-        ret = lseek64(fd, 0, SEEK_SET);
+        ret = source->SetOffset(0);
         if (ret < 0) {
                 verbose_error(verbose, ret, "seeking");
                 sparse_file_destroy(s);
@@ -441,7 +547,7 @@ struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc)
 
         s->verbose = verbose;
 
-        ret = sparse_file_read(s, fd, true, crc);
+        ret = sparse_file_read_sparse(s, source, crc);
         if (ret < 0) {
                 sparse_file_destroy(s);
                 return NULL;
@@ -450,6 +556,16 @@ struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc)
         return s;
 }
 
+struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc) {
+        SparseFileFdSource source(fd);
+        return sparse_file_import_source(&source, verbose, crc);
+}
+
+struct sparse_file *sparse_file_import_buf(char* buf, bool verbose, bool crc) {
+        SparseFileBufSource source(buf);
+        return sparse_file_import_source(&source, verbose, crc);
+}
+
 struct sparse_file *sparse_file_import_auto(int fd, bool crc, bool verbose)
 {
         struct sparse_file *s;