X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=include%2Fwimlib%2Fapply.h;h=54850feccc1f486ac9eb46d8e2a12ce270e04371;hp=becef7acfd23cfbf9ed97e7801ecf2d5423e61d7;hb=944ca027b829261f33af8577fd8fe2afdc4d02b7;hpb=b6f6a919c8291da9cf2a9ea72ec7f8e47fbd79cf

diff --git a/include/wimlib/apply.h b/include/wimlib/apply.h
index becef7ac..54850fec 100644
--- a/include/wimlib/apply.h
+++ b/include/wimlib/apply.h
@@ -1,102 +1,258 @@
 #ifndef _WIMLIB_APPLY_H
 #define _WIMLIB_APPLY_H
 
-#include "wimlib.h"
+#include "wimlib/compiler.h"
+#include "wimlib/file_io.h"
+#include "wimlib/list.h"
+#include "wimlib/progress.h"
 #include "wimlib/types.h"
+#include "wimlib.h"
 
-#ifdef WITH_NTFS_3G
-struct _ntfs_volume;
-#endif
+/* These can be treated as counts (for required_features) or booleans (for
+ * supported_features).  */
+struct wim_features {
+	unsigned long archive_files;
+	unsigned long hidden_files;
+	unsigned long system_files;
+	unsigned long compressed_files;
+	unsigned long encrypted_files;
+	unsigned long encrypted_directories;
+	unsigned long not_context_indexed_files;
+	unsigned long sparse_files;
+	unsigned long named_data_streams;
+	unsigned long hard_links;
+	unsigned long reparse_points;
+	unsigned long symlink_reparse_points;
+	unsigned long other_reparse_points;
+	unsigned long security_descriptors;
+	unsigned long short_names;
+	unsigned long unix_data;
+	unsigned long timestamps;
+	unsigned long case_sensitive_filenames;
+};
 
-struct apply_args {
-	WIMStruct *w;
+struct wim_lookup_table_entry;
+struct read_stream_list_callbacks;
+struct apply_operations;
+struct wim_dentry;
 
-	/* Directory to which we're extracting the WIM image or directory tree,
-	 * in user-specified form (may be slightly altered) */
-	const tchar *target;
-	unsigned target_nchars;
+struct apply_ctx {
+	/* The WIMStruct from which files are being extracted from the currently
+	 * selected image.  */
+	WIMStruct *wim;
 
-#ifdef __WIN32__
-	/* \\?\-prefixed full path to the above directory; needed to work around
-	 * lack of default support for long paths on Windoze. */
-	tchar *target_lowlevel_path;
-	unsigned target_lowlevel_path_nchars;
-#endif
+	/* The target of the extraction, usually the path to a directory.  */
+	const tchar *target;
 
-	/* Absolute path to the above directory; on UNIX this is simply a path
-	 * beginning with /, while on Windoze this will be a path beginning with
-	 * a drive letter followed by a backslash, but not with \\?\. */
-	tchar *target_realpath;
-	unsigned target_realpath_len;
+	/* Length of @target in tchars.  */
+	size_t target_nchars;
 
-	struct wim_dentry *extract_root;
-	unsigned long invalid_sequence;
+	/* Extraction flags (WIMLIB_EXTRACT_FLAG_*)  */
 	int extract_flags;
+
+	/* User-provided progress function, or NULL if not specified.  */
+	wimlib_progress_func_t progfunc;
+	void *progctx;
+
+	/* Progress data buffer, with progress.extract initialized.  */
 	union wimlib_progress_info progress;
-	wimlib_progress_func_t progress_func;
-	int (*apply_dentry)(struct wim_dentry *, void *);
-	union {
-	#ifdef WITH_NTFS_3G
-		struct {
-			/* NTFS apply only */
-			struct _ntfs_volume *vol;
-		};
-	#endif
-	#ifdef __WIN32__
-		struct {
-			/* Normal apply only (Win32) */
-			unsigned long num_set_sacl_priv_notheld;
-			unsigned long num_set_sd_access_denied;
-			unsigned vol_flags;
-			unsigned long num_hard_links_failed;
-			unsigned long num_soft_links_failed;
-			unsigned long num_long_paths;
-			bool have_vol_flags;
-		};
-	#else
-		struct {
-			/* Normal apply only (UNIX) */
-			unsigned long num_utime_warnings;
-		};
-	#endif
-	};
+
+	/* Features required to extract the files (with counts)  */
+	struct wim_features required_features;
+
+	/* Features supported by the extraction mode (with booleans)  */
+	struct wim_features supported_features;
+
+	/* The members below should not be used outside of extract.c  */
+	const struct apply_operations *apply_ops;
+	u64 next_progress;
+	unsigned long invalid_sequence;
+	unsigned long num_streams_remaining;
+	struct list_head stream_list;
+	const struct read_stream_list_callbacks *saved_cbs;
+	struct wim_lookup_table_entry *cur_stream;
+	u64 cur_stream_offset;
+	struct filedes tmpfile_fd;
+	tchar *tmpfile_name;
+	unsigned int count_until_file_progress;
 };
 
-#ifdef WITH_NTFS_3G
+/* Maximum number of UNIX file descriptors, NTFS attributes, or Windows file
+ * handles that can be opened simultaneously to extract a single-instance
+ * stream to multiple destinations.  */
+#define MAX_OPEN_STREAMS 512
+
+static inline int
+extract_progress(struct apply_ctx *ctx, enum wimlib_progress_msg msg)
+{
+	return call_progress(ctx->progfunc, msg, &ctx->progress, ctx->progctx);
+}
+
 extern int
-apply_dentry_ntfs(struct wim_dentry *dentry, void *arg);
+do_file_extract_progress(struct apply_ctx *ctx, enum wimlib_progress_msg msg);
+
+#define COUNT_PER_FILE_PROGRESS 256
+
+static inline int
+maybe_do_file_progress(struct apply_ctx *ctx, enum wimlib_progress_msg msg)
+{
+	ctx->progress.extract.current_file_count++;
+	if (unlikely(!--ctx->count_until_file_progress))
+		return do_file_extract_progress(ctx, msg);
+	return 0;
+}
 
 extern int
-apply_dentry_timestamps_ntfs(struct wim_dentry *dentry, void *arg);
-#endif
+start_file_structure_phase(struct apply_ctx *ctx, uint64_t end_file_count);
 
-#ifdef __WIN32__
 extern int
-win32_do_apply_dentry(const tchar *output_path,
-		      size_t output_path_nbytes,
-		      struct wim_dentry *dentry,
-		      struct apply_args *args);
+start_file_metadata_phase(struct apply_ctx *ctx, uint64_t end_file_count);
+
+/* Report that a file was created, prior to stream extraction.  */
+static inline int
+report_file_created(struct apply_ctx *ctx)
+{
+	return maybe_do_file_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE);
+}
+
+/* Report that file metadata was applied, after stream extraction.  */
+static inline int
+report_file_metadata_applied(struct apply_ctx *ctx)
+{
+	return maybe_do_file_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_METADATA);
+}
 
 extern int
-win32_do_apply_dentry_timestamps(const tchar *output_path,
-				 size_t output_path_nbytes,
-				 struct wim_dentry *dentry,
-				 struct apply_args *args);
-#else /* __WIN32__ */
+end_file_structure_phase(struct apply_ctx *ctx);
+
 extern int
-unix_do_apply_dentry(const tchar *output_path, size_t output_path_nbytes,
-		     struct wim_dentry *dentry, struct apply_args *args);
+end_file_metadata_phase(struct apply_ctx *ctx);
+
+static inline int
+report_apply_error(struct apply_ctx *ctx, int error_code, const tchar *path)
+{
+	return report_error(ctx->progfunc, ctx->progctx, error_code, path);
+}
+
+/* Returns any of the aliases of an inode that are being extracted.  */
+#define inode_first_extraction_dentry(inode)		\
+	list_first_entry(&(inode)->i_extraction_aliases,	\
+			 struct wim_dentry, d_extraction_alias_node)
+
 extern int
-unix_do_apply_dentry_timestamps(const tchar *output_path,
-				size_t output_path_nbytes,
-				struct wim_dentry *dentry,
-				struct apply_args *args);
-#endif /* !__WIN32__ */
+extract_stream_list(struct apply_ctx *ctx,
+		    const struct read_stream_list_callbacks *cbs);
+
+/*
+ * Represents an extraction backend.
+ */
+struct apply_operations {
+
+	/* Name of the extraction backend.  */
+	const char *name;
 
-/* Internal use only */
-#define WIMLIB_EXTRACT_FLAG_MULTI_IMAGE		0x80000000
-#define WIMLIB_EXTRACT_FLAG_NO_STREAMS		0x40000000
-#define WIMLIB_EXTRACT_MASK_PUBLIC		0x3fffffff
+	/*
+	 * Query the features supported by the extraction backend.
+	 *
+	 * @target
+	 *	The target string that was provided by the user.  (Often a
+	 *	directory, but extraction backends are free to interpret this
+	 *	differently.)
+	 *
+	 * @supported_features
+	 *	A structure, each of whose members represents a feature that may
+	 *	be supported by the extraction backend.  For each feature that
+	 *	the extraction backend supports, this routine must set the
+	 *	corresponding member to a nonzero value.
+	 *
+	 * Return 0 if successful; otherwise a positive wimlib error code.
+	 */
+	int (*get_supported_features)(const tchar *target,
+				      struct wim_features *supported_features);
 
+	/*
+	 * Main extraction routine.
+	 *
+	 * The extraction backend is provided a list of dentries that have been
+	 * prepared for extraction.  It is free to extract them in any way that
+	 * it chooses.  Ideally, it should choose a method that maximizes
+	 * performance.
+	 *
+	 * The target string will be provided in ctx->common.target.  This might
+	 * be a directory, although extraction backends are free to interpret it
+	 * as they wish.  TODO: in some cases, the common extraction code also
+	 * interprets the target string.  This should be completely isolated to
+	 * extraction backends.
+	 *
+	 * The extraction flags will be provided in ctx->common.extract_flags.
+	 * Extraction backends should examine them and implement the behaviors
+	 * for as many flags as possible.  Some flags are already handled by the
+	 * common extraction code.  TODO: this needs to be better formalized.
+	 *
+	 * @dentry_list, the list of dentries, will be ordered such that the
+	 * ancestor of any dentry always precedes any descendents.  Unless
+	 * @single_tree_only is set, it's possible that the dentries consist of
+	 * multiple disconnected trees.
+	 *
+	 * 'd_extraction_name' and 'd_extraction_name_nchars' of each dentry
+	 * will be set to indicate the actual name with which the dentry should
+	 * be extracted.  This may or may not be the same as 'file_name'.
+	 * TODO: really, the extraction backends should be responsible for
+	 * generating 'd_extraction_name'.
+	 *
+	 * Each dentry will refer to a valid inode in 'd_inode'.
+	 * 'd_inode->i_extraction_aliases' will contain a list of just the
+	 * dentries of that inode being extracted.  This will be a (possibly
+	 * nonproper) subset of the 'd_inode->i_dentry' list.
+	 *
+	 * The streams required to be extracted will already be prepared in
+	 * 'apply_ctx'.  The extraction backend should call
+	 * extract_stream_list() to extract them.
+	 *
+	 * The will_extract_dentry() utility function, given an arbitrary dentry
+	 * in the WIM image (which may not be in the extraction list), can be
+	 * used to determine if that dentry is in the extraction list.
+	 *
+	 * Return 0 if successful; otherwise a positive wimlib error code.
+	 */
+	int (*extract)(struct list_head *dentry_list, struct apply_ctx *ctx);
+
+	/*
+	 * Query whether the unnamed data stream of the specified file will be
+	 * extracted as "externally backed".  If so, the extraction backend is
+	 * assumed to handle this separately, and the common extraction code
+	 * will not register a usage of that stream.
+	 *
+	 * This routine is optional.
+	 *
+	 * Return:
+	 *	< 0 if the file will *not* be externally backed.
+	 *	= 0 if the file will be externally backed.
+	 *	> 0 (wimlib error code) if another error occurred.
+	 */
+	int (*will_externally_back)(struct wim_dentry *dentry, struct apply_ctx *ctx);
+
+	/*
+	 * Size of the backend-specific extraction context.  It must contain
+	 * 'struct apply_ctx' as its first member.
+	 */
+	size_t context_size;
+
+	/*
+	 * Set this if the extraction backend only supports extracting dentries
+	 * that form a single tree, not multiple trees.
+	 */
+	bool single_tree_only;
+};
+
+#ifdef __WIN32__
+  extern const struct apply_operations win32_apply_ops;
+#else
+  extern const struct apply_operations unix_apply_ops;
+#endif
+
+#ifdef WITH_NTFS_3G
+  extern const struct apply_operations ntfs_3g_apply_ops;
+#endif
 
 #endif /* _WIMLIB_APPLY_H */