X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fextract_image.c;h=d91f7262fbaf56bf79b5b6b95bbbe7935b778052;hp=ba9b8c675d47e90dd98c70e502236330dcfbf199;hb=a2984b07d10ef6b49a509cf0289bd9dc824e42e7;hpb=36a737d734cdc6c6eb0ce9da3183a1f8fa4288e6 diff --git a/src/extract_image.c b/src/extract_image.c index ba9b8c67..d91f7262 100644 --- a/src/extract_image.c +++ b/src/extract_image.c @@ -10,7 +10,7 @@ */ /* - * Copyright (C) 2012 Eric Biggers + * Copyright (C) 2012, 2013 Eric Biggers * * This file is part of wimlib, a library for working with WIM files. * @@ -30,6 +30,14 @@ #include "config.h" +#if defined(__CYGWIN__) || defined(__WIN32__) +#include +# ifdef ERROR +# undef ERROR +# endif +#include +#endif + #include #include #include @@ -54,10 +62,205 @@ #include #endif -static int extract_regular_file_linked(struct dentry *dentry, +#ifdef HAVE_ALLOCA_H +#include +#else +#include +#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, + const char *path_utf8) +{ + int ret; + u8 *buf; + size_t len; + + if (!lte) { + WARNING("\"%s\" is marked as a reparse point but had no reparse data", + path_utf8); + return 0; + } + len = wim_resource_size(lte); + if (len > 16 * 1024 - 8) { + WARNING("\"%s\": reparse data too long!", path_utf8); + return 0; + } + 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; + if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, buf, len + 8, + NULL, 0, NULL, NULL)) + { + DWORD err = GetLastError(); + ERROR("Failed to set reparse data on \"%s\"", + path_utf8); + win32_error(err); + ret = WIMLIB_ERR_WRITE; + } else + ret = 0; + return ret; +} + + +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, + const char *path_utf8) +{ + wchar_t *stream_path; + HANDLE h; + int ret; + + if (stream_name_utf16) { + size_t stream_path_nchars; + size_t path_nchars = wcslen(path); + size_t stream_name_nchars = wcslen(stream_name_utf16); + + stream_path_nchars = path_nchars + 1 + stream_name_nchars; + + stream_path = alloca((stream_path_nchars + 1) * sizeof(wchar_t)); + + memcpy(stream_path, path, path_nchars * sizeof(wchar_t)); + stream_path[path_nchars] = L':'; + memcpy(&stream_path[path_nchars + 1], stream_name_utf16, + stream_name_nchars * sizeof(wchar_t)); + stream_path[stream_path_nchars] = L'\0'; + + /*wsprintf(stream_path, stream_path_nchars, L"%ls:%ls",*/ + /*path, stream_name_utf16);*/ + } else { + stream_path = (wchar_t*)path; + } + + h = CreateFileW(stream_path, + GENERIC_WRITE | WRITE_OWNER | WRITE_DAC, + 0, + NULL, + CREATE_ALWAYS, + FILE_FLAG_OPEN_REPARSE_POINT | + FILE_FLAG_BACKUP_SEMANTICS | + inode->i_attributes, + NULL); + if (!h) { + win32_error(GetLastError()); + ret = WIMLIB_ERR_OPEN; + goto fail; + } + + if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { + ret = win32_set_reparse_data(h, inode->i_reparse_tag, + lte, path, path_utf8); + if (ret) + goto fail_close_handle; + } else { + if (lte) { + ret = do_win32_extract_stream(h, lte); + if (ret) + goto fail_close_handle; + } + } + + if (!CloseHandle(h)) { + win32_error(GetLastError()); + ret = WIMLIB_ERR_WRITE; + goto fail; + } + ret = 0; + goto out; +fail_close_handle: + CloseHandle(h); +fail: + ERROR("Error extracting %s", path_utf8); +out: + return ret; +} + +static int win32_extract_streams(struct wim_inode *inode, + const wchar_t *path, + const char *path_utf8) +{ + struct wim_lookup_table_entry *unnamed_lte; + int ret; + + ret = win32_extract_stream(inode, path, NULL, unnamed_lte, path_utf8); + 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) { + ret = win32_extract_stream(inode, + path, + (const wchar_t*)ads_entry->stream_name, + ads_entry->lte, + path_utf8); + if (ret) + goto out; + } + } + ret = 0; +out: + return ret; +} + +static int win32_set_security_data(const struct wim_inode *inode, + const wchar_t *path, + const struct wim_security_data *sd, + const char *path_utf8) +{ + 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 \"%s\"", path_utf8); + win32_error(err); + return WIMLIB_ERR_WRITE; + } + return 0; +} + +#else +static int extract_regular_file_linked(struct wim_dentry *dentry, const char *output_path, struct apply_args *args, - struct lookup_table_entry *lte) + struct wim_lookup_table_entry *lte) { /* This mode overrides the normal hard-link extraction and * instead either symlinks or hardlinks *all* identical files in @@ -114,44 +317,101 @@ static int extract_regular_file_linked(struct dentry *dentry, return 0; } -static int extract_regular_file_unlinked(struct dentry *dentry, +static int symlink_apply_unix_data(const char *link, + const struct wimlib_unix_data *unix_data) +{ + if (lchown(link, unix_data->uid, unix_data->gid)) { + if (errno == EPERM) { + /* Ignore */ + WARNING_WITH_ERRNO("failed to set symlink UNIX owner/group"); + } else { + ERROR_WITH_ERRNO("failed to set symlink UNIX owner/group"); + return WIMLIB_ERR_INVALID_DENTRY; + } + } + return 0; +} + +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) { + WARNING_WITH_ERRNO("failed to set file UNIX owner/group"); + /* Ignore? */ + } else { + ERROR_WITH_ERRNO("failed to set file UNIX owner/group"); + return WIMLIB_ERR_INVALID_DENTRY; + } + } + + if (fchmod(fd, unix_data->mode)) { + if (errno == EPERM) { + WARNING_WITH_ERRNO("failed to set UNIX file mode"); + /* Ignore? */ + } else { + ERROR_WITH_ERRNO("failed to set UNIX file mode"); + return WIMLIB_ERR_INVALID_DENTRY; + } + } + return 0; +} + +static int dir_apply_unix_data(const char *dir, + const struct wimlib_unix_data *unix_data) +{ + int dfd = open(dir, O_RDONLY); + int ret; + if (dfd >= 0) { + ret = fd_apply_unix_data(dfd, unix_data); + if (close(dfd)) { + ERROR_WITH_ERRNO("can't close directory `%s'", dir); + ret = WIMLIB_ERR_MKDIR; + } + } else { + ERROR_WITH_ERRNO("can't open directory `%s'", dir); + ret = WIMLIB_ERR_MKDIR; + } + return ret; +} + +static int extract_regular_file_unlinked(struct wim_dentry *dentry, struct apply_args *args, const char *output_path, - struct lookup_table_entry *lte) + 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. */ int out_fd; int ret; - struct inode *inode = dentry->d_inode; + struct wim_inode *inode = dentry->d_inode; if (!((args->extract_flags & WIMLIB_EXTRACT_FLAG_MULTI_IMAGE) && (args->extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)))) { - /* If the dentry is one of a hard link set of at least 2 + /* If the dentry is part of a hard link set of at least 2 * dentries and one of the other dentries has already been * extracted, make a hard link to the file corresponding to this - * already-extracted directory. Otherwise, extract the file, - * and set the inode->extracted_file field so that other - * dentries in the hard link group can link to it. */ - if (inode->link_count > 1) { - if (inode->extracted_file) { + * already-extracted directory. Otherwise, extract the file and + * set the inode->i_extracted_file field so that other dentries + * in the hard link group can link to it. */ + if (inode->i_nlink > 1) { + if (inode->i_extracted_file) { DEBUG("Extracting hard link `%s' => `%s'", - output_path, inode->extracted_file); - if (link(inode->extracted_file, output_path) != 0) { + output_path, inode->i_extracted_file); + if (link(inode->i_extracted_file, output_path) != 0) { ERROR_WITH_ERRNO("Failed to hard link " "`%s' to `%s'", output_path, - inode->extracted_file); + inode->i_extracted_file); return WIMLIB_ERR_LINK; } return 0; } - FREE(inode->extracted_file); - inode->extracted_file = STRDUP(output_path); - if (!inode->extracted_file) { + FREE(inode->i_extracted_file); + inode->i_extracted_file = STRDUP(output_path); + if (!inode->i_extracted_file) { ERROR("Failed to allocate memory for filename"); return WIMLIB_ERR_NOMEM; } @@ -171,7 +431,7 @@ static int extract_regular_file_unlinked(struct dentry *dentry, /* Empty file with no lookup table entry */ DEBUG("Empty file `%s'.", output_path); ret = 0; - goto out; + goto out_extract_unix_data; } ret = extract_wim_resource_to_fd(lte, out_fd, wim_resource_size(lte)); @@ -179,24 +439,37 @@ static int extract_regular_file_unlinked(struct dentry *dentry, ERROR("Failed to extract resource to `%s'", output_path); goto out; } - args->progress.extract.completed_bytes += wim_resource_size(lte); + +out_extract_unix_data: + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + struct wimlib_unix_data unix_data; + ret = inode_get_unix_data(inode, &unix_data, NULL); + if (ret > 0) + ; + else if (ret < 0) + ret = 0; + else + ret = fd_apply_unix_data(out_fd, &unix_data); + if (ret != 0) + goto out; + } + if (lte) + args->progress.extract.completed_bytes += wim_resource_size(lte); out: if (close(out_fd) != 0) { ERROR_WITH_ERRNO("Failed to close file `%s'", output_path); - ret = WIMLIB_ERR_WRITE; + if (ret == 0) + ret = WIMLIB_ERR_WRITE; } return ret; } -/* - * Extracts a regular file from the WIM archive. - */ -static int extract_regular_file(struct dentry *dentry, +static int extract_regular_file(struct wim_dentry *dentry, struct apply_args *args, const char *output_path) { - struct lookup_table_entry *lte; - const struct inode *inode = dentry->d_inode; + struct wim_lookup_table_entry *lte; + const struct wim_inode *inode = dentry->d_inode; lte = inode_unnamed_lte_resolved(inode); @@ -214,14 +487,14 @@ static int extract_regular_file(struct dentry *dentry, return extract_regular_file_unlinked(dentry, args, output_path, lte); } -static int extract_symlink(struct dentry *dentry, +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, sizeof(target), args->w, 0); - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; if (ret <= 0) { ERROR("Could not read the symbolic link from dentry `%s'", @@ -235,27 +508,37 @@ static int extract_symlink(struct dentry *dentry, return WIMLIB_ERR_LINK; } lte = inode_unnamed_lte_resolved(dentry->d_inode); + wimlib_assert(lte != NULL); + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + struct wimlib_unix_data unix_data; + ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL); + if (ret > 0) + ; + else if (ret < 0) + ret = 0; + else + ret = symlink_apply_unix_data(output_path, &unix_data); + if (ret != 0) + return ret; + } args->progress.extract.completed_bytes += wim_resource_size(lte); return 0; } -/* - * Extracts a directory from the WIM archive. - * - * @dentry: The directory entry for the directory. - * @output_path: The path to which the directory is to be extracted to. - * @return: True on success, false on failure. - */ -static int extract_directory(const char *output_path, bool is_root) +#endif /* !__CYGWIN__ && !__WIN32__ */ + +static int extract_directory(struct wim_dentry *dentry, + const char *output_path, bool is_root) { int ret; struct stat stbuf; + ret = stat(output_path, &stbuf); if (ret == 0) { if (S_ISDIR(stbuf.st_mode)) { /*if (!is_root)*/ /*WARNING("`%s' already exists", output_path);*/ - return 0; + goto dir_exists; } else { ERROR("`%s' is not a directory", output_path); return WIMLIB_ERR_MKDIR; @@ -266,42 +549,34 @@ static int extract_directory(const char *output_path, bool is_root) return WIMLIB_ERR_STAT; } } - /* Compute the output path directory to the directory. */ if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) { ERROR_WITH_ERRNO("Cannot create directory `%s'", output_path); return WIMLIB_ERR_MKDIR; } - return 0; +dir_exists: + if (dentry) { + struct wimlib_unix_data unix_data; + ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL); + if (ret > 0) + ; + else if (ret < 0) + ret = 0; + else + ret = dir_apply_unix_data(output_path, &unix_data); + } else { + ret = 0; + } + return ret; } -/* - * Extracts a file, directory, or symbolic link from the WIM archive. For use - * in for_dentry_in_tree(). - */ -static int apply_dentry_normal(struct dentry *dentry, void *arg) +/* 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; - int extract_flags = args->extract_flags; - struct inode *inode = dentry->d_inode; + struct wim_inode *inode = dentry->d_inode; size_t len; - int ret; - - if (dentry->is_extracted) - return 0; - - if (extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) - if (inode_unnamed_lte_resolved(inode)) - return 0; - - if ((extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) && - args->progress_func) - { - args->progress.extract.cur_path = dentry->full_path_utf8; - args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY, - &args->progress); - } len = strlen(args->target); char output_path[len + dentry->full_path_utf8_len + 1]; @@ -309,33 +584,136 @@ static int apply_dentry_normal(struct dentry *dentry, void *arg) memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len); output_path[len + dentry->full_path_utf8_len] = '\0'; +#if defined(__CYGWIN__) || defined(__WIN32__) + char *utf16_path; + size_t utf16_path_len; + DWORD err; + int ret; + ret = utf8_to_utf16(output_path, len + dentry->full_path_utf8_len, + &utf16_path, &utf16_path_len); + if (ret) + return ret; + + if (inode->i_nlink > 1 && inode->i_extracted_file != NULL) { + /* Linked file, with another name already extracted */ + if (!CreateHardLinkW((const wchar_t*)inode->i_extracted_file, + (const wchar_t*)utf16_path, + NULL)) + { + err = GetLastError(); + ERROR("Can't create hard link \"%s\"", output_path); + ret = WIMLIB_ERR_LINK; + win32_error(err); + goto out_free_utf16_path; + } + ret = 0; + goto out_free_utf16_path; + } + ret = win32_extract_streams(inode, (const wchar_t*)utf16_path, + output_path); + if (ret) + goto out_free_utf16_path; + + if (inode->i_security_id != -1) { + ret = win32_set_security_data(inode, + (const wchar_t*)utf16_path, + wim_const_security_data(args->w), + output_path); + if (ret) + goto out_free_utf16_path; + } + + /*if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {*/ + /*ret = win32_set_reparse_data(inode, path, output_path);*/ + /*if (ret)*/ + /*goto out_free_utf16_path;*/ + /*}*/ + + if (inode->i_nlink > 1) { + inode->i_extracted_file = utf16_path; + utf16_path = NULL; + } + ret = 0; +out_free_utf16_path: + FREE(utf16_path); + return ret; +#else if (inode_is_symlink(inode)) - ret = extract_symlink(dentry, args, output_path); + return extract_symlink(dentry, args, output_path); else if (inode_is_directory(inode)) - ret = extract_directory(output_path, false); + return extract_directory((args->extract_flags & + WIMLIB_EXTRACT_FLAG_UNIX_DATA) ? dentry : NULL, + output_path, false); else - ret = extract_regular_file(dentry, args, output_path); - if (ret == 0) - dentry->is_extracted = 1; - return ret; + return extract_regular_file(dentry, args, output_path); +#endif } -/* Apply timestamp to extracted file */ -static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) +/* 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 = strlen(args->target); char output_path[len + dentry->full_path_utf8_len + 1]; - const struct inode *inode = dentry->d_inode; + const struct wim_inode *inode = dentry->d_inode; int ret; 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'; +#if defined(__CYGWIN__) || defined(__WIN32__) + /* Win32 */ + char *utf16_path; + size_t utf16_path_len; + DWORD err; + HANDLE h; + BOOL bret1, bret2; + + ret = utf8_to_utf16(output_path, len + dentry->full_path_utf8_len, + &utf16_path, &utf16_path_len); + if (ret) + return ret; + h = CreateFile(utf16_path, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, + NULL); + + if (!h) + err = GetLastError(); + FREE(utf16_path); + if (!h) + 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}; + + if (!SetFileTime(h, &creationTime, &lastAccessTime, &lastWriteTime)) { + err = GetLastError(); + CloseHandle(h); + goto fail; + } + if (!CloseHandle(h)) { + err = GetLastError(); + goto fail; + } + return 0; +fail: + err = GetLastError(); + ERROR("Can't set timestamps on \"%s\"", output_path); + win32_error(err); + return WIMLIB_ERR_WRITE; +#else + /* UNIX */ + + /* Convert the WIM timestamps, which are accurate to 100 nanoseconds, + * into struct timeval's. */ struct timeval tv[2]; - wim_timestamp_to_timeval(inode->last_access_time, &tv[0]); - wim_timestamp_to_timeval(inode->last_write_time, &tv[1]); + 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 @@ -346,26 +724,53 @@ static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) #ifdef HAVE_UTIME if (errno == ENOSYS) { struct utimbuf buf; - buf.actime = wim_timestamp_to_unix(inode->last_access_time); - buf.modtime = wim_timestamp_to_unix(inode->last_write_time); + 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("Failed to set timestamp on file `%s': %s",*/ - /*output_path, strerror(errno));*/ + /*WARNING_WITH_ERRNO("Failed to set timestamp on file `%s',*/ + /*output_path");*/ args->num_lutimes_warnings++; } } return 0; +#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) +{ + struct apply_args *args = arg; + int ret; + + if (dentry->is_extracted) + return 0; + + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) + if (inode_unnamed_lte_resolved(dentry->d_inode)) + return 0; + + if ((args->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) && + args->progress_func) { + args->progress.extract.cur_path = dentry->full_path_utf8; + args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY, + &args->progress); + } + ret = args->apply_dentry(dentry, args); + if (ret == 0) + dentry->is_extracted = 1; + return ret; } static int cmp_streams_by_wim_position(const void *p1, const void *p2) { - const struct lookup_table_entry *lte1, *lte2; - lte1 = *(const struct lookup_table_entry**)p1; - lte2 = *(const struct lookup_table_entry**)p2; + const struct wim_lookup_table_entry *lte1, *lte2; + lte1 = *(const struct wim_lookup_table_entry**)p1; + lte2 = *(const struct wim_lookup_table_entry**)p2; if (lte1->resource_entry.offset < lte2->resource_entry.offset) return -1; else if (lte1->resource_entry.offset > lte2->resource_entry.offset) @@ -378,7 +783,7 @@ static int sort_stream_list_by_wim_position(struct list_head *stream_list) { struct list_head *cur; size_t num_streams; - struct lookup_table_entry **array; + struct wim_lookup_table_entry **array; size_t i; size_t array_size; @@ -394,7 +799,7 @@ static int sort_stream_list_by_wim_position(struct list_head *stream_list) } cur = stream_list->next; for (i = 0; i < num_streams; i++) { - array[i] = container_of(cur, struct lookup_table_entry, staging_list); + array[i] = container_of(cur, struct wim_lookup_table_entry, staging_list); cur = cur->next; } @@ -411,7 +816,7 @@ static void calculate_bytes_to_extract(struct list_head *stream_list, int extract_flags, union wimlib_progress_info *progress) { - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; u64 total_bytes = 0; u64 num_streams = 0; @@ -438,7 +843,7 @@ static void calculate_bytes_to_extract(struct list_head *stream_list, progress->extract.completed_bytes = 0; } -static void maybe_add_stream_for_extraction(struct lookup_table_entry *lte, +static void maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte, struct list_head *stream_list) { if (++lte->out_refcnt == 1) { @@ -447,30 +852,29 @@ static void maybe_add_stream_for_extraction(struct lookup_table_entry *lte, } } -static void inode_find_streams_for_extraction(struct inode *inode, +static void inode_find_streams_for_extraction(struct wim_inode *inode, struct list_head *stream_list, int extract_flags) { - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; bool inode_added = false; lte = inode_unnamed_lte_resolved(inode); - if (lte) { maybe_add_stream_for_extraction(lte, stream_list); - list_add_tail(&inode->lte_inode_list, <e->inode_list); + list_add_tail(&inode->i_lte_inode_list, <e->inode_list); inode_added = true; } #ifdef WITH_NTFS_3G if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { - for (unsigned i = 0; i < inode->num_ads; i++) { - if (inode->ads_entries[i].stream_name_len != 0) { - lte = inode->ads_entries[i].lte; + for (unsigned i = 0; i < inode->i_num_ads; i++) { + if (inode->i_ads_entries[i].stream_name_len != 0) { + lte = inode->i_ads_entries[i].lte; if (lte) { maybe_add_stream_for_extraction(lte, stream_list); if (!inode_added) { - list_add_tail(&inode->lte_inode_list, + list_add_tail(&inode->i_lte_inode_list, <e->inode_list); inode_added = true; } @@ -483,17 +887,17 @@ static void inode_find_streams_for_extraction(struct inode *inode, static void find_streams_for_extraction(struct hlist_head *inode_list, struct list_head *stream_list, - struct lookup_table *lookup_table, + struct wim_lookup_table *lookup_table, int extract_flags) { - struct inode *inode; + struct wim_inode *inode; struct hlist_node *cur; - struct dentry *dentry; + struct wim_dentry *dentry; for_lookup_table_entry(lookup_table, lte_zero_out_refcnt, NULL); INIT_LIST_HEAD(stream_list); - hlist_for_each_entry(inode, cur, inode_list, hlist) { - if (!inode->resolved) + hlist_for_each_entry(inode, cur, inode_list, i_hlist) { + if (!inode->i_resolved) inode_resolve_ltes(inode, lookup_table); inode_for_each_dentry(dentry, inode) dentry->is_extracted = 0; @@ -503,8 +907,8 @@ static void find_streams_for_extraction(struct hlist_head *inode_list, } struct apply_operations { - int (*apply_dentry)(struct dentry *dentry, void *arg); - int (*apply_dentry_timestamps)(struct dentry *dentry, void *arg); + int (*apply_dentry)(struct wim_dentry *dentry, void *arg); + int (*apply_dentry_timestamps)(struct wim_dentry *dentry, void *arg); }; static const struct apply_operations normal_apply_operations = { @@ -526,40 +930,54 @@ static int apply_stream_list(struct list_head *stream_list, { uint64_t bytes_per_progress = args->progress.extract.total_bytes / 100; uint64_t next_progress = bytes_per_progress; - struct lookup_table_entry *lte; - struct inode *inode; - struct dentry *dentry; - int ret = 0; + struct wim_lookup_table_entry *lte; + struct wim_inode *inode; + struct wim_dentry *dentry; + int ret; - /* This complicated loop is actually just looping through the dentries - * (as for_dentry_in_tree() does), but the outer loop is actually over - * the distinct streams to be extracted so that sequential reading of - * the WIM can be implemented. */ + /* This complicated loop is essentially looping through the dentries, + * although dentries may be visited more than once (if a dentry contains + * two different nonempty streams) or not at all (if a dentry contains + * no non-empty streams). + * + * The outer loop is over the distinct streams to be extracted so that + * sequential reading of the WIM can be implemented. */ /* For each distinct stream to be extracted */ list_for_each_entry(lte, stream_list, staging_list) { /* For each inode that contains the stream */ - list_for_each_entry(inode, <e->inode_list, lte_inode_list) { + list_for_each_entry(inode, <e->inode_list, i_lte_inode_list) { /* For each dentry that points to the inode */ inode_for_each_dentry(dentry, inode) { - ret = ops->apply_dentry(dentry, args); + /* Extract the dentry if it was not already + * extracted */ + ret = maybe_apply_dentry(dentry, args); if (ret != 0) - goto out; + return ret; if (progress_func && - args->progress.extract.completed_bytes >= next_progress && - args->progress.extract.total_bytes != 0) + args->progress.extract.completed_bytes >= next_progress) { progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS, &args->progress); - next_progress += bytes_per_progress; + if (args->progress.extract.completed_bytes >= + args->progress.extract.total_bytes) + { + next_progress = ~0ULL; + } else { + next_progress = + min (args->progress.extract.completed_bytes + + bytes_per_progress, + args->progress.extract.total_bytes); + } } } } } -out: - return ret; + return 0; } +/* 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) @@ -575,7 +993,6 @@ static int extract_single_image(WIMStruct *w, int image, args.target = target; args.extract_flags = extract_flags; args.num_lutimes_warnings = 0; - args.target = target; args.stream_list = &stream_list; args.progress_func = progress_func; @@ -606,9 +1023,11 @@ static int extract_single_image(WIMStruct *w, int image, inode_list = &w->image_metadata[image - 1].inode_list; + /* Build a list of the streams that need to be extracted */ find_streams_for_extraction(inode_list, &stream_list, w->lookup_table, extract_flags); + /* Calculate the number of bytes of data that will be extracted */ calculate_bytes_to_extract(&stream_list, extract_flags, &args.progress); @@ -617,6 +1036,9 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* If a sequential extraction was specified, sort the streams to be + * extracted by their position in the WIM file, so that the WIM file can + * be read sequentially. */ if (extract_flags & WIMLIB_EXTRACT_FLAG_SEQUENTIAL) { ret = sort_stream_list_by_wim_position(&stream_list); if (ret != 0) { @@ -630,8 +1052,10 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* Make the directory structure and extract empty files */ args.extract_flags |= WIMLIB_EXTRACT_FLAG_NO_STREAMS; - ret = for_dentry_in_tree(wim_root_dentry(w), ops->apply_dentry, &args); + args.apply_dentry = ops->apply_dentry; + ret = for_dentry_in_tree(wim_root_dentry(w), maybe_apply_dentry, &args); args.extract_flags &= ~WIMLIB_EXTRACT_FLAG_NO_STREAMS; if (ret != 0) goto out; @@ -641,13 +1065,17 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* Extract non-empty files */ ret = apply_stream_list(&stream_list, &args, ops, progress_func); if (ret != 0) goto out; - if (progress_func) - progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, NULL); + if (progress_func) { + progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, + &args.progress); + } + /* Apply timestamps */ ret = for_dentry_in_tree_depth(wim_root_dentry(w), ops->apply_dentry_timestamps, &args); if (ret != 0) @@ -659,6 +1087,7 @@ static int extract_single_image(WIMStruct *w, int image, } out: #ifdef WITH_NTFS_3G + /* 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); @@ -671,8 +1100,8 @@ out: } -/* Extracts all images from the WIM to @output_dir, with the images placed in - * subdirectories named by their image names. */ +/* 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) @@ -684,7 +1113,7 @@ static int extract_all_images(WIMStruct *w, const char *target, int image; const char *image_name; - ret = extract_directory(target, true); + ret = extract_directory(NULL, target, true); if (ret != 0) return ret; @@ -706,15 +1135,17 @@ static int extract_all_images(WIMStruct *w, const char *target, return 0; } -/* Extracts a single image or all images from a WIM file. */ -WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, +/* 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) { - struct lookup_table *joined_tab, *w_tab_save; + struct wim_lookup_table *joined_tab, *w_tab_save; int ret; if (!target) @@ -726,6 +1157,13 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, == (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)) return WIMLIB_ERR_INVALID_PARAM; +#if defined(__CYGWIN__) || defined(__WIN32__) + if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + ERROR("Extracting UNIX data is not supported on Windows"); + return WIMLIB_ERR_INVALID_PARAM; + } +#endif + if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { #ifdef WITH_NTFS_3G if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))) { @@ -738,6 +1176,10 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, "directly to a NTFS volume"); return WIMLIB_ERR_INVALID_PARAM; } + if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + ERROR("Cannot restore UNIX-specific data in the NTFS extraction mode"); + return WIMLIB_ERR_INVALID_PARAM; + } #else ERROR("wimlib was compiled without support for NTFS-3g, so"); ERROR("we cannot apply a WIM image directly to a NTFS volume");