+ struct list_head *next = inode->i_extraction_aliases.next;
+ struct wim_dentry *dentry;
+
+ do {
+ dentry = list_entry(next, struct wim_dentry,
+ d_extraction_alias_node);
+ if (dentry_has_short_name(dentry))
+ break;
+ next = next->next;
+ } while (next != &inode->i_extraction_aliases);
+ return dentry;
+}
+
+/*
+ * Add a hard link for the NTFS inode @ni at the location corresponding to the
+ * WIM dentry @dentry.
+ *
+ * The parent directory must have already been created on the NTFS volume.
+ *
+ * Returns 0 on success; returns WIMLIB_ERR_NTFS_3G and sets errno on failure.
+ */
+static int
+ntfs_3g_add_link(ntfs_inode *ni, struct wim_dentry *dentry)
+{
+ ntfs_inode *dir_ni;
+ int res;
+
+ /* Open the inode of the parent directory. */
+ dir_ni = ntfs_inode_open(ni->vol, dentry->d_parent->d_inode->i_mft_no);
+ if (!dir_ni)
+ goto fail;
+
+ /* Create the link. */
+ res = ntfs_link(ni, dir_ni, dentry->d_extraction_name,
+ dentry->d_extraction_name_nchars);
+
+ /* Close the parent directory. */
+ if (ntfs_inode_close(dir_ni) || res)
+ goto fail;
+
+ return 0;
+
+fail:
+ ERROR_WITH_ERRNO("Can't create link \"%s\" in NTFS volume",
+ dentry_full_path(dentry));
+ return WIMLIB_ERR_NTFS_3G;
+}
+
+static int
+ntfs_3g_create_nondirectory(struct wim_inode *inode,
+ const struct ntfs_3g_apply_ctx *ctx)
+{
+ struct wim_dentry *first_dentry;
+ ntfs_inode *dir_ni;
+ ntfs_inode *ni;
+ struct list_head *next;
+ struct wim_dentry *dentry;
+ int ret;
+
+ first_dentry = ntfs_3g_first_extraction_alias(inode);
+
+ /* Create first link. */
+
+ dir_ni = ntfs_inode_open(ctx->vol, first_dentry->d_parent->d_inode->i_mft_no);
+ if (!dir_ni) {
+ ERROR_WITH_ERRNO("Can't open \"%s\" in NTFS volume",
+ dentry_full_path(first_dentry->d_parent));
+ return WIMLIB_ERR_NTFS_3G;
+ }
+
+ ni = ntfs_create(dir_ni, 0, first_dentry->d_extraction_name,
+ first_dentry->d_extraction_name_nchars, S_IFREG);
+
+ if (!ni) {
+ ERROR_WITH_ERRNO("Can't create \"%s\" in NTFS volume",
+ dentry_full_path(first_dentry));
+ ntfs_inode_close(dir_ni);
+ return WIMLIB_ERR_NTFS_3G;
+ }
+
+ inode->i_mft_no = ni->mft_no;
+
+ /* Set short name if present. */
+ if (dentry_has_short_name(first_dentry)) {
+
+ ret = ntfs_3g_restore_dos_name(ni, dir_ni, first_dentry, ctx->vol);
+
+ /* ntfs_3g_restore_dos_name() closed both 'ni' and 'dir_ni'. */
+
+ if (ret)
+ return ret;
+
+ /* Reopen the inode. */
+ ni = ntfs_inode_open(ctx->vol, inode->i_mft_no);
+ if (!ni) {
+ ERROR_WITH_ERRNO("Failed to reopen \"%s\" "
+ "in NTFS volume",
+ dentry_full_path(first_dentry));
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ } else {
+ /* Close the directory in which the first link was created. */
+ if (ntfs_inode_close(dir_ni)) {
+ ERROR_WITH_ERRNO("Failed to close \"%s\" in NTFS volume",
+ dentry_full_path(first_dentry->d_parent));
+ ret = WIMLIB_ERR_NTFS_3G;
+ goto out_close_ni;
+ }
+ }
+
+ /* Create additional links if present. */
+ next = inode->i_extraction_aliases.next;
+ do {
+ dentry = list_entry(next, struct wim_dentry,
+ d_extraction_alias_node);
+ if (dentry != first_dentry) {
+ ret = ntfs_3g_add_link(ni, dentry);
+ if (ret)
+ goto out_close_ni;
+ }
+ next = next->next;
+ } while (next != &inode->i_extraction_aliases);
+
+ /* Set metadata. */
+ ret = ntfs_3g_set_metadata(ni, inode, ctx);
+ if (ret)
+ goto out_close_ni;
+
+ ret = ntfs_3g_create_any_empty_ads(ni, inode, ctx);
+
+out_close_ni:
+ /* Close the inode. */
+ if (ntfs_inode_close(ni) && !ret) {
+ ERROR_WITH_ERRNO("Error closing \"%s\" in NTFS volume",
+ dentry_full_path(first_dentry));
+ ret = WIMLIB_ERR_NTFS_3G;
+ }
+ return ret;
+}
+
+/* For each WIM dentry in the @dentry_list that represents a nondirectory file,
+ * create the corresponding nondirectory file in the NTFS volume.
+ *
+ * Directories must have already been created. */
+static int
+ntfs_3g_create_nondirectories(struct list_head *dentry_list,
+ struct ntfs_3g_apply_ctx *ctx)
+{
+ struct wim_dentry *dentry;
+ struct wim_inode *inode;
+ int ret;
+
+ list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
+ inode = dentry->d_inode;
+ if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
+ continue;
+ if (dentry != inode_first_extraction_dentry(inode))
+ continue;
+ ret = ntfs_3g_create_nondirectory(inode, ctx);
+ if (ret)
+ return ret;
+ ret = report_file_created(&ctx->common);
+ if (ret)
+ return ret;
+ }
+ return 0;
+}
+
+static int
+ntfs_3g_begin_extract_stream_to_attr(struct wim_lookup_table_entry *stream,
+ ntfs_inode *ni,
+ struct wim_inode *inode,
+ ntfschar *stream_name,
+ struct ntfs_3g_apply_ctx *ctx)
+{
+ struct wim_dentry *one_dentry = inode_first_extraction_dentry(inode);
+ size_t stream_name_nchars = 0;
+ ntfs_attr *attr;
+
+ if (stream_name)
+ for (const ntfschar *p = stream_name; *p; p++)
+ stream_name_nchars++;
+
+ if (stream_name_nchars == 0)
+ stream_name = AT_UNNAMED;
+ if ((inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT)
+ && (stream_name_nchars == 0))
+ {
+ if (stream->size > REPARSE_DATA_MAX_SIZE) {
+ ERROR("Reparse data of \"%s\" has size "
+ "%"PRIu64" bytes (exceeds %u bytes)",
+ dentry_full_path(one_dentry),
+ stream->size, REPARSE_DATA_MAX_SIZE);
+ return WIMLIB_ERR_INVALID_REPARSE_DATA;
+ }
+ ctx->reparse_ptr = ctx->rpbuf.rpdata;
+ ctx->rpbuf.rpdatalen = cpu_to_le16(stream->size);
+ ctx->rpbuf.rpreserved = cpu_to_le16(0);
+ ctx->ntfs_reparse_inodes[ctx->num_reparse_inodes] = ni;
+ ctx->wim_reparse_inodes[ctx->num_reparse_inodes] = inode;
+ ctx->num_reparse_inodes++;
+ return 0;
+ }
+
+ if (stream_name_nchars &&
+ (ntfs_attr_add(ni, AT_DATA, stream_name,
+ stream_name_nchars, NULL, 0)))
+ {
+ ERROR_WITH_ERRNO("Failed to create named data stream of \"%s\"",
+ dentry_full_path(one_dentry));
+ return WIMLIB_ERR_NTFS_3G;
+ }
+
+ /* This should be ensured by extract_stream_list() */
+ wimlib_assert(ctx->num_open_attrs < MAX_OPEN_STREAMS);
+
+ attr = ntfs_attr_open(ni, AT_DATA, stream_name, stream_name_nchars);
+ if (!attr) {
+ ERROR_WITH_ERRNO("Failed to open data stream of \"%s\"",
+ dentry_full_path(one_dentry));
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ ctx->open_attrs[ctx->num_open_attrs++] = attr;
+ ntfs_attr_truncate_solid(attr, stream->size);
+ return 0;
+}
+
+static int
+ntfs_3g_cleanup_stream_extract(struct ntfs_3g_apply_ctx *ctx)
+{
+ int ret = 0;
+
+ for (unsigned i = 0; i < ctx->num_open_attrs; i++) {
+ if (ntfs_attr_pclose(ctx->open_attrs[i]))
+ ret = -1;
+ ntfs_attr_close(ctx->open_attrs[i]);
+ }
+
+ ctx->num_open_attrs = 0;
+
+ for (unsigned i = 0; i < ctx->num_open_inodes; i++) {
+ if (ntfs_inode_close(ctx->open_inodes[i]))
+ ret = -1;
+ }
+ ctx->num_open_inodes = 0;
+
+ ctx->offset = 0;
+ ctx->reparse_ptr = NULL;
+ ctx->num_reparse_inodes = 0;
+ return ret;
+}
+
+static ntfs_inode *
+ntfs_3g_open_inode(struct wim_inode *inode, struct ntfs_3g_apply_ctx *ctx)
+{
+ ntfs_inode *ni = NULL;
+
+ if (inode->i_visited) {
+ for (u32 i = 0; i < ctx->num_open_inodes; i++) {
+ if (ctx->open_inodes[i]->mft_no == inode->i_mft_no) {
+ ni = ctx->open_inodes[i];
+ break;
+ }
+ }
+ }
+ if (!ni) {
+ ni = ntfs_inode_open(ctx->vol, inode->i_mft_no);
+ ctx->open_inodes[ctx->num_open_inodes++] = ni;
+ inode->i_visited = 1;
+ }
+
+ if (!ni) {
+ ERROR_WITH_ERRNO("Can't open \"%s\" in NTFS volume",
+ dentry_full_path(
+ inode_first_extraction_dentry(inode)));
+ return NULL;
+ }
+ return ni;
+}
+
+static int
+ntfs_3g_begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx)
+{
+ struct ntfs_3g_apply_ctx *ctx = _ctx;
+ const struct stream_owner *owners = stream_owners(stream);
+ int ret;
+
+ for (u32 i = 0; i < stream->out_refcnt; i++) {
+ struct wim_inode *inode = owners[i].inode;
+ ntfschar *stream_name = (ntfschar *)owners[i].stream_name;
+ ntfs_inode *ni;
+
+ ret = WIMLIB_ERR_NTFS_3G;
+ ni = ntfs_3g_open_inode(inode, ctx);
+ if (!ni)
+ goto out_cleanup;
+
+ ret = ntfs_3g_begin_extract_stream_to_attr(stream, ni, inode,
+ stream_name, ctx);
+ if (ret)
+ goto out_cleanup;
+ }
+ ret = 0;
+ goto out;
+
+out_cleanup:
+ ntfs_3g_cleanup_stream_extract(ctx);
+out:
+ for (u32 i = 0; i < stream->out_refcnt; i++)
+ owners[i].inode->i_visited = 0;
+ return ret;
+}
+
+static int
+ntfs_3g_extract_chunk(const void *chunk, size_t size, void *_ctx)
+{
+ struct ntfs_3g_apply_ctx *ctx = _ctx;
+ s64 res;
+
+ for (unsigned i = 0; i < ctx->num_open_attrs; i++) {
+ res = ntfs_attr_pwrite(ctx->open_attrs[i],
+ ctx->offset, size, chunk);
+ if (res != size) {
+ ERROR_WITH_ERRNO("Error writing data to NTFS volume");
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ }
+ if (ctx->reparse_ptr)
+ ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
+ ctx->offset += size;
+ return 0;
+}
+
+static int
+ntfs_3g_end_extract_stream(struct wim_lookup_table_entry *stream,
+ int status, void *_ctx)
+{
+ struct ntfs_3g_apply_ctx *ctx = _ctx;
+ int ret;
+
+ if (status) {
+ ret = status;
+ goto out;
+ }
+
+ for (u32 i = 0; i < ctx->num_reparse_inodes; i++) {
+ struct wim_inode *inode = ctx->wim_reparse_inodes[i];
+
+ ctx->rpbuf.rptag = cpu_to_le32(inode->i_reparse_tag);
+
+ if (ntfs_set_ntfs_reparse_data(ctx->ntfs_reparse_inodes[i],
+ (const char *)&ctx->rpbuf,
+ stream->size + REPARSE_DATA_OFFSET,
+ 0))
+ {
+ ERROR_WITH_ERRNO("Failed to set reparse "
+ "data on \"%s\"",
+ dentry_full_path(
+ inode_first_extraction_dentry(inode)));
+ ret = WIMLIB_ERR_NTFS_3G;
+ goto out;
+ }
+ }
+ ret = 0;
+out:
+ if (ntfs_3g_cleanup_stream_extract(ctx) && !ret) {
+ ERROR_WITH_ERRNO("Error writing data to NTFS volume");
+ ret = WIMLIB_ERR_NTFS_3G;
+ }
+ return ret;
+}
+
+static int
+ntfs_3g_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
+{
+ struct ntfs_3g_apply_ctx *ctx = (struct ntfs_3g_apply_ctx *)_ctx;
+ ntfs_volume *vol;
+ struct wim_dentry *root;
+ int ret;
+
+ /* For NTFS-3g extraction mode we require that the dentries to extract
+ * form a single tree. */
+ root = list_first_entry(dentry_list, struct wim_dentry,
+ d_extraction_list_node);
+
+ /* Mount the NTFS volume. */
+ vol = ntfs_mount(ctx->common.target, 0);
+ if (!vol) {
+ ERROR_WITH_ERRNO("Failed to mount \"%s\" with NTFS-3g",
+ ctx->common.target);
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ ctx->vol = vol;
+
+ /* Create all inodes and aliases, including short names, and set
+ * metadata (attributes, security descriptors, and timestamps). */
+
+ reset_file_progress(&ctx->common);
+
+ ret = ntfs_3g_create_directories(root, dentry_list, ctx);
+ if (ret)
+ goto out_unmount;
+
+ ret = ntfs_3g_create_nondirectories(dentry_list, ctx);
+ if (ret)
+ goto out_unmount;
+
+ /* Extract streams. */
+ struct read_stream_list_callbacks cbs = {
+ .begin_stream = ntfs_3g_begin_extract_stream,
+ .begin_stream_ctx = ctx,
+ .consume_chunk = ntfs_3g_extract_chunk,
+ .consume_chunk_ctx = ctx,
+ .end_stream = ntfs_3g_end_extract_stream,
+ .end_stream_ctx = ctx,
+ };
+ ret = extract_stream_list(&ctx->common, &cbs);
+
+ /* We do not need a final pass to set timestamps because libntfs-3g does
+ * not update timestamps automatically (exception:
+ * ntfs_set_ntfs_dos_name() does, but we handle this elsewhere). */
+
+out_unmount:
+ if (ntfs_umount(ctx->vol, FALSE) && !ret) {
+ ERROR_WITH_ERRNO("Failed to unmount \"%s\" with NTFS-3g",
+ ctx->common.target);
+ ret = WIMLIB_ERR_NTFS_3G;
+ }
+ return ret;