diff --git a/Makefile b/Makefile
index dd76e2a..31a7b4b 100644
--- a/Makefile
+++ b/Makefile
@@ -55,7 +55,7 @@ install-vm:
 	install -D -m 0440 misc/qubes.sudoers $(DESTDIR)/etc/sudoers.d/qubes
 	install -D -m 0644 misc/qubes.repo $(DESTDIR)/etc/yum.repos.d/qubes.repo
 	install -D -m 0644 misc/serial.conf $(DESTDIR)/usr/lib/qubes/serial.conf
-	install -D misc/qubes-serial-login $(DESTDIR)$(SBINDIR)/qubes-serial-login
+	install -D misc/qubes-serial-login $(DESTDIR)/$(SBINDIR)/qubes-serial-login
 	install -d $(DESTDIR)/usr/share/glib-2.0/schemas/
 	install -m 0644 misc/org.gnome.settings-daemon.plugins.updates.gschema.override $(DESTDIR)/usr/share/glib-2.0/schemas/
 	install -d $(DESTDIR)/usr/lib/yum-plugins/
@@ -111,9 +111,9 @@ install-vm:
 	install -d $(DESTDIR)/etc/yum.conf.d
 	touch $(DESTDIR)/etc/yum.conf.d/qubes-proxy.conf
 
-	install -d $(DESTDIR)$(SBINDIR)
-	install network/qubes-firewall $(DESTDIR)$(SBINDIR)/
-	install network/qubes-netwatcher $(DESTDIR)$(SBINDIR)/
+	install -d $(DESTDIR)/$(SBINDIR)
+	install network/qubes-firewall $(DESTDIR)/$(SBINDIR)/
+	install network/qubes-netwatcher $(DESTDIR)/$(SBINDIR)/
 
 	install -d $(DESTDIR)/usr/bin
 
@@ -122,6 +122,7 @@ install-vm:
 	install qubes-rpc/qvm-copy-to-vm.kde $(DESTDIR)/usr/lib/qubes
 	install qubes-rpc/qvm-copy-to-vm.gnome $(DESTDIR)/usr/lib/qubes
 	install qubes-rpc/{vm-file-editor,qfile-agent,qopen-in-vm} $(DESTDIR)/usr/lib/qubes
+	install qubes-rpc/tar2qfile $(DESTDIR)/usr/lib/qubes
 	# Install qfile-unpacker as SUID - because it will fail to receive files from other vm
 	install -m 4555  qubes-rpc/qfile-unpacker $(DESTDIR)/usr/lib/qubes
 	install qubes-rpc/qrun-in-vm $(DESTDIR)/usr/lib/qubes
@@ -134,6 +135,7 @@ install-vm:
 	install -m 0644 qubes-rpc/{qubes.SuspendPre,qubes.SuspendPost,qubes.GetAppmenus} $(DESTDIR)/etc/qubes-rpc
 	install -m 0644 qubes-rpc/qubes.WaitForSession $(DESTDIR)/etc/qubes-rpc
 	install -m 0644 qubes-rpc/qubes.DetachPciDevice $(DESTDIR)/etc/qubes-rpc
+	install -m 0644 qubes-rpc/qubes.{Backup,Restore} $(DESTDIR)/etc/qubes-rpc
 
 	install -d $(DESTDIR)/usr/share/file-manager/actions
 	install -m 0644 qubes-rpc/*-gnome.desktop $(DESTDIR)/usr/share/file-manager/actions
diff --git a/qubes-rpc/Makefile b/qubes-rpc/Makefile
index 4f153b2..0a3d5e8 100644
--- a/qubes-rpc/Makefile
+++ b/qubes-rpc/Makefile
@@ -1,14 +1,16 @@
 CC=gcc
 CFLAGS=-g -Wall -I. -fPIC -pie
-all:	vm-file-editor qopen-in-vm qfile-agent qfile-unpacker
+all:	vm-file-editor qopen-in-vm qfile-agent qfile-unpacker tar2qfile
 vm-file-editor: vm-file-editor.o ioall.o
 	$(CC) -pie -g -o $@ $^
 qopen-in-vm: qopen-in-vm.o ioall.o gui-fatal.o
 	$(CC) -pie -g -o $@ $^
-qfile-agent: qfile-agent.o gui-fatal.o
+qfile-agent: qfile-agent.o gui-fatal.o qfile-utils.o
 	$(CC) -pie -g -o $@ $^ -lqubes-rpc-filecopy
 qfile-unpacker: qfile-unpacker.o gui-fatal.o
 	$(CC) -pie -g -o $@ $^ -lqubes-rpc-filecopy
+tar2qfile: qfile-utils.o tar2qfile.o gui-fatal.o
+	$(CC) -pie -g -o $@ $^ -lqubes-rpc-filecopy
 
 clean:
-	rm -f qopen-in-vm qfile-agent qfile-unpacker vm-file-editor *.o *~
+	rm -f qopen-in-vm qfile-agent qfile-unpacker tar2qfile vm-file-editor *.o *~
diff --git a/qubes-rpc/ioall.c b/qubes-rpc/ioall.c
index 2a81df4..ce61700 100644
--- a/qubes-rpc/ioall.c
+++ b/qubes-rpc/ioall.c
@@ -35,12 +35,16 @@ void perror_wrapper(char * msg)
 void set_nonblock(int fd)
 {
 	int fl = fcntl(fd, F_GETFL, 0);
+	if (fl & O_NONBLOCK)
+		return;
 	fcntl(fd, F_SETFL, fl | O_NONBLOCK);
 }
 
 void set_block(int fd)
 {
 	int fl = fcntl(fd, F_GETFL, 0);
+	if (!(fl & O_NONBLOCK))
+		return;
 	fcntl(fd, F_SETFL, fl & ~O_NONBLOCK);
 }
 
diff --git a/qubes-rpc/qfile-agent.c b/qubes-rpc/qfile-agent.c
index 22712c7..2eb8205 100644
--- a/qubes-rpc/qfile-agent.c
+++ b/qubes-rpc/qfile-agent.c
@@ -1,186 +1,12 @@
-#define _GNU_SOURCE
-#include <dirent.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <malloc.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <gui-fatal.h>
-#include <libqubes-rpc-filecopy.h>
+#include "qfile-utils.h"
 
-enum {
-	PROGRESS_FLAG_NORMAL,
-	PROGRESS_FLAG_INIT,
-	PROGRESS_FLAG_DONE
-};
-
-int ignore_symlinks = 0;
-
-unsigned long crc32_sum;
-int write_all_with_crc(int fd, void *buf, int size)
+char *get_abs_path(char *cwd, char *pathname)
 {
-	crc32_sum = Crc32_ComputeBuf(crc32_sum, buf, size);
-	return write_all(fd, buf, size);
-}
-
-void do_notify_progress(long long total, int flag)
-{
-	char *du_size_env = getenv("FILECOPY_TOTAL_SIZE");
-	char *progress_type_env = getenv("PROGRESS_TYPE");
-	char *saved_stdout_env = getenv("SAVED_FD_1");
-	if (!progress_type_env)
-		return;
-	if (!strcmp(progress_type_env, "console") && du_size_env) {
-		char msg[256];
-		snprintf(msg, sizeof(msg), "sent %lld/%lld KB\r",
-			 total / 1024, strtoull(du_size_env, NULL, 0));
-		write(2, msg, strlen(msg));
-		if (flag == PROGRESS_FLAG_DONE)
-			write(2, "\n", 1);
-	}
-	if (!strcmp(progress_type_env, "gui") && saved_stdout_env) {
-		char msg[256];
-		snprintf(msg, sizeof(msg), "%lld\n", total);
-		write(strtoul(saved_stdout_env, NULL, 0), msg,
-		      strlen(msg));
-	}
-}
-
-void wait_for_result()
-{
-	struct result_header hdr;
-	struct result_header_ext hdr_ext;
-	char last_filename[MAX_PATH_LENGTH + 1];
-	char last_filename_prefix[] = "; Last file: ";
-
-	if (!read_all(0, &hdr, sizeof(hdr))) {
-		if (errno == EAGAIN) {
-			// no result sent and stdin still open
-			return;
-		} else {
-			// other read error or EOF
-			exit(1);	// hopefully remote has produced error message
-		}
-	}
-	if (!read_all(0, &hdr_ext, sizeof(hdr_ext))) {
-		// remote used old result_header struct
-		hdr_ext.last_namelen = 0;
-	}
-	if (hdr_ext.last_namelen > MAX_PATH_LENGTH) {
-		// read only at most MAX_PATH_LENGTH chars
-		hdr_ext.last_namelen = MAX_PATH_LENGTH;
-	}
-	if (!read_all(0, last_filename, hdr_ext.last_namelen)) {
-		fprintf(stderr, "Failed to get last filename\n");
-		hdr_ext.last_namelen = 0;
-	}
-	last_filename[hdr_ext.last_namelen] = '\0';
-	if (!hdr_ext.last_namelen)
-		/* set prefix to empty string */
-		last_filename_prefix[0] = '\0';
-
-	errno = hdr.error_code;
-	if (hdr.error_code != 0) {
-		switch (hdr.error_code) {
-			case EEXIST:
-				gui_fatal("File copy: not overwriting existing file. Clean QubesIncoming dir, and retry copy%s%s", last_filename_prefix, last_filename);
-				break;
-			case EINVAL:
-				gui_fatal("File copy: Corrupted data from packer%s%s", last_filename_prefix, last_filename);
-				break;
-			default:
-				gui_fatal("File copy: %s%s%s",
-						strerror(hdr.error_code), last_filename_prefix, last_filename);
-		}
-	}
-	if (hdr.crc32 != crc32_sum) {
-		gui_fatal("File transfer failed: checksum mismatch");
-	}
-}
-
-void notify_progress(int size, int flag)
-{
-	static long long total = 0;
-	static long long prev_total = 0;
-	total += size;
-	if (total > prev_total + PROGRESS_NOTIFY_DELTA
-	    || (flag != PROGRESS_FLAG_NORMAL)) {
-		// check for possible error from qfile-unpacker; if error occured,
-		// exit() will be called, so don't bother with current state
-		// (notify_progress can be called as callback from copy_file())
-		if (flag == PROGRESS_FLAG_NORMAL)
-			wait_for_result();
-		do_notify_progress(total, flag);
-		prev_total = total;
-	}
-}
-
-void write_headers(struct file_header *hdr, char *filename)
-{
-	if (!write_all_with_crc(1, hdr, sizeof(*hdr))
-	    || !write_all_with_crc(1, filename, hdr->namelen)) {
-		set_block(0);
-		wait_for_result();
-		exit(1);
-	}
-}
-
-int single_file_processor(char *filename, struct stat *st)
-{
-	struct file_header hdr;
-	int fd;
-	mode_t mode = st->st_mode;
-
-	hdr.namelen = strlen(filename) + 1;
-	hdr.mode = mode;
-	hdr.atime = st->st_atim.tv_sec;
-	hdr.atime_nsec = st->st_atim.tv_nsec;
-	hdr.mtime = st->st_mtim.tv_sec;
-	hdr.mtime_nsec = st->st_mtim.tv_nsec;
-
-	if (S_ISREG(mode)) {
-		int ret;
-		fd = open(filename, O_RDONLY);
-		if (fd < 0)
-			gui_fatal("open %s", filename);
-		hdr.filelen = st->st_size;
-		write_headers(&hdr, filename);
-		ret = copy_file(1, fd, hdr.filelen, &crc32_sum);
-		if (ret != COPY_FILE_OK) {
-			if (ret != COPY_FILE_WRITE_ERROR)
-				gui_fatal("Copying file %s: %s", filename,
-					  copy_file_status_to_str(ret));
-			else {
-				set_block(0);
-				wait_for_result();
-				exit(1);
-			}
-		}
-		close(fd);
-	}
-	if (S_ISDIR(mode)) {
-		hdr.filelen = 0;
-		write_headers(&hdr, filename);
-	}
-	if (S_ISLNK(mode) && !ignore_symlinks) {
-		char name[st->st_size + 1];
-		if (readlink(filename, name, sizeof(name)) != st->st_size)
-			gui_fatal("readlink %s", filename);
-		hdr.filelen = st->st_size + 1;
-		write_headers(&hdr, filename);
-		if (!write_all_with_crc(1, name, st->st_size + 1)) {
-			set_block(0);
-			wait_for_result();
-			exit(1);
-		}
-	}
-	// check for possible error from qfile-unpacker
-	wait_for_result();
-	return 0;
+	char *ret;
+	if (pathname[0] == '/')
+		return strdup(pathname);
+	asprintf(&ret, "%s/%s", cwd, pathname);
+	return ret;
 }
 
 int do_fs_walk(char *file)
@@ -213,29 +39,6 @@ int do_fs_walk(char *file)
 	return 0;
 }
 
-void notify_end_and_wait_for_result()
-{
-	struct file_header end_hdr;
-
-	/* nofity end of transfer */
-	memset(&end_hdr, 0, sizeof(end_hdr));
-	end_hdr.namelen = 0;
-	end_hdr.filelen = 0;
-	write_all_with_crc(1, &end_hdr, sizeof(end_hdr));
-
-	set_block(0);
-	wait_for_result();
-}
-
-char *get_abs_path(char *cwd, char *pathname)
-{
-	char *ret;
-	if (pathname[0] == '/')
-		return strdup(pathname);
-	asprintf(&ret, "%s/%s", cwd, pathname);
-	return ret;
-}
-
 int main(int argc, char **argv)
 {
 	int i;
@@ -275,3 +78,5 @@ int main(int argc, char **argv)
 	notify_progress(0, PROGRESS_FLAG_DONE);
 	return 0;
 }
+
+
diff --git a/qubes-rpc/qfile-utils.c b/qubes-rpc/qfile-utils.c
new file mode 100644
index 0000000..ac804f8
--- /dev/null
+++ b/qubes-rpc/qfile-utils.c
@@ -0,0 +1,193 @@
+
+#include <qfile-utils.h>
+
+unsigned long crc32_sum;
+int ignore_symlinks = 0;
+int ignore_quota_error = 0;
+
+void notify_progress(int size, int flag)
+{
+	static long long total = 0;
+	static long long prev_total = 0;
+	total += size;
+	if (total > prev_total + PROGRESS_NOTIFY_DELTA
+	    || (flag != PROGRESS_FLAG_NORMAL)) {
+		// check for possible error from qfile-unpacker; if error occured,
+		// exit() will be called, so don't bother with current state
+		// (notify_progress can be called as callback from copy_file())
+		if (flag == PROGRESS_FLAG_NORMAL)
+			wait_for_result();
+		do_notify_progress(total, flag);
+		prev_total = total;
+	}
+}
+
+void do_notify_progress(long long total, int flag)
+{
+	char *du_size_env = getenv("FILECOPY_TOTAL_SIZE");
+	char *progress_type_env = getenv("PROGRESS_TYPE");
+	char *saved_stdout_env = getenv("SAVED_FD_1");
+	if (!progress_type_env)
+		return;
+	if (!strcmp(progress_type_env, "console") && du_size_env) {
+		char msg[256];
+		snprintf(msg, sizeof(msg), "sent %lld/%lld KB\r",
+			 total / 1024, strtoull(du_size_env, NULL, 0));
+		write(2, msg, strlen(msg));
+		if (flag == PROGRESS_FLAG_DONE)
+			write(2, "\n", 1);
+	}
+	if (!strcmp(progress_type_env, "gui") && saved_stdout_env) {
+		char msg[256];
+		snprintf(msg, sizeof(msg), "%lld\n", total);
+		write(strtoul(saved_stdout_env, NULL, 0), msg,
+		      strlen(msg));
+	}
+}
+
+void notify_end_and_wait_for_result()
+{
+	struct file_header end_hdr;
+
+	/* nofity end of transfer */
+	memset(&end_hdr, 0, sizeof(end_hdr));
+	end_hdr.namelen = 0;
+	end_hdr.filelen = 0;
+	write_all_with_crc(1, &end_hdr, sizeof(end_hdr));
+
+	set_block(0);
+	wait_for_result();
+}
+
+int write_all_with_crc(int fd, void *buf, int size)
+{
+	crc32_sum = Crc32_ComputeBuf(crc32_sum, buf, size);
+	return write_all(fd, buf, size);
+}
+
+void wait_for_result()
+{
+	struct result_header hdr;
+	struct result_header_ext hdr_ext;
+	char last_filename[MAX_PATH_LENGTH + 1];
+	char last_filename_prefix[] = "; Last file: ";
+
+	if (!read_all(0, &hdr, sizeof(hdr))) {
+		if (errno == EAGAIN) {
+			// no result sent and stdin still open
+			return;
+		} else {
+			// other read error or EOF
+			exit(1);	// hopefully remote has produced error message
+		}
+	}
+	if (!read_all(0, &hdr_ext, sizeof(hdr_ext))) {
+		// remote used old result_header struct
+		hdr_ext.last_namelen = 0;
+	}
+	if (hdr_ext.last_namelen > MAX_PATH_LENGTH) {
+		// read only at most MAX_PATH_LENGTH chars
+		hdr_ext.last_namelen = MAX_PATH_LENGTH;
+	}
+	if (!read_all(0, last_filename, hdr_ext.last_namelen)) {
+		fprintf(stderr, "Failed to get last filename\n");
+		hdr_ext.last_namelen = 0;
+	}
+	last_filename[hdr_ext.last_namelen] = '\0';
+	if (!hdr_ext.last_namelen)
+		/* set prefix to empty string */
+		last_filename_prefix[0] = '\0';
+
+	errno = hdr.error_code;
+	if (hdr.error_code != 0) {
+		switch (hdr.error_code) {
+			case EEXIST:
+				gui_fatal("File copy: not overwriting existing file. Clean QubesIncoming dir, and retry copy%s%s", last_filename_prefix, last_filename);
+				break;
+			case EINVAL:
+				gui_fatal("File copy: Corrupted data from packer%s%s", last_filename_prefix, last_filename);
+				break;
+			case EDQUOT:
+				if (ignore_quota_error) {
+					/* skip also CRC check as sender and receiver might be
+					 * desynchronized in this case */
+					return;
+				}
+				/* fall though */
+			default:
+				gui_fatal("File copy: %s%s%s",
+						strerror(hdr.error_code), last_filename_prefix, last_filename);
+		}
+	}
+	if (hdr.crc32 != crc32_sum) {
+		gui_fatal("File transfer failed: checksum mismatch");
+	}
+}
+
+void write_headers(struct file_header *hdr, char *filename)
+{
+	if (!write_all_with_crc(1, hdr, sizeof(*hdr))
+	    || !write_all_with_crc(1, filename, hdr->namelen)) {
+		set_block(0);
+		wait_for_result();
+		exit(1);
+	}
+}
+
+int single_file_processor(char *filename, struct stat *st)
+{
+	struct file_header hdr;
+	int fd;
+	mode_t mode = st->st_mode;
+
+	hdr.namelen = strlen(filename) + 1;
+	hdr.mode = mode;
+	hdr.atime = st->st_atim.tv_sec;
+	hdr.atime_nsec = st->st_atim.tv_nsec;
+	hdr.mtime = st->st_mtim.tv_sec;
+	hdr.mtime_nsec = st->st_mtim.tv_nsec;
+
+	if (S_ISREG(mode)) {
+		int ret;
+		fd = open(filename, O_RDONLY);
+		if (fd < 0)
+			gui_fatal("open %s", filename);
+		hdr.filelen = st->st_size;
+		write_headers(&hdr, filename);
+		ret = copy_file(1, fd, hdr.filelen, &crc32_sum);
+		if (ret != COPY_FILE_OK) {
+			if (ret != COPY_FILE_WRITE_ERROR)
+				gui_fatal("Copying file %s: %s", filename,
+					  copy_file_status_to_str(ret));
+			else {
+				set_block(0);
+				wait_for_result();
+				exit(1);
+			}
+		}
+		close(fd);
+	}
+	if (S_ISDIR(mode)) {
+		hdr.filelen = 0;
+		write_headers(&hdr, filename);
+	}
+	if (S_ISLNK(mode) && !ignore_symlinks) {
+		char name[st->st_size + 1];
+		if (readlink(filename, name, sizeof(name)) != st->st_size)
+			gui_fatal("readlink %s", filename);
+		hdr.filelen = st->st_size + 1;
+		write_headers(&hdr, filename);
+		if (!write_all_with_crc(1, name, st->st_size + 1)) {
+			set_block(0);
+			wait_for_result();
+			exit(1);
+		}
+	}
+	// check for possible error from qfile-unpacker
+	wait_for_result();
+	return 0;
+}
+
+
+
+
diff --git a/qubes-rpc/qfile-utils.h b/qubes-rpc/qfile-utils.h
new file mode 100644
index 0000000..389c74a
--- /dev/null
+++ b/qubes-rpc/qfile-utils.h
@@ -0,0 +1,40 @@
+
+#ifndef _LIBQUBES_QFILE_UTILS_H
+#define _LIBQUBES_QFILE_UTILS_H 1
+
+#define _GNU_SOURCE
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <gui-fatal.h>
+#include <libqubes-rpc-filecopy.h>
+
+enum {
+	PROGRESS_FLAG_NORMAL,
+	PROGRESS_FLAG_INIT,
+	PROGRESS_FLAG_DONE
+};
+
+extern unsigned long crc32_sum;
+extern int ignore_symlinks;
+
+void notify_progress(int size, int flag);
+void do_notify_progress(long long total, int flag);
+void notify_end_and_wait_for_result();
+
+void write_headers(struct file_header *hdr, char *filename);
+
+int write_all_with_crc(int fd, void *buf, int size);
+
+int single_file_processor(char *filename, struct stat *st);
+
+void wait_for_result();
+
+#endif /* _LIBQUBES_QFILE_UTILS_H */
diff --git a/qubes-rpc/qubes.Backup b/qubes-rpc/qubes.Backup
new file mode 100644
index 0000000..6e3f1d4
--- /dev/null
+++ b/qubes-rpc/qubes.Backup
@@ -0,0 +1,23 @@
+echo Starting Backupcopy
+read args
+echo Arguments: $args 
+if [ -d "$args" ] ; then
+  echo "Performing backup to directory $args"
+  TARGET="$args/qubes-backup-`date +'%Y-%d-%d-%H%M%S'`"
+  echo "Copying STDIN data to $TARGET"
+  cat > $TARGET
+else
+  echo "Checking if arguments is matching a command"
+  COMMAND=`echo $args | cut -d ' ' -f 1`
+  TYPE=`type -t $COMMAND`
+  if [ "$TYPE" == "file" ] ; then
+    echo "Redirecting STDIN to $args"
+    # Parsing args to handle quotes correctly
+    # Dangerous method if args are uncontrolled
+    eval "set -- $args"
+    $@
+  else
+    echo "Invalid command $COMMAND"
+    exit 1
+  fi
+fi
diff --git a/qubes-rpc/qubes.Restore b/qubes-rpc/qubes.Restore
new file mode 100644
index 0000000..c77774f
--- /dev/null
+++ b/qubes-rpc/qubes.Restore
@@ -0,0 +1,34 @@
+echo Starting Restorecopy >&2
+read args
+read paths
+echo Arguments: $args >&2
+echo Paths: $paths >&2
+if [ -f "$args" ] ; then
+  echo "Performing restore from backup file $args" >&2
+  TARGET="$args"
+  echo "Copying $TARGET to STDOUT" >&2
+  /usr/lib/qubes/tar2qfile $TARGET $paths
+else
+  echo "Checking if arguments is matching a command" >&2
+  COMMAND=`echo $args | cut -d ' ' -f 1`
+  TYPE=`type -t $COMMAND`
+  if [ "$TYPE" == "file" ] ; then
+    tmpdir=`mktemp -d`
+    mkfifo $tmpdir/backup-data
+    echo "Redirecting $args to STDOUT" >&2
+    # Parsing args to handle quotes correctly
+    # Dangerous method if args are uncontrolled
+    eval "set -- $args"
+    # Use named pipe to pass original stdin to tar2file
+    $@ > $tmpdir/backup-data < /dev/null &
+    retcode=$?
+    /usr/lib/qubes/tar2qfile $tmpdir/backup-data $paths
+    wait
+    rm $tmpdir/backup-data
+    rmdir $tmpdir
+    exit $retcode
+  else
+    echo "Invalid command $COMMAND" >&2
+    exit 2
+  fi
+fi
diff --git a/qubes-rpc/tar2qfile.c b/qubes-rpc/tar2qfile.c
new file mode 100644
index 0000000..eeccc0b
--- /dev/null
+++ b/qubes-rpc/tar2qfile.c
@@ -0,0 +1,1018 @@
+/*	$OpenBSD: tar.h,v 1.7 2003/06/02 23:32:09 millert Exp $	*/
+/*	$NetBSD: tar.h,v 1.3 1995/03/21 09:07:51 cgd Exp $	*/
+
+/*-
+ * Copyright (c) 1992 Keith Muller.
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Keith Muller of the University of California, San Diego.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)tar.h	8.2 (Berkeley) 4/18/94
+ */
+
+#define _GNU_SOURCE /* For O_NOFOLLOW. */
+#include <errno.h>
+#include <ioall.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <qfile-utils.h>
+
+// #define DEBUG
+
+/***************************************************
+ * Most routines extracted from the PAX project (tar.c...) *
+ ***************************************************/
+
+/*
+ * BSD PAX global data structures and constants.
+ */
+
+#define	MAXBLK		64512	/* MAX blocksize supported (posix SPEC) */
+				/* WARNING: increasing MAXBLK past 32256 */
+				/* will violate posix spec. */
+#define	MAXBLK_POSIX	32256	/* MAX blocksize supported as per POSIX */
+#define BLKMULT		512	/* blocksize must be even mult of 512 bytes */
+				/* Don't even think of changing this */
+#define DEVBLK		8192	/* default read blksize for devices */
+#define FILEBLK		10240	/* default read blksize for files */
+#define PAXPATHLEN	3072	/* maximium path length for pax. MUST be */
+
+
+/*
+ * defines and data structures common to all tar formats
+ */
+#define CHK_LEN		8		/* length of checksum field */
+#define TNMSZ		100		/* size of name field */
+#define NULLCNT		2		/* number of null blocks in trailer */
+#define CHK_OFFSET	148		/* start of chksum field */
+#define BLNKSUM		256L		/* sum of checksum field using ' ' */
+
+/*
+ * General Defines
+ */
+#define HEX		16
+#define OCT		8
+#define _PAX_		1
+#define _TFILE_BASE	"paxXXXXXXXXXX"
+
+/*
+ * General Macros
+ */
+#ifndef MIN
+#define	MIN(a,b) (((a)<(b))?(a):(b))
+#endif
+#ifndef MAX
+#define	MAX(a,b) (((a)>(b))?(a):(b))
+#endif
+#define MAJOR(x)	major(x)
+#define MINOR(x)	minor(x)
+#define TODEV(x, y)	makedev((x), (y))
+
+
+/*
+ * Values used in typeflag field in all tar formats
+ * (only REGTYPE, LNKTYPE and SYMTYPE are used in old bsd tar headers)
+ */
+#define	REGTYPE		'0'		/* Regular File */
+#define	AREGTYPE	'\0'		/* Regular File */
+#define	LNKTYPE		'1'		/* Link */
+#define	SYMTYPE		'2'		/* Symlink */
+#define	CHRTYPE		'3'		/* Character Special File */
+#define	BLKTYPE		'4'		/* Block Special File */
+#define	DIRTYPE		'5'		/* Directory */
+#define	FIFOTYPE	'6'		/* FIFO */
+#define	CONTTYPE	'7'		/* high perf file */
+
+/*
+ * GNU tar compatibility;
+ */
+#define	LONGLINKTYPE	'K'		/* Long Symlink */
+#define	LONGNAMETYPE	'L'		/* Long File */
+#define EXTHEADERTYPE	'x'		/* Extended header */
+
+/*
+ * Pad with a bit mask, much faster than doing a mod but only works on powers
+ * of 2. Macro below is for block of 512 bytes.
+ */
+#define TAR_PAD(x)	((512 - ((x) & 511)) & 511)
+
+/*
+ * Data Interchange Format - Extended tar header format - POSIX 1003.1-1990
+ */
+#define TPFSZ		155
+#define	TMAGIC		"ustar"		/* ustar and a null */
+#define	TMAGLEN		6
+#define	TVERSION	"00"		/* 00 and no null */
+#define	TVERSLEN	2
+
+typedef struct {
+	char name[TNMSZ];		/* name of entry */
+	char mode[8]; 			/* mode */
+	char uid[8]; 			/* uid */
+	char gid[8];			/* gid */
+	char size[12];			/* size */
+	char mtime[12];			/* modification time */
+	char chksum[CHK_LEN];		/* checksum */
+	char typeflag;			/* type of file. */
+	char linkname[TNMSZ];		/* linked to name */
+	char magic[TMAGLEN];		/* magic cookie */
+	char version[TVERSLEN];		/* version */
+	char uname[32];			/* ascii owner name */
+	char gname[32];			/* ascii group name */
+	char devmajor[8];		/* major device number */
+	char devminor[8];		/* minor device number */
+	char prefix[TPFSZ];		/* linked to name */
+} HD_USTAR;
+
+
+/*
+ * Routines for manipulating headers, trailers:
+ * asc_ul()
+ * tar_trail()
+ * tar_chksm()
+ * ustar_id()
+ */
+
+static unsigned long tar_chksm (char *, int);
+char *gnu_hack_string;          /* GNU ././@LongLink hackery */
+
+char untrusted_namebuf[MAX_PATH_LENGTH];
+int use_seek = 1;
+extern int ignore_quota_error;
+
+struct filters {
+    int filters_count;
+    char **filters;
+    int *filters_matches;
+    int matched_filters;
+};
+
+
+/*
+ * asc_ul()
+ *	convert hex/octal character string into a u_long. We do not have to
+ *	check for overflow! (the headers in all supported formats are not large
+ *	enough to create an overflow).
+ *	NOTE: strings passed to us are NOT TERMINATED.
+ * Return:
+ *	unsigned long value
+ */
+
+u_long
+asc_ul (char *str, int len, int base)
+{
+  char *stop;
+  u_long tval = 0;
+
+  stop = str + len;
+
+  /*
+   * skip over leading blanks and zeros
+   */
+  while ((str < stop) && ((*str == ' ') || (*str == '0')))
+    ++str;
+
+  /*
+   * for each valid digit, shift running value (tval) over to next digit
+   * and add next digit
+   */
+  if (base == HEX)
+    {
+      while (str < stop)
+	{
+	  if ((*str >= '0') && (*str <= '9'))
+	    tval = (tval << 4) + (*str++ - '0');
+	  else if ((*str >= 'A') && (*str <= 'F'))
+	    tval = (tval << 4) + 10 + (*str++ - 'A');
+	  else if ((*str >= 'a') && (*str <= 'f'))
+	    tval = (tval << 4) + 10 + (*str++ - 'a');
+	  else
+	    break;
+	}
+    }
+  else
+    {
+      while ((str < stop) && (*str >= '0') && (*str <= '7'))
+	tval = (tval << 3) + (*str++ - '0');
+    }
+  return (tval);
+}
+
+
+/*
+ * tar_trail()
+ *	Called to determine if a header block is a valid trailer. We are passed
+ *	the block, the in_sync flag (which tells us we are in resync mode;
+ *	looking for a valid header), and cnt (which starts at zero) which is
+ *	used to count the number of empty blocks we have seen so far.
+ * Return:
+ *	0 if a valid trailer, -1 if not a valid trailer, or 1 if the block
+ *	could never contain a header.
+ */
+
+int
+tar_trail (char *buf,
+	   int in_resync, int *cnt)
+{
+  register int i;
+
+  /*
+   * look for all zero, trailer is two consecutive blocks of zero
+   */
+  for (i = 0; i < BLKMULT; ++i)
+    {
+      if (buf[i] != '\0')
+	break;
+    }
+
+  /*
+   * if not all zero it is not a trailer, but MIGHT be a header.
+   */
+  if (i != BLKMULT)
+    return (-1);
+
+  /*
+   * When given a zero block, we must be careful!
+   * If we are not in resync mode, check for the trailer. Have to watch
+   * out that we do not mis-identify file data as the trailer, so we do
+   * NOT try to id a trailer during resync mode. During resync mode we
+   * might as well throw this block out since a valid header can NEVER be
+   * a block of all 0 (we must have a valid file name).
+   */
+  if (!in_resync && (++*cnt >= NULLCNT))
+    return (0);
+  return (1);
+}
+
+
+/*
+ * tar_chksm()
+ *	calculate the checksum for a tar block counting the checksum field as
+ *	all blanks (BLNKSUM is that value pre-calculated, the sum of 8 blanks).
+ *	NOTE: we use len to short circuit summing 0's on write since we ALWAYS
+ *	pad headers with 0.
+ * Return:
+ *	unsigned long checksum
+ */
+
+static unsigned long
+tar_chksm (char *blk, int len)
+{
+  char *stop;
+  char *pt;
+  unsigned int chksm = BLNKSUM;	/* initial value is checksum field sum */
+
+  /*
+   * add the part of the block before the checksum field
+   */
+  pt = blk;
+  stop = blk + CHK_OFFSET;
+  while (pt < stop)
+    chksm += (*pt++ & 0xff);
+  /*
+   * move past the checksum field and keep going, spec counts the
+   * checksum field as the sum of 8 blanks (which is pre-computed as
+   * BLNKSUM).
+   * ASSUMED: len is greater than CHK_OFFSET. (len is where our 0 padding
+   * starts, no point in summing zero's)
+   */
+  pt += CHK_LEN;
+  stop = blk + len;
+  while (pt < stop)
+    chksm += (*pt++ & 0xff);
+
+  return chksm;
+}
+
+
+/*
+ * ustar_id()
+ *	determine if a block given to us is a valid ustar header. We have to
+ *	be on the lookout for those pesky blocks of all zero's
+ * Return:
+ *	0 if a ustar header, -1 otherwise
+ */
+
+int
+ustar_id (char *blk, size_t size)
+{
+  HD_USTAR *hd;
+
+  if (size < BLKMULT)
+    return (-1);
+  hd = (HD_USTAR *) blk;
+
+  /*
+   * check for block of zero's first, a simple and fast test then check
+   * ustar magic cookie. We should use TMAGLEN, but some USTAR archive
+   * programs are fouled up and create archives missing the \0. Last we
+   * check the checksum. If ok we have to assume it is a valid header.
+   */
+  if (hd->name[0] == '\0')
+    return (-1);
+  if (strncmp (hd->magic, TMAGIC, TMAGLEN - 1) != 0)
+    return (-1);
+  if (asc_ul (hd->chksum, sizeof (hd->chksum), OCT) !=
+      tar_chksm (blk, BLKMULT))
+    return (-1);
+  return (0);
+}
+
+
+/*
+ * Routines for reading tar files
+
+// Source: http://www.mkssoftware.com/docs/man4/pax.4.asp
+struct file_header {	// PAX header is similar as file_header and can be completely ignored
+	unsigned char[100] name;
+	unsigned char[8] mode;
+	unsigned char[8] uid; // unused
+	unsigned char[8] gid; // unused
+	unsigned char[12] size; // 0 if file is a link
+	unsigned char[12] mtime;
+	unsigned char[8] chksum;
+	unsigned char[1] typeflag;
+	unsigned char[100] linkname;
+	unsigned char[6] magic; //ustar
+	unsigned char[2] version; // 00
+	unsigned char[32] uname; // unused
+	unsigned char[32] gname; // unused
+	unsigned char[8] devmajor; // unused ?
+	unsigned char[8] devminor; // unused ?
+	unsigned char[155] prefix;  // only used for files > 100 characters. could be unused ?
+};
+
+enum {
+	TYPE_REGULAR,		//0
+	TYPE_ARCHIVE_LINK,	//1
+	TYPE_SYMLINK,		//2
+	TYPE_CHARACTER_DEVICE,	//3
+	TYPE_BLOCK_DEVICE,	//4
+	TYPE_DIRECTORY,		//5
+	TYPE_FIFO,		//6
+	// Other types:
+	TYPE_EXTENDED_USAGE,	//xxxxx
+	// A-Z are available for custom usage
+};
+
+// Extended attribute:
+// length keyword=value
+// atime, charset, comment, gname, linkpath, mtime, path, size, uname
+
+*/
+
+
+enum {
+	NEED_NOTHING,
+	NEED_SKIP,
+	NEED_SKIP_FILE, // distinguish between skipped file and unwanted blocks (extended headers etc)
+	NEED_READ,
+	NEED_SYNC_TRAIL,
+	INVALID_HEADER,
+	MEMORY_ALLOC_FAILED,
+};
+
+
+/*
+ * ustar_rd()
+ *	extract the values out of block already determined to be a ustar header.
+ *	store the values in the ARCHD parameter.
+ * Return:
+ *	0
+ */
+
+int n_dirs = 0;
+char ** dirs_headers_sent = NULL;
+
+int
+ustar_rd (int fd, struct file_header * untrusted_hdr, char *buf, struct stat * sb, struct filters *filters)
+{
+
+  register HD_USTAR *hd;
+  register char *dest;
+  register int cnt = 0;
+  int ret;
+  int i;
+  int should_extract;
+  /* DISABLED: unused
+  dev_t devmajor;
+  dev_t devminor;
+  */
+
+  /*
+   * we only get proper sized buffers
+   */
+#ifdef DEBUG
+  fprintf(stderr,"Checking if valid header\n");
+#endif
+  if (ustar_id (buf, BLKMULT) < 0) {
+#ifdef DEBUG
+    fprintf (stderr, "Invalid header\n");
+#endif
+    return INVALID_HEADER;
+  }
+#ifdef DEBUG
+  fprintf(stderr,"Valid header!\n");
+#endif
+  /* DISABLED: Internal to PAX
+  arcn->org_name = arcn->name;
+  arcn->sb.st_nlink = 1;
+  arcn->pat = NULL;
+  arcn->nlen = 0;
+  */
+  untrusted_hdr->namelen = 0;
+
+  hd = (HD_USTAR *) buf;
+
+  /*
+   * see if the filename is split into two parts. if, so joint the parts.
+   * we copy the prefix first and add a / between the prefix and name.
+   */
+  dest = untrusted_namebuf;
+  if (*(hd->prefix) != '\0')
+    {
+      cnt = strlen(strncpy (dest, hd->prefix,
+		     MIN(sizeof (untrusted_namebuf) - 1,TPFSZ+1)));
+      dest += cnt;
+      *dest++ = '/';
+      cnt++;
+    }
+  if (gnu_hack_string)
+    {
+      untrusted_hdr->namelen = cnt + strlen(strncpy (dest, gnu_hack_string,
+				  MIN(TNMSZ+1, sizeof (untrusted_namebuf) - cnt)));
+      free(gnu_hack_string);
+      gnu_hack_string = NULL;
+    } else
+      untrusted_hdr->namelen = cnt + strlen(strncpy (dest, hd->name,
+				  MIN(TNMSZ+1, sizeof (untrusted_namebuf) - cnt)));
+
+  // qfile count the \0 in the namelen
+  untrusted_hdr->namelen += 1;
+
+#ifdef DEBUG
+  fprintf(stderr,"Retrieved name len: %d\n",untrusted_hdr->namelen);
+  fprintf(stderr,"Retrieved name: %s\n",untrusted_namebuf);
+#endif
+
+  /*
+   * follow the spec to the letter. we should only have mode bits, strip
+   * off all other crud we may be passed.
+   */
+  sb->st_mode = (mode_t) (asc_ul (hd->mode, sizeof (hd->mode), OCT) &
+			       0xfff);
+  untrusted_hdr->mode = sb->st_mode;
+
+  #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
+  sb->st_size = (off_t) asc_uqd (hd->size, sizeof (hd->size), OCT);
+  #else
+  sb->st_size = (off_t) asc_ul (hd->size, sizeof (hd->size), OCT);
+  #endif
+
+  untrusted_hdr->filelen = sb->st_size;
+  untrusted_hdr->atime = (time_t) asc_ul (hd->mtime, sizeof (hd->mtime), OCT);
+  untrusted_hdr->mtime = untrusted_hdr->atime;
+  untrusted_hdr->atime_nsec = untrusted_hdr->mtime_nsec = 0;
+
+  sb->st_mtime = (time_t) asc_ul (hd->mtime, sizeof (hd->mtime), OCT);
+  sb->st_ctime = sb->st_atime = sb->st_mtime;
+
+
+  /*
+   * If we can find the ascii names for gname and uname in the password
+   * and group files we will use the uid's and gid they bind. Otherwise
+   * we use the uid and gid values stored in the header. (This is what
+   * the posix spec wants).
+   */
+  /* DISABLED: unused
+  hd->gname[sizeof (hd->gname) - 1] = '\0';
+  if (gid_name (hd->gname, &(arcn->sb.st_gid)) < 0)
+    arcn->sb.st_gid = (gid_t) asc_ul (hd->gid, sizeof (hd->gid), OCT);
+  hd->uname[sizeof (hd->uname) - 1] = '\0';
+  if (uid_name (hd->uname, &(arcn->sb.st_uid)) < 0)
+    arcn->sb.st_uid = (uid_t) asc_ul (hd->uid, sizeof (hd->uid), OCT);
+  */
+
+  /*
+   * set the defaults, these may be changed depending on the file type
+   */
+  /* Disabled: pax specific
+  arcn->ln_name[0] = '\0';
+  arcn->ln_nlen = 0;
+  arcn->pad = 0;
+  arcn->skip = 0;
+  arcn->sb.st_rdev = (dev_t) 0;
+  */
+
+
+  /*
+   * set the mode and PAX type according to the typeflag in the header
+   */
+  switch (hd->typeflag)
+    {
+    case FIFOTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is FIFOTYPE\n");
+#endif
+      /* DISABLED: unused
+      arcn->type = PAX_FIF;
+      arcn->sb.st_mode |= S_IFIFO;
+      */
+      break;
+    case DIRTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is DIRTYPE\n");
+#endif
+      /* DISABLED: unused
+      arcn->type = PAX_DIR;
+      arcn->sb.st_mode |= S_IFDIR;
+      arcn->sb.st_nlink = 2;
+      */
+      /*
+       * Some programs that create ustar archives append a '/'
+       * to the pathname for directories. This clearly violates
+       * ustar specs, but we will silently strip it off anyway.
+       */
+/*
+      if (arcn->name[arcn->nlen - 1] == '/')
+	arcn->name[--arcn->nlen] = '\0';
+*/
+      break;
+    case BLKTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is BLKTYPE\n");
+#endif
+	break;
+    case CHRTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is CHRTYPE\n");
+#endif
+      /*
+       * this type requires the rdev field to be set.
+       */
+      if (hd->typeflag == BLKTYPE)
+	{
+/*
+	  arcn->type = PAX_BLK;
+	  arcn->sb.st_mode |= S_IFBLK;
+*/
+	}
+      else
+	{
+/*
+	  arcn->type = PAX_CHR;
+	  arcn->sb.st_mode |= S_IFCHR;
+*/
+	}
+      /* DISABLED: unused
+      devmajor = (dev_t) asc_ul (hd->devmajor, sizeof (hd->devmajor), OCT);
+      devminor = (dev_t) asc_ul (hd->devminor, sizeof (hd->devminor), OCT);
+      */
+//      arcn->sb.st_rdev = TODEV (devmajor, devminor);
+      break;
+    case SYMTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is SYMTYPE\n");
+#endif
+	break;
+    case LNKTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is LNKTYPE\n");
+#endif
+      if (hd->typeflag == SYMTYPE)
+	{
+//	  arcn->type = PAX_SLK;
+//	  arcn->sb.st_mode |= S_IFLNK;
+	}
+      else
+	{
+//	  arcn->type = PAX_HLK;
+	  /*
+	   * so printing looks better
+	   */
+//	  arcn->sb.st_mode |= S_IFREG;
+//	  arcn->sb.st_nlink = 2;
+	}
+      /*
+       * copy the link name
+       */
+//      arcn->ln_nlen = strlcpy (arcn->ln_name, hd->linkname,
+//			       MIN(TNMSZ+1,sizeof (arcn->ln_name)));
+      break;
+    case LONGLINKTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is LONGLINKTYPE\n");
+#endif
+	break;
+    case LONGNAMETYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is LONGNAMETYPE\n");
+#endif
+      /*
+       * GNU long link/file; we tag these here and let the
+       * pax internals deal with it -- too ugly otherwise.
+       */
+//      arcn->type =
+//	hd->typeflag == LONGLINKTYPE ? PAX_GLL : PAX_GLF;
+//      arcn->pad = TAR_PAD(arcn->sb.st_size);
+//      arcn->skip = arcn->sb.st_size;
+//      arcn->ln_name[0] = '\0';
+//      arcn->ln_nlen = 0;
+      break;
+    case CONTTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is CONTTYPE\n");
+#endif
+	break;
+    case AREGTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is AREGTYPE\n");
+#endif
+	break;
+    case REGTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"File is REGTYPE of size %ld\n",sb->st_size);
+#endif
+
+	// Check if user want to extract this file
+	should_extract = 1;
+	for (i=0; i < filters->filters_count; i++) {
+		should_extract = 0;
+#ifdef DEBUG
+		fprintf(stderr, "Comparing with filter %s\n", filters->filters[i]);
+#endif
+		if (strncmp(untrusted_namebuf, filters->filters[i], strlen(filters->filters[i])) == 0) {
+#ifdef DEBUG
+			fprintf(stderr, "Match (%d)\n", filters->filters_matches[i]);
+#endif
+			should_extract = 1;
+			filters->filters_matches[i]++;
+			if (filters->filters_matches[i] == 1) {
+			    // first match
+			    filters->matched_filters++;
+			}
+			break;
+		}
+	}
+	if (should_extract != 1) {
+#ifdef DEBUG
+		fprintf(stderr, "File should be filtered.. Skipping\n");
+#endif
+		return NEED_SKIP_FILE;
+	}
+
+        // Create a copy of untrusted_namebuf to be used for strtok
+	char * dirbuf;
+	dirbuf = malloc(sizeof (char) * (untrusted_hdr->namelen));
+	if (dirbuf == NULL)
+		return MEMORY_ALLOC_FAILED;
+	dirbuf = strncpy(dirbuf, untrusted_namebuf, untrusted_hdr->namelen);
+
+	int i = 0;
+	int dir_found = 0;
+	size_t pathsize = 0;
+	char * path = NULL;
+	struct file_header dir_header;
+
+        // Split the path in directories and recompose it incrementally
+	char * last_token = strtok(dirbuf,"/");
+	char * token = strtok(NULL, "/");
+	while (token != NULL) {
+		
+#ifdef DEBUG
+		fprintf(stderr,"Found directory %s (last:%s)\n",token,last_token);
+#endif
+
+		// Recompose the path based on last discovered directory
+		if (path == NULL) {
+			path = malloc(sizeof (char) * (strlen(last_token)+1));
+			if (path == NULL)
+				return MEMORY_ALLOC_FAILED;
+			path = strncpy(path, last_token, strlen(last_token));
+			path[strlen(last_token)] = '\0';
+		} else {
+			pathsize = strlen(path);
+			path = realloc(path, sizeof (char) * (strlen(path)+1+strlen(last_token)+1));
+			if (path == NULL)
+				return MEMORY_ALLOC_FAILED;
+			path[pathsize] = '/';
+			
+			strncpy(path+pathsize+1, last_token, strlen(last_token));
+			path[pathsize+strlen(last_token)+1] = '\0';
+		}
+#ifdef DEBUG
+		fprintf(stderr,"Path is %s\n",path);
+#endif
+
+#ifdef DEBUG
+		fprintf(stderr,"Checking from i=0 i<%d\n",n_dirs);
+#endif
+		// Verify if qfile headers for the current path have already been sent based on the dirs_headers_sent table
+		dir_found = 0;
+		for (i = 0; i < n_dirs; ++i) {
+#ifdef DEBUG
+			fprintf(stderr,"Comparing with %d %d %s %s\n",i,n_dirs,dirs_headers_sent[i],path);
+#endif
+			if (strcmp(dirs_headers_sent[i],path)==0) {
+#ifdef DEBUG
+				fprintf(stderr,"Directory headers already sent\n");
+#endif
+				dir_found=1;
+			}
+		}
+		if (dir_found == 0) {
+                        // Register the current path as being sent in the dirs_headers_sent table
+#ifdef DEBUG
+			fprintf(stderr,"Inserting %s into register\n",path);
+#endif
+			dirs_headers_sent = realloc(dirs_headers_sent, sizeof (char*) * n_dirs++);
+			if (dirs_headers_sent == NULL)
+				return MEMORY_ALLOC_FAILED;
+			dirs_headers_sent[n_dirs-1] = malloc(sizeof (char) * (strlen(path)+1));
+			if (dirs_headers_sent[n_dirs-1] == NULL)
+				return MEMORY_ALLOC_FAILED;
+			strncpy(dirs_headers_sent[n_dirs-1], path, strlen(path)+1);
+
+                        // Initialize the qfile headers for the current directory path
+			dir_header.namelen = strlen(path)+1;
+			dir_header.atime = untrusted_hdr->atime;
+			dir_header.atime_nsec = untrusted_hdr->atime_nsec;
+			dir_header.mtime = untrusted_hdr->mtime;
+			dir_header.mtime_nsec = untrusted_hdr->mtime_nsec;
+
+			dir_header.mode = untrusted_hdr->mode | S_IFDIR;
+			dir_header.filelen = 0;
+		
+#ifdef DEBUG
+			fprintf(stderr,"Sending directory headers for %s\n",path);
+#endif
+                        // Send the qfile headers for the current directory path
+			write_headers(&dir_header, path);
+		}
+		last_token = token;
+		token = strtok(NULL, "/");
+	}
+	free(path);
+	free(dirbuf);
+	
+#ifdef DEBUG
+	fprintf(stderr,"End of directory checks\n");
+#endif
+
+	// Restore POSIX stat file mode (because PAX format use its own file type)
+	untrusted_hdr->mode |= S_IFREG;
+#ifdef DEBUG
+	fprintf(stderr,"Writing file header\n");
+#endif
+        // Send header and file content
+	write_headers(untrusted_hdr, untrusted_namebuf);
+#ifdef DEBUG
+	fprintf(stderr,"Writing file content\n");
+#endif
+	ret = copy_file(1, fd, untrusted_hdr->filelen, &crc32_sum);
+
+#ifdef DEBUG
+	fprintf(stderr,"Copyfile returned with error %d\n",ret);
+#endif
+	if (ret != COPY_FILE_OK) {
+		if (ret != COPY_FILE_WRITE_ERROR)
+			gui_fatal("Copying file %s: %s", untrusted_namebuf,
+				  copy_file_status_to_str(ret));
+		else {
+			fprintf(stderr,"UNKNOWN ERROR RETURN STATUS:%d\n.. Waiting...\n",ret);
+			set_block(0);
+			wait_for_result();
+			exit(1);
+		}
+	}
+	// Extract extra padding
+#ifdef DEBUG
+	fprintf(stderr,"Need to remove pad:%lld %lld\n",untrusted_hdr->filelen,BLKMULT-(untrusted_hdr->filelen%BLKMULT));
+#endif
+	if (untrusted_hdr->filelen%BLKMULT > 0) {
+		if (!read_all(fd, buf, BLKMULT-(untrusted_hdr->filelen%BLKMULT))) {
+			wait_for_result();
+			exit(1);
+		}
+	}
+
+	// Resync trailing headers in order to find next file chunck in the tar file
+	return NEED_SYNC_TRAIL;
+
+	break;
+    case EXTHEADERTYPE:
+#ifdef DEBUG
+	fprintf(stderr,"Extended HEADER encountered\n");
+#endif
+
+	return NEED_SKIP;
+	break;
+    default:
+#ifdef DEBUG
+	fprintf(stderr,"Default type detected:%c\n",hd->typeflag);
+#endif
+	return NEED_SKIP;
+      /*
+       * these types have file data that follows. Set the skip and
+       * pad fields.
+       */
+//      arcn->type = PAX_REG;
+//      arcn->pad = TAR_PAD (arcn->sb.st_size);
+//      arcn->skip = arcn->sb.st_size;
+//      arcn->sb.st_mode |= S_IFREG;
+      break;
+    }
+  return NEED_SKIP;
+}
+
+
+
+void tar_file_processor(int fd, struct filters *filters)
+{
+	int ret;
+	int i;
+	int current;
+
+	struct file_header hdr;
+	struct stat sb;			/* stat buffer see stat(2) */
+
+	char buf[BLKMULT+1];
+
+	i=0;
+	current = NEED_READ;
+	size_t to_skip = 0;
+	int sync_count = 0;
+	while (read_all(fd, buf, BLKMULT)) {
+		ret = 0;
+		if (current==NEED_SYNC_TRAIL) {
+			ret = tar_trail (buf, 1, &sync_count);
+#ifdef DEBUG
+			fprintf(stderr,"Synchronizing trail: %d %d\n", ret, sync_count);
+#endif
+			if (ret != 1) {
+				current = NEED_READ;
+				sync_count = 0;
+			}
+		}
+		if (current==NEED_READ) {
+			current = ustar_rd(fd, &hdr, buf, &sb, filters);
+#ifdef DEBUG
+			fprintf(stderr,"Return %d\n", current);
+#endif
+		}
+		if (current==NEED_SKIP || current==NEED_SKIP_FILE) {
+			if (current==NEED_SKIP_FILE &&
+				filters->filters_count > 0 &&
+				filters->filters_count == filters->matched_filters) {
+				// This assume that either:
+				//  a) files are sorted (using full path as sort key)
+				//  b) all the directory content is in
+				//     consecutive block and only directories
+				//      are given as filters
+				// This is true for backups prepared by qvm-backup
+#ifdef DEBUG
+				fprintf(stderr, "All filters matched at least once - assuming end of requested data\n");
+#endif
+				return;
+			}
+			to_skip = hdr.filelen;
+#ifdef DEBUG
+			fprintf(stderr,"Need to skip %lld bytes (matched filters %d < %d)\n",
+				hdr.filelen, filters->matched_filters, filters->filters_count);
+			fprintf(stderr,"Need to remove pad:%ld %lld %lld\n",to_skip,hdr.filelen,BLKMULT-(hdr.filelen%BLKMULT));
+#endif
+			if (to_skip%BLKMULT > 0) {
+				to_skip += BLKMULT-(to_skip%BLKMULT);
+			}
+			if (use_seek) {
+				ret = lseek(fd, to_skip, SEEK_CUR);
+				if (ret < 0) {
+					if (errno == ESPIPE) {
+						// fallback to read()
+						use_seek = 0;
+					} else {
+						perror("lseek");
+						exit(1);
+					}
+				}
+			}
+			// not using "else" because above can fallback to read() method
+			if (!use_seek) {
+				while (to_skip > 0) {
+					ret = read_all(fd, &buf, MIN(to_skip,BLKMULT));
+					if (ret <= 0) {
+						exit(1);
+					}
+					to_skip -= MIN(to_skip,BLKMULT);
+				}
+			}
+
+			current = NEED_SYNC_TRAIL;
+		}
+		i++;
+		//if (i >= 10)
+		//	exit(0);
+	}
+
+}
+
+int main(int argc, char **argv)
+{
+	int i;
+	char *entry;
+	int fd;
+	int use_stdin = 1;
+	struct filters filters;
+
+	signal(SIGPIPE, SIG_IGN);
+	// this will allow checking for possible feedback packet in the middle of transfer
+	// if disabled, the copy_file process could hang
+	notify_progress(0, PROGRESS_FLAG_INIT);
+	//set_size_limit(1500000000, 2048);
+
+	crc32_sum = 0;
+	/* when extracting backup header, dom0 will terminate the transfer with
+	 * EDQUOT just after getting qubes.xml */
+	ignore_quota_error = 1;
+	for (i = 1; i < argc; i++) {
+		set_nonblock(0);
+		if (strcmp(argv[i], "--ignore-symlinks")==0) {
+			ignore_symlinks = 1;
+			continue;
+		} else if (strcmp(argv[i], "-")==0) {
+			use_stdin = 1;
+			i++;
+			break;
+		} else {
+			// Parse tar file
+			use_stdin = 0;
+			entry = argv[i];
+#ifdef DEBUG
+			fprintf(stderr,"Parsing file %s\n",entry);
+#endif
+
+			fd = open(entry, O_RDONLY);
+			if (fd < 0) {
+				fprintf(stderr,"Error opening file %s\n",entry);
+				exit(2);
+			}
+			i++;
+			break;
+		}
+	}
+	filters.filters_count = argc-i;
+	filters.filters = argv+i;
+	filters.filters_matches = calloc(filters.filters_count, sizeof(int));
+	if (filters.filters_matches == NULL) {
+	    perror("calloc");
+	    exit(1);
+	}
+	filters.matched_filters = 0;
+
+	if (use_stdin == 1) {
+#ifdef DEBUG
+		fprintf(stderr,"Using STDIN\n");
+#endif
+		set_block(0);
+		fd = 0;
+	}
+	tar_file_processor(fd, &filters);
+
+
+	notify_end_and_wait_for_result();
+	notify_progress(0, PROGRESS_FLAG_DONE);
+	return 0;
+}
+
+
diff --git a/rpm_spec/core-vm.spec b/rpm_spec/core-vm.spec
index 563aa15..567f481 100644
--- a/rpm_spec/core-vm.spec
+++ b/rpm_spec/core-vm.spec
@@ -277,6 +277,8 @@ rm -f %{name}-%{version}
 /etc/qubes-rpc/qubes.SuspendPost
 /etc/qubes-rpc/qubes.WaitForSession
 /etc/qubes-rpc/qubes.DetachPciDevice
+/etc/qubes-rpc/qubes.Backup
+/etc/qubes-rpc/qubes.Restore
 /etc/sudoers.d/qubes
 %config(noreplace) /etc/sysconfig/iptables
 %config(noreplace) /etc/sysconfig/ip6tables
@@ -322,6 +324,7 @@ rm -f %{name}-%{version}
 /usr/lib/qubes/qvm-copy-to-vm.kde
 /usr/lib/qubes/serial.conf
 /usr/lib/qubes/setup-ip
+/usr/lib/qubes/tar2qfile
 /usr/lib/qubes/vm-file-editor
 /usr/lib/qubes/wrap-in-html-if-url.sh
 /usr/lib/qubes/iptables-yum-proxy