Delay xml_update_image_info() until write
[wimlib] / src / mount_image.c
1 /*
2  * mount_image.c
3  *
4  * This file implements mounting of WIM images using FUSE
5  * (Filesystem in Userspace).  See http://fuse.sourceforge.net/.
6  *
7  * Currently it is only expected to work on Linux.
8  */
9
10 /*
11  * Copyright (C) 2012, 2013, 2014, 2015 Eric Biggers
12  *
13  * This file is free software; you can redistribute it and/or modify it under
14  * the terms of the GNU Lesser General Public License as published by the Free
15  * Software Foundation; either version 3 of the License, or (at your option) any
16  * later version.
17  *
18  * This file is distributed in the hope that it will be useful, but WITHOUT
19  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
21  * details.
22  *
23  * You should have received a copy of the GNU Lesser General Public License
24  * along with this file; if not, see http://www.gnu.org/licenses/.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 #  include "config.h"
29 #endif
30
31 #include "wimlib.h"
32 #include "wimlib/error.h"
33
34 #ifdef WITH_FUSE
35
36 #ifdef __WIN32__
37 #  error "FUSE mount not supported on Windows!  Please configure --without-fuse"
38 #endif
39
40 #define FUSE_USE_VERSION 26
41
42 #include <sys/types.h> /* sometimes required before <attr/xattr.h> */
43
44 #include <attr/xattr.h>
45 #include <dirent.h>
46 #include <errno.h>
47 #include <fuse.h>
48 #include <limits.h>
49 #include <mqueue.h>
50 #include <pthread.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <sys/stat.h>
54 #include <sys/time.h>
55 #include <unistd.h>
56 #include <utime.h>
57
58 #include "wimlib/blob_table.h"
59 #include "wimlib/dentry.h"
60 #include "wimlib/encoding.h"
61 #include "wimlib/metadata.h"
62 #include "wimlib/paths.h"
63 #include "wimlib/progress.h"
64 #include "wimlib/reparse.h"
65 #include "wimlib/timestamp.h"
66 #include "wimlib/unix_data.h"
67 #include "wimlib/write.h"
68 #include "wimlib/xml.h"
69
70 #ifndef O_NOFOLLOW
71 #  define O_NOFOLLOW 0  /* Security only...  */
72 #endif
73
74 #define WIMFS_MQUEUE_NAME_LEN 32
75
76 #define WIMLIB_UNMOUNT_FLAG_SEND_PROGRESS 0x80000000
77
78 struct wimfs_unmount_info {
79         unsigned unmount_flags;
80         char mq_name[WIMFS_MQUEUE_NAME_LEN + 1];
81 };
82
83 struct commit_progress_report {
84         enum wimlib_progress_msg msg;
85         union wimlib_progress_info info;
86 };
87
88 /* Description of an open file on a mounted WIM image.  Actually, this
89  * represents the open state of a particular data stream of an inode, rather
90  * than the inode itself.  (An inode might have multiple named data streams in
91  * addition to the default, unnamed data stream.)  At a given time, an inode in
92  * the WIM image might have multiple file descriptors open to it, each to any
93  * one of its data streams.  */
94 struct wimfs_fd {
95
96         /* Pointer to the inode of this open file.
97          * 'i_num_opened_fds' of the inode tracks the number of file descriptors
98          * that reference it.  */
99         struct wim_inode *f_inode;
100
101         /* Pointer to the blob descriptor for the data stream that has been
102          * opened.  'num_opened_fds' of the blob descriptor tracks the number of
103          * file descriptors that reference it.  Or, this value may be NULL,
104          * which indicates that the opened stream is empty and consequently does
105          * not have a blob descriptor.  */
106         struct blob_descriptor *f_blob;
107
108         /* If valid (filedes_valid(&f_staging_fd)), this contains the
109          * corresponding native file descriptor for the staging file that has
110          * been created for reading from and/or writing to this open stream.  A
111          * single staging file might have multiple file descriptors open to it
112          * simultaneously, each used by a different 'struct wimfs_fd'.
113          *
114          * Or, if invalid (!filedes_valid(&f_staging_fd)), this 'struct
115          * wimfs_fd' is not associated with a staging file.  This is permissible
116          * only if this 'struct wimfs_fd' was opened read-only and the stream
117          * has not yet been extracted to a staging file.  */
118         struct filedes f_staging_fd;
119
120         /* 0-based index of this file descriptor in the file descriptor table of
121          * its inode.  */
122         u16 f_idx;
123
124         /* Unique ID of the opened stream in the inode.  This will stay the same
125          * even if the indices of the inode's streams are changed by a deletion.
126          */
127         u32 f_stream_id;
128 };
129
130 #define WIMFS_FD(fi) ((struct wimfs_fd *)(uintptr_t)((fi)->fh))
131
132 /* Context structure for a mounted WIM image.  */
133 struct wimfs_context {
134         /* The WIMStruct containing the mounted image.  The mounted image is the
135          * currently selected image (wim->current_image).  */
136         WIMStruct *wim;
137
138         /* Flags passed to wimlib_mount_image() (WIMLIB_MOUNT_FLAG_*).  */
139         int mount_flags;
140
141         /* Default flags for path lookup in the WIM image.  */
142         int default_lookup_flags;
143
144         /* Information about the user who has mounted the WIM image  */
145         uid_t owner_uid;
146         gid_t owner_gid;
147
148         /* Absolute path to the mountpoint directory (may be needed for absolute
149          * symbolic link fixups)  */
150         char *mountpoint_abspath;
151         size_t mountpoint_abspath_nchars;
152
153         /* Information about the staging directory for a read-write mount.  */
154         int parent_dir_fd;
155         int staging_dir_fd;
156         char *staging_dir_name;
157
158         /* For read-write mounts, the inode number to be assigned to the next
159          * created file.  Note: since this isn't a persistent filesystem and we
160          * can re-assign the inode numbers just before mounting the image, it's
161          * good enough to just generate inode numbers sequentially.  */
162         u64 next_ino;
163
164         /* Number of file descriptors open to the mounted WIM image.  */
165         unsigned long num_open_fds;
166
167         /* Original list of blobs in the mounted image, linked by
168          * 'struct blob_descriptor'.orig_blob_list.  */
169         struct list_head orig_blob_list;
170
171         /* Parameters for unmounting the image (can be set via extended
172          * attribute "wimfs.unmount_info").  */
173         struct wimfs_unmount_info unmount_info;
174 };
175
176 #define WIMFS_CTX(fuse_ctx) ((struct wimfs_context*)(fuse_ctx)->private_data)
177
178 /* Retrieve the context structure for the currently mounted WIM image.
179  *
180  * Note: this is a per-thread variable.  It is possible for different threads to
181  * mount different images at the same time in the same process, although they
182  * must use different WIMStructs!  */
183 static inline struct wimfs_context *
184 wimfs_get_context(void)
185 {
186         return WIMFS_CTX(fuse_get_context());
187 }
188
189 static void
190 wimfs_inc_num_open_fds(void)
191 {
192         wimfs_get_context()->num_open_fds++;
193 }
194
195 static void
196 wimfs_dec_num_open_fds(void)
197 {
198         wimfs_get_context()->num_open_fds--;
199 }
200
201 /* Retrieve the WIMStruct for the currently mounted WIM image.  */
202 static inline WIMStruct *
203 wimfs_get_WIMStruct(void)
204 {
205         return wimfs_get_context()->wim;
206 }
207
208 /* Is write permission requested on the file?  */
209 static inline bool
210 flags_writable(int open_flags)
211 {
212         int accmode = (open_flags & O_ACCMODE);
213         return (accmode == O_RDWR || accmode == O_WRONLY);
214 }
215
216 static mode_t
217 fuse_mask_mode(mode_t mode, const struct fuse_context *fuse_ctx)
218 {
219 #if FUSE_MAJOR_VERSION > 2 || (FUSE_MAJOR_VERSION == 2 && FUSE_MINOR_VERSION >= 8)
220         mode &= ~fuse_ctx->umask;
221 #endif
222         return mode;
223 }
224
225 /*
226  * Allocate a file descriptor to a data stream in the mounted WIM image.
227  *
228  * @inode
229  *      The inode containing the stream being opened
230  * @strm
231  *      The stream of the inode being opened
232  * @fd_ret
233  *      On success, a pointer to the new file descriptor will be stored here.
234  *
235  * Returns 0 or a -errno code.
236  */
237 static int
238 alloc_wimfs_fd(struct wim_inode *inode,
239                struct wim_inode_stream *strm,
240                struct wimfs_fd **fd_ret)
241 {
242         static const u16 min_fds_per_alloc = 8;
243         static const u16 max_fds = 0xffff;
244         u16 i;
245         struct wimfs_fd *fd;
246
247         if (inode->i_num_opened_fds == inode->i_num_allocated_fds) {
248                 u16 num_new_fds;
249                 struct wimfs_fd **fds;
250
251                 /* Expand this inode's file descriptor table.  */
252
253                 num_new_fds = max(min_fds_per_alloc,
254                                   inode->i_num_allocated_fds / 4);
255
256                 num_new_fds = min(num_new_fds,
257                                   max_fds - inode->i_num_allocated_fds);
258
259                 if (num_new_fds == 0)
260                         return -EMFILE;
261
262                 fds = REALLOC(inode->i_fds,
263                               (inode->i_num_allocated_fds + num_new_fds) *
264                                 sizeof(fds[0]));
265                 if (!fds)
266                         return -ENOMEM;
267
268                 memset(&fds[inode->i_num_allocated_fds], 0,
269                        num_new_fds * sizeof(fds[0]));
270                 inode->i_fds = fds;
271                 inode->i_num_allocated_fds += num_new_fds;
272                 inode->i_next_fd = inode->i_num_opened_fds;
273         }
274
275         /* Allocate the file descriptor in the first available space in the
276          * inode's file descriptor table.
277          *
278          * i_next_fd is the lower bound on the next open slot.  */
279         for (i = inode->i_next_fd; inode->i_fds[i]; i++)
280                 ;
281
282         fd = MALLOC(sizeof(*fd));
283         if (!fd)
284                 return -ENOMEM;
285
286         fd->f_inode     = inode;
287         fd->f_blob      = stream_blob_resolved(strm);
288         filedes_invalidate(&fd->f_staging_fd);
289         fd->f_idx       = i;
290         fd->f_stream_id = strm->stream_id;
291         *fd_ret         = fd;
292         inode->i_fds[i] = fd;
293         inode->i_num_opened_fds++;
294         if (fd->f_blob)
295                 fd->f_blob->num_opened_fds++;
296         wimfs_inc_num_open_fds();
297         inode->i_next_fd = i + 1;
298         return 0;
299 }
300
301 /*
302  * Close a file descriptor to a data stream in the mounted WIM image.
303  *
304  * Returns 0 or a -errno code.  The file descriptor is always closed.
305  */
306 static int
307 close_wimfs_fd(struct wimfs_fd *fd)
308 {
309         int ret = 0;
310         struct wim_inode *inode;
311
312         /* Close the staging file if open.  */
313         if (filedes_valid(&fd->f_staging_fd))
314                  if (filedes_close(&fd->f_staging_fd))
315                          ret = -errno;
316
317         /* Release this file descriptor from its blob descriptor.  */
318         if (fd->f_blob)
319                 blob_decrement_num_opened_fds(fd->f_blob);
320
321         wimfs_dec_num_open_fds();
322
323         /* Release this file descriptor from its inode.  */
324         inode = fd->f_inode;
325         inode->i_fds[fd->f_idx] = NULL;
326         if (fd->f_idx < inode->i_next_fd)
327                 inode->i_next_fd = fd->f_idx;
328         FREE(fd);
329         inode_dec_num_opened_fds(inode);
330         return ret;
331 }
332
333 /*
334  * Translate a path into the corresponding inode in the mounted WIM image.
335  *
336  * See get_dentry() for more information.
337  *
338  * Returns a pointer to the resulting inode, or NULL with errno set.
339  */
340 static struct wim_inode *
341 wim_pathname_to_inode(WIMStruct *wim, const char *path)
342 {
343         struct wim_dentry *dentry;
344
345         dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
346         if (!dentry)
347                 return NULL;
348         return dentry->d_inode;
349 }
350
351 /* Can look up named data stream with colon syntax  */
352 #define LOOKUP_FLAG_ADS_OK              0x01
353
354 /* Can look up directory (otherwise get -ENOTDIR)  */
355 #define LOOKUP_FLAG_DIRECTORY_OK        0x02
356
357 /* Get the data stream of the specified name from the specified inode.  Returns
358  * NULL with errno set if not found.  */
359 static struct wim_inode_stream *
360 inode_get_data_stream_tstr(const struct wim_inode *inode,
361                            const char *stream_name)
362 {
363         struct wim_inode_stream *strm;
364
365         if (!stream_name || !*stream_name) {
366                 strm = inode_get_unnamed_data_stream(inode);
367         } else {
368                 const utf16lechar *uname;
369
370                 if (tstr_get_utf16le(stream_name, &uname))
371                         return NULL;
372                 strm = inode_get_stream(inode, STREAM_TYPE_DATA, uname);
373                 tstr_put_utf16le(uname);
374         }
375         if (!strm)
376                 errno = ENOENT;
377         return strm;
378 }
379
380 /*
381  * Translate a path into the corresponding dentry and stream in the mounted WIM
382  * image.
383  *
384  * Returns 0 or a -errno code.  @dentry_ret and @strm_ret are both optional.
385  */
386 static int
387 wim_pathname_to_stream(const struct wimfs_context *ctx,
388                        const char *path,
389                        int lookup_flags,
390                        struct wim_dentry **dentry_ret,
391                        struct wim_inode_stream **strm_ret)
392 {
393         WIMStruct *wim = ctx->wim;
394         struct wim_dentry *dentry;
395         struct wim_inode *inode;
396         struct wim_inode_stream *strm;
397         const char *stream_name = NULL;
398         char *p = NULL;
399
400         lookup_flags |= ctx->default_lookup_flags;
401
402         if (lookup_flags & LOOKUP_FLAG_ADS_OK) {
403                 stream_name = path_stream_name(path);
404                 if (stream_name) {
405                         p = (char *)stream_name - 1;
406                         *p = '\0';
407                 }
408         }
409
410         dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
411         if (p)
412                 *p = ':';
413         if (!dentry)
414                 return -errno;
415
416         inode = dentry->d_inode;
417
418         if (inode_resolve_streams(inode, wim->blob_table, false))
419                 return -EIO;
420
421         if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)
422               && inode_is_directory(inode))
423                 return -EISDIR;
424
425         strm = inode_get_data_stream_tstr(inode, stream_name);
426         if (!strm) {
427                 /* Force creation of an unnamed data stream  */
428                 if (!stream_name)
429                         strm = inode_add_stream(inode, STREAM_TYPE_DATA,
430                                                 NO_STREAM_NAME, NULL);
431                 if (!strm)
432                         return -errno;
433         }
434
435         if (dentry_ret)
436                 *dentry_ret = dentry;
437         if (strm_ret)
438                 *strm_ret = strm;
439         return 0;
440 }
441
442 /*
443  * Create a new file in the mounted WIM image.
444  *
445  * @fuse_ctx
446  *      The FUSE context for the mounted image.
447  * @path
448  *      The path at which to create the first link to the new file.  If a file
449  *      already exists at this path, -EEXIST is returned.
450  * @mode
451  *      The UNIX mode for the new file.  This is only fully honored if
452  *      WIMLIB_MOUNT_FLAG_UNIX_DATA was passed to wimlib_mount_image().
453  * @rdev
454  *      The device ID for the new file, encoding the major and minor device
455  *      numbers.  This is only honored if WIMLIB_MOUNT_FLAG_UNIX_DATA was passed
456  *      to wimlib_mount_image().
457  * @dentry_ret
458  *      On success, a pointer to the new dentry is returned here.  Its d_inode
459  *      member will point to the new inode that was created for it and added to
460  *      the mounted WIM image.
461  *
462  * Returns 0 or a -errno code.
463  */
464 static int
465 create_file(struct fuse_context *fuse_ctx, const char *path,
466             mode_t mode, dev_t rdev, struct wim_dentry **dentry_ret)
467 {
468         struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx);
469         struct wim_dentry *parent;
470         const char *basename;
471         struct wim_dentry *dentry;
472         struct wim_inode *inode;
473
474         parent = get_parent_dentry(wimfs_ctx->wim, path, WIMLIB_CASE_SENSITIVE);
475         if (!parent)
476                 return -errno;
477
478         if (!dentry_is_directory(parent))
479                 return -ENOTDIR;
480
481         basename = path_basename(path);
482
483         if (get_dentry_child_with_name(parent, basename, WIMLIB_CASE_SENSITIVE))
484                 return -EEXIST;
485
486         if (new_dentry_with_new_inode(basename, true, &dentry))
487                 return -ENOMEM;
488
489         inode = dentry->d_inode;
490
491         inode->i_ino = wimfs_ctx->next_ino++;
492
493         /* Note: we still use FILE_ATTRIBUTE_NORMAL for device nodes, named
494          * pipes, and sockets.  The real mode is in the UNIX metadata.  */
495         if (S_ISDIR(mode))
496                 inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
497         else
498                 inode->i_attributes = FILE_ATTRIBUTE_NORMAL;
499
500         if (wimfs_ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA) {
501                 struct wimlib_unix_data unix_data;
502
503                 unix_data.uid = fuse_ctx->uid;
504                 unix_data.gid = fuse_ctx->gid;
505                 unix_data.mode = fuse_mask_mode(mode, fuse_ctx);
506                 unix_data.rdev = rdev;
507                 if (!inode_set_unix_data(inode, &unix_data, UNIX_DATA_ALL))
508                 {
509                         free_dentry(dentry);
510                         return -ENOMEM;
511                 }
512         }
513
514         hlist_add_head(&inode->i_hlist_node,
515                        &wim_get_current_image_metadata(wimfs_ctx->wim)->inode_list);
516
517         dentry_add_child(parent, dentry);
518
519         *dentry_ret = dentry;
520         return 0;
521 }
522
523 /*
524  * Remove a dentry from the mounted WIM image; i.e. remove an alias for an
525  * inode.
526  */
527 static void
528 remove_dentry(struct wim_dentry *dentry, struct blob_table *blob_table)
529 {
530         /* Drop blob references.  */
531         inode_unref_blobs(dentry->d_inode, blob_table);
532
533         /* Unlink the dentry from the image's dentry tree.  */
534         unlink_dentry(dentry);
535
536         /* Delete the dentry.  This will also decrement the link count of the
537          * corresponding inode, and possibly cause it to be deleted as well.  */
538         free_dentry(dentry);
539 }
540
541 /* Generate UNIX filetype mode bits for the specified WIM inode, based on its
542  * Windows file attributes.  */
543 static mode_t
544 inode_unix_file_type(const struct wim_inode *inode)
545 {
546         if (inode_is_symlink(inode))
547                 return S_IFLNK;
548         else if (inode_is_directory(inode))
549                 return S_IFDIR;
550         else
551                 return S_IFREG;
552 }
553
554 /* Generate a default UNIX mode for the specified WIM inode.  */
555 static mode_t
556 inode_default_unix_mode(const struct wim_inode *inode)
557 {
558         return inode_unix_file_type(inode) | 0777;
559 }
560
561 static u64
562 blob_size(const struct blob_descriptor *blob)
563 {
564         if (!blob)
565                 return 0;
566         return blob->size;
567 }
568
569 static u64
570 blob_stored_size(const struct blob_descriptor *blob)
571 {
572         if (!blob)
573                 return 0;
574         if (blob->blob_location == BLOB_IN_WIM &&
575             blob->size == blob->rdesc->uncompressed_size)
576                 return blob->rdesc->size_in_wim;
577         return blob->size;
578 }
579
580 /*
581  * Retrieve standard UNIX metadata ('struct stat') for a WIM inode.
582  *
583  * @blob is the blob descriptor for the stream of the inode that is being
584  * queried, or NULL.  We mostly return the same information for all streams, but
585  * st_size and st_blocks may be different for different streams.
586  *
587  * This always returns 0.
588  */
589 static int
590 inode_to_stbuf(const struct wim_inode *inode,
591                const struct blob_descriptor *blob, struct stat *stbuf)
592 {
593         const struct wimfs_context *ctx = wimfs_get_context();
594         struct wimlib_unix_data unix_data;
595
596         memset(stbuf, 0, sizeof(struct stat));
597         if ((ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA) &&
598             inode_get_unix_data(inode, &unix_data))
599         {
600                 /* Use the user ID, group ID, mode, and device ID from the
601                  * inode's extra UNIX metadata information.  */
602                 stbuf->st_uid = unix_data.uid;
603                 stbuf->st_gid = unix_data.gid;
604                 stbuf->st_mode = unix_data.mode;
605                 stbuf->st_rdev = unix_data.rdev;
606         } else {
607                 /* Generate default values for the user ID, group ID, and mode.
608                  *
609                  * Note: in the case of an allow_other mount, fuse_context.uid
610                  * may not be the same as wimfs_context.owner_uid!  */
611                 stbuf->st_uid = ctx->owner_uid;
612                 stbuf->st_gid = ctx->owner_gid;
613                 stbuf->st_mode = inode_default_unix_mode(inode);
614         }
615         stbuf->st_ino = inode->i_ino;
616         stbuf->st_nlink = inode->i_nlink;
617         stbuf->st_size = blob_size(blob);
618 #ifdef HAVE_STAT_NANOSECOND_PRECISION
619         stbuf->st_atim = wim_timestamp_to_timespec(inode->i_last_access_time);
620         stbuf->st_mtim = wim_timestamp_to_timespec(inode->i_last_write_time);
621         stbuf->st_ctim = stbuf->st_mtim;
622 #else
623         stbuf->st_atime = wim_timestamp_to_time_t(inode->i_last_access_time);
624         stbuf->st_mtime = wim_timestamp_to_time_t(inode->i_last_write_time);
625         stbuf->st_ctime = stbuf->st_mtime;
626 #endif
627         stbuf->st_blocks = DIV_ROUND_UP(blob_stored_size(blob), 512);
628         return 0;
629 }
630
631 /* Update the last access and last write timestamps of a WIM inode.  */
632 static void
633 touch_inode(struct wim_inode *inode)
634 {
635         u64 now = now_as_wim_timestamp();
636         inode->i_last_access_time = now;
637         inode->i_last_write_time = now;
638 }
639
640 static void
641 touch_parent(struct wim_dentry *dentry)
642 {
643         touch_inode(dentry->d_parent->d_inode);
644 }
645
646 /*
647  * Create a new file in the staging directory for a read-write mounted image.
648  *
649  * On success, returns the file descriptor for the new staging file, opened for
650  * writing.  In addition, stores the allocated name of the staging file in
651  * @name_ret.
652  *
653  * On failure, returns -1 and sets errno.
654  */
655 static int
656 create_staging_file(const struct wimfs_context *ctx, char **name_ret)
657 {
658
659         static const size_t STAGING_FILE_NAME_LEN = 20;
660         char *name;
661         int fd;
662
663         name = MALLOC(STAGING_FILE_NAME_LEN + 1);
664         if (!name)
665                 return -1;
666         name[STAGING_FILE_NAME_LEN] = '\0';
667
668 retry:
669         randomize_char_array_with_alnum(name, STAGING_FILE_NAME_LEN);
670         fd = openat(ctx->staging_dir_fd, name,
671                     O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
672         if (unlikely(fd < 0)) {
673                 if (unlikely(errno == EEXIST))
674                         /* Try again with another name.  */
675                         goto retry;
676                 FREE(name);
677         } else {
678                 *name_ret = name;
679         }
680         return fd;
681 }
682
683 /*
684  * Extract a blob to the staging directory.  This is necessary when a stream
685  * using the blob is being opened for writing and the blob has not already been
686  * extracted to the staging directory.
687  *
688  * @inode
689  *      The inode containing the stream being opened for writing.
690  * @strm
691  *      The stream being opened for writing.  The blob descriptor to which the
692  *      stream refers will be changed by this function.
693  * @size
694  *      Number of bytes of the blob to extract and include in the staging file.
695  *      It may be less than the actual blob length, in which case only a prefix
696  *      of the blob will be extracted.  It may also be more than the actual blob
697  *      length, in which case the extra space will be zero-filled.
698  *
699  * Returns 0 or a -errno code.
700  */
701 static int
702 extract_blob_to_staging_dir(struct wim_inode *inode,
703                             struct wim_inode_stream *strm,
704                             off_t size, const struct wimfs_context *ctx)
705 {
706         struct blob_descriptor *old_blob;
707         struct blob_descriptor *new_blob;
708         char *staging_file_name;
709         int staging_fd;
710         off_t extract_size;
711         int result;
712         int ret;
713
714         old_blob = stream_blob_resolved(strm);
715
716         /* Create the staging file.  */
717         staging_fd = create_staging_file(ctx, &staging_file_name);
718         if (unlikely(staging_fd < 0))
719                 return -errno;
720
721         /* Extract the stream to the staging file (possibly truncated).  */
722         if (old_blob) {
723                 struct filedes fd;
724
725                 filedes_init(&fd, staging_fd);
726                 errno = 0;
727                 extract_size = min(old_blob->size, size);
728                 result = extract_blob_prefix_to_fd(old_blob, extract_size, &fd);
729         } else {
730                 extract_size = 0;
731                 result = 0;
732         }
733
734         /* In the case of truncate() to more than the file length, extend the
735          * staging file with zeroes by calling ftruncate().  */
736         if (!result && size > extract_size)
737                 result = ftruncate(staging_fd, size);
738
739         /* Close the staging file.  */
740         if (close(staging_fd))
741                 result = -1;
742
743         /* If an error occurred, unlink the staging file.  */
744         if (unlikely(result)) {
745                 /* extract_blob_to_fd() should set errno, but if it didn't,
746                  * set a default value.  */
747                 ret = errno ? -errno : -EIO;
748                 goto out_delete_staging_file;
749         }
750
751         /* Create a blob descriptor for the staging file.  */
752         new_blob = new_blob_descriptor();
753         if (unlikely(!new_blob)) {
754                 ret = -ENOMEM;
755                 goto out_delete_staging_file;
756         }
757
758         /* There may already be open file descriptors to this stream if it's
759          * previously been opened read-only, but just now we're opening it
760          * read-write.  Identify those file descriptors, update them to use the
761          * new blob descriptor, and open staging file descriptors for them.  */
762         for (u16 i = 0, j = 0; j < inode->i_num_opened_fds; i++) {
763                 struct wimfs_fd *fd;
764                 int raw_fd;
765
766                 fd = inode->i_fds[i];
767                 if (!fd)
768                         continue;
769
770                 j++;
771
772                 if (fd->f_stream_id != strm->stream_id)
773                         continue;
774
775                 /* This is a readonly fd for the same stream.  */
776                 fd->f_blob = new_blob;
777                 new_blob->num_opened_fds++;
778                 raw_fd = openat(ctx->staging_dir_fd, staging_file_name,
779                                 O_RDONLY | O_NOFOLLOW);
780                 if (unlikely(raw_fd < 0)) {
781                         ret = -errno;
782                         goto out_revert_fd_changes;
783                 }
784                 filedes_init(&fd->f_staging_fd, raw_fd);
785         }
786
787         if (old_blob)
788                 old_blob->num_opened_fds -= new_blob->num_opened_fds;
789
790         new_blob->blob_location     = BLOB_IN_STAGING_FILE;
791         new_blob->staging_file_name = staging_file_name;
792         new_blob->staging_dir_fd    = ctx->staging_dir_fd;
793         new_blob->size              = size;
794
795         prepare_unhashed_blob(new_blob, inode, strm->stream_id,
796                               &wim_get_current_image_metadata(ctx->wim)->unhashed_blobs);
797         inode_replace_stream_blob(inode, strm, new_blob, ctx->wim->blob_table);
798         return 0;
799
800 out_revert_fd_changes:
801         for (u16 i = 0; new_blob->num_opened_fds; i++) {
802                 struct wimfs_fd *fd = inode->i_fds[i];
803                 if (fd && fd->f_stream_id == strm->stream_id) {
804                         fd->f_blob = old_blob;
805                         if (filedes_valid(&fd->f_staging_fd)) {
806                                 filedes_close(&fd->f_staging_fd);
807                                 filedes_invalidate(&fd->f_staging_fd);
808                         }
809                         new_blob->num_opened_fds--;
810                 }
811         }
812         free_blob_descriptor(new_blob);
813 out_delete_staging_file:
814         unlinkat(ctx->staging_dir_fd, staging_file_name, 0);
815         FREE(staging_file_name);
816         return ret;
817 }
818
819 /*
820  * Create the staging directory for the WIM file.
821  *
822  * The staging directory will be created in the directory specified by the open
823  * file descriptor @parent_dir_fd.  It will be given a randomly generated name
824  * based on @wim_basename, the name of the WIM file.
825  *
826  * On success, returns a file descriptor to the open staging directory with
827  * O_RDONLY access.  In addition, stores the allocated name of the staging
828  * directory (relative to @parent_dir_fd) in @staging_dir_name_ret.
829  * On failure, returns -1 and sets errno.
830  */
831 static int
832 make_staging_dir_at(int parent_dir_fd, const char *wim_basename,
833                     char **staging_dir_name_ret)
834 {
835         static const char common_suffix[8] = ".staging";
836         static const size_t random_suffix_len = 10;
837         size_t wim_basename_len;
838         size_t staging_dir_name_len;
839         char *staging_dir_name;
840         char *p;
841         int fd;
842
843         wim_basename_len = strlen(wim_basename);
844         staging_dir_name_len = wim_basename_len + sizeof(common_suffix) +
845                                random_suffix_len;
846         staging_dir_name = MALLOC(staging_dir_name_len + 1);
847         if (!staging_dir_name)
848                 return -1;
849
850         p = staging_dir_name;
851         p = mempcpy(p, wim_basename, wim_basename_len);
852         p = mempcpy(p, common_suffix, sizeof(common_suffix));
853         randomize_char_array_with_alnum(p, random_suffix_len);
854         p += random_suffix_len;
855         *p = '\0';
856
857         if (mkdirat(parent_dir_fd, staging_dir_name, 0700))
858                 goto err1;
859
860         fd = openat(parent_dir_fd, staging_dir_name,
861                     O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
862         if (fd < 0)
863                 goto err2;
864
865         *staging_dir_name_ret = staging_dir_name;
866         return fd;
867
868 err2:
869         unlinkat(parent_dir_fd, staging_dir_name, AT_REMOVEDIR);
870 err1:
871         FREE(staging_dir_name);
872         return -1;
873 }
874
875 /*
876  * Create the staging directory and set ctx->staging_dir_fd,
877  * ctx->staging_dir_name, and ctx->parent_dir_fd.
878  */
879 static int
880 make_staging_dir(struct wimfs_context *ctx, const char *parent_dir_path)
881 {
882         const char *wim_basename;
883         char *end = NULL;
884         int ret;
885
886         wim_basename = path_basename(ctx->wim->filename);
887
888         if (!parent_dir_path) {
889                 /* The user did not specify a directory.  Default to creating
890                  * the staging directory alongside the WIM file.  */
891                 if (wim_basename > ctx->wim->filename) {
892                         parent_dir_path = ctx->wim->filename;
893                         end = (char *)(wim_basename - 1);
894                         /* *end must be a slash.  Temporarily overwrite it so we
895                          * can open the parent directory.  */
896                         *end = '\0';
897                 } else {
898                         parent_dir_path = ".";
899                 }
900         }
901
902         /* Open the parent directory (in which we'll create our staging
903          * directory).  */
904         ctx->parent_dir_fd = open(parent_dir_path, O_RDONLY | O_DIRECTORY);
905         if (ctx->parent_dir_fd < 0) {
906                 ERROR_WITH_ERRNO("Can't open directory \"%s\"",
907                                  parent_dir_path);
908                 ret = WIMLIB_ERR_OPENDIR;
909                 goto out_restore_wim_filename;
910         }
911
912         ctx->staging_dir_fd = make_staging_dir_at(ctx->parent_dir_fd,
913                                                   wim_basename,
914                                                   &ctx->staging_dir_name);
915         if (ctx->staging_dir_fd < 0) {
916                 ERROR_WITH_ERRNO("Can't create staging directory in \"%s\"",
917                                  parent_dir_path);
918                 close(ctx->parent_dir_fd);
919                 ret = WIMLIB_ERR_MKDIR;
920                 goto out_restore_wim_filename;
921         }
922         ret = 0;
923 out_restore_wim_filename:
924         if (end)
925                 *end = '/';
926         return ret;
927 }
928
929 /* Deletes the staging directory, undoing the effects of a successful call to
930  * make_staging_dir().  */
931 static void
932 delete_staging_dir(struct wimfs_context *ctx)
933 {
934         DIR *dir;
935         struct dirent *ent;
936
937         dir = fdopendir(ctx->staging_dir_fd);
938         if (dir) {
939                 while ((ent = readdir(dir)))
940                         unlinkat(ctx->staging_dir_fd, ent->d_name, 0);
941                 closedir(dir);
942         } else {
943                 close(ctx->staging_dir_fd);
944         }
945         if (unlinkat(ctx->parent_dir_fd, ctx->staging_dir_name, AT_REMOVEDIR))
946                 WARNING_WITH_ERRNO("Could not delete staging directory");
947         FREE(ctx->staging_dir_name);
948         close(ctx->parent_dir_fd);
949 }
950
951 static void
952 prepare_inodes(struct wimfs_context *ctx)
953 {
954         struct wim_image_metadata *imd;
955         struct wim_inode *inode;
956
957         ctx->next_ino = 1;
958         imd = wim_get_current_image_metadata(ctx->wim);
959         image_for_each_inode(inode, imd) {
960                 inode->i_ino = ctx->next_ino++;
961                 inode->i_num_opened_fds = 0;
962                 inode->i_num_allocated_fds = 0;
963                 inode->i_fds = NULL;
964         }
965 }
966
967 static void
968 release_extra_refcnts(struct wimfs_context *ctx)
969 {
970         struct list_head *list = &ctx->orig_blob_list;
971         struct blob_table *blob_table = ctx->wim->blob_table;
972         struct blob_descriptor *blob, *tmp;
973
974         list_for_each_entry_safe(blob, tmp, list, orig_blob_list)
975                 blob_subtract_refcnt(blob, blob_table, blob->out_refcnt);
976 }
977
978 /* Delete the 'struct blob_descriptor' for any stream that was modified
979  * or created in the read-write mounted image and had a final size of 0.  */
980 static void
981 delete_empty_blobs(struct wimfs_context *ctx)
982 {
983         struct blob_descriptor *blob, *tmp;
984         struct wim_image_metadata *imd;
985
986         imd = wim_get_current_image_metadata(ctx->wim);
987
988         image_for_each_unhashed_blob_safe(blob, tmp, imd) {
989                 if (!blob->size) {
990                         *retrieve_pointer_to_unhashed_blob(blob) = NULL;
991                         list_del(&blob->unhashed_list);
992                         free_blob_descriptor(blob);
993                 }
994         }
995 }
996
997 /* Close all file descriptors open to the specified inode.
998  *
999  * Note: closing the last file descriptor might free the inode.  */
1000 static void
1001 inode_close_fds(struct wim_inode *inode)
1002 {
1003         u16 num_open_fds = inode->i_num_opened_fds;
1004         for (u16 i = 0; num_open_fds; i++) {
1005                 if (inode->i_fds[i]) {
1006                         close_wimfs_fd(inode->i_fds[i]);
1007                         num_open_fds--;
1008                 }
1009         }
1010 }
1011
1012 /* Close all file descriptors open to the mounted image.  */
1013 static void
1014 close_all_fds(struct wimfs_context *ctx)
1015 {
1016         struct wim_inode *inode;
1017         struct hlist_node *tmp;
1018         struct wim_image_metadata *imd;
1019
1020         imd = wim_get_current_image_metadata(ctx->wim);
1021
1022         image_for_each_inode_safe(inode, tmp, imd)
1023                 inode_close_fds(inode);
1024 }
1025
1026 /* Moves the currently selected image, which may have been modified, to a new
1027  * index, and sets the original index to refer to a reset (unmodified) copy of
1028  * the image.  */
1029 static int
1030 renew_current_image(struct wimfs_context *ctx)
1031 {
1032         WIMStruct *wim = ctx->wim;
1033         int idx = wim->current_image - 1;
1034         struct wim_image_metadata *imd = wim->image_metadata[idx];
1035         struct wim_image_metadata *replace_imd;
1036         struct blob_descriptor *new_blob;
1037         int ret;
1038
1039         /* Create 'replace_imd' structure to use for the reset original,
1040          * unmodified image.  */
1041         ret = WIMLIB_ERR_NOMEM;
1042         replace_imd = new_image_metadata();
1043         if (!replace_imd)
1044                 goto err;
1045
1046         /* Create new blob descriptor for the modified image's metadata
1047          * resource, which doesn't exist yet.  */
1048         ret = WIMLIB_ERR_NOMEM;
1049         new_blob = new_blob_descriptor();
1050         if (!new_blob)
1051                 goto err_put_replace_imd;
1052
1053         new_blob->refcnt = 1;
1054         new_blob->is_metadata = 1;
1055
1056         /* Make the image being moved available at a new index.  Increments the
1057          * WIM's image count, but does not increment the reference count of the
1058          * 'struct image_metadata'.  */
1059         ret = append_image_metadata(wim, imd);
1060         if (ret)
1061                 goto err_free_new_blob;
1062
1063         ret = xml_add_image(wim->xml_info, NULL);
1064         if (ret)
1065                 goto err_undo_append;
1066
1067         replace_imd->metadata_blob = imd->metadata_blob;
1068         imd->metadata_blob = new_blob;
1069         wim->image_metadata[idx] = replace_imd;
1070         wim->current_image = wim->hdr.image_count;
1071         return 0;
1072
1073 err_undo_append:
1074         wim->hdr.image_count--;
1075 err_free_new_blob:
1076         free_blob_descriptor(new_blob);
1077 err_put_replace_imd:
1078         put_image_metadata(replace_imd, NULL);
1079 err:
1080         return ret;
1081 }
1082
1083 static enum wimlib_progress_status
1084 commit_progress_func(enum wimlib_progress_msg msg,
1085                      union wimlib_progress_info *info, void *progctx)
1086 {
1087         mqd_t mq = *(mqd_t *)progctx;
1088         struct commit_progress_report report;
1089
1090         memset(&report, 0, sizeof(report));
1091         report.msg = msg;
1092         if (info)
1093                 report.info = *info;
1094         mq_send(mq, (const char *)&report, sizeof(report), 1);
1095         return WIMLIB_PROGRESS_STATUS_CONTINUE;
1096 }
1097
1098 /* Commit the mounted image to the underlying WIM file.  */
1099 static int
1100 commit_image(struct wimfs_context *ctx, int unmount_flags, mqd_t mq)
1101 {
1102         int write_flags;
1103
1104         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_SEND_PROGRESS)
1105                 wimlib_register_progress_function(ctx->wim,
1106                                                   commit_progress_func, &mq);
1107         else
1108                 wimlib_register_progress_function(ctx->wim, NULL, NULL);
1109
1110         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_NEW_IMAGE) {
1111                 int ret = renew_current_image(ctx);
1112                 if (ret)
1113                         return ret;
1114         } else {
1115                 release_extra_refcnts(ctx);
1116         }
1117         INIT_LIST_HEAD(&ctx->orig_blob_list);
1118         delete_empty_blobs(ctx);
1119         mark_image_dirty(wim_get_current_image_metadata(ctx->wim));
1120
1121         write_flags = 0;
1122
1123         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY)
1124                 write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
1125
1126         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_REBUILD)
1127                 write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
1128
1129         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_RECOMPRESS)
1130                 write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
1131
1132         return wimlib_overwrite(ctx->wim, write_flags, 0);
1133 }
1134
1135 /* In the case of an allow_other mount, only the mount owner and root are
1136  * allowed to unmount the filesystem.  */
1137 static bool
1138 may_unmount_wimfs(void)
1139 {
1140         const struct fuse_context *fuse_ctx = fuse_get_context();
1141         const struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx);
1142
1143         return (fuse_ctx->uid == wimfs_ctx->owner_uid ||
1144                 fuse_ctx->uid == 0);
1145 }
1146
1147 /* Unmount the mounted image, called from the daemon process.  */
1148 static int
1149 unmount_wimfs(void)
1150 {
1151         struct fuse_context *fuse_ctx = fuse_get_context();
1152         struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx);
1153         const struct wimfs_unmount_info *info = &wimfs_ctx->unmount_info;
1154         int unmount_flags = info->unmount_flags;
1155         mqd_t mq = (mqd_t)-1;
1156         int ret;
1157
1158         /* Ignore COMMIT if the image is mounted read-only.  */
1159         if (!(wimfs_ctx->mount_flags & WIMLIB_MOUNT_FLAG_READWRITE))
1160                 unmount_flags &= ~WIMLIB_UNMOUNT_FLAG_COMMIT;
1161
1162         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_SEND_PROGRESS) {
1163                 mq = mq_open(info->mq_name, O_WRONLY | O_NONBLOCK);
1164                 if (mq == (mqd_t)-1) {
1165                         ret = WIMLIB_ERR_MQUEUE;
1166                         goto out;
1167                 }
1168         }
1169
1170         if (wimfs_ctx->num_open_fds) {
1171
1172                 /* There are still open file descriptors to the image.  */
1173
1174                 /* With COMMIT, refuse to unmount unless FORCE is also
1175                  * specified.  */
1176                 if ((unmount_flags & (WIMLIB_UNMOUNT_FLAG_COMMIT |
1177                                       WIMLIB_UNMOUNT_FLAG_FORCE))
1178                                  == WIMLIB_UNMOUNT_FLAG_COMMIT)
1179                 {
1180                         ret = WIMLIB_ERR_MOUNTED_IMAGE_IS_BUSY;
1181                         goto out;
1182                 }
1183
1184                 /* Force-close all file descriptors.  */
1185                 close_all_fds(wimfs_ctx);
1186         }
1187
1188         if (unmount_flags & WIMLIB_UNMOUNT_FLAG_COMMIT)
1189                 ret = commit_image(wimfs_ctx, unmount_flags, mq);
1190         else
1191                 ret = 0;  /* Read-only mount, or discarding changes to
1192                              a read-write mount  */
1193
1194 out:
1195         /* Leave the image mounted if commit failed, unless this is a
1196          * forced unmount.  The user can retry without COMMIT if they
1197          * want.  */
1198         if (!ret || (unmount_flags & WIMLIB_UNMOUNT_FLAG_FORCE)) {
1199                 unlock_wim_for_append(wimfs_ctx->wim);
1200                 fuse_exit(fuse_ctx->fuse);
1201         }
1202         if (mq != (mqd_t)-1)
1203                 mq_close(mq);
1204         return ret;
1205 }
1206
1207 static int
1208 wimfs_chmod(const char *path, mode_t mask)
1209 {
1210         const struct wimfs_context *ctx = wimfs_get_context();
1211         struct wim_inode *inode;
1212         struct wimlib_unix_data unix_data;
1213
1214         if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA))
1215                 return -EOPNOTSUPP;
1216
1217         inode = wim_pathname_to_inode(ctx->wim, path);
1218         if (!inode)
1219                 return -errno;
1220
1221         unix_data.uid = ctx->owner_uid;
1222         unix_data.gid = ctx->owner_gid;
1223         unix_data.mode = mask;
1224         unix_data.rdev = 0;
1225
1226         if (!inode_set_unix_data(inode, &unix_data, UNIX_DATA_MODE))
1227                 return -ENOMEM;
1228
1229         return 0;
1230 }
1231
1232 static int
1233 wimfs_chown(const char *path, uid_t uid, gid_t gid)
1234 {
1235         const struct wimfs_context *ctx = wimfs_get_context();
1236         struct wim_inode *inode;
1237         struct wimlib_unix_data unix_data;
1238         int which;
1239
1240         if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA))
1241                 return -EOPNOTSUPP;
1242
1243         inode = wim_pathname_to_inode(ctx->wim, path);
1244         if (!inode)
1245                 return -errno;
1246
1247         which = 0;
1248
1249         if (uid != (uid_t)-1)
1250                 which |= UNIX_DATA_UID;
1251         else
1252                 uid = ctx->owner_uid;
1253
1254         if (gid != (gid_t)-1)
1255                 which |= UNIX_DATA_GID;
1256         else
1257                 gid = ctx->owner_gid;
1258
1259         unix_data.uid = uid;
1260         unix_data.gid = gid;
1261         unix_data.mode = inode_default_unix_mode(inode);
1262         unix_data.rdev = 0;
1263
1264         if (!inode_set_unix_data(inode, &unix_data, which))
1265                 return -ENOMEM;
1266
1267         return 0;
1268 }
1269
1270 static int
1271 wimfs_fgetattr(const char *path, struct stat *stbuf, struct fuse_file_info *fi)
1272 {
1273         struct wimfs_fd *fd = WIMFS_FD(fi);
1274         return inode_to_stbuf(fd->f_inode, fd->f_blob, stbuf);
1275 }
1276
1277 static int
1278 wimfs_ftruncate(const char *path, off_t size, struct fuse_file_info *fi)
1279 {
1280         struct wimfs_fd *fd = WIMFS_FD(fi);
1281         if (ftruncate(fd->f_staging_fd.fd, size))
1282                 return -errno;
1283         touch_inode(fd->f_inode);
1284         fd->f_blob->size = size;
1285         return 0;
1286 }
1287
1288 static int
1289 wimfs_getattr(const char *path, struct stat *stbuf)
1290 {
1291         const struct wimfs_context *ctx = wimfs_get_context();
1292         struct wim_dentry *dentry;
1293         struct wim_inode_stream *strm;
1294         int ret;
1295
1296         ret = wim_pathname_to_stream(ctx, path, LOOKUP_FLAG_DIRECTORY_OK,
1297                                      &dentry, &strm);
1298         if (ret)
1299                 return ret;
1300
1301         return inode_to_stbuf(dentry->d_inode,
1302                               stream_blob_resolved(strm), stbuf);
1303 }
1304
1305 static int
1306 copy_xattr(char *dest, size_t destsize, const void *src, size_t srcsize)
1307 {
1308         if (destsize) {
1309                 if (destsize < srcsize)
1310                         return -ERANGE;
1311                 memcpy(dest, src, srcsize);
1312         }
1313         return srcsize;
1314 }
1315
1316 static int
1317 wimfs_getxattr(const char *path, const char *name, char *value,
1318                size_t size)
1319 {
1320         const struct wimfs_context *ctx = wimfs_get_context();
1321         const struct wim_inode *inode;
1322         const struct wim_inode_stream *strm;
1323         const struct blob_descriptor *blob;
1324
1325         if (!strncmp(name, "wimfs.", 6)) {
1326                 /* Handle some magical extended attributes.  These really should
1327                  * be ioctls, but directory ioctls aren't supported until
1328                  * libfuse 2.9, and even then they are broken.  */
1329                 name += 6;
1330                 if (!strcmp(name, "wim_filename")) {
1331                         return copy_xattr(value, size, ctx->wim->filename,
1332                                           strlen(ctx->wim->filename));
1333                 }
1334                 if (!strcmp(name, "wim_info")) {
1335                         struct wimlib_wim_info info;
1336
1337                         wimlib_get_wim_info(ctx->wim, &info);
1338
1339                         return copy_xattr(value, size, &info, sizeof(info));
1340                 }
1341                 if (!strcmp(name, "mounted_image")) {
1342                         return copy_xattr(value, size,
1343                                           &ctx->wim->current_image, sizeof(int));
1344                 }
1345                 if (!strcmp(name, "mount_flags")) {
1346                         return copy_xattr(value, size,
1347                                           &ctx->mount_flags, sizeof(int));
1348                 }
1349                 if (!strcmp(name, "unmount")) {
1350                         if (!may_unmount_wimfs())
1351                                 return -EPERM;
1352                         if (size) {
1353                                 int status;
1354
1355                                 if (size < sizeof(int))
1356                                         return -ERANGE;
1357                                 status = unmount_wimfs();
1358                                 memcpy(value, &status, sizeof(int));
1359                         }
1360                         return sizeof(int);
1361                 }
1362                 return -ENOATTR;
1363         }
1364
1365         if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR))
1366                 return -ENOTSUP;
1367
1368         if (strncmp(name, "user.", 5))
1369                 return -ENOATTR;
1370         name += 5;
1371
1372         if (!*name)
1373                 return -ENOATTR;
1374
1375         /* Querying a named data stream  */
1376
1377         inode = wim_pathname_to_inode(ctx->wim, path);
1378         if (!inode)
1379                 return -errno;
1380
1381         strm = inode_get_data_stream_tstr(inode, name);
1382         if (!strm)
1383                 return (errno == ENOENT) ? -ENOATTR : -errno;
1384
1385         blob = stream_blob_resolved(strm);
1386         if (!blob)
1387                 return 0;
1388
1389         if (unlikely(blob->size > INT_MAX))
1390                 return -EFBIG;
1391
1392         if (size) {
1393                 if (size < blob->size)
1394                         return -ERANGE;
1395
1396                 if (read_blob_into_buf(blob, value))
1397                         return errno ? -errno : -EIO;
1398         }
1399         return blob->size;
1400 }
1401
1402 static int
1403 wimfs_link(const char *existing_path, const char *new_path)
1404 {
1405         WIMStruct *wim = wimfs_get_WIMStruct();
1406         const char *new_name;
1407         struct wim_inode *inode;
1408         struct wim_dentry *dir;
1409         struct wim_dentry *new_alias;
1410
1411         inode = wim_pathname_to_inode(wim, existing_path);
1412         if (!inode)
1413                 return -errno;
1414
1415         if (inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
1416                                    FILE_ATTRIBUTE_REPARSE_POINT))
1417                 return -EPERM;
1418
1419         new_name = path_basename(new_path);
1420
1421         dir = get_parent_dentry(wim, new_path, WIMLIB_CASE_SENSITIVE);
1422         if (!dir)
1423                 return -errno;
1424
1425         if (!dentry_is_directory(dir))
1426                 return -ENOTDIR;
1427
1428         if (get_dentry_child_with_name(dir, new_name, WIMLIB_CASE_SENSITIVE))
1429                 return -EEXIST;
1430
1431         if (new_dentry_with_existing_inode(new_name, inode, &new_alias))
1432                 return -ENOMEM;
1433
1434         dentry_add_child(dir, new_alias);
1435         touch_inode(dir->d_inode);
1436         return 0;
1437 }
1438
1439 static int
1440 wimfs_listxattr(const char *path, char *list, size_t size)
1441 {
1442         const struct wimfs_context *ctx = wimfs_get_context();
1443         const struct wim_inode *inode;
1444         char *p = list;
1445         char *end = list + size;
1446         int total_size = 0;
1447
1448         if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR))
1449                 return -ENOTSUP;
1450
1451         /* List named data streams, or get the list size.  We report each named
1452          * data stream "X" as an extended attribute "user.X".  */
1453
1454         inode = wim_pathname_to_inode(ctx->wim, path);
1455         if (!inode)
1456                 return -errno;
1457
1458         for (unsigned i = 0; i < inode->i_num_streams; i++) {
1459                 const struct wim_inode_stream *strm;
1460                 char *stream_name_mbs;
1461                 size_t stream_name_mbs_nbytes;
1462
1463                 strm = &inode->i_streams[i];
1464
1465                 if (!stream_is_named_data_stream(strm))
1466                         continue;
1467
1468                 if (utf16le_to_tstr(strm->stream_name,
1469                                     utf16le_len_bytes(strm->stream_name),
1470                                     &stream_name_mbs,
1471                                     &stream_name_mbs_nbytes))
1472                         return -errno;
1473
1474                 if (unlikely(INT_MAX - total_size < stream_name_mbs_nbytes + 6)) {
1475                         FREE(stream_name_mbs);
1476                         return -EFBIG;
1477                 }
1478
1479                 total_size += stream_name_mbs_nbytes + 6;
1480                 if (size) {
1481                         if (end - p < stream_name_mbs_nbytes + 6) {
1482                                 FREE(stream_name_mbs);
1483                                 return -ERANGE;
1484                         }
1485                         p = mempcpy(p, "user.", 5);
1486                         p = mempcpy(p, stream_name_mbs, stream_name_mbs_nbytes);
1487                         *p++ = '\0';
1488                 }
1489                 FREE(stream_name_mbs);
1490         }
1491         return total_size;
1492 }
1493
1494 static int
1495 wimfs_mkdir(const char *path, mode_t mode)
1496 {
1497         struct wim_dentry *dentry;
1498         int ret;
1499
1500         /* Note: according to fuse.h, mode may not include S_IFDIR  */
1501         ret = create_file(fuse_get_context(), path, mode | S_IFDIR, 0, &dentry);
1502         if (ret)
1503                 return ret;
1504         touch_parent(dentry);
1505         return 0;
1506 }
1507
1508 static int
1509 wimfs_mknod(const char *path, mode_t mode, dev_t rdev)
1510 {
1511         struct fuse_context *fuse_ctx = fuse_get_context();
1512         struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx);
1513         const char *stream_name;
1514
1515         if ((wimfs_ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)
1516              && (stream_name = path_stream_name(path)))
1517         {
1518                 struct wim_inode *inode;
1519                 struct wim_inode_stream *existing_strm;
1520                 struct wim_inode_stream *new_strm;
1521                 char *p;
1522                 const utf16lechar *uname;
1523
1524                 /* Create a named data stream.  */
1525
1526                 if (!S_ISREG(mode))
1527                         return -EOPNOTSUPP;
1528
1529                 p = (char *)stream_name - 1;
1530
1531                 *p = '\0';
1532                 inode = wim_pathname_to_inode(wimfs_ctx->wim, path);
1533                 *p = ':';
1534                 if (!inode)
1535                         return -errno;
1536
1537                 if (tstr_get_utf16le(stream_name, &uname))
1538                         return -errno;
1539
1540                 existing_strm = inode_get_stream(inode, STREAM_TYPE_DATA, uname);
1541                 if (existing_strm) {
1542                         tstr_put_utf16le(uname);
1543                         return -EEXIST;
1544                 }
1545
1546                 new_strm = inode_add_stream(inode, STREAM_TYPE_DATA, uname, NULL);
1547
1548                 tstr_put_utf16le(uname);
1549
1550                 if (!new_strm)
1551                         return -errno;
1552                 return 0;
1553         } else {
1554                 /* Create a regular file, device node, named pipe, or socket.
1555                  */
1556                 struct wim_dentry *dentry;
1557                 int ret;
1558
1559                 if (!S_ISREG(mode) &&
1560                     !(wimfs_ctx->mount_flags & WIMLIB_MOUNT_FLAG_UNIX_DATA))
1561                         return -EPERM;
1562
1563                 ret = create_file(fuse_ctx, path, mode, rdev, &dentry);
1564                 if (ret)
1565                         return ret;
1566                 touch_parent(dentry);
1567                 return 0;
1568         }
1569 }
1570
1571 static int
1572 wimfs_open(const char *path, struct fuse_file_info *fi)
1573 {
1574         struct wimfs_context *ctx = wimfs_get_context();
1575         struct wim_dentry *dentry;
1576         struct wim_inode *inode;
1577         struct wim_inode_stream *strm;
1578         struct blob_descriptor *blob;
1579         struct wimfs_fd *fd;
1580         int ret;
1581
1582         ret = wim_pathname_to_stream(ctx, path, 0, &dentry, &strm);
1583         if (ret)
1584                 return ret;
1585
1586         inode = dentry->d_inode;
1587         blob = stream_blob_resolved(strm);
1588
1589         /* The data of the file being opened may be in the staging directory
1590          * (read-write mounts only) or in the WIM.  If it's in the staging
1591          * directory, we need to open a native file descriptor for the
1592          * corresponding file.  Otherwise, we can read the file data directly
1593          * from the WIM file if we are opening it read-only, but we need to
1594          * extract the data to the staging directory if we are opening it
1595          * writable.  */
1596
1597         if (flags_writable(fi->flags) &&
1598             (!blob || blob->blob_location != BLOB_IN_STAGING_FILE)) {
1599                 ret = extract_blob_to_staging_dir(inode,
1600                                                   strm,
1601                                                   blob_size(blob),
1602                                                   ctx);
1603                 if (ret)
1604                         return ret;
1605                 blob = stream_blob_resolved(strm);
1606         }
1607
1608         ret = alloc_wimfs_fd(inode, strm, &fd);
1609         if (ret)
1610                 return ret;
1611
1612         if (blob && blob->blob_location == BLOB_IN_STAGING_FILE) {
1613                 int raw_fd;
1614
1615                 raw_fd = openat(blob->staging_dir_fd, blob->staging_file_name,
1616                                 (fi->flags & O_ACCMODE) | O_NOFOLLOW);
1617                 if (raw_fd < 0) {
1618                         close_wimfs_fd(fd);
1619                         return -errno;
1620                 }
1621                 filedes_init(&fd->f_staging_fd, raw_fd);
1622         }
1623         fi->fh = (uintptr_t)fd;
1624         return 0;
1625 }
1626
1627 static int
1628 wimfs_opendir(const char *path, struct fuse_file_info *fi)
1629 {
1630         WIMStruct *wim = wimfs_get_WIMStruct();
1631         struct wim_inode *inode;
1632         struct wim_inode_stream *strm;
1633         struct wimfs_fd *fd;
1634         int ret;
1635
1636         inode = wim_pathname_to_inode(wim, path);
1637         if (!inode)
1638                 return -errno;
1639         if (!inode_is_directory(inode))
1640                 return -ENOTDIR;
1641         strm = inode_get_unnamed_data_stream(inode);
1642         if (!strm)
1643                 return -ENOTDIR;
1644         ret = alloc_wimfs_fd(inode, strm, &fd);
1645         if (ret)
1646                 return ret;
1647         fi->fh = (uintptr_t)fd;
1648         return 0;
1649 }
1650
1651 static int
1652 wimfs_read(const char *path, char *buf, size_t size,
1653            off_t offset, struct fuse_file_info *fi)
1654 {
1655         struct wimfs_fd *fd = WIMFS_FD(fi);
1656         const struct blob_descriptor *blob;
1657         ssize_t ret;
1658
1659         blob = fd->f_blob;
1660         if (!blob)
1661                 return 0;
1662
1663         if (offset >= blob->size)
1664                 return 0;
1665
1666         if (size > blob->size - offset)
1667                 size = blob->size - offset;
1668
1669         if (!size)
1670                 return 0;
1671
1672         switch (blob->blob_location) {
1673         case BLOB_IN_WIM:
1674                 if (read_partial_wim_blob_into_buf(blob, offset, size, buf))
1675                         ret = errno ? -errno : -EIO;
1676                 else
1677                         ret = size;
1678                 break;
1679         case BLOB_IN_STAGING_FILE:
1680                 ret = pread(fd->f_staging_fd.fd, buf, size, offset);
1681                 if (ret < 0)
1682                         ret = -errno;
1683                 break;
1684         case BLOB_IN_ATTACHED_BUFFER:
1685                 memcpy(buf, blob->attached_buffer + offset, size);
1686                 ret = size;
1687                 break;
1688         default:
1689                 ret = -EINVAL;
1690                 break;
1691         }
1692         return ret;
1693 }
1694
1695 static int
1696 wimfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
1697               off_t offset, struct fuse_file_info *fi)
1698 {
1699         struct wimfs_fd *fd = WIMFS_FD(fi);
1700         const struct wim_inode *inode;
1701         const struct wim_dentry *child;
1702         int ret;
1703
1704         inode = fd->f_inode;
1705
1706         ret = filler(buf, ".", NULL, 0);
1707         if (ret)
1708                 return ret;
1709         ret = filler(buf, "..", NULL, 0);
1710         if (ret)
1711                 return ret;
1712
1713         for_inode_child(child, inode) {
1714                 char *name;
1715                 size_t name_nbytes;
1716
1717                 if (utf16le_to_tstr(child->d_name, child->d_name_nbytes,
1718                                     &name, &name_nbytes))
1719                         return -errno;
1720
1721                 ret = filler(buf, name, NULL, 0);
1722                 FREE(name);
1723                 if (ret)
1724                         return ret;
1725         }
1726         return 0;
1727 }
1728
1729 static int
1730 wimfs_readlink(const char *path, char *buf, size_t bufsize)
1731 {
1732         struct wimfs_context *ctx = wimfs_get_context();
1733         const struct wim_inode *inode;
1734         int ret;
1735
1736         inode = wim_pathname_to_inode(ctx->wim, path);
1737         if (!inode)
1738                 return -errno;
1739         if (bufsize <= 0)
1740                 return -EINVAL;
1741         ret = wim_inode_readlink(inode, buf, bufsize - 1, NULL,
1742                                  ctx->mountpoint_abspath,
1743                                  ctx->mountpoint_abspath_nchars);
1744         if (ret < 0)
1745                 return ret;
1746         buf[ret] = '\0';
1747         return 0;
1748 }
1749
1750 /* We use this for both release() and releasedir(), since in both cases we
1751  * simply need to close the file descriptor.  */
1752 static int
1753 wimfs_release(const char *path, struct fuse_file_info *fi)
1754 {
1755         return close_wimfs_fd(WIMFS_FD(fi));
1756 }
1757
1758 static int
1759 wimfs_removexattr(const char *path, const char *name)
1760 {
1761         struct wimfs_context *ctx = wimfs_get_context();
1762         struct wim_inode *inode;
1763         struct wim_inode_stream *strm;
1764
1765         if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR))
1766                 return -ENOTSUP;
1767
1768         if (strncmp(name, "user.", 5))
1769                 return -ENOATTR;
1770         name += 5;
1771
1772         if (!*name)
1773                 return -ENOATTR;
1774
1775         /* Removing a named data stream.  */
1776
1777         inode = wim_pathname_to_inode(ctx->wim, path);
1778         if (!inode)
1779                 return -errno;
1780
1781         strm = inode_get_data_stream_tstr(inode, name);
1782         if (!strm)
1783                 return (errno == ENOENT) ? -ENOATTR : -errno;
1784
1785         inode_remove_stream(inode, strm, ctx->wim->blob_table);
1786         return 0;
1787 }
1788
1789 static int
1790 wimfs_rename(const char *from, const char *to)
1791 {
1792         return rename_wim_path(wimfs_get_WIMStruct(), from, to,
1793                                WIMLIB_CASE_SENSITIVE, NULL);
1794 }
1795
1796 static int
1797 wimfs_rmdir(const char *path)
1798 {
1799         WIMStruct *wim = wimfs_get_WIMStruct();
1800         struct wim_dentry *dentry;
1801
1802         dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
1803         if (!dentry)
1804                 return -errno;
1805
1806         if (!dentry_is_directory(dentry))
1807                 return -ENOTDIR;
1808
1809         if (dentry_has_children(dentry))
1810                 return -ENOTEMPTY;
1811
1812         touch_parent(dentry);
1813         remove_dentry(dentry, wim->blob_table);
1814         return 0;
1815 }
1816
1817 static int
1818 wimfs_setxattr(const char *path, const char *name,
1819                const char *value, size_t size, int flags)
1820 {
1821         struct wimfs_context *ctx = wimfs_get_context();
1822         struct wim_inode *inode;
1823         struct wim_inode_stream *strm;
1824         const utf16lechar *uname;
1825         int ret;
1826
1827         if (!strncmp(name, "wimfs.", 6)) {
1828                 /* Handle some magical extended attributes.  These really should
1829                  * be ioctls, but directory ioctls aren't supported until
1830                  * libfuse 2.9, and even then they are broken.  [Fixed by
1831                  * libfuse commit e3b7d4c278a26520be63d99d6ea84b26906fe73d]  */
1832                 name += 6;
1833                 if (!strcmp(name, "unmount_info")) {
1834                         if (!may_unmount_wimfs())
1835                                 return -EPERM;
1836                         if (size < sizeof(struct wimfs_unmount_info))
1837                                 return -EINVAL;
1838                         memcpy(&ctx->unmount_info, value,
1839                                sizeof(struct wimfs_unmount_info));
1840                         return 0;
1841                 }
1842                 return -ENOATTR;
1843         }
1844
1845         if (!(ctx->mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR))
1846                 return -ENOTSUP;
1847
1848         if (strncmp(name, "user.", 5))
1849                 return -ENOATTR;
1850         name += 5;
1851
1852         if (!*name)
1853                 return -ENOATTR;
1854
1855         /* Setting the contents of a named data stream.  */
1856
1857         inode = wim_pathname_to_inode(ctx->wim, path);
1858         if (!inode)
1859                 return -errno;
1860
1861         ret = tstr_get_utf16le(name, &uname);
1862         if (ret)
1863                 return -errno;
1864
1865         strm = inode_get_stream(inode, STREAM_TYPE_DATA, uname);
1866         if (strm) {
1867                 ret = -EEXIST;
1868                 if (flags & XATTR_CREATE)
1869                         goto out_put_uname;
1870         } else {
1871                 ret = -ENOATTR;
1872                 if (flags & XATTR_REPLACE)
1873                         goto out_put_uname;
1874         }
1875
1876         if (strm) {
1877                 if (!inode_replace_stream_data(inode, strm, value, size,
1878                                                ctx->wim->blob_table))
1879                 {
1880                         ret = -errno;
1881                         goto out_put_uname;
1882                 }
1883         } else {
1884                 if (!inode_add_stream_with_data(inode, STREAM_TYPE_DATA, uname,
1885                                                 value, size, ctx->wim->blob_table))
1886                 {
1887                         ret = -errno;
1888                         goto out_put_uname;
1889                 }
1890         }
1891
1892         ret = 0;
1893 out_put_uname:
1894         tstr_put_utf16le(uname);
1895         return ret;
1896 }
1897
1898 static int
1899 wimfs_symlink(const char *to, const char *from)
1900 {
1901         struct fuse_context *fuse_ctx = fuse_get_context();
1902         struct wimfs_context *wimfs_ctx = WIMFS_CTX(fuse_ctx);
1903         struct wim_dentry *dentry;
1904         int ret;
1905
1906         ret = create_file(fuse_ctx, from, S_IFLNK | 0777, 0, &dentry);
1907         if (ret)
1908                 return ret;
1909         ret = wim_inode_set_symlink(dentry->d_inode, to,
1910                                     wimfs_ctx->wim->blob_table);
1911         if (ret) {
1912                 remove_dentry(dentry, wimfs_ctx->wim->blob_table);
1913                 if (ret == WIMLIB_ERR_NOMEM)
1914                         ret = -ENOMEM;
1915                 else
1916                         ret = -EINVAL;
1917         } else {
1918                 touch_parent(dentry);
1919         }
1920         return ret;
1921 }
1922
1923 static int
1924 wimfs_truncate(const char *path, off_t size)
1925 {
1926         const struct wimfs_context *ctx = wimfs_get_context();
1927         struct wim_dentry *dentry;
1928         struct wim_inode_stream *strm;
1929         struct blob_descriptor *blob;
1930         int ret;
1931         int fd;
1932
1933         ret = wim_pathname_to_stream(ctx, path, 0, &dentry, &strm);
1934         if (ret)
1935                 return ret;
1936
1937         blob = stream_blob_resolved(strm);
1938
1939         if (!blob && !size)
1940                 return 0;
1941
1942         if (!blob || blob->blob_location != BLOB_IN_STAGING_FILE) {
1943                 return extract_blob_to_staging_dir(dentry->d_inode,
1944                                                    strm, size, ctx);
1945         }
1946
1947         /* Truncate the staging file.  */
1948         fd = openat(blob->staging_dir_fd, blob->staging_file_name,
1949                     O_WRONLY | O_NOFOLLOW);
1950         if (fd < 0)
1951                 return -errno;
1952         ret = ftruncate(fd, size);
1953         if (close(fd) || ret)
1954                 return -errno;
1955         blob->size = size;
1956         touch_inode(dentry->d_inode);
1957         return 0;
1958 }
1959
1960 static int
1961 wimfs_unlink(const char *path)
1962 {
1963         const struct wimfs_context *ctx = wimfs_get_context();
1964         struct wim_dentry *dentry;
1965         struct wim_inode_stream *strm;
1966         int ret;
1967
1968         ret = wim_pathname_to_stream(ctx, path, 0, &dentry, &strm);
1969         if (ret)
1970                 return ret;
1971
1972         if (stream_is_named(strm)) {
1973                 inode_remove_stream(dentry->d_inode, strm,
1974                                     ctx->wim->blob_table);
1975         } else {
1976                 touch_parent(dentry);
1977                 remove_dentry(dentry, ctx->wim->blob_table);
1978         }
1979         return 0;
1980 }
1981
1982 #ifdef HAVE_UTIMENSAT
1983 /*
1984  * Change the timestamp on a file dentry.
1985  *
1986  * Note that alternate data streams do not have their own timestamps.
1987  */
1988 static int
1989 wimfs_utimens(const char *path, const struct timespec tv[2])
1990 {
1991         WIMStruct *wim = wimfs_get_WIMStruct();
1992         struct wim_inode *inode;
1993
1994         inode = wim_pathname_to_inode(wim, path);
1995         if (!inode)
1996                 return -errno;
1997
1998         if (tv[0].tv_nsec != UTIME_OMIT) {
1999                 if (tv[0].tv_nsec == UTIME_NOW)
2000                         inode->i_last_access_time = now_as_wim_timestamp();
2001                 else
2002                         inode->i_last_access_time = timespec_to_wim_timestamp(&tv[0]);
2003         }
2004         if (tv[1].tv_nsec != UTIME_OMIT) {
2005                 if (tv[1].tv_nsec == UTIME_NOW)
2006                         inode->i_last_write_time = now_as_wim_timestamp();
2007                 else
2008                         inode->i_last_write_time = timespec_to_wim_timestamp(&tv[1]);
2009         }
2010         return 0;
2011 }
2012 #else /* HAVE_UTIMENSAT */
2013 static int
2014 wimfs_utime(const char *path, struct utimbuf *times)
2015 {
2016         WIMStruct *wim = wimfs_get_WIMStruct();
2017         struct wim_inode *inode;
2018
2019         inode = wim_pathname_to_inode(wim, path);
2020         if (!inode)
2021                 return -errno;
2022
2023         inode->i_last_access_time = time_t_to_wim_timestamp(times->actime);
2024         inode->i_last_write_time = time_t_to_wim_timestamp(times->modtime);
2025         return 0;
2026 }
2027 #endif /* !HAVE_UTIMENSAT */
2028
2029 static int
2030 wimfs_write(const char *path, const char *buf, size_t size,
2031             off_t offset, struct fuse_file_info *fi)
2032 {
2033         struct wimfs_fd *fd = WIMFS_FD(fi);
2034         ssize_t ret;
2035
2036         ret = pwrite(fd->f_staging_fd.fd, buf, size, offset);
2037         if (ret < 0)
2038                 return -errno;
2039
2040         if (offset + size > fd->f_blob->size)
2041                 fd->f_blob->size = offset + size;
2042
2043         touch_inode(fd->f_inode);
2044         return ret;
2045 }
2046
2047 static struct fuse_operations wimfs_operations = {
2048         .chmod       = wimfs_chmod,
2049         .chown       = wimfs_chown,
2050         .fgetattr    = wimfs_fgetattr,
2051         .ftruncate   = wimfs_ftruncate,
2052         .getattr     = wimfs_getattr,
2053         .getxattr    = wimfs_getxattr,
2054         .link        = wimfs_link,
2055         .listxattr   = wimfs_listxattr,
2056         .mkdir       = wimfs_mkdir,
2057         .mknod       = wimfs_mknod,
2058         .open        = wimfs_open,
2059         .opendir     = wimfs_opendir,
2060         .read        = wimfs_read,
2061         .readdir     = wimfs_readdir,
2062         .readlink    = wimfs_readlink,
2063         .release     = wimfs_release,
2064         .releasedir  = wimfs_release,
2065         .removexattr = wimfs_removexattr,
2066         .rename      = wimfs_rename,
2067         .rmdir       = wimfs_rmdir,
2068         .setxattr    = wimfs_setxattr,
2069         .symlink     = wimfs_symlink,
2070         .truncate    = wimfs_truncate,
2071         .unlink      = wimfs_unlink,
2072 #ifdef HAVE_UTIMENSAT
2073         .utimens     = wimfs_utimens,
2074 #else
2075         .utime       = wimfs_utime,
2076 #endif
2077         .write       = wimfs_write,
2078
2079         /* We keep track of file descriptor structures (struct wimfs_fd), so
2080          * there is no need to have the file path provided on operations such as
2081          * read().  */
2082 #if FUSE_MAJOR_VERSION > 2 || (FUSE_MAJOR_VERSION == 2 && FUSE_MINOR_VERSION >= 8)
2083         .flag_nullpath_ok = 1,
2084 #endif
2085 #if FUSE_MAJOR_VERSION > 2 || (FUSE_MAJOR_VERSION == 2 && FUSE_MINOR_VERSION >= 9)
2086         .flag_nopath = 1,
2087         .flag_utime_omit_ok = 1,
2088 #endif
2089 };
2090
2091 /* API function documented in wimlib.h  */
2092 WIMLIBAPI int
2093 wimlib_mount_image(WIMStruct *wim, int image, const char *dir,
2094                    int mount_flags, const char *staging_dir)
2095 {
2096         int ret;
2097         struct wim_image_metadata *imd;
2098         struct wimfs_context ctx;
2099         char *fuse_argv[16];
2100         int fuse_argc;
2101
2102         if (!wim || !dir || !*dir)
2103                 return WIMLIB_ERR_INVALID_PARAM;
2104
2105         if (mount_flags & ~(WIMLIB_MOUNT_FLAG_READWRITE |
2106                             WIMLIB_MOUNT_FLAG_DEBUG |
2107                             WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE |
2108                             WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR |
2109                             WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS |
2110                             WIMLIB_MOUNT_FLAG_UNIX_DATA |
2111                             WIMLIB_MOUNT_FLAG_ALLOW_OTHER))
2112                 return WIMLIB_ERR_INVALID_PARAM;
2113
2114         /* For read-write mount, check for write access to the WIM.  */
2115         if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
2116                 if (!wim->filename)
2117                         return WIMLIB_ERR_NO_FILENAME;
2118                 ret = can_modify_wim(wim);
2119                 if (ret)
2120                         return ret;
2121         }
2122
2123         /* Select the image to mount.  */
2124         ret = select_wim_image(wim, image);
2125         if (ret)
2126                 return ret;
2127
2128         /* Get the metadata for the image to mount.  */
2129         imd = wim_get_current_image_metadata(wim);
2130
2131         /* To avoid complicating things, we don't support mounting images to
2132          * which in-memory modifications have already been made.  */
2133         if (is_image_dirty(imd)) {
2134                 ERROR("Cannot mount a modified WIM image!");
2135                 return WIMLIB_ERR_INVALID_PARAM;
2136         }
2137
2138         if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
2139                 if (imd->refcnt > 1)
2140                         return WIMLIB_ERR_IMAGE_HAS_MULTIPLE_REFERENCES;
2141                 ret = lock_wim_for_append(wim);
2142                 if (ret)
2143                         return ret;
2144         }
2145
2146         if (wim_has_solid_resources(wim)) {
2147                 WARNING("Mounting a WIM file containing solid-compressed data; "
2148                         "file access may be slow.");
2149         }
2150
2151         /* If the user did not specify an interface for accessing named
2152          * data streams, use the default (extended attributes).  */
2153         if (!(mount_flags & (WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE |
2154                              WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR |
2155                              WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)))
2156                 mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR;
2157
2158         /* Start initializing the wimfs_context.  */
2159         memset(&ctx, 0, sizeof(struct wimfs_context));
2160         ctx.wim = wim;
2161         ctx.mount_flags = mount_flags;
2162         if (mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)
2163                 ctx.default_lookup_flags = LOOKUP_FLAG_ADS_OK;
2164         /* For read-write mount, create the staging directory.  */
2165         if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
2166                 ret = make_staging_dir(&ctx, staging_dir);
2167                 if (ret)
2168                         goto out_unlock;
2169         }
2170         ctx.owner_uid = getuid();
2171         ctx.owner_gid = getgid();
2172
2173         /* Add each blob referenced by files in the image to a list and
2174          * preemptively double the number of references to each.  This is done
2175          * to allow implementing the WIMLIB_UNMOUNT_FLAG_NEW_IMAGE semantics.
2176          */
2177         INIT_LIST_HEAD(&ctx.orig_blob_list);
2178         if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
2179                 unsigned i;
2180                 struct wim_inode *inode;
2181                 struct blob_descriptor *blob;
2182
2183                 image_for_each_inode(inode, imd) {
2184                         for (i = 0; i < inode->i_num_streams; i++) {
2185                                 blob = stream_blob(&inode->i_streams[i],
2186                                                    wim->blob_table);
2187                                 if (blob)
2188                                         blob->out_refcnt = 0;
2189                         }
2190                 }
2191
2192                 image_for_each_inode(inode, imd) {
2193                         for (i = 0; i < inode->i_num_streams; i++) {
2194                                 blob = stream_blob(&inode->i_streams[i],
2195                                                    wim->blob_table);
2196                                 if (blob) {
2197                                         if (blob->out_refcnt == 0)
2198                                                 list_add(&blob->orig_blob_list,
2199                                                          &ctx.orig_blob_list);
2200                                         blob->out_refcnt += inode->i_nlink;
2201                                         blob->refcnt += inode->i_nlink;
2202                                 }
2203                         }
2204                 }
2205         }
2206
2207         /* Number the inodes in the mounted image sequentially and initialize
2208          * the file descriptor arrays  */
2209         prepare_inodes(&ctx);
2210
2211         /* Save the absolute path to the mountpoint directory.  */
2212         ctx.mountpoint_abspath = realpath(dir, NULL);
2213         if (ctx.mountpoint_abspath)
2214                 ctx.mountpoint_abspath_nchars = strlen(ctx.mountpoint_abspath);
2215
2216         /* Build the FUSE command line.  */
2217
2218         fuse_argc = 0;
2219         fuse_argv[fuse_argc++] = "wimlib";
2220         fuse_argv[fuse_argc++] = (char *)dir;
2221
2222         /* Disable multi-threaded operation.  */
2223         fuse_argv[fuse_argc++] = "-s";
2224
2225         /* Enable FUSE debug mode (don't fork) if requested by the user.  */
2226         if (mount_flags & WIMLIB_MOUNT_FLAG_DEBUG)
2227                 fuse_argv[fuse_argc++] = "-d";
2228
2229         /*
2230          * Build the FUSE mount options:
2231          *
2232          * use_ino
2233          *      FUSE will use the inode numbers we provide.  We want this,
2234          *      because we have inodes and will number them ourselves.
2235          *
2236          * subtype=wimfs
2237          *      Name for our filesystem (main type is "fuse").
2238          *
2239          * hard_remove
2240          *      If an open file is unlinked, unlink it for real rather than
2241          *      renaming it to a hidden file.  Our code supports this; an
2242          *      unlinked inode is retained until all its file descriptors have
2243          *      been closed.
2244          *
2245          * default_permissions
2246          *      FUSE will perform permission checking.  Useful when
2247          *      WIMLIB_MOUNT_FLAG_UNIX_DATA is provided and the WIM image
2248          *      contains the UNIX permissions for each file.
2249          *
2250          * kernel_cache
2251          *      Cache the contents of files.  This will speed up repeated access
2252          *      to files on a mounted WIM image, since they won't need to be
2253          *      decompressed repeatedly.  This option is valid because data in
2254          *      the WIM image should never be changed externally.  (Although, if
2255          *      someone really wanted to they could modify the WIM file or mess
2256          *      with the staging directory; but then they're asking for
2257          *      trouble.)
2258          *
2259          * entry_timeout=1000000000
2260          *      Cache positive name lookups indefinitely, since names can only
2261          *      be added, removed, or modified through the mounted filesystem
2262          *      itself.
2263          *
2264          * negative_timeout=1000000000
2265          *      Cache negative name lookups indefinitely, since names can only
2266          *      be added, removed, or modified through the mounted filesystem
2267          *      itself.
2268          *
2269          * attr_timeout=0
2270          *      Don't cache file/directory attributes.  This is needed as a
2271          *      workaround for the fact that when caching attributes, the high
2272          *      level interface to libfuse considers a file which has several
2273          *      hard-linked names as several different files.  (Otherwise, we
2274          *      could cache our file/directory attributes indefinitely, since
2275          *      they can only be changed through the mounted filesystem itself.)
2276          */
2277         char optstring[256] =
2278                 "use_ino"
2279                 ",subtype=wimfs"
2280                 ",hard_remove"
2281                 ",default_permissions"
2282                 ",kernel_cache"
2283                 ",entry_timeout=1000000000"
2284                 ",negative_timeout=1000000000"
2285                 ",attr_timeout=0"
2286                 ;
2287         fuse_argv[fuse_argc++] = "-o";
2288         fuse_argv[fuse_argc++] = optstring;
2289         if (!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE))
2290                 strcat(optstring, ",ro");
2291         if (mount_flags & WIMLIB_MOUNT_FLAG_ALLOW_OTHER)
2292                 strcat(optstring, ",allow_other");
2293         fuse_argv[fuse_argc] = NULL;
2294
2295         /* Mount our filesystem.  */
2296         ret = fuse_main(fuse_argc, fuse_argv, &wimfs_operations, &ctx);
2297
2298         /* Cleanup and return.  */
2299         if (ret)
2300                 ret = WIMLIB_ERR_FUSE;
2301         FREE(ctx.mountpoint_abspath);
2302         release_extra_refcnts(&ctx);
2303         if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
2304                 delete_staging_dir(&ctx);
2305 out_unlock:
2306         unlock_wim_for_append(wim);
2307         return ret;
2308 }
2309
2310 struct commit_progress_thread_args {
2311         mqd_t mq;
2312         wimlib_progress_func_t progfunc;
2313         void *progctx;
2314 };
2315
2316 static void *
2317 commit_progress_thread_proc(void *_args)
2318 {
2319         struct commit_progress_thread_args *args = _args;
2320         struct commit_progress_report report;
2321         ssize_t ret;
2322
2323         for (;;) {
2324                 ret = mq_receive(args->mq,
2325                                  (char *)&report, sizeof(report), NULL);
2326                 if (ret == sizeof(report)) {
2327                         call_progress(args->progfunc, report.msg,
2328                                       &report.info, args->progctx);
2329                 } else {
2330                         if (ret == 0 || (ret < 0 && errno != EINTR))
2331                                 break;
2332                 }
2333         }
2334         return NULL;
2335 }
2336
2337 static void
2338 generate_message_queue_name(char name[WIMFS_MQUEUE_NAME_LEN + 1])
2339 {
2340         name[0] = '/';
2341         memcpy(name + 1, "wimfs-", 6);
2342         randomize_char_array_with_alnum(name + 7, WIMFS_MQUEUE_NAME_LEN - 7);
2343         name[WIMFS_MQUEUE_NAME_LEN] = '\0';
2344 }
2345
2346 static mqd_t
2347 create_message_queue(const char *name)
2348 {
2349         bool am_root;
2350         mode_t umask_save;
2351         mode_t mode;
2352         struct mq_attr attr;
2353         mqd_t mq;
2354
2355         memset(&attr, 0, sizeof(attr));
2356         attr.mq_maxmsg = 8;
2357         attr.mq_msgsize = sizeof(struct commit_progress_report);
2358
2359         am_root = (geteuid() == 0);
2360         if (am_root) {
2361                 /* Filesystem mounted as normal user with --allow-other should
2362                  * be able to send messages to root user, if they're doing the
2363                  * unmount.  */
2364                 umask_save = umask(0);
2365                 mode = 0666;
2366         } else {
2367                 mode = 0600;
2368         }
2369         mq = mq_open(name, O_RDWR | O_CREAT | O_EXCL, mode, &attr);
2370         if (am_root)
2371                 umask(umask_save);
2372         return mq;
2373 }
2374
2375 /* Unmount a read-only or read-write mounted WIM image.  */
2376 static int
2377 do_unmount(const char *dir)
2378 {
2379         int status;
2380         ssize_t len;
2381
2382         len = getxattr(dir, "wimfs.unmount", &status, sizeof(int));
2383         if (len == sizeof(int))
2384                 return status;
2385         else if (len < 0 && (errno == EACCES || errno == EPERM))
2386                 return WIMLIB_ERR_NOT_PERMITTED_TO_UNMOUNT;
2387         else
2388                 return WIMLIB_ERR_NOT_A_MOUNTPOINT;
2389 }
2390
2391 static int
2392 set_unmount_info(const char *dir, const struct wimfs_unmount_info *unmount_info)
2393 {
2394         if (!setxattr(dir, "wimfs.unmount_info",
2395                       unmount_info, sizeof(struct wimfs_unmount_info), 0))
2396                 return 0;
2397         else if (errno == EROFS)
2398                 return 0;
2399         else if (errno == EACCES || errno == EPERM)
2400                 return WIMLIB_ERR_NOT_PERMITTED_TO_UNMOUNT;
2401         else
2402                 return WIMLIB_ERR_NOT_A_MOUNTPOINT;
2403 }
2404
2405 static int
2406 do_unmount_discard(const char *dir)
2407 {
2408         int ret;
2409         struct wimfs_unmount_info unmount_info;
2410
2411         memset(&unmount_info, 0, sizeof(unmount_info));
2412
2413         ret = set_unmount_info(dir, &unmount_info);
2414         if (ret)
2415                 return ret;
2416         return do_unmount(dir);
2417 }
2418
2419 /* Unmount a read-write mounted WIM image, committing the changes.  */
2420 static int
2421 do_unmount_commit(const char *dir, int unmount_flags,
2422                   wimlib_progress_func_t progfunc, void *progctx)
2423 {
2424         struct wimfs_unmount_info unmount_info;
2425         mqd_t mq;
2426         struct commit_progress_thread_args args;
2427         pthread_t commit_progress_tid;
2428         int ret;
2429
2430         memset(&unmount_info, 0, sizeof(unmount_info));
2431         unmount_info.unmount_flags = unmount_flags;
2432
2433         /* The current thread will be stuck in getxattr() until the image is
2434          * committed.  Create a thread to handle the progress messages.  */
2435         if (progfunc) {
2436                 generate_message_queue_name(unmount_info.mq_name);
2437
2438                 mq = create_message_queue(unmount_info.mq_name);
2439                 if (mq == (mqd_t)-1) {
2440                         ERROR_WITH_ERRNO("Can't create POSIX message queue");
2441                         return WIMLIB_ERR_MQUEUE;
2442                 }
2443                 args.mq = mq;
2444                 args.progfunc = progfunc;
2445                 args.progctx = progctx;
2446                 ret = pthread_create(&commit_progress_tid, NULL,
2447                                      commit_progress_thread_proc, &args);
2448                 if (ret) {
2449                         errno = ret;
2450                         ERROR_WITH_ERRNO("Can't create thread");
2451                         ret = WIMLIB_ERR_NOMEM;
2452                         goto out_delete_mq;
2453                 }
2454                 unmount_info.unmount_flags |= WIMLIB_UNMOUNT_FLAG_SEND_PROGRESS;
2455         }
2456
2457         ret = set_unmount_info(dir, &unmount_info);
2458         if (!ret)
2459                 ret = do_unmount(dir);
2460         if (progfunc) {
2461                 /* Terminate the progress thread.  */
2462                 char empty[1];
2463                 mq_send(mq, empty, 0, 1);
2464                 pthread_join(commit_progress_tid, NULL);
2465         }
2466 out_delete_mq:
2467         if (progfunc) {
2468                 mq_close(mq);
2469                 mq_unlink(unmount_info.mq_name);
2470         }
2471         return ret;
2472 }
2473
2474 static int
2475 begin_unmount(const char *dir, int unmount_flags, int *mount_flags_ret,
2476               wimlib_progress_func_t progfunc, void *progctx)
2477 {
2478         int mount_flags;
2479         int mounted_image;
2480         int wim_filename_len;
2481         union wimlib_progress_info progress;
2482
2483         if (getxattr(dir, "wimfs.mount_flags",
2484                      &mount_flags, sizeof(int)) != sizeof(int))
2485                 return WIMLIB_ERR_NOT_A_MOUNTPOINT;
2486
2487         *mount_flags_ret = mount_flags;
2488
2489         if (!progfunc)
2490                 return 0;
2491
2492         if (getxattr(dir, "wimfs.mounted_image",
2493                      &mounted_image, sizeof(int)) != sizeof(int))
2494                 return WIMLIB_ERR_NOT_A_MOUNTPOINT;
2495
2496         wim_filename_len = getxattr(dir, "wimfs.wim_filename", NULL, 0);
2497         if (wim_filename_len < 0)
2498                 return WIMLIB_ERR_NOT_A_MOUNTPOINT;
2499
2500         char wim_filename[wim_filename_len + 1];
2501         if (getxattr(dir, "wimfs.wim_filename",
2502                      wim_filename, wim_filename_len) != wim_filename_len)
2503                 return WIMLIB_ERR_NOT_A_MOUNTPOINT;
2504         wim_filename[wim_filename_len] = '\0';
2505
2506         progress.unmount.mountpoint = dir;
2507         progress.unmount.mounted_wim = wim_filename;
2508         progress.unmount.mounted_image = mounted_image;
2509         progress.unmount.mount_flags = mount_flags;
2510         progress.unmount.unmount_flags = unmount_flags;
2511
2512         return call_progress(progfunc, WIMLIB_PROGRESS_MSG_UNMOUNT_BEGIN,
2513                              &progress, progctx);
2514 }
2515
2516 /* API function documented in wimlib.h  */
2517 WIMLIBAPI int
2518 wimlib_unmount_image_with_progress(const char *dir, int unmount_flags,
2519                                    wimlib_progress_func_t progfunc, void *progctx)
2520 {
2521         int mount_flags;
2522         int ret;
2523
2524         ret = wimlib_global_init(WIMLIB_INIT_FLAG_ASSUME_UTF8);
2525         if (ret)
2526                 return ret;
2527
2528         if (unmount_flags & ~(WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY |
2529                               WIMLIB_UNMOUNT_FLAG_COMMIT |
2530                               WIMLIB_UNMOUNT_FLAG_REBUILD |
2531                               WIMLIB_UNMOUNT_FLAG_RECOMPRESS |
2532                               WIMLIB_UNMOUNT_FLAG_FORCE |
2533                               WIMLIB_UNMOUNT_FLAG_NEW_IMAGE))
2534                 return WIMLIB_ERR_INVALID_PARAM;
2535
2536         ret = begin_unmount(dir, unmount_flags, &mount_flags,
2537                             progfunc, progctx);
2538         if (ret)
2539                 return ret;
2540
2541         if ((unmount_flags & WIMLIB_UNMOUNT_FLAG_COMMIT) &&
2542             (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE))
2543                 return do_unmount_commit(dir, unmount_flags,
2544                                          progfunc, progctx);
2545         else
2546                 return do_unmount_discard(dir);
2547 }
2548
2549 #else /* WITH_FUSE */
2550
2551
2552 static int
2553 mount_unsupported_error(void)
2554 {
2555 #if defined(__WIN32__)
2556         ERROR("Sorry-- Mounting WIM images is not supported on Windows!");
2557 #else
2558         ERROR("wimlib was compiled with --without-fuse, which disables support "
2559               "for mounting WIMs.");
2560 #endif
2561         return WIMLIB_ERR_UNSUPPORTED;
2562 }
2563
2564 WIMLIBAPI int
2565 wimlib_unmount_image_with_progress(const tchar *dir, int unmount_flags,
2566                                    wimlib_progress_func_t progfunc, void *progctx)
2567 {
2568         return mount_unsupported_error();
2569 }
2570
2571 WIMLIBAPI int
2572 wimlib_mount_image(WIMStruct *wim, int image, const tchar *dir,
2573                    int mount_flags, const tchar *staging_dir)
2574 {
2575         return mount_unsupported_error();
2576 }
2577
2578 #endif /* !WITH_FUSE */
2579
2580 WIMLIBAPI int
2581 wimlib_unmount_image(const tchar *dir, int unmount_flags)
2582 {
2583         return wimlib_unmount_image_with_progress(dir, unmount_flags, NULL, NULL);
2584 }