Factor out Win32 => NT path conversion and use in win32_capture.c

[wimlib] / src / win32_apply.c

diff --git a/src/win32_apply.c b/src/win32_apply.c
index ecd71831d61518819e74426c165b5728d9d0165a..48d3ccb25501232b9a10f279b41b0ea2c600b5ce 100644 (file)
--- a/src/win32_apply.c
+++ b/src/win32_apply.c
@@ -21,6 +21,8 @@
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
+#ifdef __WIN32__
+
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
 #endif
@@ -38,10 +40,6 @@
 #include "wimlib/xml.h"
 #include "wimlib/wimboot.h"
 
-/* TODO: Add workaround for when a stream needs to be extracted to more places
- * than this  */
-#define MAX_OPEN_HANDLES 32768
-
 struct win32_apply_ctx {
 
        /* Extract flags, the pointer to the WIMStruct, etc.  */
@@ -103,7 +101,7 @@ struct win32_apply_ctx {
 
        /* Array of open handles to filesystem streams currently being written
         */
-       HANDLE open_handles[MAX_OPEN_HANDLES];
+       HANDLE open_handles[MAX_OPEN_STREAMS];
 
        /* Number of handles in @open_handles currently open (filled in from the
         * beginning of the array)  */
@@ -357,7 +355,7 @@ dentry_extraction_path_length(const struct wim_dentry *dentry)
        d = dentry;
        do {
                len += d->d_extraction_name_nchars + 1;
-               d = d->parent;
+               d = d->d_parent;
        } while (!dentry_is_root(d) && will_extract_dentry(d));
 
        return --len;  /* No leading slash  */
@@ -426,8 +424,8 @@ build_extraction_path(const struct wim_dentry *dentry,
        ctx->pathbuf.Length = len * sizeof(wchar_t);
        p = ctx->pathbuf.Buffer + len;
        for (d = dentry;
-            !dentry_is_root(d->parent) && will_extract_dentry(d->parent);
-            d = d->parent)
+            !dentry_is_root(d->d_parent) && will_extract_dentry(d->d_parent);
+            d = d->d_parent)
        {
                p -= d->d_extraction_name_nchars;
                wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
@@ -512,33 +510,15 @@ current_path(struct win32_apply_ctx *ctx)
 static int
 prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
 {
+       int ret;
        NTSTATUS status;
        size_t path_max;
 
        /* Open handle to the target directory (possibly creating it).  */
 
-       if (func_RtlDosPathNameToNtPathName_U_WithStatus) {
-               status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(ctx->common.target,
-                                                                        &ctx->target_ntpath,
-                                                                        NULL, NULL);
-       } else {
-               if ((*func_RtlDosPathNameToNtPathName_U)(ctx->common.target,
-                                                        &ctx->target_ntpath,
-                                                        NULL, NULL))
-                       status = STATUS_SUCCESS;
-               else
-                       status = STATUS_NO_MEMORY;
-       }
-       if (!NT_SUCCESS(status)) {
-               if (status == STATUS_NO_MEMORY) {
-                       return WIMLIB_ERR_NOMEM;
-               } else {
-                       ERROR("\"%ls\": invalid path name "
-                             "(status=0x%08"PRIx32")",
-                             ctx->common.target, (u32)status);
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-       }
+       ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath);
+       if (ret)
+               return ret;
 
        ctx->attr.Length = sizeof(ctx->attr);
        ctx->attr.ObjectName = &ctx->target_ntpath;
@@ -1357,9 +1337,11 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
                }
        }
 
-       /* Too many open handles?  */
-       if (ctx->num_open_handles == MAX_OPEN_HANDLES) {
-               ERROR("Too many open handles!");
+       if (ctx->num_open_handles == MAX_OPEN_STREAMS) {
+               /* XXX: Fix this.  But because of the checks in
+                * extract_stream_list(), this can now only happen on a
+                * filesystem that does not support hard links.  */
+               ERROR("Can't extract data: too many open files!");
                return WIMLIB_ERR_UNSUPPORTED;
        }
 
@@ -1469,7 +1451,13 @@ skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars)
 
 /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
  * pointer to the suffix of the path that is device-relative, such as
- * Windows\System32.  */
+ * Windows\System32.
+ *
+ * The path has an explicit length and is not necessarily null terminated.
+ *
+ * If the path just something like \??\e: then the returned pointer will point
+ * just past the colon.  In this case the length of the result will be 0
+ * characters.  */
 static const wchar_t *
 get_device_relative_path(const wchar_t *path, size_t path_nchars)
 {
@@ -1482,7 +1470,7 @@ get_device_relative_path(const wchar_t *path, size_t path_nchars)
 
        path = wmemchr(path, L'\\', (end - path));
        if (!path)
-               return orig_path;
+               return end;
        do {
                path++;
        } while (path != end && *path == L'\\');
@@ -1531,14 +1519,18 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx)
 
        target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t);
 
-       fixed_subst_name_nchars = target_ntpath_nchars + 1 + relpath_nchars;
+       fixed_subst_name_nchars = target_ntpath_nchars;
+       if (relpath_nchars)
+               fixed_subst_name_nchars += 1 + relpath_nchars;
        wchar_t fixed_subst_name[fixed_subst_name_nchars];
 
        wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer,
                target_ntpath_nchars);
-       fixed_subst_name[target_ntpath_nchars] = L'\\';
-       wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1],
-               relpath, relpath_nchars);
+       if (relpath_nchars) {
+               fixed_subst_name[target_ntpath_nchars] = L'\\';
+               wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1],
+                       relpath, relpath_nchars);
+       }
        /* Doesn't need to be null-terminated.  */
 
        /* Print name should be Win32, but not all NT names can even be
@@ -2079,3 +2071,5 @@ const struct apply_operations win32_apply_ops = {
        .extract                = win32_extract,
        .context_size           = sizeof(struct win32_apply_ctx),
 };
+
+#endif /* __WIN32__ */