#include "dentry.h"
#include "lookup_table.h"
#include "xml.h"
+#include "security.h"
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
+
#include <unistd.h>
#ifdef HAVE_ALLOCA_H
goto err_free_imd;
metadata_lte->resource_entry.flags = WIM_RESHDR_FLAG_METADATA;
- random_hash(metadata_lte->hash);
- lookup_table_insert(w->lookup_table, metadata_lte);
new_imd = &imd[w->hdr.image_count];
#ifndef __WIN32__
/*
- * build_dentry_tree():
+ * unix_build_dentry_tree():
* Recursively builds a tree of WIM dentries from an on-disk directory
- * tree.
+ * tree (UNIX version; no NTFS-specific data is captured).
*
* @root_ret: Place to return a pointer to the root of the dentry tree. Only
* modified if successful. Set to NULL if the file or directory was
* excluded from capture.
*
- * @root_disk_path: The path to the root of the directory tree on disk (UTF-8).
+ * @root_disk_path: The path to the root of the directory tree on disk.
*
* @lookup_table: The lookup table for the WIM file. For each file added to the
* dentry tree being built, an entry is added to the lookup table,
* These lookup table entries that are added point to the path of
* the file on disk.
*
- * @sd: Ignored. (Security data only captured in NTFS mode.)
+ * @sd_set: Ignored. (Security data only captured in NTFS mode.)
*
* @capture_config:
* Configuration for files to be excluded from capture.
*
* @add_flags: Bitwise or of WIMLIB_ADD_IMAGE_FLAG_*
*
- * @extra_arg: Ignored in UNIX builds; used to pass sd_set pointer in Windows
- * builds.
+ * @extra_arg: Ignored
*
* @return: 0 on success, nonzero on failure. It is a failure if any of
* the files cannot be `stat'ed, or if any of the needed
*/
static int
unix_build_dentry_tree(struct wim_dentry **root_ret,
- const mbchar *root_disk_path,
+ const char *root_disk_path,
struct wim_lookup_table *lookup_table,
- struct wim_security_data *sd,
+ struct sd_set *sd_set,
const struct capture_config *config,
int add_image_flags,
wimlib_progress_func_t progress_func,
goto out;
}
- root = new_dentry_with_timeless_inode(path_basename(root_disk_path));
- if (!root) {
- if (errno == EILSEQ)
- ret = WIMLIB_ERR_INVALID_UTF8_STRING;
- else if (errno == ENOMEM)
- ret = WIMLIB_ERR_NOMEM;
- else
- ret = WIMLIB_ERR_ICONV_NOT_AVAILABLE;
+ ret = new_dentry_with_timeless_inode(path_basename(root_disk_path),
+ &root);
+ if (ret)
goto out;
- }
inode = root->d_inode;
DEBUG("Add lte reference %u for `%s'", lte->refcnt,
root_disk_path);
} else {
- mbchar *file_on_disk = STRDUP(root_disk_path);
+ char *file_on_disk = STRDUP(root_disk_path);
if (!file_on_disk) {
ERROR("Failed to allocate memory for file path");
ret = WIMLIB_ERR_NOMEM;
/* Buffer for names of files in directory. */
size_t len = strlen(root_disk_path);
- mbchar name[len + 1 + FILENAME_MAX + 1];
+ char name[len + 1 + FILENAME_MAX + 1];
memcpy(name, root_disk_path, len);
name[len] = '/';
* drive letter).
*/
- mbchar deref_name_buf[4096];
+ char deref_name_buf[4096];
ssize_t deref_name_len;
deref_name_len = readlink(root_disk_path, deref_name_buf,
#define COMPAT_DEFAULT_CONFIG
/* Default capture configuration file when none is specified. */
-static const mbchar *default_config =
+static const tchar *default_config =
#ifdef COMPAT_DEFAULT_CONFIG /* XXX: This policy is being moved to library
users. The next ABI-incompatible library
version will default to the empty string here. */
+T(
"[ExclusionList]\n"
"\\$ntfs.log\n"
"\\hiberfil.sys\n"
"\\System Volume Information\n"
"\\RECYCLER\n"
"\\Windows\\CSC\n"
-"\n"
-"[CompressionExclusionList]\n"
-"*.mp3\n"
-"*.zip\n"
-"*.cab\n"
-"\\WINDOWS\\inf\\*.pnf\n";
+);
#else
-"";
+T("");
#endif
static void
}
static int
-pattern_list_add_pattern(struct pattern_list *list, const mbchar *pattern)
+pattern_list_add_pattern(struct pattern_list *list, const tchar *pattern)
{
- const char **pats;
+ const tchar **pats;
if (list->num_pats >= list->num_allocated_pats) {
pats = REALLOC(list->pats,
sizeof(list->pats[0]) * (list->num_allocated_pats + 8));
* `struct capture_config'. */
static int
init_capture_config(struct capture_config *config,
- const mbchar *_config_str, size_t config_len)
+ const tchar *_config_str,
+ size_t config_num_tchars)
{
- mbchar *config_str;
- mbchar *p;
- mbchar *eol;
- mbchar *next_p;
- size_t bytes_remaining;
+ tchar *config_str;
+ tchar *p;
+ tchar *eol;
+ tchar *next_p;
+ size_t num_tchars_remaining;
enum pattern_type type = NONE;
int ret;
unsigned long line_no = 0;
- DEBUG("config_len = %zu", config_len);
- bytes_remaining = config_len;
+ DEBUG("config_num_tchars = %zu", config_num_tchars);
+ num_tchars_remaining = config_num_tchars;
memset(config, 0, sizeof(*config));
- config_str = MALLOC(config_len);
+ config_str = TMALLOC(config_num_tchars);
if (!config_str) {
ERROR("Could not duplicate capture config string");
return WIMLIB_ERR_NOMEM;
}
- memcpy(config_str, _config_str, config_len);
+ tmemcpy(config_str, _config_str, config_num_tchars);
next_p = config_str;
config->config_str = config_str;
- while (bytes_remaining) {
+ while (num_tchars_remaining != 0) {
line_no++;
p = next_p;
- eol = memchr(p, '\n', bytes_remaining);
+ eol = tmemchr(p, T('\n'), num_tchars_remaining);
if (!eol) {
ERROR("Expected end-of-line in capture config file on "
"line %lu", line_no);
}
next_p = eol + 1;
- bytes_remaining -= (next_p - p);
+ num_tchars_remaining -= (next_p - p);
if (eol == p)
continue;
- if (*(eol - 1) == '\r')
+ if (*(eol - 1) == T('\r'))
eol--;
- *eol = '\0';
+ *eol = T('\0');
/* Translate backslash to forward slash */
- for (mbchar *pp = p; pp != eol; pp++)
- if (*pp == '\\')
- *pp = '/';
+ for (tchar *pp = p; pp != eol; pp++)
+ if (*pp == T('\\'))
+ *pp = T('/');
- /* Remove drive letter */
- if (eol - p > 2 && isalpha(*p) && *(p + 1) == ':')
+ /* Remove drive letter (UNIX only) */
+ #ifndef __WIN32__
+ if (eol - p > 2 && istalpha(*p) && *(p + 1) == T(':'))
p += 2;
+ #endif
ret = 0;
- if (strcmp(p, "[ExclusionList]") == 0)
+ if (!tstrcmp(p, T("[ExclusionList]")))
type = EXCLUSION_LIST;
- else if (strcmp(p, "[ExclusionException]") == 0)
+ else if (!tstrcmp(p, T("[ExclusionException]")))
type = EXCLUSION_EXCEPTION;
- else if (strcmp(p, "[CompressionExclusionList]") == 0)
+ else if (!tstrcmp(p, T("[CompressionExclusionList]")))
type = COMPRESSION_EXCLUSION_LIST;
- else if (strcmp(p, "[AlignmentList]") == 0)
+ else if (!tstrcmp(p, T("[AlignmentList]")))
type = ALIGNMENT_LIST;
- else if (p[0] == '[' && strrchr(p, ']')) {
- ERROR("Unknown capture configuration section `%s'", p);
+ else if (p[0] == T('[') && tstrrchr(p, T(']'))) {
+ ERROR("Unknown capture configuration section \"%"TS"\"", p);
ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
} else switch (type) {
case EXCLUSION_LIST:
- DEBUG("Adding pattern \"%s\" to exclusion list", p);
+ DEBUG("Adding pattern \"%"TS"\" to exclusion list", p);
ret = pattern_list_add_pattern(&config->exclusion_list, p);
break;
case EXCLUSION_EXCEPTION:
- DEBUG("Adding pattern \"%s\" to exclusion exception list", p);
+ DEBUG("Adding pattern \"%"TS"\" to exclusion exception list", p);
ret = pattern_list_add_pattern(&config->exclusion_exception, p);
break;
case COMPRESSION_EXCLUSION_LIST:
- DEBUG("Adding pattern \"%s\" to compression exclusion list", p);
+ DEBUG("Adding pattern \"%"TS"\" to compression exclusion list", p);
ret = pattern_list_add_pattern(&config->compression_exclusion_list, p);
break;
case ALIGNMENT_LIST:
- DEBUG("Adding pattern \"%s\" to alignment list", p);
+ DEBUG("Adding pattern \"%"TS"\" to alignment list", p);
ret = pattern_list_add_pattern(&config->alignment_list, p);
break;
default:
}
static int capture_config_set_prefix(struct capture_config *config,
- const mbchar *_prefix)
+ const tchar *_prefix)
{
- mbchar *prefix = STRDUP(_prefix);
+ tchar *prefix = TSTRDUP(_prefix);
if (!prefix)
return WIMLIB_ERR_NOMEM;
FREE(config->prefix);
config->prefix = prefix;
- config->prefix_len = strlen(prefix);
+ config->prefix_num_tchars = tstrlen(prefix);
return 0;
}
-static bool match_pattern(const mbchar *path,
- const mbchar *path_basename,
+static bool match_pattern(const tchar *path,
+ const tchar *path_basename,
const struct pattern_list *list)
{
for (size_t i = 0; i < list->num_pats; i++) {
- const char *pat = list->pats[i];
- const char *string;
+ const tchar *pat = list->pats[i];
+ const tchar *string;
if (pat[0] == '/')
/* Absolute path from root of capture */
string = path;
else {
- if (strchr(pat, '/'))
+ if (tstrchr(pat, T('/')))
/* Relative path from root of capture */
string = path + 1;
else
#endif
) == 0)
{
- DEBUG("`%s' matches the pattern \"%s\"",
+ DEBUG("\"%"TS"\" matches the pattern \"%"TS"\"",
string, pat);
return true;
}
* directory.
*/
bool
-exclude_path(const mbchar *path, const struct capture_config *config,
+exclude_path(const tchar *path, const struct capture_config *config,
bool exclude_prefix)
{
- const mbchar *basename = path_basename(path);
+ const tchar *basename = path_basename(path);
if (exclude_prefix) {
- wimlib_assert(strlen(path) >= config->prefix_len);
- if (memcmp(config->prefix, path, config->prefix_len) == 0
- && path[config->prefix_len] == '/')
- path += config->prefix_len;
+ wimlib_assert(tstrlen(path) >= config->prefix_num_tchars);
+ if (!tmemcmp(config->prefix, path, config->prefix_num_tchars) &&
+ path[config->prefix_num_tchars] == T('/'))
+ {
+ path += config->prefix_num_tchars;
+ }
}
return match_pattern(path, basename, &config->exclusion_list) &&
!match_pattern(path, basename, &config->exclusion_exception);
/* Strip leading and trailing forward slashes from a string. Modifies it in
* place and returns the stripped string. */
-static const char *
-canonicalize_target_path(char *target_path)
+static const tchar *
+canonicalize_target_path(tchar *target_path)
{
- char *p;
+ tchar *p;
if (target_path == NULL)
- return "";
+ return T("");
for (;;) {
- if (*target_path == '\0')
+ if (*target_path == T('\0'))
return target_path;
- else if (*target_path == '/')
+ else if (*target_path == T('/'))
target_path++;
else
break;
}
- p = target_path + strlen(target_path) - 1;
- while (*p == '/')
- *p-- = '\0';
+ p = tstrchr(target_path, T('\0')) - 1;
+ while (*p == T('/'))
+ *p-- = T('\0');
return target_path;
}
-#ifdef __WIN32__
-static void
-zap_backslashes(char *s)
-{
- while (*s) {
- if (*s == '\\')
- *s = '/';
- s++;
- }
-}
-#endif
-
/* Strip leading and trailing slashes from the target paths */
static void
canonicalize_targets(struct wimlib_capture_source *sources, size_t num_sources)
{
while (num_sources--) {
- DEBUG("Canonicalizing { source: \"%s\", target=\"%s\"}",
+ DEBUG("Canonicalizing { source: \"%"TS"\", target=\"%"TS"\"}",
sources->fs_source_path,
sources->wim_target_path);
-#ifdef __WIN32__
+
/* The Windows API can handle forward slashes. Just get rid of
* backslashes to avoid confusing other parts of the library
* code. */
zap_backslashes(sources->fs_source_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);
- DEBUG("Canonical target: \"%s\"", sources->wim_target_path);
+ (tchar*)canonicalize_target_path(sources->wim_target_path);
+ DEBUG("Canonical target: \"%"TS"\"", sources->wim_target_path);
sources++;
}
}
capture_source_cmp(const void *p1, const void *p2)
{
const struct wimlib_capture_source *s1 = p1, *s2 = p2;
- return strcmp(s1->wim_target_path, s2->wim_target_path);
+ return tstrcmp(s1->wim_target_path, s2->wim_target_path);
}
/* Sorts the capture sources lexicographically by target path. This occurs
"(the NTFS volume) in NTFS mode!");
return WIMLIB_ERR_INVALID_PARAM;
}
- if (sources[0].wim_target_path[0] != '\0') {
+ if (sources[0].wim_target_path[0] != T('\0')) {
ERROR("In NTFS capture mode the target path inside "
"the image must be the root directory!");
return WIMLIB_ERR_INVALID_PARAM;
/* Creates a new directory to place in the WIM image. This is to create parent
* directories that are not part of any target as needed. */
-static struct wim_dentry *
-new_filler_directory(const mbchar *name)
+static int
+new_filler_directory(const tchar *name, struct wim_dentry **dentry_ret)
{
+ int ret;
struct wim_dentry *dentry;
- DEBUG("Creating filler directory \"%s\"", name);
- dentry = new_dentry_with_inode(name);
- if (dentry) {
+
+ DEBUG("Creating filler directory \"%"TS"\"", name);
+ ret = new_dentry_with_inode(name, &dentry);
+ if (ret == 0) {
/* Leave the inode number as 0 for now. The final inode number
* will be assigned later by assign_inode_numbers(). */
dentry->d_inode->i_resolved = 1;
dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
+ *dentry_ret = dentry;
}
- return dentry;
+ return ret;
}
/* Transfers the children of @branch to @target. It is an error if @target is
{
struct rb_root *rb_root;
- DEBUG("Doing overlay \"%W\" => \"%W\"",
+ DEBUG("Doing overlay \"%"WS"\" => \"%"WS"\"",
branch->file_name, target->file_name);
if (!dentry_is_directory(target)) {
- ERROR("Cannot overlay directory \"%W\" over non-directory",
- branch->file_name);
+ ERROR("Cannot overlay directory \"%"WS"\" "
+ "over non-directory", branch->file_name);
return WIMLIB_ERR_INVALID_OVERLAY;
}
/* Revert the change to avoid leaking the directory tree
* rooted at @child */
dentry_add_child(branch, child);
- ERROR("Overlay error: file \"%W\" already exists "
- "as a child of \"%W\"",
+ ERROR("Overlay error: file \"%"WS"\" already exists "
+ "as a child of \"%"WS"\"",
child->file_name, target->file_name);
return WIMLIB_ERR_INVALID_OVERLAY;
}
*/
static int
attach_branch(struct wim_dentry **root_p, struct wim_dentry *branch,
- mbchar *target_path)
+ tchar *target_path)
{
- char *slash;
+ tchar *slash;
struct wim_dentry *dentry, *parent, *target;
+ int ret;
- DEBUG("Attaching branch \"%W\" => \"%s\"",
+ DEBUG("Attaching branch \"%"WS"\" => \"%"TS"\"",
branch->file_name, target_path);
- if (*target_path == '\0') {
+ if (*target_path == T('\0')) {
/* Target: root directory */
if (*root_p) {
/* Overlay on existing root */
/* Adding a non-root branch. Create root if it hasn't been created
* already. */
if (!*root_p) {
- *root_p = new_filler_directory("");
- if (!*root_p)
- return WIMLIB_ERR_NOMEM;
+ ret = new_filler_directory(T(""), root_p);
+ if (ret)
+ return ret;
}
/* Walk the path to the branch, creating filler directories as needed.
* */
parent = *root_p;
- while ((slash = strchr(target_path, '/'))) {
- *slash = '\0';
+ while ((slash = tstrchr(target_path, T('/')))) {
+ *slash = T('\0');
dentry = get_dentry_child_with_name(parent, target_path);
if (!dentry) {
- dentry = new_filler_directory(target_path);
- if (!dentry)
- return WIMLIB_ERR_NOMEM;
+ ret = new_filler_directory(target_path, &dentry);
+ if (ret)
+ return ret;
dentry_add_child(parent, dentry);
}
parent = dentry;
* trailing slashes were tripped. */
do {
++target_path;
- } while (*target_path == '/');
+ } while (*target_path == T('/'));
}
/* If the target path already existed, overlay the branch onto it.
* Otherwise, set the branch as the target path. */
- target = get_dentry_child_with_utf16le_name(parent, branch->file_name);
+ target = get_dentry_child_with_utf16le_name(parent, branch->file_name,
+ branch->file_name_nbytes);
if (target) {
return do_overlay(target, branch);
} else {
wimlib_add_image_multisource(WIMStruct *w,
struct wimlib_capture_source *sources,
size_t num_sources,
- const utf8char *name,
- const mbchar *config_str,
+ const tchar *name,
+ const tchar *config_str,
size_t config_len,
int add_image_flags,
wimlib_progress_func_t progress_func)
{
int (*capture_tree)(struct wim_dentry **,
- const mbchar *,
+ const tchar *,
struct wim_lookup_table *,
- struct wim_security_data *,
+ struct sd_set *,
const struct capture_config *,
int,
wimlib_progress_func_t,
struct capture_config config;
struct wim_image_metadata *imd;
int ret;
+ struct sd_set sd_set;
if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) {
#ifdef WITH_NTFS_3G
}
if (wimlib_image_name_in_use(w, name)) {
- ERROR("There is already an image named \"%s\" in `%s'",
- name, w->filename);
+ ERROR("There is already an image named \"%"TS"\" in the WIM!",
+ name);
return WIMLIB_ERR_IMAGE_NAME_COLLISION;
}
if (!config_str) {
DEBUG("Using default capture configuration");
config_str = default_config;
- config_len = strlen(default_config);
+ config_len = tstrlen(default_config);
}
ret = init_capture_config(&config, config_str, config_len);
if (ret)
sd->total_length = 8;
sd->refcnt = 1;
+ sd_set.sd = sd;
+ sd_set.rb_root.rb_node = NULL;
+
DEBUG("Using %zu capture sources", num_sources);
canonicalize_targets(sources, num_sources);
sort_sources(sources, num_sources);
}
DEBUG("Building dentry tree.");
- if (num_sources == 0) {
- root_dentry = new_filler_directory("");
- if (!root_dentry) {
- ret = WIMLIB_ERR_NOMEM;
- goto out_free_security_data;
+ root_dentry = NULL;
+
+ for (size_t i = 0; i < num_sources; i++) {
+ int flags;
+ union wimlib_progress_info progress;
+
+ DEBUG("Building dentry tree for source %zu of %zu "
+ "(\"%"TS"\" => \"%"TS"\")", i + 1, num_sources,
+ sources[i].fs_source_path,
+ sources[i].wim_target_path);
+ if (progress_func) {
+ memset(&progress, 0, sizeof(progress));
+ progress.scan.source = sources[i].fs_source_path;
+ progress.scan.wim_target_path = sources[i].wim_target_path;
+ progress_func(WIMLIB_PROGRESS_MSG_SCAN_BEGIN, &progress);
}
- } else {
- size_t i;
-
- #ifdef __WIN32__
- win32_acquire_capture_privileges();
- #endif
+ ret = capture_config_set_prefix(&config,
+ sources[i].fs_source_path);
+ if (ret)
+ goto out_free_dentry_tree;
+ flags = add_image_flags | WIMLIB_ADD_IMAGE_FLAG_SOURCE;
+ if (!*sources[i].wim_target_path)
+ flags |= WIMLIB_ADD_IMAGE_FLAG_ROOT;
+ ret = (*capture_tree)(&branch,
+ sources[i].fs_source_path,
+ w->lookup_table,
+ &sd_set,
+ &config,
+ flags,
+ progress_func, extra_arg);
+ if (ret) {
+ ERROR("Failed to build dentry tree for `%"TS"'",
+ sources[i].fs_source_path);
+ goto out_free_dentry_tree;
+ }
+ if (branch) {
+ /* Use the target name, not the source name, for
+ * the root of each branch from a capture
+ * source. (This will also set the root dentry
+ * of the entire image to be unnamed.) */
+ ret = set_dentry_name(branch,
+ path_basename(sources[i].wim_target_path));
+ if (ret)
+ goto out_free_branch;
- root_dentry = NULL;
- i = 0;
- do {
- int flags;
- union wimlib_progress_info progress;
-
- DEBUG("Building dentry tree for source %zu of %zu "
- "(\"%s\" => \"%s\")", i + 1, num_sources,
- sources[i].fs_source_path,
- sources[i].wim_target_path);
- if (progress_func) {
- memset(&progress, 0, sizeof(progress));
- progress.scan.source = sources[i].fs_source_path;
- progress.scan.wim_target_path = sources[i].wim_target_path;
- progress_func(WIMLIB_PROGRESS_MSG_SCAN_BEGIN, &progress);
- }
- ret = capture_config_set_prefix(&config,
- sources[i].fs_source_path);
+ ret = attach_branch(&root_dentry, branch,
+ sources[i].wim_target_path);
if (ret)
- goto out_free_dentry_tree;
- flags = add_image_flags | WIMLIB_ADD_IMAGE_FLAG_SOURCE;
- if (!*sources[i].wim_target_path)
- flags |= WIMLIB_ADD_IMAGE_FLAG_ROOT;
- ret = (*capture_tree)(&branch, sources[i].fs_source_path,
- w->lookup_table, sd,
- &config,
- flags,
- progress_func, extra_arg);
- if (ret) {
- ERROR("Failed to build dentry tree for `%s'",
- sources[i].fs_source_path);
- goto out_free_dentry_tree;
- }
- if (branch) {
- /* Use the target name, not the source name, for
- * the root of each branch from a capture
- * source. (This will also set the root dentry
- * of the entire image to be unnamed.) */
- ret = set_dentry_name(branch,
- path_basename(sources[i].wim_target_path));
- if (ret)
- goto out_free_branch;
-
- ret = attach_branch(&root_dentry, branch,
- sources[i].wim_target_path);
- if (ret)
- goto out_free_branch;
- }
- if (progress_func)
- progress_func(WIMLIB_PROGRESS_MSG_SCAN_END, &progress);
- } while (++i != num_sources);
+ goto out_free_branch;
+ }
+ if (progress_func)
+ progress_func(WIMLIB_PROGRESS_MSG_SCAN_END, &progress);
+ }
+
+ if (root_dentry == NULL) {
+ ret = new_filler_directory(T(""), &root_dentry);
+ if (ret)
+ goto out_free_dentry_tree;
}
DEBUG("Calculating full paths of dentries.");
if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_BOOT)
wimlib_set_boot_idx(w, w->hdr.image_count);
ret = 0;
- goto out_destroy_capture_config;
+ goto out_destroy_sd_set;
out_destroy_imd:
destroy_image_metadata(&w->image_metadata[w->hdr.image_count - 1],
w->lookup_table);
w->hdr.image_count--;
- goto out;
+ goto out_destroy_sd_set;
out_free_branch:
free_dentry_tree(branch, w->lookup_table);
out_free_dentry_tree:
free_dentry_tree(root_dentry, w->lookup_table);
out_free_security_data:
free_security_data(sd);
+out_destroy_sd_set:
+ destroy_sd_set(&sd_set);
out_destroy_capture_config:
destroy_capture_config(&config);
out:
-#ifdef __WIN32__
- win32_release_capture_privileges();
-#endif
return ret;
}
WIMLIBAPI int
wimlib_add_image(WIMStruct *w,
- const mbchar *source,
- const utf8char *name,
- const mbchar *config_str,
+ const tchar *source,
+ const tchar *name,
+ const tchar *config_str,
size_t config_len,
int add_image_flags,
wimlib_progress_func_t progress_func)
if (!source || !*source)
return WIMLIB_ERR_INVALID_PARAM;
- char *fs_source_path = STRDUP(source);
+ tchar *fs_source_path = TSTRDUP(source);
int ret;
struct wimlib_capture_source capture_src = {
.fs_source_path = fs_source_path,
git://wimlib.net / wimlib / blobdiff