X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fmount.c;h=984666e6b6c2c88e35f0fd55e325694a4b0d888a;hp=f3043c2b5a7e26f910d9c4f51840290fd9e416d1;hb=72cc9a31b518ca830fcc7a2ed74a20415d6e13ec;hpb=5577584b8a50baa958f832ddb9418986e3e38847

diff --git a/src/mount.c b/src/mount.c
index f3043c2b..984666e6 100644
--- a/src/mount.c
+++ b/src/mount.c
@@ -32,6 +32,7 @@
 #include "sha1.h"
 #include "lookup_table.h"
 #include "xml.h"
+#include "io.h"
 #include "timestamp.h"
 #include <stdlib.h>
 #include <unistd.h>
@@ -44,6 +45,14 @@
 #include <ftw.h>
 #include <mqueue.h>
 
+struct wimlib_fd {
+	u16 idx;
+	int staging_fd;
+	u64 hard_link_group;
+	struct lookup_table_entry *lte;
+	struct dentry *dentry;
+};
+
 /* The WIMStruct for the mounted WIM. */
 static WIMStruct *w;
 
@@ -65,6 +74,245 @@ static int mount_flags;
 static const char *mount_dir;
 
 
+static inline int get_lookup_flags()
+{
+	if (mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)
+		return LOOKUP_FLAG_ADS_OK;
+	else
+		return 0;
+}
+
+static inline int flags_writable(int open_flags)
+{
+	return open_flags & (O_RDWR | O_WRONLY);
+}
+
+static int alloc_wimlib_fd(struct lookup_table_entry *lte,
+			   struct wimlib_fd **fd_ret)
+{
+	static const u16 fds_per_alloc = 8;
+	static const u16 max_fds = 0xffff;
+
+	if (lte->num_opened_fds == lte->num_allocated_fds) {
+		struct wimlib_fd **fds;
+		u16 num_new_fds;
+
+		if (lte->num_allocated_fds == max_fds)
+			return -EMFILE;
+		num_new_fds = min(fds_per_alloc, max_fds - lte->num_allocated_fds);
+		
+		fds = CALLOC(lte->num_allocated_fds + num_new_fds,
+			     sizeof(lte->fds[0]));
+		if (!fds)
+			return -ENOMEM;
+		memcpy(fds, lte->fds,
+		       lte->num_allocated_fds * sizeof(lte->fds[0]));
+		FREE(lte->fds);
+		lte->fds = fds;
+		lte->num_allocated_fds += num_new_fds;
+	}
+	for (u16 i = 0; ; i++) {
+		if (!lte->fds[i]) {
+			struct wimlib_fd *fd = CALLOC(1, sizeof(*fd));
+			if (!fd)
+				return -ENOMEM;
+			fd->staging_fd = -1;
+			fd->idx        = i;
+			fd->lte        = lte;
+			lte->fds[i]    = fd;
+			lte->num_opened_fds++;
+			*fd_ret        = fd;
+			return 0;
+		}
+	}
+}
+
+static int close_wimlib_fd(struct wimlib_fd *fd)
+{
+	struct lookup_table_entry *lte = fd->lte;
+
+	wimlib_assert(lte);
+	wimlib_assert(lte->num_opened_fds);
+
+	if (lte->staging_file_name) {
+		wimlib_assert(fd->staging_fd != -1);
+		if (close(fd->staging_fd) != 0)
+			return -errno;
+	}
+	if (--lte->num_opened_fds == 0 && lte->refcnt == 0)
+		free_lookup_table_entry(lte);
+	lte->fds[fd->idx] = NULL;
+	FREE(fd);
+	return 0;
+}
+
+/* Creates a new staging file and returns its file descriptor opened for
+ * writing.
+ *
+ * @name_ret: A location into which the a pointer to the newly allocated name of
+ * 			the staging file is stored.
+ * @return:  The file descriptor for the new file.  Returns -1 and sets errno on
+ * 		error, for any reason possible from the creat() function.
+ */
+static int create_staging_file(char **name_ret, int open_flags)
+{
+	size_t name_len;
+	char *name;
+	struct stat stbuf;
+	int fd;
+	int errno_save;
+
+	name_len = staging_dir_name_len + 1 + WIM_HASH_SIZE;
+ 	name = MALLOC(name_len + 1);
+	if (!name) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	do {
+
+		memcpy(name, staging_dir_name, staging_dir_name_len);
+		name[staging_dir_name_len] = '/';
+		randomize_char_array_with_alnum(name + staging_dir_name_len + 1,
+						WIM_HASH_SIZE);
+		name[name_len] = '\0';
+
+
+	/* Just in case, verify that the randomly generated name doesn't name an
+	 * existing file, and try again if so  */
+	} while (stat(name, &stbuf) == 0);
+
+	if (errno != ENOENT)
+		/* other error! */
+		return -1;
+
+	/* doesn't exist--- ok */
+
+	DEBUG("Creating staging file `%s'", name);
+
+	fd = open(name, open_flags | O_CREAT | O_TRUNC, 0600); 
+	if (fd == -1) {
+		errno_save = errno;
+		FREE(name);
+		errno = errno_save;
+	} else {
+		*name_ret = name;
+	}
+	return fd;
+}
+
+/* 
+ * Extract a WIM resource to the staging directory.
+ *
+ * We need to:
+ * - Create a staging file for the WIM resource
+ * - Extract the resource to it
+ * - Create a new lte for the file resource
+ * - Transfer fds from the old lte to the new lte, but
+ *   only if they share the same hard link group as this
+ *   dentry
+ */
+static int extract_resource_to_staging_dir(struct dentry *dentry,
+					   struct lookup_table_entry **lte,
+					   off_t size)
+{
+	char *staging_file_name;
+	int ret;
+	int fd;
+	struct lookup_table_entry *old_lte, *new_lte;
+	size_t link_group_size;
+	
+	old_lte = *lte;
+	fd = create_staging_file(&staging_file_name, O_WRONLY);
+	if (fd == -1)
+		return -errno;
+
+	if (old_lte)
+		ret = extract_resource_to_fd(w, &old_lte->resource_entry, fd,
+					     size);
+	else
+		ret = 0;
+	if (ret != 0 || close(fd) != 0) {
+		if (errno != 0)
+			ret = -errno;
+		else
+			ret = -EIO;
+		close(fd);
+		unlink(staging_file_name);
+		FREE(staging_file_name);
+		return ret;
+	}
+
+	link_group_size = dentry_link_group_size(dentry);
+
+	if (old_lte) {
+		if (link_group_size == old_lte->refcnt) {
+			/* This hard link group is the only user of the lookup
+			 * table entry, so we can re-use it. */
+			lookup_table_remove(w->lookup_table, old_lte);
+			new_lte = old_lte;
+		} else {
+			/* Split a hard link group away from the "lookup table
+			 * entry" hard link group (i.e. we had two hard link
+			 * groups that were identical, but now we are changing
+			 * one of them) */
+
+			/* XXX The ADS really complicate things here and not
+			 * everything is going to work correctly yet.  For
+			 * example it could be the same that a file contains two
+			 * file streams that are identical and therefore share
+			 * the same lookup table entry despite the fact that the
+			 * streams themselves are not hardlinked. */
+			wimlib_assert(old_lte->refcnt > link_group_size);
+
+			new_lte = new_lookup_table_entry();
+			if (!new_lte)
+				return -ENOMEM;
+
+			u16 num_transferred_fds = 0;
+			for (u16 i = 0; i < old_lte->num_allocated_fds; i++) {
+				if (old_lte->fds[i] &&
+				    old_lte->fds[i]->dentry->hard_link ==
+				      dentry->hard_link)
+				{
+					num_transferred_fds++;
+				}
+			}
+			new_lte->fds = MALLOC(num_transferred_fds *
+					      sizeof(new_lte->fds[0]));
+			if (!new_lte->fds) {
+				free_lookup_table_entry(new_lte);
+				return -ENOMEM;
+			}
+			u16 j = 0;
+			for (u16 i = 0; i < old_lte->num_allocated_fds; i++) {
+				if (old_lte->fds[i] &&
+				    old_lte->fds[i]->dentry->hard_link ==
+				      dentry->hard_link)
+				{
+					struct wimlib_fd *fd = old_lte->fds[i];
+					old_lte->fds[i] = NULL;
+					fd->lte = new_lte;
+					fd->idx = j;
+					new_lte->fds[j] = fd;
+				}
+			}
+			old_lte->refcnt -= link_group_size;
+			old_lte->num_opened_fds -= j;
+			new_lte->num_opened_fds = j;
+
+		} 
+	}
+	new_lte->resource_entry.original_size = size;
+	new_lte->refcnt = link_group_size;
+	randomize_byte_array(new_lte->hash, WIM_HASH_SIZE);
+	new_lte->staging_file_name = staging_file_name;
+
+	lookup_table_insert(w->lookup_table, new_lte);
+	*lte = new_lte;
+	return 0;
+}
+
 /* 
  * Creates a randomly named staging directory and returns its name into the
  * static variable staging_dir_name.
@@ -299,13 +547,15 @@ static int wimfs_access(const char *path, int mask)
 
 /* Closes the staging file descriptor associated with the lookup table entry, if
  * it is opened. */
-static int close_staging_file(struct lookup_table_entry *lte, void *ignore)
+static int close_lte_fds(struct lookup_table_entry *lte, void *ignore)
 {
-	if (lte->staging_file_name && lte->staging_num_times_opened) {
-		if (close(lte->staging_fd) != 0) {
-			ERROR_WITH_ERRNO("Failed close file `%s'",
-					 lte->staging_file_name);
-			return WIMLIB_ERR_WRITE;
+	for (u16 i = 0; i < lte->num_opened_fds; i++) {
+		if (lte->fds[i] && lte->fds[i]->staging_fd != -1) {
+			if (close(lte->fds[i]->staging_fd) != 0) {
+				ERROR_WITH_ERRNO("Failed close file `%s'",
+						 lte->staging_file_name);
+				return WIMLIB_ERR_WRITE;
+			}
 		}
 	}
 	return 0;
@@ -316,35 +566,40 @@ static int close_staging_file(struct lookup_table_entry *lte, void *ignore)
  * file.  Updates the SHA1 sum in the dentry and the lookup table entry.  If
  * there is already a lookup table entry with the same checksum, increment its
  * reference count and destroy the lookup entry with the updated checksum. */
-static int calculate_sha1sum_for_staging_file(struct dentry *dentry, void *lookup_table)
+static int calculate_sha1sum_for_staging_file(struct dentry *dentry,
+					      void *_lookup_table)
 {
-	struct lookup_table *table;
-	struct lookup_table_entry *lte; 
-	struct lookup_table_entry *existing;
-	int ret;
-
-	table = lookup_table;
-	lte = lookup_resource(table, dentry->hash);
-	
-	if (lte && lte->staging_file_name) {
-
-		DEBUG("Calculating SHA1 hash for file `%s'",
-		      dentry->file_name_utf8);
-		ret = sha1sum(lte->staging_file_name, dentry->hash);
-		if (ret != 0)
-			return ret;
-
-		lookup_table_unlink(table, lte);
-		memcpy(lte->hash, dentry->hash, WIM_HASH_SIZE);
-		existing = lookup_resource(table, dentry->hash);
-		if (existing) {
-			DEBUG("Merging duplicate lookup table entries for file "
-			      "`%s'", dentry->file_name_utf8);
-			free_lookup_table_entry(lte);
-			existing->refcnt++;
-		} else {
-			lookup_table_insert(table, lte);
+	struct lookup_table *lookup_table =  _lookup_table;
+	u8 *hash = dentry->hash;
+	u16 i = 0;
+	while (1) {
+		struct lookup_table_entry *lte = __lookup_resource(lookup_table, hash);
+		if (lte && lte->staging_file_name) {
+			struct lookup_table_entry *existing;
+			int ret;
+
+			DEBUG("Calculating SHA1 hash for file `%s'",
+			      dentry->file_name_utf8);
+			ret = sha1sum(lte->staging_file_name, lte->hash);
+			if (ret != 0)
+				return ret;
+
+			lookup_table_unlink(lookup_table, lte);
+			memcpy(hash, lte->hash, WIM_HASH_SIZE);
+			existing = __lookup_resource(lookup_table, hash);
+			if (existing) {
+				DEBUG("Merging duplicate lookup table entries for file "
+				      "`%s'", dentry->file_name_utf8);
+				free_lookup_table_entry(lte);
+				existing->refcnt++;
+			} else {
+				lookup_table_insert(lookup_table, lte);
+			}
 		}
+		if (i == dentry->num_ads)
+			break;
+		hash = dentry->ads_entries[i].hash;
+		i++;
 	}
 	return 0;
 }
@@ -359,7 +614,7 @@ static int rebuild_wim(WIMStruct *w, bool check_integrity)
 
 	DEBUG("Closing all staging file descriptors.");
 	/* Close all the staging file descriptors. */
-	ret = for_lookup_table_entry(w->lookup_table, close_staging_file, NULL);
+	ret = for_lookup_table_entry(w->lookup_table, close_lte_fds, NULL);
 	if (ret != 0) {
 		ERROR("Failed to close all staging files");
 		return ret;
@@ -461,6 +716,17 @@ done:
 	close_message_queues();
 }
 
+static int wimfs_ftruncate(const char *path, off_t size,
+			   struct fuse_file_info *fi)
+{
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
+	int ret = ftruncate(fd->staging_fd, size);
+	if (ret != 0)
+		return ret;
+	fd->lte->resource_entry.original_size = size;
+	return 0;
+}
+
 /*
  * Fills in a `struct stat' that corresponds to a file or directory in the WIM.
  */
@@ -495,174 +761,109 @@ static int wimfs_mkdir(const char *path, mode_t mode)
 		return -EEXIST;
 
 	newdir = new_dentry(basename);
-	newdir->attributes |= WIM_FILE_ATTRIBUTE_DIRECTORY;
+	newdir->attributes |= FILE_ATTRIBUTE_DIRECTORY;
 	link_dentry(newdir, parent);
 	return 0;
 }
 
-/* Creates a new staging file and returns its file descriptor opened for
- * writing.
- *
- * @name_ret: A location into which the a pointer to the newly allocated name of
- * 			the staging file is stored.
- * @return:  The file descriptor for the new file.  Returns -1 and sets errno on
- * 		error, for any reason possible from the creat() function.
- */
-static int create_staging_file(char **name_ret)
-{
-	size_t name_len;
-	char *name;
-	struct stat stbuf;
-	int fd;
-	int errno_save;
-
-	name_len = staging_dir_name_len + 1 + WIM_HASH_SIZE;
- 	name = MALLOC(name_len + 1);
-	if (!name) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	memcpy(name, staging_dir_name, staging_dir_name_len);
-	name[staging_dir_name_len] = '/';
-	randomize_char_array_with_alnum(name + staging_dir_name_len + 1,
-					WIM_HASH_SIZE);
-	name[name_len] = '\0';
-
 
-	/* Just in case, verify that the randomly generated name doesn't name an
-	 * existing file, and try again if so  */
-	if (stat(name, &stbuf) == 0) {
-		/* stat succeeded-- the file must exist. Try another name. */
-		FREE(name);
-		return create_staging_file(name_ret);
-	} else {
-		if (errno != ENOENT)
-			/* other error! */
-			return -1;
-		/* doesn't exist--- ok */
-	}
-
-	DEBUG("Creating staging file '%s'", name);
-
-	fd = creat(name, 0600); 
-	if (fd == -1) {
-		errno_save = errno;
-		FREE(name);
-		errno = errno_save;
-	} else {
-		*name_ret = name;
-	}
-	return fd;
-}
-
-/* Creates a regular file.  This is done in the staging directory.  */
+/* Creates a regular file. */
 static int wimfs_mknod(const char *path, mode_t mode, dev_t rdev)
 {
-	struct dentry *parent, *dentry;
-	const char *basename;
-	struct lookup_table_entry *lte;
-	char *tmpfile_name;
-	int fd;
-	int err;
-
-	/* Make sure that the parent of @path exists and is a directory, and
-	 * that the dentry named by @path does not already exist.  */
-	parent = get_parent_dentry(w, path);
-	if (!parent)
-		return -ENOENT;
-	if (!dentry_is_directory(parent))
-		return -ENOTDIR;
-	basename = path_basename(path);
-	if (get_dentry_child_with_name(parent, path))
-		return -EEXIST;
-
-	dentry = new_dentry(basename);
-
-	/* XXX fill in a temporary random hash value- really should check for
-	 * duplicates */
-	randomize_byte_array(dentry->hash, WIM_HASH_SIZE);
-
-	/* Create a lookup table entry having the same hash value */
-	lte = new_lookup_table_entry();
-	lte->staging_num_times_opened = 0;
-	lte->resource_entry.original_size = 0;
-	memcpy(lte->hash, dentry->hash, WIM_HASH_SIZE);
-
-	fd = create_staging_file(&tmpfile_name);
-
-	if (fd == -1)
-		goto mknod_error;
-
-	if (close(fd) != 0)
-		goto mknod_error;
-
-	lte->staging_file_name = tmpfile_name;
+	const char *stream_name;
+	if ((mount_flags & WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)
+	     && (stream_name = path_stream_name(path))) {
+		struct ads_entry *new_entry;
+		struct dentry *dentry;
+
+		dentry = get_dentry(w, path);
+		if (!dentry || !dentry_is_regular_file(dentry))
+			return -ENOENT;
+		if (dentry_get_ads_entry(dentry, stream_name))
+			return -EEXIST;
+		new_entry = dentry_add_ads(dentry, stream_name);
+		if (!new_entry)
+			return -ENOENT;
+	} else {
+		struct dentry *dentry, *parent;
+		const char *basename;
 
-	/* Insert the lookup table entry, and link the new dentry with its
-	 * parent. */
-	lookup_table_insert(w->lookup_table, lte);
-	link_dentry(dentry, parent);
+		/* Make sure that the parent of @path exists and is a directory, and
+		 * that the dentry named by @path does not already exist.  */
+		parent = get_parent_dentry(w, path);
+		if (!parent)
+			return -ENOENT;
+		if (!dentry_is_directory(parent))
+			return -ENOTDIR;
+		basename = path_basename(path);
+		if (get_dentry_child_with_name(parent, path))
+			return -EEXIST;
+
+		dentry = new_dentry(basename);
+		link_dentry(dentry, parent);
+	}
 	return 0;
-mknod_error:
-	err = errno;
-	free_lookup_table_entry(lte);
-	return -err;
 }
 
+
 /* Open a file.  */
 static int wimfs_open(const char *path, struct fuse_file_info *fi)
 {
 	struct dentry *dentry;
 	struct lookup_table_entry *lte;
-	
-	dentry = get_dentry(w, path);
+	u8 *dentry_hash;
+	int ret;
+	struct wimlib_fd *fd;
 
-	if (!dentry)
-		return -EEXIST;
-	if (dentry_is_directory(dentry))
-		return -EISDIR;
-	lte = wim_lookup_resource(w, dentry);
-
-	if (lte) {
-		/* If this file is in the staging directory and the file is not
-		 * currently open, open it. */
-		if (lte->staging_file_name && lte->staging_num_times_opened == 0) {
-			lte->staging_fd = open(lte->staging_file_name, O_RDWR);
-			if (lte->staging_fd == -1)
-				return -errno;
-			lte->staging_offset = 0;
-		}
-	} else {
-		/* no lookup table entry, so the file must be empty.  Create a
-		 * lookup table entry for the file, unless it's a read-only
-		 * filesystem.  */
-		char *tmpfile_name;
-		int fd;
+	ret = lookup_resource(w, path, get_lookup_flags(), &dentry, &lte,
+			      &dentry_hash);
+	if (ret != 0)
+		return ret;
 
-		if (!staging_dir_name) /* Read-only filesystem */
+	if (!lte) {
+		/* Empty file with no lookup-table entry.  This is fine if it's
+		 * a read-only filesystem.  Otherwise we need to create a lookup
+		 * table entry so that we can keep track of the file descriptors
+		 * (this is important in case someone opens the file for
+		 * writing) */
+		if (!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)) {
+			fi->fh = 0;
 			return 0;
+		}
 
-		lte = new_lookup_table_entry();
-		if (!lte)
-			return -ENOMEM;
+		ret = extract_resource_to_staging_dir(dentry, &lte,
+						      lte->resource_entry.original_size);
+		if (ret != 0)
+			return ret;
+	}
 
-		fd = create_staging_file(&tmpfile_name);
+	ret = alloc_wimlib_fd(lte, &fd);
+	if (ret != 0)
+		return ret;
 
-		if (fd == -1) {
-			int err = errno;
-			free(lte);
-			return -err;
+	fd->dentry = dentry;
+
+	/* The file resource may be in the staging directory (read-write
+	 * mounts only) or in the WIM.  If it's in the staging
+	 * directory, we need to open a native file descriptor for the
+	 * corresponding file.  Otherwise, we can read the file resource
+	 * directly from the WIM file if we are opening it read-only,
+	 * but we need to extract the resource to the staging directory
+	 * if we are opening it writable. */
+	if (flags_writable(fi->flags) && !lte->staging_file_name) {
+		ret = extract_resource_to_staging_dir(dentry, &lte,
+						      lte->resource_entry.original_size);
+		if (ret != 0)
+			return ret;
+	}
+	if (lte->staging_file_name) {
+		fd->staging_fd = open(lte->staging_file_name, fi->flags);
+		if (fd->staging_fd == -1) {
+			close_wimlib_fd(fd);
+			return -errno;
 		}
-		lte->resource_entry.original_size = 0;
-		randomize_byte_array(lte->hash, WIM_HASH_SIZE);
-		memcpy(dentry->hash, lte->hash, WIM_HASH_SIZE);
-		lte->staging_file_name = tmpfile_name;
-		lte->staging_fd = fd;
-		lte->staging_offset = 0;
-		lookup_table_insert(w->lookup_table, lte);
 	}
-	lte->staging_num_times_opened++;
+	fi->fh = (uint64_t)fd;
 	return 0;
 }
 
@@ -674,6 +875,7 @@ static int wimfs_opendir(const char *path, struct fuse_file_info *fi)
 	dentry = get_dentry(w, path);
 	if (!dentry || !dentry_is_directory(dentry))
 		return -ENOTDIR;
+	fi->fh = (uint64_t)dentry;
 	return 0;
 }
 
@@ -682,46 +884,29 @@ static int wimfs_opendir(const char *path, struct fuse_file_info *fi)
  * Read data from a file in the WIM or in the staging directory. 
  */
 static int wimfs_read(const char *path, char *buf, size_t size, 
-		off_t offset, struct fuse_file_info *fi)
+		      off_t offset, struct fuse_file_info *fi)
 {
-	struct dentry *dentry;
-	struct lookup_table_entry *lte;
-	
-	dentry = get_dentry(w, path);
-
-	if (!dentry)
-		return -EEXIST;
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
 
-	if (!dentry_is_regular_file(dentry))
-		return -EISDIR;
-
-	lte = wim_lookup_resource(w, dentry);
-
-	if (!lte)
+	if (!fd) {
+		/* Empty file with no lookup table entry on read-only mounted
+		 * WIM */
+		wimlib_assert(!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE));
 		return 0;
+	}
 
-	if (lte->staging_file_name) {
-
-		/* Read from staging */
-		int fd;
-		off_t cur_offset;
-		ssize_t ret;
+	if (fd->lte->staging_file_name) {
+		/* Read from staging file */
 
-		if (lte->staging_num_times_opened == 0)
-			return -EBADF;
+		wimlib_assert(fd->staging_fd != -1);
 
-		fd = lte->staging_fd;
-		cur_offset = lte->staging_offset;
-		if (cur_offset != offset)
-			if (lseek(fd, offset, SEEK_SET) == -1)
-				return -errno;
-		lte->staging_offset = offset;
+		ssize_t ret;
 
-		ret = read(fd, buf, size);
+		if (lseek(fd->staging_fd, offset, SEEK_SET) == -1)
+			return -errno;
+		ret = read(fd->staging_fd, buf, size);
 		if (ret == -1)
 			return -errno;
-		lte->staging_offset = offset + ret;
-
 		return ret;
 	} else {
 
@@ -730,7 +915,7 @@ static int wimfs_read(const char *path, char *buf, size_t size,
 		struct resource_entry *res_entry;
 		int ctype;
 		
-		res_entry = &lte->resource_entry;
+		res_entry = &fd->lte->resource_entry;
 
 		ctype = wim_resource_compression_type(w, res_entry);
 
@@ -753,59 +938,54 @@ static int wimfs_read(const char *path, char *buf, size_t size,
 static int wimfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler, 
 				off_t offset, struct fuse_file_info *fi)
 {
-	struct dentry *parent;
-	struct dentry *child;
-	struct stat st;
-
-	parent = get_dentry(w, path);
-
-	if (!parent)
-		return -EEXIST;
-
-	if (!dentry_is_directory(parent))
-		return -ENOTDIR;
+	struct dentry *parent, *child;
+	
+	parent = (struct dentry*)fi->fh;
+	child = parent->children;
 
 	filler(buf, ".", NULL, 0);
 	filler(buf, "..", NULL, 0);
 
-	child = parent->children;
-
 	if (!child)
 		return 0;
 
 	do {
-		memset(&st, 0, sizeof(st));
-		if (filler(buf, child->file_name_utf8, &st, 0))
+		if (filler(buf, child->file_name_utf8, NULL, 0))
 			return 0;
 		child = child->next;
 	} while (child != parent->children);
 	return 0;
 }
 
+
+static int wimfs_readlink(const char *path, char *buf, size_t buf_len)
+{
+	struct dentry *dentry = get_dentry(w, path);
+	int ret;
+	if (!dentry)
+		return -ENOENT;
+	if (!dentry_is_symlink(dentry))
+		return -EINVAL;
+
+	ret = dentry_readlink(dentry, buf, buf_len, w);
+	if (ret > 0)
+		ret = 0;
+	return ret;
+}
+
 /* Close a file. */
 static int wimfs_release(const char *path, struct fuse_file_info *fi)
 {
-	struct dentry *dentry;
-	struct lookup_table_entry *lte;
 	int ret;
-	
-	dentry = get_dentry(w, path);
-	if (!dentry)
-		return -EEXIST;
-	lte = wim_lookup_resource(w, dentry);
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
 
-	if (!lte)
+	if (!fd) {
+		/* Empty file with no lookup table entry on read-only mounted
+		 * WIM */
+		wimlib_assert(!(mount_flags & WIMLIB_MOUNT_FLAG_READWRITE));
 		return 0;
-	
-	if (lte->staging_num_times_opened == 0)
-		return -EBADF;
-
-	if (--lte->staging_num_times_opened == 0 && lte->staging_file_name) {
-		ret = close(lte->staging_fd);
-		if (ret != 0)
-			return -errno;
 	}
-	return 0;
+	return close_wimlib_fd(fd);
 }
 
 /* Renames a file or directory.  See rename (3) */
@@ -858,79 +1038,16 @@ static int wimfs_rmdir(const char *path)
 	
 	dentry = get_dentry(w, path);
 	if (!dentry)
-		return -EEXIST;
+		return -ENOENT;
 
 	if (!dentry_is_empty_directory(dentry))
-		return -EEXIST;
+		return -ENOTEMPTY;
 
 	unlink_dentry(dentry);
 	free_dentry(dentry);
 	return 0;
 }
 
-/* Extracts the resource corresponding to @dentry and its lookup table entry
- * @lte to a file in the staging directory.  The lookup table entry for @dentry
- * is updated to point to the new file.  If @lte has multiple dentries
- * referencing it, a new lookup table entry is created and the hash of @dentry
- * is changed to point to the new lookup table entry.
- *
- * Only @size bytes are extracted, to support truncating the file. 
- *
- * Returns the negative error code on failure.
- */
-static int extract_resource_to_staging_dir(struct dentry *dentry, 
-					   struct lookup_table_entry *lte, 
-					   u64 size)
-{
-	int fd;
-	bool ret;
-	char *staging_file_name;
-	struct lookup_table_entry *new_lte;
-
-	/* File in WIM.  Copy it to the staging directory. */
-	fd = create_staging_file(&staging_file_name);
-	if (fd == -1)
-		return -errno;
-
-	ret = extract_resource_to_fd(w, &lte->resource_entry, fd, size);
-	if (ret != 0) {
-		if (errno != 0)
-			ret = -errno;
-		else
-			ret = -EIO;
-		unlink(staging_file_name);
-		FREE(staging_file_name);
-		return ret;
-	}
-
-	if (lte->refcnt != 1) {
-		/* Need to make a new lookup table entry if we are
-		 * changing only one copy of a hardlinked entry */
-		lte->refcnt--;
-
-		new_lte = new_lookup_table_entry();
-		if (!new_lte)
-			return -ENOMEM;
-		randomize_byte_array(dentry->hash, WIM_HASH_SIZE);
-		memcpy(new_lte->hash, dentry->hash, WIM_HASH_SIZE);
-
-		new_lte->resource_entry.flags = 0;
-		new_lte->staging_num_times_opened = lte->staging_num_times_opened;
-
-		lookup_table_insert(w->lookup_table, new_lte);
-
-		lte = new_lte;
-	} 
-
-	lte->resource_entry.original_size = size;
-	lte->staging_file_name = staging_file_name;
-	
-	if (lte->staging_num_times_opened == 0)
-		close(fd);
-	else
-		lte->staging_fd = fd;
-	return 0;
-}
 
 /* Reduce the size of a file */
 static int wimfs_truncate(const char *path, off_t size)
@@ -938,30 +1055,29 @@ static int wimfs_truncate(const char *path, off_t size)
 	struct dentry *dentry;
 	struct lookup_table_entry *lte;
 	int ret;
+	u8 *dentry_hash;
+	
+	ret = lookup_resource(w, path, get_lookup_flags(), &dentry,
+			      &lte, &dentry_hash);
 
-	dentry = get_dentry(w, path);
-	if (!dentry)
-		return -EEXIST;
-	lte = wim_lookup_resource(w, dentry);
+	if (ret != 0)
+		return ret;
 
 	if (!lte) /* Already a zero-length file */
 		return 0;
+
 	if (lte->staging_file_name) {
-		/* File on disk.  Call POSIX API */
-		if (lte->staging_num_times_opened != 0)
-			ret = ftruncate(lte->staging_fd, size);
-		else
-			ret = truncate(lte->staging_file_name, size);
+		ret = truncate(lte->staging_file_name, size);
 		if (ret != 0)
 			return -errno;
-		dentry_update_all_timestamps(dentry);
 		lte->resource_entry.original_size = size;
-		return 0;
 	} else {
 		/* File in WIM.  Extract it to the staging directory, but only
 		 * the first @size bytes of it. */
-		return extract_resource_to_staging_dir(dentry, lte, size);
+		ret = extract_resource_to_staging_dir(dentry, &lte, size);
 	}
+	dentry_update_all_timestamps(dentry);
+	return ret;
 }
 
 /* Remove a regular file */
@@ -969,27 +1085,52 @@ static int wimfs_unlink(const char *path)
 {
 	struct dentry *dentry;
 	struct lookup_table_entry *lte;
+	int ret;
+	u8 *dentry_hash;
 	
-	dentry = get_dentry(w, path);
-	if (!dentry)
-		return -EEXIST;
+	ret = lookup_resource(w, path, get_lookup_flags(), &dentry,
+			      &lte, &dentry_hash);
 
-	if (!dentry_is_regular_file(dentry))
-		return -EEXIST;
+	if (ret != 0)
+		return ret;
 
-	lte = wim_lookup_resource(w, dentry);
-	if (lte) {
-		if (lte->staging_file_name)
-			if (unlink(lte->staging_file_name) != 0)
-				return -errno;
-		lookup_table_decrement_refcnt(w->lookup_table, dentry->hash);
-	}
+	if (lte && lte->staging_file_name)
+		if (unlink(lte->staging_file_name) != 0)
+			return -errno;
 
-	unlink_dentry(dentry);
-	free_dentry(dentry);
+	if (dentry_hash == dentry->hash) {
+		/* We are removing the full dentry including all alternate data
+		 * streams. */
+		const u8 *hash = dentry->hash;
+		u16 i = 0;
+		while (1) {
+			lookup_table_decrement_refcnt(w->lookup_table, hash);
+			if (i == dentry->num_ads)
+				break;
+			hash = dentry->ads_entries[i].hash;
+			i++;
+		}
+
+		unlink_dentry(dentry);
+		free_dentry(dentry);
+	} else {
+		/* We are removing an alternate data stream. */
+		struct ads_entry *cur_entry = dentry->ads_entries;
+		while (cur_entry->hash != dentry_hash)
+			cur_entry++;
+		lookup_table_decrement_refcnt(w->lookup_table, cur_entry->hash);
+		
+		dentry_remove_ads(dentry, cur_entry);
+	}
+	/* Beware: The lookup table entry(s) may still be referenced by users
+	 * that have opened the corresponding streams.  They are freed later in
+	 * wimfs_release() when the last file user has closed the stream. */
 	return 0;
 }
 
+/* Change the timestamp on a file dentry. 
+ *
+ * There is no distinction between a file and its alternate data streams here.  */
 static int wimfs_utimens(const char *path, const struct timespec tv[2])
 {
 	struct dentry *dentry = get_dentry(w, path);
@@ -1004,81 +1145,51 @@ static int wimfs_utimens(const char *path, const struct timespec tv[2])
 	return 0;
 }
 
-/* Writes to a file in the WIM filesystem. */
+/* Writes to a file in the WIM filesystem. 
+ * It may be an alternate data stream, but here we don't even notice because we
+ * just get a lookup table entry. */
 static int wimfs_write(const char *path, const char *buf, size_t size, 
-				off_t offset, struct fuse_file_info *fi)
+		       off_t offset, struct fuse_file_info *fi)
 {
-	struct dentry *dentry;
-	struct lookup_table_entry *lte;
-	ssize_t ret;
-
-	dentry = get_dentry(w, path);
-	if (!dentry)
-		return -EEXIST;
-	lte = wim_lookup_resource(w, dentry);
-
-	if (!lte) /* this should not happen */
-		return -EEXIST;
-
-	if (lte->staging_num_times_opened == 0)
-		return -EBADF;
-	if (lte->staging_file_name) {
-
-		/* File in staging directory. We can write to it directly. */
-
-		/* Seek to correct position in file if needed. */
-		if (lte->staging_offset != offset) {
-			if (lseek(lte->staging_fd, offset, SEEK_SET) == -1)
-				return -errno;
-			lte->staging_offset = offset;
-		}
+	struct wimlib_fd *fd = (struct wimlib_fd*)fi->fh;
+	int ret;
 
-		/* Write the data. */
-		ret = write(lte->staging_fd, buf, size);
-		if (ret == -1)
-			return -errno;
+	wimlib_assert(fd->lte);
+	wimlib_assert(fd->lte->staging_file_name);
+	wimlib_assert(fd->staging_fd != -1);
 
-		/* Adjust the stored offset of staging_fd. */
-		lte->staging_offset = offset + ret;
+	/* Write the data. */
+	ret = write(fd->staging_fd, buf, size);
+	if (ret == -1)
+		return -errno;
 
-		/* Increase file size if needed. */
-		if (lte->resource_entry.original_size < lte->staging_offset)
-			lte->resource_entry.original_size = lte->staging_offset;
+	/* The file has been modified, so all its timestamps must be
+	 * updated. */
+	dentry_update_all_timestamps(fd->dentry);
 
-		/* The file has been modified, so all its timestamps must be
-		 * updated. */
-		dentry_update_all_timestamps(dentry);
-		return ret;
-	} else {
-		/* File in the WIM.  We must extract it to the staging directory
-		 * before it can be written to. */
-		ret = extract_resource_to_staging_dir(dentry, lte, 
-					lte->resource_entry.original_size);
-		if (ret != 0)
-			return ret;
-		else
-			return wimfs_write(path, buf, size, offset, fi);
-	}
+	return ret;
 }
 
 
 static struct fuse_operations wimfs_oper = {
-	.access   = wimfs_access,
-	.destroy  = wimfs_destroy,
-	.getattr  = wimfs_getattr,
-	.mkdir    = wimfs_mkdir,
-	.mknod    = wimfs_mknod,
-	.open     = wimfs_open,
-	.opendir  = wimfs_opendir,
-	.read     = wimfs_read,
-	.readdir  = wimfs_readdir,
-	.release  = wimfs_release,
-	.rename   = wimfs_rename,
-	.rmdir    = wimfs_rmdir,
-	.truncate = wimfs_truncate,
-	.unlink   = wimfs_unlink,
-	.utimens  = wimfs_utimens,
-	.write    = wimfs_write,
+	.access    = wimfs_access,
+	.destroy   = wimfs_destroy,
+	.ftruncate = wimfs_ftruncate,
+	.getattr   = wimfs_getattr,
+	.mkdir     = wimfs_mkdir,
+	.mknod     = wimfs_mknod,
+	.open      = wimfs_open,
+	.opendir   = wimfs_opendir,
+	.read      = wimfs_read,
+	.readdir   = wimfs_readdir,
+	.readlink  = wimfs_readlink,
+	.release   = wimfs_release,
+	.rename    = wimfs_rename,
+	.rmdir     = wimfs_rmdir,
+	.truncate  = wimfs_truncate,
+	.unlink    = wimfs_unlink,
+	.utimens   = wimfs_utimens,
+	.write     = wimfs_write,
 };
 
 
@@ -1105,6 +1216,11 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 	if (flags & WIMLIB_MOUNT_FLAG_READWRITE)
 		wim_get_current_image_metadata(wim)->modified = true;
 
+	if (!(flags & (WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE |
+		       WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR |
+		       WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS)))
+		flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR;
+
 	mount_dir = dir;
 	working_directory = getcwd(NULL, 0);
 	if (!working_directory) {