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