extract_wim_resource() refactor
[wimlib] / src / ntfs-apply.c
1 /*
2  * ntfs-apply.c
3  *
4  * Apply a WIM image to a NTFS volume.  We restore everything we can, including
5  * security data and alternate data streams.
6  */
7
8 /*
9  * Copyright (C) 2012 Eric Biggers
10  *
11  * This file is part of wimlib, a library for working with WIM files.
12  *
13  * wimlib is free software; you can redistribute it and/or modify it under the
14  * terms of the GNU General Public License as published by the Free
15  * Software Foundation; either version 3 of the License, or (at your option)
16  * any later version.
17  *
18  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
20  * A PARTICULAR PURPOSE. See the GNU General Public License for more
21  * details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with wimlib; if not, see http://www.gnu.org/licenses/.
25  */
26
27
28 #include "config.h"
29
30
31 #include <ntfs-3g/endians.h>
32 #include <ntfs-3g/types.h>
33
34 #include "wimlib_internal.h"
35 #include "dentry.h"
36 #include "lookup_table.h"
37 #include "buffer_io.h"
38 #include <ntfs-3g/layout.h>
39 #include <ntfs-3g/acls.h>
40 #include <ntfs-3g/attrib.h>
41 #include <ntfs-3g/security.h> /* security.h before xattrs.h */
42 #include <ntfs-3g/xattrs.h>
43 #include <ntfs-3g/reparse.h>
44 #include <stdlib.h>
45 #include <unistd.h>
46
47 static int extract_wim_chunk_to_ntfs_attr(const u8 *buf, size_t len,
48                                           u64 offset, void *arg)
49 {
50         ntfs_attr *na = arg;
51         if (ntfs_attr_pwrite(na, offset, len, buf) == len) {
52                 return 0;
53         } else {
54                 ERROR_WITH_ERRNO("Error extracting WIM resource to NTFS attribute");
55                 return WIMLIB_ERR_WRITE;
56         }
57 }
58
59 /*
60  * Extracts a WIM resource to a NTFS attribute.
61  */
62 static int
63 extract_wim_resource_to_ntfs_attr(const struct lookup_table_entry *lte,
64                                   ntfs_attr *na)
65 {
66         return extract_wim_resource(lte, wim_resource_size(lte),
67                                     extract_wim_chunk_to_ntfs_attr, na);
68 }
69
70 /* Writes the data streams to a NTFS file
71  *
72  * @ni:      The NTFS inode for the file.
73  * @inode:   The WIM dentry that has an inode containing the streams.
74  *
75  * Returns 0 on success, nonzero on failure.
76  */
77 static int write_ntfs_data_streams(ntfs_inode *ni, const struct dentry *dentry,
78                                    struct apply_args *args)
79 {
80         int ret = 0;
81         unsigned stream_idx = 0;
82         ntfschar *stream_name = AT_UNNAMED;
83         u32 stream_name_len = 0;
84         const struct inode *inode = dentry->d_inode;
85
86         DEBUG("Writing %u NTFS data stream%s for `%s'",
87               inode->num_ads + 1,
88               (inode->num_ads == 0 ? "" : "s"),
89               dentry->full_path_utf8);
90
91         while (1) {
92                 struct lookup_table_entry *lte;
93                 ntfs_attr *na;
94
95                 lte = inode_stream_lte_resolved(inode, stream_idx);
96
97                 if (stream_name_len) {
98                         /* Create an empty named stream. */
99                         ret = ntfs_attr_add(ni, AT_DATA, stream_name,
100                                             stream_name_len, NULL, 0);
101                         if (ret != 0) {
102                                 ERROR_WITH_ERRNO("Failed to create name data "
103                                                  "stream for extracted file "
104                                                  "`%s'",
105                                                  dentry->full_path_utf8);
106                                 ret = WIMLIB_ERR_NTFS_3G;
107                                 break;
108
109                         }
110                 }
111                 /* If there's no lookup table entry, it's an empty stream.
112                  * Otherwise, we must open the attribute and extract the data.
113                  * */
114                 if (lte) {
115                         na = ntfs_attr_open(ni, AT_DATA, stream_name, stream_name_len);
116                         if (!na) {
117                                 ERROR_WITH_ERRNO("Failed to open a data stream of "
118                                                  "extracted file `%s'",
119                                                  dentry->full_path_utf8);
120                                 ret = WIMLIB_ERR_NTFS_3G;
121                                 break;
122                         }
123                         ret = extract_wim_resource_to_ntfs_attr(lte, na);
124                         if (ret != 0)
125                                 break;
126                         args->progress.extract.completed_bytes += wim_resource_size(lte);
127                         ntfs_attr_close(na);
128                 }
129                 if (stream_idx == inode->num_ads)
130                         break;
131                 stream_name = (ntfschar*)inode->ads_entries[stream_idx].stream_name;
132                 stream_name_len = inode->ads_entries[stream_idx].stream_name_len / 2;
133                 stream_idx++;
134         }
135         return ret;
136 }
137
138 /*
139  * Makes a NTFS hard link
140  *
141  * It is named @from_dentry->file_name and is located under the directory
142  * specified by @dir_ni, and it is made to point to the previously extracted
143  * file located at @inode->extracted_file.
144  *
145  * Return 0 on success, nonzero on failure.
146  */
147 static int apply_hardlink_ntfs(const struct dentry *from_dentry,
148                                const struct inode *inode,
149                                ntfs_inode *dir_ni,
150                                ntfs_inode **to_ni_ret)
151 {
152         int ret;
153         char *p;
154         char orig;
155         const char *dir_name;
156
157         ntfs_inode *to_ni;
158         ntfs_volume *vol;
159
160         wimlib_assert(dentry_is_regular_file(from_dentry)
161                         && inode_is_regular_file(inode));
162
163         if (ntfs_inode_close(dir_ni) != 0) {
164                 ERROR_WITH_ERRNO("Error closing directory");
165                 return WIMLIB_ERR_NTFS_3G;
166         }
167
168         vol = dir_ni->vol;
169
170         DEBUG("Extracting NTFS hard link `%s' => `%s'",
171               from_dentry->full_path_utf8, inode->extracted_file);
172
173         to_ni = ntfs_pathname_to_inode(vol, NULL, inode->extracted_file);
174         if (!to_ni) {
175                 ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
176                                  inode->extracted_file);
177                 return WIMLIB_ERR_NTFS_3G;
178         }
179         p = from_dentry->full_path_utf8 + from_dentry->full_path_utf8_len;
180         do {
181                 p--;
182         } while (*p != '/');
183
184         orig = *p;
185         *p = '\0';
186         dir_name = from_dentry->full_path_utf8;
187
188         dir_ni = ntfs_pathname_to_inode(vol, NULL, dir_name);
189         if (!dir_ni) {
190                 ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
191                                  from_dentry->full_path_utf8);
192                 *p = orig;
193                 return WIMLIB_ERR_NTFS_3G;
194         }
195         *p = orig;
196
197         ret = ntfs_link(to_ni, dir_ni,
198                         (ntfschar*)from_dentry->file_name,
199                         from_dentry->file_name_len / 2);
200         if (ret != 0) {
201                 ERROR_WITH_ERRNO("Could not create hard link `%s' => `%s'",
202                                  from_dentry->full_path_utf8,
203                                  inode->extracted_file);
204                 ret = WIMLIB_ERR_NTFS_3G;
205         }
206         *to_ni_ret = to_ni;
207         return ret;
208 }
209
210 static int
211 apply_file_attributes_and_security_data(ntfs_inode *ni,
212                                         ntfs_inode *dir_ni,
213                                         const struct dentry *dentry,
214                                         const WIMStruct *w)
215 {
216         DEBUG("Setting NTFS file attributes on `%s' to %#"PRIx32,
217               dentry->full_path_utf8, dentry->d_inode->attributes);
218         int ret;
219         struct SECURITY_CONTEXT ctx;
220         u32 attributes_le32;
221         attributes_le32 = cpu_to_le32(dentry->d_inode->attributes);
222         memset(&ctx, 0, sizeof(ctx));
223         ctx.vol = ni->vol;
224         ret = ntfs_xattr_system_setxattr(&ctx, XATTR_NTFS_ATTRIB,
225                                          ni, dir_ni,
226                                          (const char*)&attributes_le32,
227                                          sizeof(u32), 0);
228         if (ret != 0) {
229                 ERROR("Failed to set NTFS file attributes on `%s'",
230                        dentry->full_path_utf8);
231                 return WIMLIB_ERR_NTFS_3G;
232         }
233         if (dentry->d_inode->security_id != -1) {
234                 const struct wim_security_data *sd;
235                 const char *descriptor;
236
237                 sd = wim_const_security_data(w);
238                 wimlib_assert(dentry->d_inode->security_id < sd->num_entries);
239                 descriptor = (const char *)sd->descriptors[dentry->d_inode->security_id];
240                 DEBUG("Applying security descriptor %d to `%s'",
241                       dentry->d_inode->security_id, dentry->full_path_utf8);
242
243                 ret = ntfs_xattr_system_setxattr(&ctx, XATTR_NTFS_ACL,
244                                                  ni, dir_ni, descriptor,
245                                                  sd->sizes[dentry->d_inode->security_id], 0);
246
247                 if (ret != 0) {
248                         ERROR_WITH_ERRNO("Failed to set security data on `%s'",
249                                         dentry->full_path_utf8);
250                         return WIMLIB_ERR_NTFS_3G;
251                 }
252         }
253         return 0;
254 }
255
256 static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry,
257                               struct apply_args *args)
258 {
259         struct lookup_table_entry *lte;
260         int ret = 0;
261
262         lte = inode_unnamed_lte_resolved(dentry->d_inode);
263
264         DEBUG("Applying reparse data to `%s'", dentry->full_path_utf8);
265
266         if (!lte) {
267                 ERROR("Could not find reparse data for `%s'",
268                       dentry->full_path_utf8);
269                 return WIMLIB_ERR_INVALID_DENTRY;
270         }
271
272         if (wim_resource_size(lte) >= 0xffff) {
273                 ERROR("Reparse data of `%s' is too long (%"PRIu64" bytes)",
274                       dentry->full_path_utf8, wim_resource_size(lte));
275                 return WIMLIB_ERR_INVALID_DENTRY;
276         }
277
278         u8 reparse_data_buf[8 + wim_resource_size(lte)];
279         u8 *p = reparse_data_buf;
280         p = put_u32(p, dentry->d_inode->reparse_tag); /* ReparseTag */
281         p = put_u16(p, wim_resource_size(lte)); /* ReparseDataLength */
282         p = put_u16(p, 0); /* Reserved */
283
284         ret = read_full_wim_resource(lte, p, 0);
285         if (ret != 0)
286                 return ret;
287
288         ret = ntfs_set_ntfs_reparse_data(ni, (char*)reparse_data_buf,
289                                          wim_resource_size(lte) + 8, 0);
290         if (ret != 0) {
291                 ERROR_WITH_ERRNO("Failed to set NTFS reparse data on `%s'",
292                                  dentry->full_path_utf8);
293                 return WIMLIB_ERR_NTFS_3G;
294         }
295         args->progress.extract.completed_bytes += wim_resource_size(lte);
296         return 0;
297 }
298
299 static int do_apply_dentry_ntfs(struct dentry *dentry, ntfs_inode *dir_ni,
300                                 struct apply_args *args);
301
302 /*
303  * If @dentry is part of a hard link group, search for hard-linked dentries in
304  * the same directory that have a nonempty DOS (short) filename.  There should
305  * be exactly 0 or 1 such dentries.  If there is 1, extract that dentry first,
306  * so that the DOS name is correctly associated with the corresponding long name
307  * in the Win32 namespace, and not any of the additional names in the POSIX
308  * namespace created from hard links.
309  */
310 static int preapply_dentry_with_dos_name(struct dentry *dentry,
311                                          ntfs_inode **dir_ni_p,
312                                          struct apply_args *args)
313 {
314         struct dentry *other;
315         struct dentry *dentry_with_dos_name;
316
317         dentry_with_dos_name = NULL;
318         inode_for_each_dentry(other, dentry->d_inode) {
319                 if (other != dentry && (dentry->parent == other->parent)
320                     && other->short_name_len)
321                 {
322                         if (dentry_with_dos_name) {
323                                 ERROR("Found multiple DOS names for file `%s' "
324                                       "in the same directory",
325                                       dentry_with_dos_name->full_path_utf8);
326                                 return WIMLIB_ERR_INVALID_DENTRY;
327                         }
328                         dentry_with_dos_name = other;
329                 }
330         }
331         /* If there's a dentry with a DOS name, extract it first */
332         if (dentry_with_dos_name && !dentry_with_dos_name->is_extracted) {
333                 char *p;
334                 const char *dir_name;
335                 char orig;
336                 int ret;
337                 ntfs_volume *vol = (*dir_ni_p)->vol;
338
339                 DEBUG("pre-applying DOS name `%s'",
340                       dentry_with_dos_name->full_path_utf8);
341                 ret = do_apply_dentry_ntfs(dentry_with_dos_name,
342                                            *dir_ni_p, args);
343                 if (ret != 0)
344                         return ret;
345                 p = dentry->full_path_utf8 + dentry->full_path_utf8_len;
346                 do {
347                         p--;
348                 } while (*p != '/');
349
350                 orig = *p;
351                 *p = '\0';
352                 dir_name = dentry->full_path_utf8;
353
354                 *dir_ni_p = ntfs_pathname_to_inode(vol, NULL, dir_name);
355                 *p = orig;
356                 if (!*dir_ni_p) {
357                         ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
358                                          dir_name);
359                         return WIMLIB_ERR_NTFS_3G;
360                 }
361         }
362         return 0;
363 }
364
365 /*
366  * Applies a WIM dentry to a NTFS filesystem.
367  *
368  * @dentry:  The WIM dentry to apply
369  * @dir_ni:  The NTFS inode for the parent directory
370  *
371  * @return:  0 on success; nonzero on failure.
372  */
373 static int do_apply_dentry_ntfs(struct dentry *dentry, ntfs_inode *dir_ni,
374                                 struct apply_args *args)
375 {
376         int ret = 0;
377         mode_t type;
378         ntfs_inode *ni = NULL;
379         bool is_hardlink = false;
380         ntfs_volume *vol = dir_ni->vol;
381         struct inode *inode = dentry->d_inode;
382         dentry->is_extracted = true;
383
384         if (inode->attributes & FILE_ATTRIBUTE_DIRECTORY) {
385                 type = S_IFDIR;
386         } else {
387                 /* Apply hard-linked directory in same directory with DOS name
388                  * (if there is one) before this dentry */
389                 if (dentry->short_name_len == 0) {
390                         ret = preapply_dentry_with_dos_name(dentry,
391                                                             &dir_ni, args);
392                         if (ret != 0)
393                                 return ret;
394                 }
395
396                 type = S_IFREG;
397
398                 if (inode->link_count > 1) {
399                         /* Already extracted another dentry in the hard link
400                          * group.  We can make a hard link instead of extracting
401                          * the file data. */
402                         if (inode->extracted_file) {
403                                 ret = apply_hardlink_ntfs(dentry, inode,
404                                                           dir_ni, &ni);
405                                 is_hardlink = true;
406                                 if (ret)
407                                         goto out_close_dir_ni;
408                                 else
409                                         goto out_set_dos_name;
410                         }
411                         /* Can't make a hard link; extract the file itself */
412                         FREE(inode->extracted_file);
413                         inode->extracted_file = STRDUP(dentry->full_path_utf8);
414                         if (!inode->extracted_file) {
415                                 ret = WIMLIB_ERR_NOMEM;
416                                 goto out_close_dir_ni;
417                         }
418                 }
419         }
420
421         /*
422          * Create a directory or file.
423          *
424          * Note: For symbolic links that are not directory junctions, pass
425          * S_IFREG here, since we manually set the reparse data later.
426          */
427         ni = ntfs_create(dir_ni, 0, (ntfschar*)dentry->file_name,
428                          dentry->file_name_len / 2, type);
429
430         if (!ni) {
431                 ERROR_WITH_ERRNO("Could not create NTFS object for `%s'",
432                                  dentry->full_path_utf8);
433                 ret = WIMLIB_ERR_NTFS_3G;
434                 goto out_close_dir_ni;
435         }
436
437         /* Write the data streams, unless this is a directory or reparse point
438          * */
439         if (!(inode->attributes & (FILE_ATTRIBUTE_REPARSE_POINT |
440                                    FILE_ATTRIBUTE_DIRECTORY))) {
441                 ret = write_ntfs_data_streams(ni, dentry, args);
442                 if (ret != 0)
443                         goto out_close_dir_ni;
444         }
445
446
447         ret = apply_file_attributes_and_security_data(ni, dir_ni,
448                                                       dentry, args->w);
449         if (ret != 0)
450                 goto out_close_dir_ni;
451
452         if (inode->attributes & FILE_ATTR_REPARSE_POINT) {
453                 ret = apply_reparse_data(ni, dentry, args);
454                 if (ret != 0)
455                         goto out_close_dir_ni;
456         }
457
458 out_set_dos_name:
459         /* Set DOS (short) name if given */
460         if (dentry->short_name_len != 0) {
461
462                 char *short_name_utf8;
463                 size_t short_name_utf8_len;
464                 short_name_utf8 = utf16_to_utf8(dentry->short_name,
465                                                 dentry->short_name_len,
466                                                 &short_name_utf8_len);
467                 if (!short_name_utf8) {
468                         ERROR("Out of memory");
469                         ret = WIMLIB_ERR_NOMEM;
470                         goto out_close_dir_ni;
471                 }
472
473                 if (is_hardlink) {
474                         char *p;
475                         char orig;
476                         const char *dir_name;
477
478                         /* ntfs_set_ntfs_dos_name() closes the inodes in the
479                          * wrong order if we have applied a hard link.   Close
480                          * them ourselves, then re-open then. */
481                         if (ntfs_inode_close(dir_ni) != 0) {
482                                 if (ret == 0)
483                                         ret = WIMLIB_ERR_NTFS_3G;
484                                 ERROR_WITH_ERRNO("Failed to close directory inode");
485                         }
486                         if (ntfs_inode_close(ni) != 0) {
487                                 if (ret == 0)
488                                         ret = WIMLIB_ERR_NTFS_3G;
489                                 ERROR_WITH_ERRNO("Failed to close hard link target inode");
490                         }
491                         p = dentry->full_path_utf8 + dentry->full_path_utf8_len;
492                         do {
493                                 p--;
494                         } while (*p != '/');
495
496                         orig = *p;
497                         *p = '\0';
498                         dir_name = dentry->full_path_utf8;
499
500                         dir_ni = ntfs_pathname_to_inode(vol, NULL, dir_name);
501                         *p = orig;
502                         if (!dir_ni) {
503                                 ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
504                                                  dir_name);
505                                 return WIMLIB_ERR_NTFS_3G;
506                         }
507                         ni = ntfs_pathname_to_inode(vol, dir_ni,
508                                                     dentry->file_name_utf8);
509                         if (!ni) {
510                                 ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
511                                                  dir_name);
512                                 return WIMLIB_ERR_NTFS_3G;
513                         }
514                 }
515
516                 DEBUG("Setting short (DOS) name of `%s' to %s",
517                       dentry->full_path_utf8, short_name_utf8);
518
519                 ret = ntfs_set_ntfs_dos_name(ni, dir_ni, short_name_utf8,
520                                              short_name_utf8_len, 0);
521                 FREE(short_name_utf8);
522                 if (ret != 0) {
523                         ERROR_WITH_ERRNO("Could not set DOS (short) name for `%s'",
524                                          dentry->full_path_utf8);
525                         ret = WIMLIB_ERR_NTFS_3G;
526                 }
527                 /* inodes have been closed by ntfs_set_ntfs_dos_name(). */
528                 return ret;
529         }
530
531 out_close_dir_ni:
532         if (ntfs_inode_close(dir_ni) != 0) {
533                 if (ret == 0)
534                         ret = WIMLIB_ERR_NTFS_3G;
535                 ERROR_WITH_ERRNO("Failed to close directory inode");
536         }
537         if (ni && ntfs_inode_close(ni) != 0) {
538                 if (ret == 0)
539                         ret = WIMLIB_ERR_NTFS_3G;
540                 ERROR_WITH_ERRNO("Failed to close inode");
541         }
542         return ret;
543 }
544
545 static int apply_root_dentry_ntfs(const struct dentry *dentry,
546                                   ntfs_volume *vol, const WIMStruct *w)
547 {
548         ntfs_inode *ni;
549         int ret = 0;
550
551         wimlib_assert(dentry_is_directory(dentry));
552         ni = ntfs_pathname_to_inode(vol, NULL, "/");
553         if (!ni) {
554                 ERROR_WITH_ERRNO("Could not find root NTFS inode");
555                 return WIMLIB_ERR_NTFS_3G;
556         }
557         ret = apply_file_attributes_and_security_data(ni, ni, dentry, w);
558         if (ntfs_inode_close(ni) != 0) {
559                 ERROR_WITH_ERRNO("Failed to close NTFS inode for root "
560                                  "directory");
561                 ret = WIMLIB_ERR_NTFS_3G;
562         }
563         return ret;
564 }
565
566 /* Applies a WIM dentry to the NTFS volume */
567 int apply_dentry_ntfs(struct dentry *dentry, void *arg)
568 {
569         struct apply_args *args = arg;
570         ntfs_volume *vol             = args->vol;
571         int extract_flags            = args->extract_flags;
572         WIMStruct *w                 = args->w;
573         ntfs_inode *dir_ni;
574         char *p;
575         char orig;
576         const char *dir_name;
577
578         if (dentry->is_extracted)
579                 return 0;
580
581         if (extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS)
582                 if (inode_unnamed_lte_resolved(dentry->d_inode))
583                         return 0;
584
585         DEBUG("Applying dentry `%s' to NTFS", dentry->full_path_utf8);
586
587         if ((extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) &&
588              args->progress_func)
589         {
590                 args->progress.extract.cur_path = dentry->full_path_utf8;
591                 args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY,
592                                     &args->progress);
593         }
594
595         if (dentry_is_root(dentry))
596                 return apply_root_dentry_ntfs(dentry, vol, w);
597
598         p = dentry->full_path_utf8 + dentry->full_path_utf8_len;
599         do {
600                 p--;
601         } while (*p != '/');
602
603         orig = *p;
604         *p = '\0';
605         dir_name = dentry->full_path_utf8;
606
607         dir_ni = ntfs_pathname_to_inode(vol, NULL, dir_name);
608         *p = orig;
609         if (!dir_ni) {
610                 ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
611                                  dir_name);
612                 return WIMLIB_ERR_NTFS_3G;
613         }
614         return do_apply_dentry_ntfs(dentry, dir_ni, arg);
615 }
616
617 int apply_dentry_timestamps_ntfs(struct dentry *dentry, void *arg)
618 {
619         struct apply_args *args = arg;
620         ntfs_volume *vol = args->vol;
621         u8 *p;
622         u8 buf[24];
623         ntfs_inode *ni;
624         int ret = 0;
625
626         DEBUG("Setting timestamps on `%s'", dentry->full_path_utf8);
627
628         ni = ntfs_pathname_to_inode(vol, NULL, dentry->full_path_utf8);
629         if (!ni) {
630                 ERROR_WITH_ERRNO("Could not find NTFS inode for `%s'",
631                                  dentry->full_path_utf8);
632                 return WIMLIB_ERR_NTFS_3G;
633         }
634
635         p = buf;
636         p = put_u64(p, dentry->d_inode->creation_time);
637         p = put_u64(p, dentry->d_inode->last_write_time);
638         p = put_u64(p, dentry->d_inode->last_access_time);
639         ret = ntfs_inode_set_times(ni, (const char*)buf, 3 * sizeof(u64), 0);
640         if (ret != 0) {
641                 ERROR_WITH_ERRNO("Failed to set NTFS timestamps on `%s'",
642                                  dentry->full_path_utf8);
643                 ret = WIMLIB_ERR_NTFS_3G;
644         }
645
646         if (ntfs_inode_close(ni) != 0) {
647                 if (ret == 0)
648                         ret = WIMLIB_ERR_NTFS_3G;
649                 ERROR_WITH_ERRNO("Failed to close NTFS inode for `%s'",
650                                  dentry->full_path_utf8);
651         }
652         return ret;
653 }