[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[Libguestfs] [PATCH 2/2] FUSE filesystem support.



If you wish to try it, pick a guest or image and do (as root) the
following command.  You'll have to adjust the drives and mount
point(s) suitably, just like with guestfish.

# ./fuse/guestmount -a guest.img -m /dev/sda1 --ro --trace -- -f /mnt/tmp

Those parameters will produce lots of debugging information and the
guestmount command will stay in the foreground so you can see what's
going on.

Then, also as root, look around the /mnt/tmp directory.

read(2) and write(2) aren't implemented (will return EINVAL) so you
can't actually read any of the files.

>From my limited observations it seems like nothing much is cached.  If
we added a big "get absolutely everything about this directory" call
to the guestfs(3) API and invoked that the first time that FUSE does
an lstat(2) (or readdir(2)) call on a directory, that would massively
speed up directory listings.  There are likely to be lots of
opportunities like that.

It's not segfaulted on me yet, but I'm guessing there's a first time
for everything ...

Rich.

-- 
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones
virt-top is 'top' for virtual machines.  Tiny program with many
powerful monitoring features, net stats, disk stats, logging, etc.
http://et.redhat.com/~rjones/virt-top
>From d6eb58b353789e018ad24107ceb3172316087a25 Mon Sep 17 00:00:00 2001
From: Richard Jones <rjones redhat com>
Date: Fri, 30 Oct 2009 16:13:13 +0000
Subject: [PATCH 2/2] FUSE filesystem support.

This implements FUSE filesystem support so that any libguestfs-
accessible disk image can be mounted as a local filesystem.

The API needs more test coverage, particularly lesser-used system
calls.

The big unresolved issue is UID/GID mapping between guest filesystem
IDs and the host.  It's not easy to automate this because you need
extra details about the guest itself in order to get to its
UID->username map (eg. /etc/passwd from the guest).
---
 .gitignore        |    1 +
 HACKING           |    3 +
 Makefile.am       |    4 +
 README            |    2 +
 TODO              |   35 +--
 configure.ac      |    9 +
 fuse/Makefile.am  |   38 +++
 fuse/fusexmp.c    |  385 ++++++++++++++++++++++++
 fuse/fusexmp_fh.c |  495 +++++++++++++++++++++++++++++++
 fuse/guestmount.c |  844 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 po/POTFILES.in    |    3 +
 11 files changed, 1793 insertions(+), 26 deletions(-)
 create mode 100644 fuse/Makefile.am
 create mode 100644 fuse/fusexmp.c
 create mode 100644 fuse/fusexmp_fh.c
 create mode 100644 fuse/guestmount.c

diff --git a/.gitignore b/.gitignore
index ffa9764..f4b772b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,6 +54,7 @@ fish/completion.c
 fish/guestfish
 fish/rc_protocol.c
 fish/rc_protocol.h
+fuse/guestmount
 guestfish.1
 guestfish-actions.pod
 guestfs.3
diff --git a/HACKING b/HACKING
index cc5b1c2..5752ec3 100644
--- a/HACKING
+++ b/HACKING
@@ -83,6 +83,9 @@ examples/
 fish/
         Guestfish (the command-line program / shell)
 
+fuse/
+	FUSE (userspace filesystem) built on top of libguestfs.
+
 haskell/
         Haskell bindings.
 
diff --git a/Makefile.am b/Makefile.am
index 0b905ca..05f6dd0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -34,6 +34,10 @@ if HAVE_TOOLS
 SUBDIRS += tools
 endif
 
+if HAVE_FUSE
+SUBDIRS += fuse
+endif
+
 if HAVE_OCAML
 SUBDIRS += ocaml ocaml/examples
 endif
diff --git a/README b/README
index 41902ea..0877775 100644
--- a/README
+++ b/README
@@ -52,6 +52,8 @@ Requirements
 
 - libxml2
 
+- (Optional) FUSE to build the FUSE module
+
 - (Optional) Augeas (http://augeas.net/)
 
 - perldoc (pod2man, pod2text) to generate the manual pages and
diff --git a/TODO b/TODO
index fc14cdc..9c09557 100644
--- a/TODO
+++ b/TODO
@@ -12,33 +12,16 @@ Python bindings
 Ideas for the Python bindings:
 https://www.redhat.com/archives/fedora-virt/2009-April/msg00114.html
 
-FTP server or FUSE?
--------------------
+FUSE API
+--------
+
+The API needs more test coverage, particularly lesser-used system
+calls.
 
-Originally we had intended to implement an NFS server inside the
-appliance, which would allow the guest filesystems to be mounted on
-the host, and large changes to be made.  We eventually rejected the
-idea of using NFS, partly because it requires root to mount
-filesystems in the host, and partly because of problems handling UID
-mappings between host and guest filesystem.
-
-Then we look at implementing an FTP server instead.  FTP clients are
-widely available for many languages, don't require root, and don't
-have any UID mapping problems.  However there is the problem of
-getting the TCP connection into the guest, and that FTP requires a
-secondary data connection either in or out of the guest (the NFS
-situation is even more dire).
-
-Thirdly we looked at implementing a FUSE-based filesystem.  This is
-plausible - it could be implemented just by adding the additional FUSE
-operations to the standard guestfs(3) API, and then implementing a
-simple FUSE daemon.  (The FUSE website has some very helpful
-documentation and examples).  I [RWMJ] am not particularly convinced
-that a FUSE-based filesystem would really be useful to anyone, but am
-prepared to accept patches if someone does all the work.
-
-See also the mountlo project:
-http://sourceforge.net/project/showfiles.php?group_id=121684&package_id=150116
+The big unresolved issue is UID/GID mapping between guest filesystem
+IDs and the host.  It's not easy to automate this because you need
+extra details about the guest itself in order to get to its
+UID->username map (eg. /etc/passwd from the guest).
 
 BufferIn
 --------
diff --git a/configure.ac b/configure.ac
index b31c193..b500b5b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -421,6 +421,13 @@ PKG_CHECK_MODULES([LIBXML2], [libxml-2.0])
 AC_SUBST([LIBXML2_CFLAGS])
 AC_SUBST([LIBXML2_LIBS])
 
+dnl FUSE is optional to build the FUSE module.
+HAVE_FUSE=yes
+PKG_CHECK_MODULES([FUSE],[fuse],,[
+	HAVE_FUSE=no
+	AC_MSG_WARN([FUSE library and headers are missing, so optional FUSE module won't be built])])
+AM_CONDITIONAL([HAVE_FUSE],[test "x$HAVE_FUSE" = "xyes"])
+
 dnl Check for OCaml (optional, for OCaml bindings).
 AC_PROG_OCAML
 AC_PROG_FINDLIB
@@ -729,6 +736,7 @@ AC_CONFIG_FILES([Makefile
                  gnulib/lib/Makefile
                  gnulib/tests/Makefile
 		 hivex/Makefile
+		 fuse/Makefile
                  ocaml/META perl/Makefile.PL])
 AC_OUTPUT
 
@@ -758,6 +766,7 @@ if test "x$HAVE_INSPECTOR" = "x"; then echo "yes"; else echo "no"; fi
 echo -n "virt-* tools ........................ "
 if test "x$HAVE_TOOLS" = "x"; then echo "yes"; else echo "no"; fi
 echo "supermin appliance .................. $enable_supermin"
+echo "FUSE filesystem ..................... $HAVE_FUSE"
 echo
 echo "If any optional component is configured 'no' when you expected 'yes'"
 echo "then you should check the preceeding messages."
diff --git a/fuse/Makefile.am b/fuse/Makefile.am
new file mode 100644
index 0000000..2bf66c9
--- /dev/null
+++ b/fuse/Makefile.am
@@ -0,0 +1,38 @@
+# libguestfs
+# Copyright (C) 2009 Red Hat Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+EXTRA_DIST = fusexmp.c fusexmp_fh.c
+
+if HAVE_FUSE
+
+bin_PROGRAMS = guestmount
+
+guestmount_SOURCES = guestmount.c
+
+guestmount_CFLAGS = \
+	-I$(top_srcdir)/src -I$(top_builddir)/src \
+	-I$(srcdir)/../gnulib/lib -I../gnulib/lib \
+	-DGUESTFS_DEFAULT_PATH='"$(libdir)/guestfs"' \
+	$(FUSE_CFLAGS) \
+	$(WARN_CFLAGS) $(WERROR_CFLAGS)
+
+guestmount_LDADD = \
+	$(FUSE_LIBS) -lulockmgr \
+	$(top_builddir)/src/libguestfs.la \
+	../gnulib/lib/libgnu.la
+
+endif
diff --git a/fuse/fusexmp.c b/fuse/fusexmp.c
new file mode 100644
index 0000000..083bbea
--- /dev/null
+++ b/fuse/fusexmp.c
@@ -0,0 +1,385 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos szeredi hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall `pkg-config fuse --cflags --libs` fusexmp.c -o fusexmp
+*/
+
+#define FUSE_USE_VERSION 26
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef linux
+/* For pread()/pwrite() */
+#define _XOPEN_SOURCE 500
+#endif
+
+#include <fuse.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/time.h>
+#ifdef HAVE_SETXATTR
+#include <sys/xattr.h>
+#endif
+
+static int xmp_getattr(const char *path, struct stat *stbuf)
+{
+	int res;
+
+	res = lstat(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_access(const char *path, int mask)
+{
+	int res;
+
+	res = access(path, mask);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_readlink(const char *path, char *buf, size_t size)
+{
+	int res;
+
+	res = readlink(path, buf, size - 1);
+	if (res == -1)
+		return -errno;
+
+	buf[res] = '\0';
+	return 0;
+}
+
+
+static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+		       off_t offset, struct fuse_file_info *fi)
+{
+	DIR *dp;
+	struct dirent *de;
+
+	(void) offset;
+	(void) fi;
+
+	dp = opendir(path);
+	if (dp == NULL)
+		return -errno;
+
+	while ((de = readdir(dp)) != NULL) {
+		struct stat st;
+		memset(&st, 0, sizeof(st));
+		st.st_ino = de->d_ino;
+		st.st_mode = de->d_type << 12;
+		if (filler(buf, de->d_name, &st, 0))
+			break;
+	}
+
+	closedir(dp);
+	return 0;
+}
+
+static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
+{
+	int res;
+
+	/* On Linux this could just be 'mknod(path, mode, rdev)' but this
+	   is more portable */
+	if (S_ISREG(mode)) {
+		res = open(path, O_CREAT | O_EXCL | O_WRONLY, mode);
+		if (res >= 0)
+			res = close(res);
+	} else if (S_ISFIFO(mode))
+		res = mkfifo(path, mode);
+	else
+		res = mknod(path, mode, rdev);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_mkdir(const char *path, mode_t mode)
+{
+	int res;
+
+	res = mkdir(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_unlink(const char *path)
+{
+	int res;
+
+	res = unlink(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rmdir(const char *path)
+{
+	int res;
+
+	res = rmdir(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_symlink(const char *from, const char *to)
+{
+	int res;
+
+	res = symlink(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rename(const char *from, const char *to)
+{
+	int res;
+
+	res = rename(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_link(const char *from, const char *to)
+{
+	int res;
+
+	res = link(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chmod(const char *path, mode_t mode)
+{
+	int res;
+
+	res = chmod(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+{
+	int res;
+
+	res = lchown(path, uid, gid);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_truncate(const char *path, off_t size)
+{
+	int res;
+
+	res = truncate(path, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_utimens(const char *path, const struct timespec ts[2])
+{
+	int res;
+	struct timeval tv[2];
+
+	tv[0].tv_sec = ts[0].tv_sec;
+	tv[0].tv_usec = ts[0].tv_nsec / 1000;
+	tv[1].tv_sec = ts[1].tv_sec;
+	tv[1].tv_usec = ts[1].tv_nsec / 1000;
+
+	res = utimes(path, tv);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_open(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+
+	res = open(path, fi->flags);
+	if (res == -1)
+		return -errno;
+
+	close(res);
+	return 0;
+}
+
+static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
+		    struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+	fd = open(path, O_RDONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = pread(fd, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	close(fd);
+	return res;
+}
+
+static int xmp_write(const char *path, const char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+	fd = open(path, O_WRONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = pwrite(fd, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	close(fd);
+	return res;
+}
+
+static int xmp_statfs(const char *path, struct statvfs *stbuf)
+{
+	int res;
+
+	res = statvfs(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_release(const char *path, struct fuse_file_info *fi)
+{
+	/* Just a stub.	 This method is optional and can safely be left
+	   unimplemented */
+
+	(void) path;
+	(void) fi;
+	return 0;
+}
+
+static int xmp_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+	/* Just a stub.	 This method is optional and can safely be left
+	   unimplemented */
+
+	(void) path;
+	(void) isdatasync;
+	(void) fi;
+	return 0;
+}
+
+#ifdef HAVE_SETXATTR
+/* xattr operations are optional and can safely be left unimplemented */
+static int xmp_setxattr(const char *path, const char *name, const char *value,
+			size_t size, int flags)
+{
+	int res = lsetxattr(path, name, value, size, flags);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+
+static int xmp_getxattr(const char *path, const char *name, char *value,
+			size_t size)
+{
+	int res = lgetxattr(path, name, value, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_listxattr(const char *path, char *list, size_t size)
+{
+	int res = llistxattr(path, list, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_removexattr(const char *path, const char *name)
+{
+	int res = lremovexattr(path, name);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+#endif /* HAVE_SETXATTR */
+
+static struct fuse_operations xmp_oper = {
+	.getattr	= xmp_getattr,
+	.access		= xmp_access,
+	.readlink	= xmp_readlink,
+	.readdir	= xmp_readdir,
+	.mknod		= xmp_mknod,
+	.mkdir		= xmp_mkdir,
+	.symlink	= xmp_symlink,
+	.unlink		= xmp_unlink,
+	.rmdir		= xmp_rmdir,
+	.rename		= xmp_rename,
+	.link		= xmp_link,
+	.chmod		= xmp_chmod,
+	.chown		= xmp_chown,
+	.truncate	= xmp_truncate,
+	.utimens	= xmp_utimens,
+	.open		= xmp_open,
+	.read		= xmp_read,
+	.write		= xmp_write,
+	.statfs		= xmp_statfs,
+	.release	= xmp_release,
+	.fsync		= xmp_fsync,
+#ifdef HAVE_SETXATTR
+	.setxattr	= xmp_setxattr,
+	.getxattr	= xmp_getxattr,
+	.listxattr	= xmp_listxattr,
+	.removexattr	= xmp_removexattr,
+#endif
+};
+
+int main(int argc, char *argv[])
+{
+	umask(0);
+	return fuse_main(argc, argv, &xmp_oper, NULL);
+}
diff --git a/fuse/fusexmp_fh.c b/fuse/fusexmp_fh.c
new file mode 100644
index 0000000..b86d3f6
--- /dev/null
+++ b/fuse/fusexmp_fh.c
@@ -0,0 +1,495 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos szeredi hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall `pkg-config fuse --cflags --libs` -lulockmgr fusexmp_fh.c -o fusexmp_fh
+*/
+
+#define FUSE_USE_VERSION 26
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+
+#include <fuse.h>
+#include <ulockmgr.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/time.h>
+#ifdef HAVE_SETXATTR
+#include <sys/xattr.h>
+#endif
+
+static int xmp_getattr(const char *path, struct stat *stbuf)
+{
+	int res;
+
+	res = lstat(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_fgetattr(const char *path, struct stat *stbuf,
+			struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+
+	res = fstat(fi->fh, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_access(const char *path, int mask)
+{
+	int res;
+
+	res = access(path, mask);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_readlink(const char *path, char *buf, size_t size)
+{
+	int res;
+
+	res = readlink(path, buf, size - 1);
+	if (res == -1)
+		return -errno;
+
+	buf[res] = '\0';
+	return 0;
+}
+
+struct xmp_dirp {
+	DIR *dp;
+	struct dirent *entry;
+	off_t offset;
+};
+
+static int xmp_opendir(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+	struct xmp_dirp *d = malloc(sizeof(struct xmp_dirp));
+	if (d == NULL)
+		return -ENOMEM;
+
+	d->dp = opendir(path);
+	if (d->dp == NULL) {
+		res = -errno;
+		free(d);
+		return res;
+	}
+	d->offset = 0;
+	d->entry = NULL;
+
+	fi->fh = (unsigned long) d;
+	return 0;
+}
+
+static inline struct xmp_dirp *get_dirp(struct fuse_file_info *fi)
+{
+	return (struct xmp_dirp *) (uintptr_t) fi->fh;
+}
+
+static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+		       off_t offset, struct fuse_file_info *fi)
+{
+	struct xmp_dirp *d = get_dirp(fi);
+
+	(void) path;
+	if (offset != d->offset) {
+		seekdir(d->dp, offset);
+		d->entry = NULL;
+		d->offset = offset;
+	}
+	while (1) {
+		struct stat st;
+		off_t nextoff;
+
+		if (!d->entry) {
+			d->entry = readdir(d->dp);
+			if (!d->entry)
+				break;
+		}
+
+		memset(&st, 0, sizeof(st));
+		st.st_ino = d->entry->d_ino;
+		st.st_mode = d->entry->d_type << 12;
+		nextoff = telldir(d->dp);
+		if (filler(buf, d->entry->d_name, &st, nextoff))
+			break;
+
+		d->entry = NULL;
+		d->offset = nextoff;
+	}
+
+	return 0;
+}
+
+static int xmp_releasedir(const char *path, struct fuse_file_info *fi)
+{
+	struct xmp_dirp *d = get_dirp(fi);
+	(void) path;
+	closedir(d->dp);
+	free(d);
+	return 0;
+}
+
+static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
+{
+	int res;
+
+	if (S_ISFIFO(mode))
+		res = mkfifo(path, mode);
+	else
+		res = mknod(path, mode, rdev);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_mkdir(const char *path, mode_t mode)
+{
+	int res;
+
+	res = mkdir(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_unlink(const char *path)
+{
+	int res;
+
+	res = unlink(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rmdir(const char *path)
+{
+	int res;
+
+	res = rmdir(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_symlink(const char *from, const char *to)
+{
+	int res;
+
+	res = symlink(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rename(const char *from, const char *to)
+{
+	int res;
+
+	res = rename(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_link(const char *from, const char *to)
+{
+	int res;
+
+	res = link(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chmod(const char *path, mode_t mode)
+{
+	int res;
+
+	res = chmod(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+{
+	int res;
+
+	res = lchown(path, uid, gid);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_truncate(const char *path, off_t size)
+{
+	int res;
+
+	res = truncate(path, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_ftruncate(const char *path, off_t size,
+			 struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+
+	res = ftruncate(fi->fh, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_utimens(const char *path, const struct timespec ts[2])
+{
+	int res;
+	struct timeval tv[2];
+
+	tv[0].tv_sec = ts[0].tv_sec;
+	tv[0].tv_usec = ts[0].tv_nsec / 1000;
+	tv[1].tv_sec = ts[1].tv_sec;
+	tv[1].tv_usec = ts[1].tv_nsec / 1000;
+
+	res = utimes(path, tv);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_create(const char *path, mode_t mode, struct fuse_file_info *fi)
+{
+	int fd;
+
+	fd = open(path, fi->flags, mode);
+	if (fd == -1)
+		return -errno;
+
+	fi->fh = fd;
+	return 0;
+}
+
+static int xmp_open(const char *path, struct fuse_file_info *fi)
+{
+	int fd;
+
+	fd = open(path, fi->flags);
+	if (fd == -1)
+		return -errno;
+
+	fi->fh = fd;
+	return 0;
+}
+
+static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
+		    struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	res = pread(fi->fh, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	return res;
+}
+
+static int xmp_write(const char *path, const char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	res = pwrite(fi->fh, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	return res;
+}
+
+static int xmp_statfs(const char *path, struct statvfs *stbuf)
+{
+	int res;
+
+	res = statvfs(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_flush(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	/* This is called from every close on an open file, so call the
+	   close on the underlying filesystem.	But since flush may be
+	   called multiple times for an open file, this must not really
+	   close the file.  This is important if used on a network
+	   filesystem like NFS which flush the data/metadata on close() */
+	res = close(dup(fi->fh));
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_release(const char *path, struct fuse_file_info *fi)
+{
+	(void) path;
+	close(fi->fh);
+
+	return 0;
+}
+
+static int xmp_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+	int res;
+	(void) path;
+
+#ifndef HAVE_FDATASYNC
+	(void) isdatasync;
+#else
+	if (isdatasync)
+		res = fdatasync(fi->fh);
+	else
+#endif
+		res = fsync(fi->fh);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+#ifdef HAVE_SETXATTR
+/* xattr operations are optional and can safely be left unimplemented */
+static int xmp_setxattr(const char *path, const char *name, const char *value,
+			size_t size, int flags)
+{
+	int res = lsetxattr(path, name, value, size, flags);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+
+static int xmp_getxattr(const char *path, const char *name, char *value,
+			size_t size)
+{
+	int res = lgetxattr(path, name, value, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_listxattr(const char *path, char *list, size_t size)
+{
+	int res = llistxattr(path, list, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_removexattr(const char *path, const char *name)
+{
+	int res = lremovexattr(path, name);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+#endif /* HAVE_SETXATTR */
+
+static int xmp_lock(const char *path, struct fuse_file_info *fi, int cmd,
+		    struct flock *lock)
+{
+	(void) path;
+
+	return ulockmgr_op(fi->fh, cmd, lock, &fi->lock_owner,
+			   sizeof(fi->lock_owner));
+}
+
+static struct fuse_operations xmp_oper = {
+	.getattr	= xmp_getattr,
+	.fgetattr	= xmp_fgetattr,
+	.access		= xmp_access,
+	.readlink	= xmp_readlink,
+	.opendir	= xmp_opendir,
+	.readdir	= xmp_readdir,
+	.releasedir	= xmp_releasedir,
+	.mknod		= xmp_mknod,
+	.mkdir		= xmp_mkdir,
+	.symlink	= xmp_symlink,
+	.unlink		= xmp_unlink,
+	.rmdir		= xmp_rmdir,
+	.rename		= xmp_rename,
+	.link		= xmp_link,
+	.chmod		= xmp_chmod,
+	.chown		= xmp_chown,
+	.truncate	= xmp_truncate,
+	.ftruncate	= xmp_ftruncate,
+	.utimens	= xmp_utimens,
+	.create		= xmp_create,
+	.open		= xmp_open,
+	.read		= xmp_read,
+	.write		= xmp_write,
+	.statfs		= xmp_statfs,
+	.flush		= xmp_flush,
+	.release	= xmp_release,
+	.fsync		= xmp_fsync,
+#ifdef HAVE_SETXATTR
+	.setxattr	= xmp_setxattr,
+	.getxattr	= xmp_getxattr,
+	.listxattr	= xmp_listxattr,
+	.removexattr	= xmp_removexattr,
+#endif
+	.lock		= xmp_lock,
+
+	.flag_nullpath_ok = 1,
+};
+
+int main(int argc, char *argv[])
+{
+	umask(0);
+	return fuse_main(argc, argv, &xmp_oper, NULL);
+}
diff --git a/fuse/guestmount.c b/fuse/guestmount.c
new file mode 100644
index 0000000..c949e6a
--- /dev/null
+++ b/fuse/guestmount.c
@@ -0,0 +1,844 @@
+/* guestmount - mount guests using libguestfs and FUSE
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Derived from the example program 'fusexmp.c':
+ * Copyright (C) 2001-2007  Miklos Szeredi <miklos szeredi hu>
+ *
+ * This program can be distributed under the terms of the GNU GPL.
+ * See the file COPYING.
+ */
+
+#define FUSE_USE_VERSION 26
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <fuse.h>
+#include <guestfs.h>
+
+#include "progname.h"
+
+/* See <attr/xattr.h> */
+#ifndef ENOATTR
+#define ENOATTR ENODATA
+#endif
+
+#ifdef HAVE_GETTEXT
+#include "gettext.h"
+#define _(str) dgettext(PACKAGE, (str))
+//#define N_(str) dgettext(PACKAGE, (str))
+#else
+#define _(str) str
+//#define N_(str) str
+#endif
+
+static inline char *
+bad_cast (char const *s)
+{
+  return (char *) s;
+}
+
+static guestfs_h *g = NULL;
+static int read_only = 0;
+static int verbose = 0;
+
+/* This is ugly: guestfs errors are strings, FUSE wants -errno.  We have
+ * to do the conversion as best we can.
+ */
+#define MAX_ERRNO 256
+
+static int
+error (void)
+{
+  int i;
+  const char *err = guestfs_last_error (g);
+
+  if (!err)
+    return -EINVAL;
+
+  /* Print the real error message on stderr. */
+  fprintf (stderr, "%s\n", err);
+
+  /* Now see if it matches an errno string in the host. */
+  for (i = 0; i < MAX_ERRNO; ++i) {
+    const char *e = strerror (i);
+    if (e && strstr (err, e) != NULL)
+      return -i;
+  }
+
+  /* Too bad, return a generic error. */
+  return -EINVAL;
+}
+
+static int
+fg_getattr (const char *path, struct stat *statbuf)
+{
+  struct guestfs_stat *r;
+
+  r = guestfs_lstat (g, path);
+  if (r == NULL)
+    return error ();
+
+  statbuf->st_dev = r->dev;
+  statbuf->st_ino = r->ino;
+  statbuf->st_mode = r->mode;
+  statbuf->st_nlink = r->nlink;
+  statbuf->st_uid = r->uid;
+  statbuf->st_gid = r->gid;
+  statbuf->st_rdev = r->rdev;
+  statbuf->st_size = r->size;
+  statbuf->st_blksize = r->blksize;
+  statbuf->st_blocks = r->blocks;
+  statbuf->st_atime = r->atime;
+  statbuf->st_mtime = r->mtime;
+  statbuf->st_ctime = r->ctime;
+
+  guestfs_free_stat (r);
+
+  return 0;
+}
+
+/* XXX It's not clear what access is being tested here.  If this
+ * daemon runs as root, then access always succeeds.  The guestfsd
+ * always runs as root, so no access test there is possible.
+ */
+static int
+fg_access (const char *path, int mask)
+{
+  int r = guestfs_exists (g, path);
+  if (r == -1)
+    return error ();
+
+  if (mask == F_OK)
+    return r ? 0 : -EACCES;
+
+  int ok = 1;
+  /* if the file exists, it's readable */
+  if (mask & R_OK)
+    ok &= r;
+  /* if the file exists and we're not mounted r/o, it's writable */
+  if (mask & W_OK)
+    ok &= r & !read_only;
+  /* if the file exists, presume it's executable here */
+  if (mask & X_OK)
+    ok &= r;
+  return ok;
+}
+
+static int
+fg_readlink (const char *path, char *buf, size_t size)
+{
+  char *r;
+
+  r = guestfs_readlink (g, path);
+  if (r == NULL)
+    return error ();
+
+  /* Note this is different from the real readlink(2) syscall.  FUSE wants
+   * the string to be always nul-terminated, even if truncated.
+   */
+  size_t len = strlen (r);
+  if (len > size - 1)
+    len = size - 1;
+
+  memcpy (buf, r, len);
+  buf[len] = '\0';
+
+  free (r);
+
+  return 0;
+}
+
+static int
+fg_readdir (const char *path, void *buf, fuse_fill_dir_t filler,
+            off_t offset, struct fuse_file_info *fi)
+{
+  struct guestfs_dirent_list *ents;
+
+  ents = guestfs_readdir (g, path);
+  if (ents == NULL)
+    return error ();
+
+  size_t i;
+  for (i = 0; i < ents->len; ++i) {
+    struct stat stat;
+    memset (&stat, 0, sizeof stat);
+
+    stat.st_ino = ents->val[i].ino;
+    switch (ents->val[i].ftyp) {
+    case 'b': stat.st_mode = S_IFBLK; break;
+    case 'c': stat.st_mode = S_IFCHR; break;
+    case 'd': stat.st_mode = S_IFDIR; break;
+    case 'f': stat.st_mode = S_IFIFO; break;
+    case 'l': stat.st_mode = S_IFLNK; break;
+    case 'r': stat.st_mode = S_IFREG; break;
+    case 's': stat.st_mode = S_IFSOCK; break;
+    case 'u':
+    case '?':
+    default:  stat.st_mode = 0;
+    }
+
+    /* Copied from the example, which also ignores 'offset'.  I'm
+     * not quite sure how this is ever supposed to work on large
+     * directories. XXX
+     */
+    if (filler (buf, ents->val[i].name, &stat, 0))
+      break;
+  }
+
+  guestfs_free_dirent_list (ents);
+
+  return 0;
+}
+
+static int
+fg_mknod (const char *path, mode_t mode, dev_t rdev)
+{
+  int r;
+
+  r = guestfs_mknod (g, mode, major (rdev), minor (rdev), path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_mkdir (const char *path, mode_t mode)
+{
+  int r;
+
+  r = guestfs_mkdir_mode (g, path, mode);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_unlink (const char *path)
+{
+  int r;
+
+  r = guestfs_rm (g, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_rmdir (const char *path)
+{
+  int r;
+
+  r = guestfs_rmdir (g, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_symlink (const char *from, const char *to)
+{
+  int r;
+
+  r = guestfs_ln_s (g, to, from);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_rename (const char *from, const char *to)
+{
+  int r;
+
+  /* XXX It's not clear how close the 'mv' command is to the
+   * rename syscall.  We might need to add the rename syscall
+   * to the guestfs(3) API.
+   */
+  r = guestfs_mv (g, from, to);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_link (const char *from, const char *to)
+{
+  int r;
+
+  r = guestfs_ln (g, to, from);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_chmod (const char *path, mode_t mode)
+{
+  int r;
+
+  r = guestfs_chmod (g, mode, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_chown (const char *path, uid_t uid, gid_t gid)
+{
+  int r;
+
+  /* XXX Example uses lchown here. */
+  r = guestfs_chown (g, uid, gid, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_truncate (const char *path, off_t size)
+{
+  int r;
+
+  r = guestfs_truncate_size (g, path, size);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_utimens (const char *path, const struct timespec ts[2])
+{
+  int r;
+
+  time_t atsecs = ts[0].tv_sec;
+  long atnsecs = ts[0].tv_nsec;
+  time_t mtsecs = ts[1].tv_sec;
+  long mtnsecs = ts[1].tv_nsec;
+
+  if (atnsecs == UTIME_NOW)
+    atnsecs = -1;
+  if (atnsecs == UTIME_OMIT)
+    atnsecs = -2;
+  if (mtnsecs == UTIME_NOW)
+    mtnsecs = -1;
+  if (mtnsecs == UTIME_OMIT)
+    mtnsecs = -2;
+
+  r = guestfs_utimens (g, path, atsecs, atnsecs, mtsecs, mtnsecs);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+/* This call is quite hard to emulate through the guestfs(3) API.  In
+ * one sense it's a little like access (see above) because it tests
+ * whether opening a file would succeed given the flags.  But it also
+ * has side effects such as truncating the file if O_TRUNC is given.
+ * Therefore we need to emulate it ... painfully.
+ */
+static int
+fg_open (const char *path, struct fuse_file_info *fi)
+{
+  int r, exists;
+
+  if (fi->flags & O_WRONLY) {
+    if (read_only)
+      return -EROFS;
+  }
+
+  exists = guestfs_exists (g, path);
+  if (exists == -1)
+    return error ();
+
+  if (fi->flags & O_CREAT) {
+    /* Exclusive?  File must not exist already. */
+    if (fi->flags & O_EXCL) {
+      if (exists)
+        return -EEXIST;
+    }
+
+    /* Create?  Touch it and optionally truncate it. */
+    r = guestfs_touch (g, path);
+    if (r == -1)
+      return error ();
+
+    if (fi->flags & O_TRUNC) {
+      r = guestfs_truncate (g, path);
+      if (r == -1)
+        return error ();
+    }
+  } else {
+    /* Not create, just check it exists. */
+    if (!exists)
+      return -ENOENT;
+  }
+
+  return 0;
+}
+
+static int
+fg_read (const char *path, char *buf, size_t size, off_t offset,
+         struct fuse_file_info *fi)
+{
+  return -ENOSYS;               /* XXX */
+}
+
+static int
+fg_write (const char *path, const char *buf, size_t size,
+          off_t offset, struct fuse_file_info *fi)
+{
+  return -ENOSYS;               /* XXX */
+}
+
+static int
+fg_statfs (const char *path, struct statvfs *stbuf)
+{
+  struct guestfs_statvfs *r;
+
+  r = guestfs_statvfs (g, path);
+  if (r == NULL)
+    return error ();
+
+  stbuf->f_bsize = r->bsize;
+  stbuf->f_frsize = r->frsize;
+  stbuf->f_blocks = r->blocks;
+  stbuf->f_bfree = r->bfree;
+  stbuf->f_bavail = r->bavail;
+  stbuf->f_files = r->files;
+  stbuf->f_ffree = r->ffree;
+  stbuf->f_favail = r->favail;
+  stbuf->f_fsid = r->fsid;
+  stbuf->f_flag = r->flag;
+  stbuf->f_namemax = r->namemax;
+
+  guestfs_free_statvfs (r);
+
+  return 0;
+}
+
+static int
+fg_release (const char *path, struct fuse_file_info *fi)
+{
+  /* Just a stub. This method is optional and can safely be left
+   * unimplemented.
+   */
+  return 0;
+}
+
+/* Emulate this by calling sync. */
+static int fg_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+  int r;
+
+  r = guestfs_sync (g);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_setxattr (const char *path, const char *name, const char *value,
+             size_t size, int flags)
+{
+  int r;
+
+  /* XXX Underlying guestfs(3) API doesn't understand the flags. */
+  r = guestfs_lsetxattr (g, name, value, size, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+/* The guestfs(3) API for getting xattrs is much easier to use
+ * than the real syscall.  Unfortunately we now have to emulate
+ * the real syscall using that API :-(
+ */
+static int
+fg_getxattr (const char *path, const char *name, char *value,
+             size_t size)
+{
+  struct guestfs_xattr_list *attrs;
+
+  attrs = guestfs_lgetxattrs (g, path);
+  if (attrs == NULL)
+    return error ();
+
+  size_t i;
+  int r = -ENOATTR;
+  for (i = 0; i < attrs->len; ++i) {
+    if (strcmp (attrs->val[i].attrname, name) == 0) {
+      size_t sz = attrs->val[i].attrval_len;
+      if (sz > size)
+        sz = size;
+      memcpy (value, attrs->val[i].attrval, sz);
+      r = 0;
+      break;
+    }
+  }
+
+  guestfs_free_xattr_list (attrs);
+
+  return r;
+}
+
+/* Ditto as above. */
+static int
+fg_listxattr (const char *path, char *list, size_t size)
+{
+  struct guestfs_xattr_list *attrs;
+
+  attrs = guestfs_lgetxattrs (g, path);
+  if (attrs == NULL)
+    return error ();
+
+  size_t i;
+  ssize_t copied = 0;
+  for (i = 0; i < attrs->len; ++i) {
+    size_t len = strlen (attrs->val[i].attrname) + 1;
+    if (size >= len) {
+      memcpy (list, attrs->val[i].attrname, len);
+      size -= len;
+      list += len;
+      copied += len;
+    } else {
+      copied = -ERANGE;
+      break;
+    }
+  }
+
+  guestfs_free_xattr_list (attrs);
+
+  return copied;
+}
+
+static int
+fg_removexattr(const char *path, const char *name)
+{
+  int r;
+
+  r = guestfs_lremovexattr (g, name, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static struct fuse_operations fg_operations = {
+  .getattr	= fg_getattr,
+  .access	= fg_access,
+  .readlink	= fg_readlink,
+  .readdir	= fg_readdir,
+  .mknod	= fg_mknod,
+  .mkdir	= fg_mkdir,
+  .symlink	= fg_symlink,
+  .unlink	= fg_unlink,
+  .rmdir	= fg_rmdir,
+  .rename	= fg_rename,
+  .link		= fg_link,
+  .chmod	= fg_chmod,
+  .chown	= fg_chown,
+  .truncate	= fg_truncate,
+  .utimens	= fg_utimens,
+  .open		= fg_open,
+  .read		= fg_read,
+  .write	= fg_write,
+  .statfs	= fg_statfs,
+  .release	= fg_release,
+  .fsync	= fg_fsync,
+  .setxattr	= fg_setxattr,
+  .getxattr	= fg_getxattr,
+  .listxattr	= fg_listxattr,
+  .removexattr	= fg_removexattr,
+};
+
+struct drv {
+  struct drv *next;
+  char *filename;
+};
+
+struct mp {
+  struct mp *next;
+  char *device;
+  char *mountpoint;
+};
+
+static void add_drives (struct drv *);
+static void mount_mps (struct mp *);
+
+static void __attribute__((noreturn))
+usage (int status)
+{
+  if (status != EXIT_SUCCESS)
+    fprintf (stderr, _("Try `%s --help' for more information.\n"),
+             program_name);
+  else {
+    fprintf (stdout,
+           _("%s: FUSE module for libguestfs\n"
+             "%s lets you mount a virtual machine filesystem\n"
+             "Copyright (C) 2009 Red Hat Inc.\n"
+             "Usage:\n"
+             "  %s [--options] [-- [--fuse-options]] mountpoint\n"
+             "Options:\n"
+             "  -a|--add image       Add image\n"
+             "  -f|--file file       Read commands from file\n"
+             "  -m|--mount dev[:mnt] Mount dev on mnt (if omitted, /)\n"
+             "  -n|--no-sync         Don't autosync\n"
+             "  -r|--ro              Mount read-only\n"
+             "  --selinux            Enable SELinux support\n"
+             "  --trace              Trace guestfs API calls (to stderr)\n"
+             "  -v|--verbose         Verbose messages\n"
+             "  -V|--version         Display version and exit\n"
+             "FUSE options aren't documented here.  To get a list of options\n"
+             "supported by FUSE itself, do:\n"
+             "  %s -- --help\n"
+             ),
+             program_name, program_name, program_name, program_name);
+  }
+  exit (status);
+}
+
+int
+main (int argc, char *argv[])
+{
+  enum { HELP_OPTION = CHAR_MAX + 1 };
+
+  /* The command line arguments are broadly compatible with (a subset
+   * of) guestfish.  Thus we have to deal mainly with -a, -m and --ro.
+   */
+  static const char *options = "a:m:nrv?V";
+  static const struct option long_options[] = {
+    { "add", 1, 0, 'a' },
+    { "help", 0, 0, HELP_OPTION },
+    { "mount", 1, 0, 'm' },
+    { "no-sync", 0, 0, 'n' },
+    { "ro", 0, 0, 'r' },
+    { "selinux", 0, 0, 0 },
+    { "trace", 0, 0, 0 },
+    { "verbose", 0, 0, 'v' },
+    { "version", 0, 0, 'V' },
+    { 0, 0, 0, 0 }
+  };
+
+  struct drv *drvs = NULL;
+  struct drv *drv;
+  struct mp *mps = NULL;
+  struct mp *mp;
+  char *p;
+  int c, i;
+  int option_index;
+  struct sigaction sa;
+
+  /* LC_ALL=C is required so we can parse error messages. */
+  setenv ("LC_ALL", "C", 1);
+
+  /* Set global program name that is not polluted with libtool artifacts.  */
+  set_program_name (argv[0]);
+
+  memset (&sa, 0, sizeof sa);
+  sa.sa_handler = SIG_IGN;
+  sa.sa_flags = SA_RESTART;
+  sigaction (SIGPIPE, &sa, NULL);
+
+  g = guestfs_create ();
+  if (g == NULL) {
+    fprintf (stderr, _("guestfs_create: failed to create handle\n"));
+    exit (1);
+  }
+
+  guestfs_set_autosync (g, 1);
+
+  /* If developing, add ./appliance to the path.  Note that libtools
+   * interferes with this because uninstalled guestfish is a shell
+   * script that runs the real program with an absolute path.  Detect
+   * that too.
+   *
+   * BUT if LIBGUESTFS_PATH environment variable is already set by
+   * the user, then don't override it.
+   */
+  if (getenv ("LIBGUESTFS_PATH") == NULL &&
+      argv[0] &&
+      (argv[0][0] != '/' || strstr (argv[0], "/.libs/lt-") != NULL))
+    guestfs_set_path (g, "appliance:" GUESTFS_DEFAULT_PATH);
+
+  for (;;) {
+    c = getopt_long (argc, argv, options, long_options, &option_index);
+    if (c == -1) break;
+
+    switch (c) {
+    case 0:			/* options which are long only */
+      if (strcmp (long_options[option_index].name, "selinux") == 0)
+        guestfs_set_selinux (g, 1);
+      else if (strcmp (long_options[option_index].name, "trace") == 0)
+        guestfs_set_trace (g, 1);
+      else {
+        fprintf (stderr, _("%s: unknown long option: %s (%d)\n"),
+                 program_name, long_options[option_index].name, option_index);
+        exit (1);
+      }
+      break;
+
+    case 'a':
+      if (access (optarg, R_OK) != 0) {
+        perror (optarg);
+        exit (1);
+      }
+      drv = malloc (sizeof (struct drv));
+      if (!drv) {
+        perror ("malloc");
+        exit (1);
+      }
+      drv->filename = optarg;
+      drv->next = drvs;
+      drvs = drv;
+      break;
+
+    case 'm':
+      mp = malloc (sizeof (struct mp));
+      if (!mp) {
+        perror ("malloc");
+        exit (1);
+      }
+      p = strchr (optarg, ':');
+      if (p) {
+        *p = '\0';
+        mp->mountpoint = p+1;
+      } else
+        mp->mountpoint = bad_cast ("/");
+      mp->device = optarg;
+      mp->next = mps;
+      mps = mp;
+      break;
+
+    case 'n':
+      guestfs_set_autosync (g, 0);
+      break;
+
+    case 'r':
+      read_only = 1;
+      break;
+
+    case 'v':
+      verbose++;
+      guestfs_set_verbose (g, verbose);
+      break;
+
+    case 'V':
+      printf ("%s %s\n", program_name, PACKAGE_VERSION);
+      exit (0);
+
+    case HELP_OPTION:
+      usage (0);
+
+    default:
+      usage (1);
+    }
+  }
+
+  /* We must have at least one -a and at least one -m. */
+  if (!drvs || !mps) {
+    fprintf (stderr,
+             _("%s: must have at least one -a and at least one -m option\n"),
+             program_name);
+    exit (1);
+  }
+
+  add_drives (drvs);
+  if (guestfs_launch (g) == -1)
+    exit (1);
+  mount_mps (mps);
+
+  /* FUSE example does this, not clear if it's necessary, but ... */
+  if (guestfs_umask (g, 0) == -1)
+    exit (1);
+
+  /* At the last minute, remove the libguestfs error handler.  In code
+   * above this point, the default error handler has been used which
+   * sends all errors to stderr.  Now before entering FUSE itself we
+   * want to silence errors so we can convert them (see error()
+   * function above).
+   */
+  guestfs_set_error_handler (g, NULL, NULL);
+
+  /* Skip our args.  Rest are passed to FUSE. */
+  argc -= optind-1;
+  for (i = 1; i <= argc; ++i)
+    argv[i] = argv[optind+i-1];
+
+  /* Enter FUSE main loop. */
+  return fuse_main (argc, argv, &fg_operations, NULL);
+}
+
+/* List is built in reverse order, so add them in reverse order. */
+static void
+add_drives (struct drv *drv)
+{
+  int r;
+
+  if (drv) {
+    add_drives (drv->next);
+    if (!read_only)
+      r = guestfs_add_drive (g, drv->filename);
+    else
+      r = guestfs_add_drive_ro (g, drv->filename);
+    if (r == -1)
+      exit (1);
+  }
+}
+
+/* List is built in reverse order, so mount them in reverse order. */
+static void
+mount_mps (struct mp *mp)
+{
+  int r;
+
+  if (mp) {
+    mount_mps (mp->next);
+    if (!read_only)
+      r = guestfs_mount (g, mp->device, mp->mountpoint);
+    else
+      r = guestfs_mount_ro (g, mp->device, mp->mountpoint);
+    if (r == -1)
+      exit (1);
+  }
+}
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 8c3c8f5..d2bfcc0 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -71,6 +71,9 @@ fish/rc.c
 fish/reopen.c
 fish/tilde.c
 fish/time.c
+fuse/fusexmp.c
+fuse/fusexmp_fh.c
+fuse/guestmount.c
 hivex/hivex.c
 hivex/hivexget.c
 hivex/hivexml.c
-- 
1.6.5.rc2


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]