# include "timestamp.h"
#endif
+#ifdef __WIN32__
+#include <shlwapi.h>
+#endif
+
#include "wimlib_internal.h"
#include "dentry.h"
#include "lookup_table.h"
#include "xml.h"
#include <ctype.h>
#include <errno.h>
+
+#ifndef __WIN32__
#include <fnmatch.h>
+#endif
+
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
DWORD len = lenNeeded;
char buf[len];
if (GetFileSecurityW(path_utf16, requestedInformation,
- buf, len, &lenNeeded))
+ (PSECURITY_DESCRIPTOR)buf, len, &lenNeeded))
{
int security_id = sd_set_add_sd(sd_set, buf, len);
if (security_id < 0)
{
/* Begin reading the directory by calling FindFirstFileW.
- * Unlink UNIX opendir(), FindFirstFileW has file globbing built
+ * Unlike UNIX opendir(), FindFirstFileW has file globbing built
* into it. But this isn't what we actually want, so just add a
* dummy glob to get all entries. */
wchar_t pattern_buf[path_utf16_nchars + 3];
* message digest */
lte->refcnt++;
} else {
- /* Make a new new wim_lookup_table_entry */
+ /* Make a new wim_lookup_table_entry */
lte = new_lookup_table_entry();
if (!lte) {
ret = WIMLIB_ERR_NOMEM;
FindClose(hFind);
return ret;
}
+
#endif
/*
inode->i_last_write_time = unix_timestamp_to_wim(root_stbuf.st_mtime);
inode->i_last_access_time = unix_timestamp_to_wim(root_stbuf.st_atime);
#endif
- if (sizeof(ino_t) >= 8)
- inode->i_ino = (u64)root_stbuf.st_ino;
- else
- inode->i_ino = (u64)root_stbuf.st_ino |
- ((u64)root_stbuf.st_dev << ((sizeof(ino_t) * 8) & 63));
+ /* Leave the inode number at 0 for directories. */
+ if (!S_ISDIR(root_stbuf.st_mode)) {
+ if (sizeof(ino_t) >= 8)
+ inode->i_ino = (u64)root_stbuf.st_ino;
+ else
+ inode->i_ino = (u64)root_stbuf.st_ino |
+ ((u64)root_stbuf.st_dev <<
+ ((sizeof(ino_t) * 8) & 63));
+ }
inode->i_resolved = 1;
if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
ret = inode_set_unix_data(inode, root_stbuf.st_uid,
ret = utf8_to_utf16(root_disk_path, strlen(root_disk_path),
(char**)&path_utf16, &path_utf16_nchars);
if (ret)
- goto out;
+ goto out_destroy_sd_set;
path_utf16_nchars /= sizeof(wchar_t);
HANDLE hFile = win32_open_file_readonly(path_utf16);
}
out_close_handle:
CloseHandle(hFile);
+out_free_path_utf16:
+ FREE(path_utf16);
out_destroy_sd_set:
if (extra_arg == NULL)
destroy_sd_set(sd_set);
-out_free_path_utf16:
- FREE(path_utf16);
#endif
/* The below lines of code are common to both UNIX and Win32 builds. It
* simply returns the captured directory tree if the capture was
return 0;
}
+static bool path_matches_pattern(const char *path, const char *pattern)
+{
+#ifdef __WIN32__
+ return PathMatchSpecA(path, pattern);
+#else
+ return fnmatch(pattern, path, FNM_PATHNAME
+ #ifdef FNM_CASEFOLD
+ | FNM_CASEFOLD
+ #endif
+ ) == 0;
+#endif
+}
+
static bool match_pattern(const char *path, const char *path_basename,
const struct pattern_list *list)
{
/* A file name pattern */
string = path_basename;
}
- if (fnmatch(pat, string, FNM_PATHNAME
- #ifdef FNM_CASEFOLD
- | FNM_CASEFOLD
- #endif
- ) == 0)
- {
+
+ if (path_matches_pattern(string, pat)) {
DEBUG("`%s' matches the pattern \"%s\"",
string, pat);
return true;
{
char *p;
if (target_path == NULL)
- target_path = "";
+ return "";
for (;;) {
if (*target_path == '\0')
return target_path;
* backslashes to avoid confusing other parts of the library
* code. */
zap_backslashes(sources->fs_source_path);
- zap_backslashes(sources->wim_target_path);
+ if (sources->wim_target_path)
+ zap_backslashes(sources->wim_target_path);
#endif
sources->wim_target_path =
(char*)canonicalize_target_path(sources->wim_target_path);
* after leading and trailing forward slashes are stripped.
*
* One purpose of this is to make sure that target paths that are inside other
- * target paths are extracted after the containing target paths. */
+ * target paths are added after the containing target paths. */
static void sort_sources(struct wimlib_capture_source *sources,
size_t num_sources)
{
DEBUG("Creating filler directory \"%s\"", name);
dentry = new_dentry_with_inode(name);
if (dentry) {
- /* Set the inode number to 0 for now. The final inode number
+ /* Leave the inode number as 0 for now. The final inode number
* will be assigned later by assign_inode_numbers(). */
- dentry->d_inode->i_ino = 0;
dentry->d_inode->i_resolved = 1;
dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
}
{
struct rb_root *rb_root;
+ DEBUG("Doing overlay %s => %s",
+ branch->file_name_utf8, target->file_name_utf8);
+
if (!dentry_is_directory(target)) {
ERROR("Cannot overlay directory `%s' over non-directory",
branch->file_name_utf8);
return WIMLIB_ERR_INVALID_OVERLAY;
}
}
+ free_dentry(branch);
return 0;
}
char *slash;
struct wim_dentry *dentry, *parent, *target;
+ DEBUG("Attaching branch \"%s\" => \"%s\"",
+ branch->file_name_utf8, target_path);
+
if (*target_path == '\0') {
/* Target: root directory */
if (*root_p) {
DEBUG("Building dentry tree.");
if (num_sources == 0) {
root_dentry = new_filler_directory("");
- if (!root_dentry)
+ if (!root_dentry) {
+ ret = WIMLIB_ERR_NOMEM;
goto out_free_security_data;
+ }
} else {
size_t i;
+#if defined(__CYGWIN__) || defined(__WIN32__)
+ win32_acquire_privilege(SE_BACKUP_NAME);
+ win32_acquire_privilege(SE_SECURITY_NAME);
+ win32_acquire_privilege(SE_TAKE_OWNERSHIP_NAME);
+#endif
root_dentry = NULL;
i = 0;
do {
if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_BOOT)
wimlib_set_boot_idx(w, w->hdr.image_count);
ret = 0;
- goto out;
+ goto out_destroy_capture_config;
out_destroy_imd:
destroy_image_metadata(&w->image_metadata[w->hdr.image_count - 1],
w->lookup_table);
out_destroy_capture_config:
destroy_capture_config(&config);
out:
+#if defined(__CYGWIN__) || defined(__WIN32__)
+ win32_release_privilege(SE_BACKUP_NAME);
+ win32_release_privilege(SE_SECURITY_NAME);
+ win32_release_privilege(SE_TAKE_OWNERSHIP_NAME);
+#endif
return ret;
}