#include "config.h"
-#if defined(__CYGWIN__) || defined(__WIN32__)
-# include <windows.h>
-# ifdef ERROR
-# undef ERROR
-# endif
-# include <wchar.h>
+#include <dirent.h>
+
+#ifdef __WIN32__
+# include "win32.h"
#else
-# include <dirent.h>
-# ifdef HAVE_UTIME_H
-# include <utime.h>
-# endif
-# include "timestamp.h"
-# include <sys/time.h>
+# ifdef HAVE_UTIME_H
+# include <utime.h>
+# endif
+# include "timestamp.h"
+# include <sys/time.h>
#endif
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
-
#include <unistd.h>
#include "dentry.h"
#include "xml.h"
#ifdef WITH_NTFS_3G
-#include <ntfs-3g/volume.h>
+# include <ntfs-3g/volume.h>
#endif
#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
+# include <alloca.h>
#endif
-#if defined(__CYGWIN__) || defined(__WIN32__)
-
-static int win32_set_reparse_data(HANDLE h,
- u32 reparse_tag,
- const struct wim_lookup_table_entry *lte,
- const wchar_t *path)
-{
- int ret;
- u8 *buf;
- size_t len;
-
- if (!lte) {
- WARNING("\"%ls\" is marked as a reparse point but had no reparse data",
- path);
- return 0;
- }
- len = wim_resource_size(lte);
- if (len > 16 * 1024 - 8) {
- WARNING("\"%ls\": reparse data too long!", path);
- return 0;
- }
-
- /* The WIM stream omits the ReparseTag and ReparseDataLength fields, so
- * leave 8 bytes of space for them at the beginning of the buffer, then
- * set them manually. */
- buf = alloca(len + 8);
- ret = read_full_wim_resource(lte, buf + 8, 0);
- if (ret)
- return ret;
- *(u32*)(buf + 0) = reparse_tag;
- *(u16*)(buf + 4) = len;
- *(u16*)(buf + 6) = 0;
-
- /* Set the reparse data on the open file using the
- * FSCTL_SET_REPARSE_POINT ioctl.
- *
- * There are contradictions in Microsoft's documentation for this:
- *
- * "If hDevice was opened without specifying FILE_FLAG_OVERLAPPED,
- * lpOverlapped is ignored."
- *
- * --- So setting lpOverlapped to NULL is okay since it's ignored.
- *
- * "If lpOverlapped is NULL, lpBytesReturned cannot be NULL. Even when an
- * operation returns no output data and lpOutBuffer is NULL,
- * DeviceIoControl makes use of lpBytesReturned. After such an
- * operation, the value of lpBytesReturned is meaningless."
- *
- * --- So lpOverlapped not really ignored, as it affects another
- * parameter. This is the actual behavior: lpBytesReturned must be
- * specified, even though lpBytesReturned is documented as:
- *
- * "Not used with this operation; set to NULL."
- */
- DWORD bytesReturned;
- if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, buf, len + 8,
- NULL, 0,
- &bytesReturned /* lpBytesReturned */,
- NULL /* lpOverlapped */))
- {
- DWORD err = GetLastError();
- ERROR("Failed to set reparse data on \"%ls\"", path);
- win32_error(err);
- return WIMLIB_ERR_WRITE;
- }
- return 0;
-}
-
-
-static int win32_extract_chunk(const u8 *buf, size_t len, u64 offset, void *arg)
-{
- HANDLE hStream = arg;
-
- DWORD nbytes_written;
- wimlib_assert(len <= 0xffffffff);
-
- if (!WriteFile(hStream, buf, len, &nbytes_written, NULL) ||
- nbytes_written != len)
- {
- DWORD err = GetLastError();
- ERROR("WriteFile(): write error");
- win32_error(err);
- return WIMLIB_ERR_WRITE;
- }
- return 0;
-}
-
-static int do_win32_extract_stream(HANDLE hStream, struct wim_lookup_table_entry *lte)
-{
- return extract_wim_resource(lte, wim_resource_size(lte),
- win32_extract_chunk, hStream);
-}
-
-static int win32_extract_stream(const struct wim_inode *inode,
- const wchar_t *path,
- const wchar_t *stream_name_utf16,
- struct wim_lookup_table_entry *lte)
-{
- wchar_t *stream_path;
- HANDLE h;
- int ret;
- DWORD err;
- DWORD creationDisposition = CREATE_ALWAYS;
-
- if (stream_name_utf16) {
- /* Named stream. Create a buffer that contains the UTF-16LE
- * string [./]@path:@stream_name_utf16. This is needed to
- * create and open the stream using CreateFileW(). I'm not
- * aware of any other APIs to do this. Note: note that the
- * '$DATA' suffix seems to be unneeded; Additional note: a "./"
- * prefix needs to be added when the path is not absolute to
- * avoid ambiguity with drive letters. */
- size_t stream_path_nchars;
- size_t path_nchars;
- size_t stream_name_nchars;
- const wchar_t *prefix;
-
- path_nchars = wcslen(path);
- stream_name_nchars = wcslen(stream_name_utf16);
- stream_path_nchars = path_nchars + 1 + stream_name_nchars;
- if (path[0] != L'/' && path[1] != L'\\') {
- prefix = L"./";
- stream_path_nchars += 2;
- } else {
- prefix = L"";
- }
- stream_path = alloca((stream_path_nchars + 1) * sizeof(wchar_t));
- swprintf(stream_path, stream_path_nchars + 1, L"%ls%ls:%ls",
- prefix, path, stream_name_utf16);
- } else {
- /* Unnamed stream; it's path is just the path to the file
- * itself. */
- stream_path = (wchar_t*)path;
-
- /* Directories must be created with CreateDirectoryW(). Then
- * the call to CreateFileW() will merely open the directory that
- * was already created rather than creating a new file. */
- if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
- if (!CreateDirectoryW(stream_path, NULL)) {
- err = GetLastError();
- if (err != ERROR_ALREADY_EXISTS) {
- ERROR("Failed to create directory \"%ls\"",
- path);
- win32_error(err);
- ret = WIMLIB_ERR_MKDIR;
- goto fail;
- }
- }
- DEBUG("Created directory \"%ls\"", stream_path);
- if (!(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
- ret = 0;
- goto out;
- }
- creationDisposition = OPEN_EXISTING;
- }
- }
-
- DEBUG("Opening \"%ls\"", stream_path);
- h = CreateFileW(stream_path,
- GENERIC_WRITE | WRITE_OWNER | WRITE_DAC,
- 0,
- NULL,
- creationDisposition,
- FILE_FLAG_OPEN_REPARSE_POINT |
- FILE_FLAG_BACKUP_SEMANTICS |
- inode->i_attributes,
- NULL);
- if (h == INVALID_HANDLE_VALUE) {
- err = GetLastError();
- ERROR("Failed to create \"%ls\"", stream_path);
- win32_error(err);
- ret = WIMLIB_ERR_OPEN;
- goto fail;
- }
-
- if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
- stream_name_utf16 == NULL)
- {
- DEBUG("Setting reparse data on \"%ls\"", path);
- ret = win32_set_reparse_data(h, inode->i_reparse_tag, lte, path);
- if (ret)
- goto fail_close_handle;
- } else {
- if (lte) {
- DEBUG("Extracting \"%ls\" (len = %zu)",
- stream_path, wim_resource_size(lte));
- ret = do_win32_extract_stream(h, lte);
- if (ret)
- goto fail_close_handle;
- }
- }
-
- DEBUG("Closing \"%ls\"", stream_path);
- if (!CloseHandle(h)) {
- err = GetLastError();
- ERROR("Failed to close \"%ls\"", stream_path);
- win32_error(err);
- ret = WIMLIB_ERR_WRITE;
- goto fail;
- }
- ret = 0;
- goto out;
-fail_close_handle:
- CloseHandle(h);
-fail:
- ERROR("Error extracting %ls", stream_path);
-out:
- return ret;
-}
-
-/*
- * Creates a file, directory, or reparse point and extracts all streams to it
- * (unnamed data stream and/or reparse point stream, plus any alternate data
- * streams). This in Win32-specific code.
- *
- * @inode: WIM inode for this file or directory.
- * @path: UTF-16LE external path to extract the inode to.
- *
- * Returns 0 on success; nonzero on failure.
- */
-static int win32_extract_streams(struct wim_inode *inode,
- const wchar_t *path)
-{
- struct wim_lookup_table_entry *unnamed_lte;
- int ret;
-
- unnamed_lte = inode_unnamed_lte_resolved(inode);
- ret = win32_extract_stream(inode, path, NULL, unnamed_lte);
- if (ret)
- goto out;
- for (u16 i = 0; i < inode->i_num_ads; i++) {
- const struct wim_ads_entry *ads_entry = &inode->i_ads_entries[i];
- if (ads_entry->stream_name_len != 0) {
- /* Skip special UNIX data entries (see documentation for
- * WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) */
- if (ads_entry->stream_name_len == WIMLIB_UNIX_DATA_TAG_LEN
- && !memcmp(ads_entry->stream_name_utf8,
- WIMLIB_UNIX_DATA_TAG,
- WIMLIB_UNIX_DATA_TAG_LEN))
- continue;
- ret = win32_extract_stream(inode,
- path,
- (const wchar_t*)ads_entry->stream_name,
- ads_entry->lte);
- if (ret)
- break;
- }
- }
-out:
- return ret;
-}
-
-/*
- * Sets the security descriptor on an extracted file. This is Win32-specific
- * code.
- *
- * @inode: The WIM inode that was extracted and has a security descriptor.
- * @path: UTF-16LE external path that the inode was extracted to.
- * @sd: Security data for the WIM image.
- * @path_utf8: @path in UTF-8 for error messages only.
- *
- * Returns 0 on success; nonzero on failure.
- */
-static int win32_set_security_data(const struct wim_inode *inode,
- const wchar_t *path,
- const struct wim_security_data *sd)
-{
- SECURITY_INFORMATION securityInformation = DACL_SECURITY_INFORMATION |
- SACL_SECURITY_INFORMATION |
- OWNER_SECURITY_INFORMATION |
- GROUP_SECURITY_INFORMATION;
- if (!SetFileSecurityW(path, securityInformation,
- (PSECURITY_DESCRIPTOR)sd->descriptors[inode->i_security_id]))
- {
- DWORD err = GetLastError();
- ERROR("Can't set security descriptor on \"%ls\"", path);
- win32_error(err);
- return WIMLIB_ERR_WRITE;
- }
- return 0;
-}
+#if TCHAR_IS_UTF16LE
+# include <wchar.h>
+#endif
-#else /* __CYGWIN__ || __WIN32__ */
-static int extract_regular_file_linked(struct wim_dentry *dentry,
- const char *output_path,
- struct apply_args *args,
- struct wim_lookup_table_entry *lte)
+#ifndef __WIN32__
+static int
+extract_regular_file_linked(struct wim_dentry *dentry,
+ const char *output_path,
+ struct apply_args *args,
+ struct wim_lookup_table_entry *lte)
{
/* This mode overrides the normal hard-link extraction and
* instead either symlinks or hardlinks *all* identical files in
size_t i;
num_path_components =
- get_num_path_components(dentry->full_path_utf8) - 1;
+ get_num_path_components(dentry->full_path) - 1;
num_output_dir_path_components =
get_num_path_components(args->target);
p2 = path_next_part(p2, NULL);
strcpy(p, p2);
if (symlink(buf, output_path) != 0) {
- ERROR_WITH_ERRNO("Failed to symlink `%s' to "
- "`%s'",
+ ERROR_WITH_ERRNO("Failed to symlink `%s' to `%s'",
buf, lte->extracted_file);
return WIMLIB_ERR_LINK;
}
return 0;
}
-static int symlink_apply_unix_data(const char *link,
- const struct wimlib_unix_data *unix_data)
+static int
+symlink_apply_unix_data(const mbchar *link,
+ const struct wimlib_unix_data *unix_data)
{
if (lchown(link, unix_data->uid, unix_data->gid)) {
if (errno == EPERM) {
return 0;
}
-static int fd_apply_unix_data(int fd, const struct wimlib_unix_data *unix_data)
+static int
+fd_apply_unix_data(int fd, const struct wimlib_unix_data *unix_data)
{
if (fchown(fd, unix_data->uid, unix_data->gid)) {
if (errno == EPERM) {
return 0;
}
-static int dir_apply_unix_data(const char *dir,
- const struct wimlib_unix_data *unix_data)
+static int
+dir_apply_unix_data(const char *dir, const struct wimlib_unix_data *unix_data)
{
int dfd = open(dir, O_RDONLY);
int ret;
return ret;
}
-static int extract_regular_file_unlinked(struct wim_dentry *dentry,
- struct apply_args *args,
- const char *output_path,
- struct wim_lookup_table_entry *lte)
+static int
+extract_regular_file_unlinked(struct wim_dentry *dentry,
+ struct apply_args *args,
+ const char *output_path,
+ struct wim_lookup_table_entry *lte)
{
/* Normal mode of extraction. Regular files and hard links are
* extracted in the way that they appear in the WIM. */
return ret;
}
-static int extract_regular_file(struct wim_dentry *dentry,
- struct apply_args *args,
- const char *output_path)
+static int
+extract_regular_file(struct wim_dentry *dentry,
+ struct apply_args *args,
+ const char *output_path)
{
struct wim_lookup_table_entry *lte;
const struct wim_inode *inode = dentry->d_inode;
return extract_regular_file_unlinked(dentry, args, output_path, lte);
}
-static int extract_symlink(struct wim_dentry *dentry,
- struct apply_args *args,
- const char *output_path)
+static int
+extract_symlink(struct wim_dentry *dentry,
+ struct apply_args *args,
+ const char *output_path)
{
char target[4096];
ssize_t ret = inode_readlink(dentry->d_inode, target,
if (ret <= 0) {
ERROR("Could not read the symbolic link from dentry `%s'",
- dentry->full_path_utf8);
+ dentry->full_path);
return WIMLIB_ERR_INVALID_DENTRY;
}
ret = symlink(target, output_path);
return 0;
}
-#endif /* !(__CYGWIN__ || __WIN32__) */
+#endif /* !__WIN32__ */
-static int extract_directory(struct wim_dentry *dentry,
- const char *output_path, bool is_root)
+static int
+extract_directory(struct wim_dentry *dentry,
+ const tchar *output_path, bool is_root)
{
int ret;
struct stat stbuf;
- ret = stat(output_path, &stbuf);
+ ret = tstat(output_path, &stbuf);
if (ret == 0) {
if (S_ISDIR(stbuf.st_mode)) {
/*if (!is_root)*/
/*WARNING("`%s' already exists", output_path);*/
goto dir_exists;
} else {
- ERROR("`%s' is not a directory", output_path);
+ ERROR("`%"TS"' is not a directory", output_path);
return WIMLIB_ERR_MKDIR;
}
} else {
if (errno != ENOENT) {
- ERROR_WITH_ERRNO("Failed to stat `%s'", output_path);
+ ERROR_WITH_ERRNO("Failed to stat `%"TS"'", output_path);
return WIMLIB_ERR_STAT;
}
}
- if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP |
- S_IROTH | S_IXOTH) != 0) {
- ERROR_WITH_ERRNO("Cannot create directory `%s'",
- output_path);
+
+ if (tmkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
+ {
+ ERROR_WITH_ERRNO("Cannot create directory `%"TS"'", output_path);
return WIMLIB_ERR_MKDIR;
}
dir_exists:
ret = 0;
-#if !defined(__CYGWIN__) && !defined(__WIN32__)
+#ifndef __WIN32__
if (dentry) {
struct wimlib_unix_data unix_data;
ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL);
return ret;
}
-/* Extracts a file, directory, or symbolic link from the WIM archive. */
-static int apply_dentry_normal(struct wim_dentry *dentry, void *arg)
+#ifndef __WIN32__
+static int unix_do_apply_dentry(const char *output_path,
+ size_t output_path_len,
+ struct wim_dentry *dentry,
+ struct apply_args *args)
{
- struct apply_args *args = arg;
- struct wim_inode *inode = dentry->d_inode;
- size_t len;
- char *output_path;
-
- len = strlen(args->target);
- if (dentry_is_root(dentry)) {
- output_path = (char*)args->target;
- } else {
- output_path = alloca(len + dentry->full_path_utf8_len + 1);
- memcpy(output_path, args->target, len);
- memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len);
- output_path[len + dentry->full_path_utf8_len] = '\0';
- len += dentry->full_path_utf8_len;
- }
-
-#if defined(__CYGWIN__) || defined(__WIN32__)
- char *utf16_path;
- size_t utf16_path_len;
- DWORD err;
- int ret;
- ret = utf8_to_utf16(output_path, len, &utf16_path, &utf16_path_len);
- if (ret)
- return ret;
+ const struct wim_inode *inode = dentry->d_inode;
- if (inode->i_nlink > 1 && inode->i_extracted_file != NULL) {
- /* Linked file, with another name already extracted. Create a
- * hard link. */
- DEBUG("Creating hard link \"%ls => %ls\"",
- (const wchar_t*)utf16_path,
- (const wchar_t*)inode->i_extracted_file);
- if (!CreateHardLinkW((const wchar_t*)utf16_path,
- (const wchar_t*)inode->i_extracted_file,
- NULL))
- {
- err = GetLastError();
- ERROR("Can't create hard link \"%ls => %ls\"",
- (const wchar_t*)utf16_path,
- (const wchar_t*)inode->i_extracted_file);
- ret = WIMLIB_ERR_LINK;
- win32_error(err);
- }
- } else {
- /* Create the file, directory, or reparse point, and extract the
- * data streams. */
- ret = win32_extract_streams(inode, (const wchar_t*)utf16_path);
- if (ret)
- goto out_free_utf16_path;
-
- /* Set security descriptor if present */
- if (inode->i_security_id != -1) {
- DEBUG("Setting security descriptor %d on %s",
- inode->i_security_id, output_path);
- ret = win32_set_security_data(inode,
- (const wchar_t*)utf16_path,
- wim_const_security_data(args->w));
- if (ret)
- goto out_free_utf16_path;
- }
- if (inode->i_nlink > 1) {
- /* Save extracted path for a later call to
- * CreateHardLinkW() if this inode has multiple links.
- * */
- inode->i_extracted_file = utf16_path;
- goto out;
- }
- }
-out_free_utf16_path:
- FREE(utf16_path);
-out:
- return ret;
-#else
if (inode_is_symlink(inode))
return extract_symlink(dentry, args, output_path);
else if (inode_is_directory(inode))
output_path, false);
else
return extract_regular_file(dentry, args, output_path);
-#endif
}
-/* Apply timestamps to an extracted file or directory */
-static int apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg)
+static int
+unix_do_apply_dentry_timestamps(const char *output_path,
+ size_t output_path_len,
+ const struct wim_dentry *dentry,
+ struct apply_args *args)
{
- struct apply_args *args = arg;
- size_t len;
- char *output_path;
int ret;
const struct wim_inode *inode = dentry->d_inode;
- len = strlen(args->target);
- if (dentry_is_root(dentry)) {
- output_path = (char*)args->target;
- } else {
- output_path = alloca(len + dentry->full_path_utf8_len + 1);
- memcpy(output_path, args->target, len);
- memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len);
- output_path[len + dentry->full_path_utf8_len] = '\0';
- len += dentry->full_path_utf8_len;
- }
-
-#if defined(__CYGWIN__) || defined(__WIN32__)
- /* Win32 */
- char *utf16_path;
- size_t utf16_path_len;
- DWORD err;
- HANDLE h;
- BOOL bret1, bret2;
+#ifdef HAVE_UTIMENSAT
+ /* Convert the WIM timestamps, which are accurate to 100 nanoseconds,
+ * into `struct timespec's for passing to utimensat(), which is accurate
+ * to 1 nanosecond. */
- ret = utf8_to_utf16(output_path, len, &utf16_path, &utf16_path_len);
+ struct timespec ts[2];
+ ts[0] = wim_timestamp_to_timespec(inode->i_last_access_time);
+ ts[1] = wim_timestamp_to_timespec(inode->i_last_write_time);
+ ret = utimensat(AT_FDCWD, output_path, ts, AT_SYMLINK_NOFOLLOW);
if (ret)
- return ret;
+ ret = errno;
+#else
+ ret = ENOSYS;
+#endif
- DEBUG("Opening \"%ls\" to set timestamps", utf16_path);
- h = CreateFileW((const wchar_t*)utf16_path,
- GENERIC_WRITE,
- FILE_SHARE_READ,
- NULL,
- OPEN_EXISTING,
- FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
- NULL);
-
- if (h == INVALID_HANDLE_VALUE)
- err = GetLastError();
- FREE(utf16_path);
- if (h == INVALID_HANDLE_VALUE)
- goto fail;
-
- FILETIME creationTime = {.dwLowDateTime = dentry->d_inode->i_creation_time & 0xffffffff,
- .dwHighDateTime = dentry->d_inode->i_creation_time >> 32};
- FILETIME lastAccessTime = {.dwLowDateTime = dentry->d_inode->i_last_access_time & 0xffffffff,
- .dwHighDateTime = dentry->d_inode->i_last_access_time >> 32};
- FILETIME lastWriteTime = {.dwLowDateTime = dentry->d_inode->i_last_write_time & 0xffffffff,
- .dwHighDateTime = dentry->d_inode->i_last_write_time >> 32};
-
- DEBUG("Calling SetFileTime() on \"%s\"", output_path);
- if (!SetFileTime(h, &creationTime, &lastAccessTime, &lastWriteTime)) {
- err = GetLastError();
- CloseHandle(h);
- goto fail;
+ if (ret == ENOSYS) {
+ /* utimensat() not implemented or not available */
+ #ifdef HAVE_LUTIMES
+ /* Convert the WIM timestamps, which are accurate to 100
+ * nanoseconds, into `struct timeval's for passing to lutimes(),
+ * which is accurate to 1 microsecond. */
+ struct timeval tv[2];
+ tv[0] = wim_timestamp_to_timeval(inode->i_last_access_time);
+ tv[1] = wim_timestamp_to_timeval(inode->i_last_write_time);
+ ret = lutimes(output_path, tv);
+ if (ret)
+ ret = errno;
+ #endif
+ }
+
+ if (ret == ENOSYS) {
+ /* utimensat() and lutimes() both not implemented or not
+ * available */
+ #ifdef HAVE_UTIME
+ /* Convert the WIM timestamps, which are accurate to 100
+ * nanoseconds, into a `struct utimbuf's for passing to
+ * utime(), which is accurate to 1 second. */
+ struct utimbuf buf;
+ buf.actime = wim_timestamp_to_unix(inode->i_last_access_time);
+ buf.modtime = wim_timestamp_to_unix(inode->i_last_write_time);
+ ret = utime(output_path, &buf);
+ #endif
}
- DEBUG("Closing \"%s\"", output_path);
- if (!CloseHandle(h)) {
- err = GetLastError();
- goto fail;
+ if (ret && args->num_utime_warnings < 10) {
+ WARNING_WITH_ERRNO("Failed to set timestamp on file `%s'",
+ output_path);
+ args->num_utime_warnings++;
}
return 0;
-fail:
- ERROR("Can't set timestamps on \"%s\"", output_path);
- win32_error(err);
- return WIMLIB_ERR_WRITE;
+}
+#endif /* !__WIN32__ */
+
+/* Extracts a file, directory, or symbolic link from the WIM archive. */
+static int
+apply_dentry_normal(struct wim_dentry *dentry, void *arg)
+{
+ struct apply_args *args = arg;
+ tchar *output_path;
+ size_t len;
+
+ len = tstrlen(args->target);
+ if (dentry_is_root(dentry)) {
+ output_path = (tchar*)args->target;
+ } else {
+ output_path = alloca(len * sizeof(tchar) + dentry->full_path_nbytes +
+ sizeof(tchar));
+ memcpy(output_path, args->target, len * sizeof(tchar));
+ memcpy(output_path + len, dentry->full_path, dentry->full_path_nbytes);
+ len += dentry->full_path_nbytes / sizeof(tchar);
+ output_path[len] = T('\0');
+ }
+#ifdef __WIN32__
+ return win32_do_apply_dentry(output_path, len, dentry, args);
#else
- /* UNIX */
+ return unix_do_apply_dentry(output_path, len, dentry, args);
+#endif
+}
- /* Convert the WIM timestamps, which are accurate to 100 nanoseconds,
- * into struct timeval's. */
- struct timeval tv[2];
- wim_timestamp_to_timeval(inode->i_last_access_time, &tv[0]);
- wim_timestamp_to_timeval(inode->i_last_write_time, &tv[1]);
- #ifdef HAVE_LUTIMES
- ret = lutimes(output_path, tv);
- #else
- ret = -1;
- errno = ENOSYS;
- #endif
- if (ret != 0) {
- #ifdef HAVE_UTIME
- if (errno == ENOSYS) {
- struct utimbuf buf;
- buf.actime = wim_timestamp_to_unix(inode->i_last_access_time);
- buf.modtime = wim_timestamp_to_unix(inode->i_last_write_time);
- if (utime(output_path, &buf) == 0)
- return 0;
- }
- #endif
- if (errno != ENOSYS || args->num_lutimes_warnings < 10) {
- /*WARNING_WITH_ERRNO("Failed to set timestamp on file `%s',*/
- /*output_path");*/
- args->num_lutimes_warnings++;
- }
+
+/* Apply timestamps to an extracted file or directory */
+static int
+apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg)
+{
+ struct apply_args *args = arg;
+ size_t len;
+ tchar *output_path;
+
+ len = tstrlen(args->target);
+ if (dentry_is_root(dentry)) {
+ output_path = (tchar*)args->target;
+ } else {
+ output_path = alloca(len * sizeof(tchar) + dentry->full_path_nbytes +
+ sizeof(tchar));
+ memcpy(output_path, args->target, len * sizeof(tchar));
+ memcpy(output_path + len, dentry->full_path, dentry->full_path_nbytes);
+ len += dentry->full_path_nbytes / sizeof(tchar);
+ output_path[len] = T('\0');
}
- return 0;
+
+
+#ifdef __WIN32__
+ return win32_do_apply_dentry_timestamps(output_path, len, dentry, args);
+#else
+ return unix_do_apply_dentry_timestamps(output_path, len, dentry, args);
#endif
}
/* Extract a dentry if it hasn't already been extracted, and either the dentry
* has no streams or WIMLIB_EXTRACT_FLAG_NO_STREAMS is not specified. */
-static int maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
+static int
+maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
{
struct apply_args *args = arg;
int ret;
if ((args->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) &&
args->progress_func) {
- args->progress.extract.cur_path = dentry->full_path_utf8;
+ args->progress.extract.cur_path = dentry->full_path;
args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY,
&args->progress);
}
return ret;
}
-static int cmp_streams_by_wim_position(const void *p1, const void *p2)
+static int
+cmp_streams_by_wim_position(const void *p1, const void *p2)
{
const struct wim_lookup_table_entry *lte1, *lte2;
lte1 = *(const struct wim_lookup_table_entry**)p1;
return 0;
}
-static int sort_stream_list_by_wim_position(struct list_head *stream_list)
+static int
+sort_stream_list_by_wim_position(struct list_head *stream_list)
{
struct list_head *cur;
size_t num_streams;
return 0;
}
-static void calculate_bytes_to_extract(struct list_head *stream_list,
- int extract_flags,
- union wimlib_progress_info *progress)
+static void
+calculate_bytes_to_extract(struct list_head *stream_list,
+ int extract_flags,
+ union wimlib_progress_info *progress)
{
struct wim_lookup_table_entry *lte;
u64 total_bytes = 0;
progress->extract.completed_bytes = 0;
}
-static void maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte,
- struct list_head *stream_list)
+static void
+maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte,
+ struct list_head *stream_list)
{
if (++lte->out_refcnt == 1) {
INIT_LIST_HEAD(<e->inode_list);
}
}
-static void inode_find_streams_for_extraction(struct wim_inode *inode,
- struct list_head *stream_list,
- int extract_flags)
+static void
+inode_find_streams_for_extraction(struct wim_inode *inode,
+ struct list_head *stream_list,
+ int extract_flags)
{
struct wim_lookup_table_entry *lte;
bool inode_added = false;
#ifdef WITH_NTFS_3G
if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
for (unsigned i = 0; i < inode->i_num_ads; i++) {
- if (inode->i_ads_entries[i].stream_name_len != 0) {
+ if (inode->i_ads_entries[i].stream_name_nbytes != 0) {
lte = inode->i_ads_entries[i].lte;
if (lte) {
maybe_add_stream_for_extraction(lte,
#endif
}
-static void find_streams_for_extraction(struct hlist_head *inode_list,
- struct list_head *stream_list,
- struct wim_lookup_table *lookup_table,
- int extract_flags)
+static void
+find_streams_for_extraction(struct hlist_head *inode_list,
+ struct list_head *stream_list,
+ struct wim_lookup_table *lookup_table,
+ int extract_flags)
{
struct wim_inode *inode;
struct hlist_node *cur;
};
#endif
-static int apply_stream_list(struct list_head *stream_list,
- struct apply_args *args,
- const struct apply_operations *ops,
- wimlib_progress_func_t progress_func)
+static int
+apply_stream_list(struct list_head *stream_list,
+ struct apply_args *args,
+ const struct apply_operations *ops,
+ wimlib_progress_func_t progress_func)
{
uint64_t bytes_per_progress = args->progress.extract.total_bytes / 100;
uint64_t next_progress = bytes_per_progress;
/* Extracts the image @image from the WIM @w to the directory or NTFS volume
* @target. */
-static int extract_single_image(WIMStruct *w, int image,
- const char *target, int extract_flags,
- wimlib_progress_func_t progress_func)
+static int
+extract_single_image(WIMStruct *w, int image,
+ const tchar *target, int extract_flags,
+ wimlib_progress_func_t progress_func)
{
int ret;
struct list_head stream_list;
struct apply_args args;
const struct apply_operations *ops;
- args.w = w;
- args.target = target;
- args.extract_flags = extract_flags;
- args.num_lutimes_warnings = 0;
- args.stream_list = &stream_list;
- args.progress_func = progress_func;
+ args.w = w;
+ args.target = target;
+ args.extract_flags = extract_flags;
+ args.num_utime_warnings = 0;
+ args.stream_list = &stream_list;
+ args.progress_func = progress_func;
if (progress_func) {
args.progress.extract.wimfile_name = w->filename;
if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
args.vol = ntfs_mount(target, 0);
if (!args.vol) {
- ERROR_WITH_ERRNO("Failed to mount NTFS volume `%s'", target);
+ ERROR_WITH_ERRNO("Failed to mount NTFS volume `%"TS"'",
+ target);
return WIMLIB_ERR_NTFS_3G;
}
ops = &ntfs_apply_operations;
/* Unmount the NTFS volume */
if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
if (ntfs_umount(args.vol, FALSE) != 0) {
- ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", args.target);
+ ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%"TS"'",
+ args.target);
if (ret == 0)
ret = WIMLIB_ERR_NTFS_3G;
}
}
+static bool
+image_name_ok_as_dir(const tchar *image_name)
+{
+ if (image_name == NULL)
+ return false;
+ if (image_name[0] == T('\0'))
+ return false;
+ if (tstrchr(image_name, T('/')))
+ return false;
+ if (tstrchr(image_name, T('\\')))
+ return false;
+ return true;
+}
+
/* Extracts all images from the WIM to the directory @target, with the images
* placed in subdirectories named by their image names. */
-static int extract_all_images(WIMStruct *w, const char *target,
- int extract_flags,
- wimlib_progress_func_t progress_func)
+static int
+extract_all_images(WIMStruct *w,
+ const tchar *target,
+ int extract_flags,
+ wimlib_progress_func_t progress_func)
{
size_t image_name_max_len = max(xml_get_max_image_name_len(w), 20);
- size_t output_path_len = strlen(target);
- char buf[output_path_len + 1 + image_name_max_len + 1];
+ size_t output_path_len = tstrlen(target);
+ tchar buf[output_path_len + 1 + image_name_max_len + 1];
int ret;
int image;
- const char *image_name;
+ const tchar *image_name;
ret = extract_directory(NULL, target, true);
- if (ret != 0)
+ if (ret)
return ret;
- memcpy(buf, target, output_path_len);
- buf[output_path_len] = '/';
+ wmemcpy(buf, target, output_path_len);
+ buf[output_path_len] = T('/');
for (image = 1; image <= w->hdr.image_count; image++) {
image_name = wimlib_get_image_name(w, image);
- if (image_name && *image_name) {
- strcpy(buf + output_path_len + 1, image_name);
+ if (image_name_ok_as_dir(image_name)) {
+ tstrcpy(buf + output_path_len + 1, image_name);
} else {
- /* Image name is empty. Use image number instead */
- sprintf(buf + output_path_len + 1, "%d", image);
+ /* Image name is empty, or may not be representable in
+ * the current locale, or contains path separators. Use
+ * the image number instead. */
+ tsprintf(buf + output_path_len + 1, T("%d"), image);
}
ret = extract_single_image(w, image, buf, extract_flags,
progress_func);
/* Extracts a single image or all images from a WIM file to a directory or NTFS
* volume. */
-WIMLIBAPI int wimlib_extract_image(WIMStruct *w,
- int image,
- const char *target,
- int extract_flags,
- WIMStruct **additional_swms,
- unsigned num_additional_swms,
- wimlib_progress_func_t progress_func)
+WIMLIBAPI int
+wimlib_extract_image(WIMStruct *w,
+ int image,
+ const tchar *target,
+ int extract_flags,
+ WIMStruct **additional_swms,
+ unsigned num_additional_swms,
+ wimlib_progress_func_t progress_func)
{
struct wim_lookup_table *joined_tab, *w_tab_save;
int ret;
== (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))
return WIMLIB_ERR_INVALID_PARAM;
-#if defined(__CYGWIN__) || defined(__WIN32__)
+#ifdef __WIN32__
if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
ERROR("Extracting UNIX data is not supported on Windows");
return WIMLIB_ERR_INVALID_PARAM;