file_iterator: implement a _copy() function

This function creates a copy of the iterator that has the same state as
the original iterator.

common/include/sqsh_reader_private.h

@@ -140,6 +140,20 @@ SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__reader_init(
 		struct SqshReader *reader,
 		const struct SqshReaderIteratorImpl *iterator_impl, void *iterator);
 
+/**
+ * @internal
+ * @memberof SqshReader
+ * @brief Creates a copy of an extractor reader.
+ *
+ * @param[out] target The reader to copy to.
+ * @param[in]  source The reader to copy from.
+ *
+ * @return 0 on success, a negative value on error.
+ */
+SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__reader_copy(
+		struct SqshReader *target, const struct SqshReader *source,
+		void *copied_iterator);
+
 /**
  * @internal
  * @memberof SqshReader

common/src/reader/reader.c

@@ -65,6 +65,49 @@ sqsh__reader_init(
 	return cx_buffer_init(&reader->buffer);
 }
 
+int
+sqsh__reader_copy(
+		struct SqshReader *target, const struct SqshReader *source,
+		void *copied_iterator) {
+	int rv = 0;
+
+	target->iterator = copied_iterator;
+	target->iterator_impl = source->iterator_impl;
+	target->iterator_offset = source->iterator_offset;
+	target->offset = source->offset;
+	const uint8_t *buffer_data = cx_buffer_data(&source->buffer);
+	const size_t buffer_size = cx_buffer_size(&source->buffer);
+	rv = cx_buffer_init(&target->buffer);
+	if (rv < 0) {
+		goto out;
+	}
+	rv = cx_buffer_append(
+			&target->buffer, cx_buffer_data(&source->buffer),
+			cx_buffer_size(&source->buffer));
+	if (rv < 0) {
+		goto out;
+	}
+	buffer_data = cx_buffer_data(&target->buffer);
+	const uint8_t *iterator_data = target->iterator_impl->data(copied_iterator);
+	const size_t iterator_size = target->iterator_impl->size(copied_iterator);
+	const uint8_t *data = source->data;
+
+	if (data == NULL) {
+		target->data = NULL;
+	} else if (data >= buffer_data && data < buffer_data + buffer_size) {
+		target->data = &buffer_data[data - buffer_data];
+	} else if (data >= iterator_data && data < iterator_data + iterator_size) {
+		target->data = &iterator_data[data - iterator_data];
+	} else {
+		rv = -SQSH_ERROR_INTERNAL;
+		goto out;
+	}
+	target->size = source->size;
+
+out:
+	return rv;
+}
+
 /**
  * @brief copies data from the iterator to the buffer until the buffer
  * reaches the desired size.

libsqsh/include/sqsh_extract_private.h

@@ -176,10 +176,10 @@ struct SqshExtractManager {
 	/**
 	 * @privatesection
 	 */
-	struct CxRcRadixTree cache;
 	const struct SqshExtractorImpl *extractor_impl;
-	uint32_t block_size;
 	struct SqshMapManager *map_manager;
+	struct CxRcRadixTree cache;
+	uint32_t block_size;
 	struct CxLru lru;
 	sqsh__mutex_t lock;
 };
@@ -215,6 +215,19 @@ SQSH_NO_EXPORT int sqsh__extract_manager_uncompress(
 		struct SqshExtractManager *manager, const struct SqshMapReader *reader,
 		const struct CxBuffer **target);
 
+/**
+ * @internal
+ * @memberof SqshExtractManager
+ * @brief Retains a buffer retrieved by sqsh__extract_manager_uncompress.
+ *
+ * @param[in]     manager     The manager to use.
+ * @param[out]    buffer      The buffer that needs to be retained
+ *
+ * @return 0 on success, a negative value on error.
+ */
+SQSH_NO_EXPORT int sqsh__extract_manager_retain_buffer(
+		struct SqshExtractManager *manager, const struct CxBuffer *buffer);
+
 /**
  * @internal
  * @memberof SqshExtractManager
@@ -272,6 +285,18 @@ SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__extract_view_init(
 		struct SqshExtractView *view, struct SqshExtractManager *manager,
 		const struct SqshMapReader *reader);
 
+/**
+ * @internal
+ * @memberof SqshExtractView
+ * @brief Creates a copy of an extractor view.
+ *
+ * @param[out] target The view to copy to.
+ * @param[in]  source The view to copy from.
+ *
+ * @return 0 on success, a negative value on error.
+ */
+SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__extract_view_copy(
+		struct SqshExtractView *target, const struct SqshExtractView *source);
 /**
  * @internal
  * @memberof SqshExtractView

libsqsh/include/sqsh_file_private.h

@@ -81,6 +81,19 @@ single file.
 SQSH_NO_EXPORT int sqsh__fragment_view_init(
 		struct SqshFragmentView *view, const struct SqshFile *file);
 
+/**
+ * @internal
+ * @memberof SqshFragmentView
+ * @brief Creates a copy of an fragment view.
+ *
+ * @param[out] target The view to copy to.
+ * @param[in]  source The view to copy from.
+ *
+ * @return 0 on success, a negative value on error.
+ */
+SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__fragment_view_copy(
+		struct SqshFragmentView *target, const struct SqshFragmentView *source);
+
 /**
  * @internal
  * @memberof SqshFragmentView
@@ -270,6 +283,9 @@ struct SqshFile {
 SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__file_init(
 		struct SqshFile *context, struct SqshArchive *sqsh, uint64_t inode_ref);
 
+SQSH_NO_EXPORT SQSH_NO_UNUSED int
+sqsh__file_copy(struct SqshFile *context, const struct SqshFile *other);
+
 /**
  * @memberof SqshFile
  * @brief sets the parent inode reference.

libsqsh/include/sqsh_mapper_private.h

@@ -266,12 +266,12 @@ struct SqshMapIterator {
 	/**
 	 * @privatesection
 	 */
-	sqsh_index_t next_index;
-	uint64_t segment_count;
 	struct SqshMapManager *map_manager;
 	const struct SqshMapSlice *mapping;
 	const uint8_t *data;
 	size_t size;
+	sqsh_index_t next_index;
+	uint64_t segment_count;
 };
 
 /**
@@ -288,6 +288,19 @@ SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__map_iterator_init(
 		struct SqshMapIterator *iterator, struct SqshMapManager *manager,
 		uint64_t address);
 
+/**
+ * @internal
+ * @memberof SqshMapIterator
+ * @brief Copies the content of a iterator to another iterator
+ *
+ * @param target The iterator to copy to
+ * @param source The iterator to copy from
+ *
+ * @return 0 on success, negative on error
+ */
+SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__map_iterator_copy(
+		struct SqshMapIterator *target, const struct SqshMapIterator *source);
+
 /**
  * @internal
  * @memberof SqshMapIterator
@@ -394,6 +407,19 @@ SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__map_reader_init(
 		struct SqshMapReader *reader, struct SqshMapManager *mapper,
 		const uint64_t start_address, uint64_t upper_limit);
 
+/**
+ * @internal
+ * @memberof SqshMapReader
+ * @brief Copies the content of a reader to another reader
+ *
+ * @param target The reader to copy to
+ * @param source The reader to copy from
+ *
+ * @return 0 on success, negative on error
+ */
+SQSH_NO_EXPORT SQSH_NO_UNUSED int sqsh__map_reader_copy(
+		struct SqshMapReader *target, const struct SqshMapReader *source);
+
 /**
  * @internal
  * @memberof SqshMapReader

libsqsh/src/extract/extract_manager.c

@@ -172,6 +172,13 @@ sqsh__extract_manager_uncompress(
 	return rv;
 }
 
+int
+sqsh__extract_manager_retain_buffer(
+		struct SqshExtractManager *manager, const struct CxBuffer *buffer) {
+	cx_rc_radix_tree_retain_value(&manager->cache, (void *)buffer);
+	return 0;
+}
+
 int
 sqsh__extract_manager_release(
 		struct SqshExtractManager *manager, uint64_t address) {

libsqsh/src/extract/extract_view.c

@@ -59,6 +59,28 @@ sqsh__extract_view_init(
 	return rv;
 }
 
+int
+sqsh__extract_view_copy(
+		struct SqshExtractView *target, const struct SqshExtractView *source) {
+	int rv = 0;
+
+	target->manager = source->manager;
+	if (source->buffer) {
+		rv = sqsh__extract_manager_retain_buffer(
+				source->manager, source->buffer);
+		if (rv < 0) {
+			goto out;
+		}
+	}
+	target->buffer = source->buffer;
+	target->size = source->size;
+out:
+	if (rv < 0) {
+		sqsh__extract_view_cleanup(target);
+	}
+	return rv;
+}
+
 const uint8_t *
 sqsh__extract_view_data(const struct SqshExtractView *view) {
 	return cx_buffer_data(view->buffer);

libsqsh/src/file/file_iterator.c

@@ -90,6 +90,38 @@ sqsh__file_iterator_init(
 	return rv;
 }
 
+int
+sqsh__file_iterator_copy(
+		struct SqshFileIterator *target,
+		const struct SqshFileIterator *source) {
+	int rv = 0;
+	target->file = source->file;
+	target->compression_manager = source->compression_manager;
+	rv = sqsh__map_reader_copy(&target->map_reader, &source->map_reader);
+	if (rv < 0) {
+		goto out;
+	}
+	rv = sqsh__extract_view_copy(&target->extract_view, &source->extract_view);
+	if (rv < 0) {
+		goto out;
+	}
+	rv = sqsh__fragment_view_copy(
+			&target->fragment_view, &source->fragment_view);
+	if (rv < 0) {
+		goto out;
+	}
+	target->sparse_size = source->sparse_size;
+	target->block_size = source->block_size;
+	target->block_index = source->block_index;
+	target->data = source->data;
+	target->size = source->size;
+out:
+	if (rv < 0) {
+		sqsh__file_iterator_cleanup(target);
+	}
+	return rv;
+}
+
 struct SqshFileIterator *
 sqsh_file_iterator_new(const struct SqshFile *file, int *err) {
 	SQSH_NEW_IMPL(sqsh__file_iterator_init, struct SqshFileIterator, file);

libsqsh/src/file/fragment_view.c

@@ -38,6 +38,7 @@
 #include <sqsh_archive_private.h>
 #include <sqsh_common_private.h>
 #include <sqsh_error.h>
+#include <sys/types.h>
 
 static int
 apply_fragment(
@@ -156,6 +157,47 @@ sqsh__fragment_view_init(
 	return rv;
 }
 
+int
+sqsh__fragment_view_copy(
+		struct SqshFragmentView *target,
+		const struct SqshFragmentView *source) {
+	int rv = 0;
+	target->fragment_table = source->fragment_table;
+	rv = sqsh__map_reader_copy(&target->map_reader, &source->map_reader);
+	if (rv < 0) {
+		goto out;
+	}
+	rv = sqsh__extract_view_copy(&target->extract_view, &source->extract_view);
+	if (rv < 0) {
+		goto out;
+	}
+	const uint8_t *map_data = sqsh__map_reader_data(&target->map_reader);
+	size_t map_size = sqsh__map_reader_size(&target->map_reader);
+	const uint8_t *extract_data =
+			sqsh__extract_view_data(&target->extract_view);
+	size_t extract_size = sqsh__extract_view_size(&target->extract_view);
+
+	// Check if the data field is within the map or extract data
+	// and adjust the pointer accordingly
+	if (source->data >= map_data &&
+		(size_t)(source->data - map_data) < map_size) {
+		target->data = &map_data[source->data - map_data];
+	} else if (
+			source->data >= extract_data &&
+			(size_t)(source->data - extract_data) < extract_size) {
+		target->data = &extract_data[source->data - extract_data];
+	} else {
+		rv = -SQSH_ERROR_INVALID_ARGUMENT;
+		goto out;
+	}
+	target->size = source->size;
+out:
+	if (rv < 0) {
+		sqsh__fragment_view_cleanup(target);
+	}
+	return rv;
+}
+
 const uint8_t *
 sqsh__fragment_view_data(const struct SqshFragmentView *view) {
 	return view->data;

libsqsh/src/mapper/map_iterator.c

@@ -68,6 +68,31 @@ sqsh__map_iterator_init(
 	return 0;
 }
 
+int
+sqsh__map_iterator_copy(
+		struct SqshMapIterator *target, const struct SqshMapIterator *source) {
+	int rv = 0;
+	target->map_manager = source->map_manager;
+	// TODO
+	// rv = sqsh__map_slice_copy(target->mapping, source->mapping);
+	if (rv < 0) {
+		goto out;
+	}
+	target->mapping = NULL;
+	target->next_index = source->next_index;
+	target->segment_count = source->segment_count;
+	if (source->data != NULL) {
+		target->data = sqsh__map_slice_data(source->mapping);
+		target->size = sqsh__map_slice_size(source->mapping);
+	} else {
+		target->data = NULL;
+		target->size = 0;
+	}
+
+out:
+	return rv;
+}
+
 int
 sqsh__map_iterator_skip(struct SqshMapIterator *iterator, uint64_t *offset) {
 	int rv = 0;