X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=d41bb4b0bb924e02b4d0b70f9021d77a08285242;hp=cc48747331dc6f3c6d161583499f5ca2d9ce5524;hb=f583f0cf35fc227db5f73ecd04daf7702735b740;hpb=ed8a3ad086e56fa40c72c531b3f563e35a7c0753

diff --git a/discover/device-handler.c b/discover/device-handler.c
index cc48747..d41bb4b 100644
--- a/discover/device-handler.c
+++ b/discover/device-handler.c
@@ -1,4 +1,5 @@
 #include <assert.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <unistd.h>
@@ -18,7 +19,9 @@
 #include <process/process.h>
 #include <url/url.h>
 #include <i18n/i18n.h>
+#include <pb-config/pb-config.h>
 
+#include <sys/sysmacros.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>
@@ -40,12 +43,30 @@
 #include "ipmi.h"
 
 enum default_priority {
-	DEFAULT_PRIORITY_REMOTE		= 1,
-	DEFAULT_PRIORITY_LOCAL_FIRST	= 2,
+	DEFAULT_PRIORITY_TEMP_USER	= 1,
+	DEFAULT_PRIORITY_REMOTE		= 2,
+	DEFAULT_PRIORITY_LOCAL_FIRST	= 3,
 	DEFAULT_PRIORITY_LOCAL_LAST	= 0xfe,
 	DEFAULT_PRIORITY_DISABLED	= 0xff,
 };
 
+static int default_rescan_timeout = 5 * 60; /* seconds */
+
+struct progress_info {
+	unsigned int			percentage;
+	unsigned long			size;		/* size in bytes */
+
+	const struct process_info	*procinfo;
+	struct list_item	list;
+};
+
+struct crypt_info {
+	struct discover_device	*source_device;
+	char			*dm_name;
+
+	struct list_item	list;
+};
+
 struct device_handler {
 	struct discover_server	*server;
 	int			dry_run;
@@ -64,14 +85,25 @@ struct device_handler {
 	struct waiter		*timeout_waiter;
 	bool			autoboot_enabled;
 	unsigned int		sec_to_boot;
+	struct autoboot_option	*temp_autoboot;
 
 	struct discover_boot_option *default_boot_option;
+	struct discover_boot_option *last_boot_option;
 	int			default_boot_option_priority;
 
 	struct list		unresolved_boot_options;
 
 	struct boot_task	*pending_boot;
 	bool			pending_boot_is_default;
+
+	struct list		progress;
+	unsigned int		n_progress;
+
+	struct plugin_option	**plugins;
+	unsigned int		n_plugins;
+	bool			plugin_installing;
+
+	struct list		crypt_devices;
 };
 
 static int mount_device(struct discover_device *dev);
@@ -114,6 +146,34 @@ const struct discover_device *device_handler_get_device(
 	return handler->devices[index];
 }
 
+/**
+ * device_handler_get_plugin_count - Get the count of current handler plugins.
+ */
+int device_handler_get_plugin_count(const struct device_handler *handler)
+{
+	return handler->n_plugins;
+}
+
+/**
+ * discover_handler_get_plugin - Get a handler plugin by index.
+ */
+const struct plugin_option *device_handler_get_plugin(
+	const struct device_handler *handler, unsigned int index)
+{
+	if (index >= handler->n_plugins) {
+		assert(0 && "bad index");
+		return NULL;
+	}
+
+	return handler->plugins[index];
+}
+
+struct network *device_handler_get_network(
+		const struct device_handler *handler)
+{
+	return handler->network;
+}
+
 struct discover_boot_option *discover_boot_option_create(
 		struct discover_context *ctx,
 		struct discover_device *device)
@@ -214,24 +274,50 @@ void device_handler_destroy(struct device_handler *handler)
 static int destroy_device(void *arg)
 {
 	struct discover_device *dev = arg;
+	struct process *p;
 
 	umount_device(dev);
 
+	devmapper_destroy_snapshot(dev);
+
+	if (dev->crypt_device) {
+		const char *argv[] = {
+			pb_system_apps.cryptsetup,
+			"luksClose",
+			dev->device->id,
+			NULL
+		};
+
+		p = process_create(dev);
+		p->path = pb_system_apps.cryptsetup;
+		p->argv = argv;
+
+		if (process_run_async(p)) {
+			pb_log("Failed to run cryptsetup\n");
+			return -1;
+		}
+	}
+
 	return 0;
 }
 
 struct discover_device *discover_device_create(struct device_handler *handler,
-		const char *id)
+		const char *uuid, const char *id)
 {
 	struct discover_device *dev;
 
-	dev = device_lookup_by_id(handler, id);
+	if (uuid)
+		dev = device_lookup_by_uuid(handler, uuid);
+	else
+		dev = device_lookup_by_id(handler, id);
+
 	if (dev)
 		return dev;
 
 	dev = talloc_zero(handler, struct discover_device);
 	dev->device = talloc_zero(dev, struct device);
 	dev->device->id = talloc_strdup(dev->device, id);
+	dev->uuid = talloc_strdup(dev, uuid);
 	list_init(&dev->params);
 	list_init(&dev->boot_options);
 
@@ -289,6 +375,22 @@ const char *discover_device_get_param(struct discover_device *device,
 	return NULL;
 }
 
+static void set_env_variables(const struct config *config)
+{
+	if (config->http_proxy)
+		setenv("http_proxy", config->http_proxy, 1);
+	else
+		unsetenv("http_proxy");
+
+	if (config->https_proxy)
+		setenv("https_proxy", config->https_proxy, 1);
+	else
+		unsetenv("https_proxy");
+
+	/* Reduce noise in the log from LVM listing open file descriptors */
+	setenv("LVM_SUPPRESS_FD_WARNINGS", "1", 1);
+}
+
 struct device_handler *device_handler_init(struct discover_server *server,
 		struct waitset *waitset, int dry_run)
 {
@@ -299,10 +401,13 @@ struct device_handler *device_handler_init(struct discover_server *server,
 	handler->server = server;
 	handler->waitset = waitset;
 	handler->dry_run = dry_run;
-	handler->autoboot_enabled = config_get()->autoboot_enabled;
+	handler->autoboot_enabled = config_autoboot_active(config_get());
 
 	list_init(&handler->unresolved_boot_options);
 
+	list_init(&handler->progress);
+	list_init(&handler->crypt_devices);
+
 	/* set up our mount point base */
 	pb_mkdir_recursive(mount_base());
 
@@ -311,6 +416,8 @@ struct device_handler *device_handler_init(struct discover_server *server,
 	if (config_get()->safe_mode)
 		return handler;
 
+	set_env_variables(config_get());
+
 	rc = device_handler_init_sources(handler);
 	if (rc) {
 		talloc_free(handler);
@@ -323,10 +430,22 @@ struct device_handler *device_handler_init(struct discover_server *server,
 void device_handler_reinit(struct device_handler *handler)
 {
 	struct discover_boot_option *opt, *tmp;
+	struct crypt_info *crypt, *c;
 	struct ramdisk_device *ramdisk;
+	struct config *config;
 	unsigned int i;
 
 	device_handler_cancel_default(handler);
+	/* Cancel any pending non-default boot */
+	if (handler->pending_boot) {
+		boot_cancel(handler->pending_boot);
+		handler->pending_boot = NULL;
+		handler->pending_boot_is_default = false;
+	}
+
+	/* Cancel any remaining async jobs */
+	process_stop_async_all();
+	pending_network_jobs_cancel();
 
 	/* free unresolved boot options */
 	list_for_each_entry_safe(&handler->unresolved_boot_options,
@@ -336,10 +455,13 @@ void device_handler_reinit(struct device_handler *handler)
 
 	/* drop all devices */
 	for (i = 0; i < handler->n_devices; i++) {
+		struct discover_device *device = handler->devices[i];
 		discover_server_notify_device_remove(handler->server,
-				handler->devices[i]->device);
-		ramdisk = handler->devices[i]->ramdisk;
-		talloc_free(handler->devices[i]);
+				device->device);
+		ramdisk = device->ramdisk;
+		if (device->requery_waiter)
+			waiter_remove(device->requery_waiter);
+		talloc_free(device);
 		talloc_free(ramdisk);
 	}
 
@@ -350,6 +472,33 @@ void device_handler_reinit(struct device_handler *handler)
 	handler->ramdisks = NULL;
 	handler->n_ramdisks = 0;
 
+	/* drop any known plugins */
+	for (i = 0; i < handler->n_plugins; i++)
+		talloc_free(handler->plugins[i]);
+	talloc_free(handler->plugins);
+	handler->plugins = NULL;
+	handler->n_plugins = 0;
+
+	discover_server_notify_plugins_remove(handler->server);
+
+	/* forget encrypted devices */
+	list_for_each_entry_safe(&handler->crypt_devices, crypt, c, list)
+		talloc_free(crypt);
+	list_init(&handler->crypt_devices);
+
+	set_env_variables(config_get());
+
+	/* If the safe mode warning was active disable it now */
+	if (config_get()->safe_mode) {
+		config = config_copy(handler, config_get());
+		config->safe_mode = false;
+		config_set(config);
+		discover_server_notify_config(handler->server, config);
+	}
+
+	/* Force rediscovery on SCSI devices */
+	process_run_simple(handler, pb_system_apps.scsi_rescan, NULL);
+
 	device_handler_reinit_sources(handler);
 }
 
@@ -359,6 +508,18 @@ void device_handler_remove(struct device_handler *handler,
 	struct discover_boot_option *opt, *tmp;
 	unsigned int i;
 
+	if (device->requery_waiter)
+		waiter_remove(device->requery_waiter);
+
+	list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
+		if (opt == handler->default_boot_option) {
+			pb_log("Default option %s cancelled since device removed",
+					opt->option->name);
+			device_handler_cancel_default(handler);
+			break;
+		}
+	}
+
 	for (i = 0; i < handler->n_devices; i++)
 		if (handler->devices[i] == device)
 			break;
@@ -396,25 +557,226 @@ void device_handler_remove(struct device_handler *handler,
 	talloc_free(device);
 }
 
-static void boot_status(void *arg, struct boot_status *status)
+void device_handler_status(struct device_handler *handler,
+		struct status *status)
+{
+	pb_debug("%s: %s\n", __func__, status->message);
+	discover_server_notify_boot_status(handler->server, status);
+}
+
+static void _device_handler_vstatus(struct device_handler *handler,
+		enum status_type type, const char *fmt, va_list ap)
+{
+	struct status status;
+
+	status.type = type;
+	status.message = talloc_vasprintf(handler, fmt, ap);
+	status.backlog = false;
+	status.boot_active = false;
+
+	device_handler_status(handler, &status);
+
+	talloc_free(status.message);
+}
+
+static void _device_handler_vdevstatus(struct device_handler *handler,
+		struct discover_device *device, enum status_type type,
+		const char *fmt, va_list ap)
+{
+	char *msg;
+
+	msg = talloc_asprintf(handler, "[%s] %s",
+			device ? device->device->id : "unknown", fmt);
+	_device_handler_vstatus(handler, type, msg, ap);
+	talloc_free(msg);
+}
+
+void device_handler_status_dev_info(struct device_handler *handler,
+		struct discover_device *dev, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	_device_handler_vdevstatus(handler, dev, STATUS_INFO, fmt, ap);
+	va_end(ap);
+}
+
+void device_handler_status_dev_err(struct device_handler *handler,
+		struct discover_device *dev, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	_device_handler_vdevstatus(handler, dev, STATUS_ERROR, fmt, ap);
+	va_end(ap);
+}
+
+void device_handler_status_info(struct device_handler *handler,
+		const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	_device_handler_vstatus(handler, STATUS_INFO, fmt, ap);
+	va_end(ap);
+}
+
+void device_handler_status_err(struct device_handler *handler,
+		const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	_device_handler_vstatus(handler, STATUS_ERROR, fmt, ap);
+	va_end(ap);
+}
+
+void device_handler_status_download(struct device_handler *handler,
+		const struct process_info *procinfo,
+		unsigned int percentage, unsigned int size, char suffix)
+{
+	struct progress_info *p, *progress = NULL;
+	uint64_t current_converted, current = 0;
+	const char *units = " kMGTP";
+	unsigned long size_bytes;
+	char *update = NULL;
+	double total = 0;
+	unsigned int i;
+	int unit = 0;
+
+	list_for_each_entry(&handler->progress, p, list)
+		if (p->procinfo == procinfo)
+			progress = p;
+
+	if (!progress) {
+		pb_log("Registering new progress struct\n");
+		progress = talloc_zero(handler, struct progress_info);
+		if (!progress) {
+			pb_log("Failed to allocate room for progress struct\n");
+			return;
+		}
+		progress->procinfo = procinfo;
+		list_add(&handler->progress, &progress->list);
+		handler->n_progress++;
+	}
+
+	size_bytes = size;
+	for (i = 0; i < strlen(units); i++) {
+		if (units[i] == suffix)
+			break;
+	}
+
+	if (i >= strlen(units)) {
+	    pb_log("Couldn't recognise suffix '%c'\n", suffix);
+	    size_bytes = 0;
+	} else {
+		while (i--)
+			size_bytes <<= 10;
+	}
+
+	progress->percentage = percentage;
+	progress->size = size_bytes;
+
+	/*
+	 * Aggregate the info we have and update status. If a progress struct
+	 * has zero for both percentage and size we assume progress information
+	 * is unavailable and fall back to a generic progress message.
+	 */
+	list_for_each_entry(&handler->progress, p, list) {
+		uint64_t c;
+		double t;
+		if (!p->percentage || !p->size) {
+			update = talloc_asprintf(handler,
+					_("%u downloads in progress..."),
+					handler->n_progress);
+			current = total = 0;
+			break;
+		}
+
+		c = p->size;
+		t = (100 * c) / p->percentage;
+
+		current += c;
+		total += t;
+	}
+
+	if (total) {
+		current_converted = current;
+		while (current_converted >= 1000) {
+			current_converted >>= 10;
+			unit++;
+		}
+		update = talloc_asprintf(handler,
+				_("%u %s downloading: %.0f%% - %" PRIu64 "%cB"),
+				handler->n_progress,
+				ngettext("item", "items", handler->n_progress),
+				(current / total) * 100, current_converted,
+				units[unit]);
+	}
+
+	if (!update) {
+		pb_log_fn("failed to allocate new status\n");
+	} else {
+		device_handler_status_info(handler, "%s\n", update);
+		talloc_free(update);
+	}
+}
+
+static void device_handler_plugin_scan_device(struct device_handler *handler,
+		struct discover_device *dev)
+{
+	int rc;
+
+	pb_debug("Scanning %s for plugin files\n", dev->device->id);
+
+	rc = process_run_simple(handler, pb_system_apps.pb_plugin,
+				"scan", dev->mount_path,
+				NULL);
+	if (rc)
+		pb_log("Error from pb-plugin scan %s\n",
+				dev->mount_path);
+}
+
+void device_handler_status_download_remove(struct device_handler *handler,
+		struct process_info *procinfo)
+{
+	struct progress_info *p, *tmp;
+
+	list_for_each_entry_safe(&handler->progress, p, tmp, list)
+		if (p->procinfo == procinfo) {
+			list_remove(&p->list);
+			talloc_free(p);
+			handler->n_progress--;
+		}
+}
+
+static void device_handler_boot_status_cb(void *arg, struct status *status)
 {
 	struct device_handler *handler = arg;
 
-	discover_server_notify_boot_status(handler->server, status);
+	/* boot had failed; update handler state to allow a new default if one
+	 * is found later
+	 */
+	if (status->type == STATUS_ERROR) {
+		handler->pending_boot = NULL;
+		handler->default_boot_option = NULL;
+	}
+
+	device_handler_status(handler, status);
 }
 
 static void countdown_status(struct device_handler *handler,
 		struct discover_boot_option *opt, unsigned int sec)
 {
-	struct boot_status status;
+	struct status status;
 
-	status.type = BOOT_STATUS_INFO;
-	status.progress = -1;
-	status.detail = NULL;
+	status.type = STATUS_INFO;
 	status.message = talloc_asprintf(handler,
-			_("Booting in %d sec: %s"), sec, opt->option->name);
+			_("Booting in %d sec: [%s] %s"), sec,
+			opt->device->device->id, opt->option->name);
+	status.backlog = false;
 
-	discover_server_notify_boot_status(handler->server, &status);
+	device_handler_status(handler, &status);
 
 	talloc_free(status.message);
 }
@@ -432,6 +794,8 @@ static int default_timeout(void *arg)
 
 	opt = handler->default_boot_option;
 
+	handler->last_boot_option = opt;
+
 	if (handler->sec_to_boot) {
 		countdown_status(handler, opt, handler->sec_to_boot);
 		handler->sec_to_boot--;
@@ -448,7 +812,8 @@ static int default_timeout(void *arg)
 	platform_pre_boot();
 
 	handler->pending_boot = boot(handler, handler->default_boot_option,
-			NULL, handler->dry_run, boot_status, handler);
+			NULL, handler->dry_run, device_handler_boot_status_cb,
+			handler);
 	handler->pending_boot_is_default = true;
 	return 0;
 }
@@ -476,24 +841,31 @@ static bool ipmi_device_type_matches(enum ipmi_bootdev ipmi_type,
 	return false;
 }
 
+static bool autoboot_option_matches(struct autoboot_option *opt,
+		struct discover_device *dev)
+{
+	if (opt->boot_type == BOOT_DEVICE_UUID)
+		if (!strcmp(opt->uuid, dev->uuid))
+			return true;
+
+	if (opt->boot_type == BOOT_DEVICE_TYPE)
+		if (opt->type == dev->device->type ||
+		    opt->type == DEVICE_TYPE_ANY)
+			return true;
+
+	return false;
+}
+
 static int autoboot_option_priority(const struct config *config,
 				struct discover_boot_option *opt)
 {
-	enum device_type type = opt->device->device->type;
-	const char *uuid = opt->device->uuid;
 	struct autoboot_option *auto_opt;
 	unsigned int i;
 
 	for (i = 0; i < config->n_autoboot_opts; i++) {
 		auto_opt = &config->autoboot_opts[i];
-		if (auto_opt->boot_type == BOOT_DEVICE_UUID)
-			if (!strcmp(auto_opt->uuid, uuid))
-				return DEFAULT_PRIORITY_LOCAL_FIRST + i;
-
-		if (auto_opt->boot_type == BOOT_DEVICE_TYPE)
-			if (auto_opt->type == type ||
-			    auto_opt->type == DEVICE_TYPE_ANY)
-				return DEFAULT_PRIORITY_LOCAL_FIRST + i;
+		if (autoboot_option_matches(auto_opt, opt->device))
+			return DEFAULT_PRIORITY_LOCAL_FIRST + i;
 	}
 
 	return -1;
@@ -505,15 +877,27 @@ static int autoboot_option_priority(const struct config *config,
  * for these options.
  */
 static enum default_priority default_option_priority(
+		struct device_handler *handler,
 		struct discover_boot_option *opt)
 {
 	const struct config *config;
 
+	/* Temporary user-provided autoboot options have highest priority */
+	if (handler->temp_autoboot) {
+		if (autoboot_option_matches(handler->temp_autoboot,
+					opt->device))
+			return DEFAULT_PRIORITY_TEMP_USER;
+
+		pb_debug("handler: disabled default priority due to "
+				"temporary user override\n");
+		return DEFAULT_PRIORITY_DISABLED;
+	}
+
 	config = config_get();
 
-	/* We give highest priority to IPMI-configured boot options. If
-	 * we have an IPMI bootdev configuration set, then we don't allow
-	 * any other defaults */
+	/* Next highest priority to IPMI-configured boot options. If we have an
+	 * IPMI bootdev configuration set, then we don't allow any other
+	 * defaults */
 	if (config->ipmi_bootdev) {
 		bool ipmi_match = ipmi_device_type_matches(config->ipmi_bootdev,
 				opt->device->device->type);
@@ -532,6 +916,9 @@ static enum default_priority default_option_priority(
 		int boot_match = autoboot_option_priority(config, opt);
 		if (boot_match > 0)
 			return boot_match;
+	} else {
+		/* If there is no specific boot order, boot any device */
+		return DEFAULT_PRIORITY_LOCAL_FIRST;
 	}
 
 	/* If the option didn't match any entry in the array, it is disabled */
@@ -550,7 +937,7 @@ static void set_default(struct device_handler *handler,
 
 	pb_debug("handler: new default option: %s\n", opt->option->id);
 
-	new_prio = default_option_priority(opt);
+	new_prio = default_option_priority(handler, opt);
 
 	/* Anything outside our range prevents a default boot */
 	if (new_prio >= DEFAULT_PRIORITY_DISABLED)
@@ -580,6 +967,10 @@ static void set_default(struct device_handler *handler,
 		return;
 	}
 
+	if (handler->default_boot_option)
+		handler->default_boot_option->option->is_autoboot_default = false;
+	opt->option->is_autoboot_default = true;
+
 	handler->sec_to_boot = config_get()->autoboot_timeout_sec;
 	handler->default_boot_option = opt;
 	handler->default_boot_option_priority = new_prio;
@@ -590,6 +981,68 @@ static void set_default(struct device_handler *handler,
 	default_timeout(handler);
 }
 
+static char *autoboot_option_desc(void *ctx, const struct autoboot_option *opt)
+{
+	const char *type, *val;
+
+	if (opt->boot_type == BOOT_DEVICE_TYPE) {
+		type = _("device type");
+		val = device_type_display_name(opt->type);
+	} else if (opt->boot_type == BOOT_DEVICE_UUID) {
+		type = _("device UUID");
+		val = opt->uuid;
+	} else {
+		type = _("unknown specifier");
+		val = NULL;
+	}
+
+	return talloc_asprintf(ctx, "%s = %s", type, val);
+}
+
+void device_handler_apply_temp_autoboot(struct device_handler *handler,
+		struct autoboot_option *opt)
+{
+	unsigned int i;
+	char *desc;
+
+	handler->temp_autoboot = talloc_steal(handler, opt);
+
+	desc = autoboot_option_desc(handler, opt);
+	device_handler_status_info(handler,
+			_("Applying temporary autoboot override: %s"),
+			desc);
+	talloc_free(desc);
+
+	if (!handler->autoboot_enabled)
+		return;
+
+	if (!handler->default_boot_option)
+		return;
+
+	if (autoboot_option_matches(opt, handler->default_boot_option->device))
+		return;
+
+	/* cancel the default, and rescan available options */
+	device_handler_cancel_default(handler);
+
+	handler->autoboot_enabled = true;
+
+	for (i = 0; i < handler->n_devices; i++) {
+		struct discover_device *dev = handler->devices[i];
+		struct discover_boot_option *boot_opt;
+
+		if (!autoboot_option_matches(opt, dev))
+			continue;
+
+		list_for_each_entry(&dev->boot_options, boot_opt, list) {
+			if (boot_opt->option->is_default) {
+				set_default(handler, boot_opt);
+				break;
+			}
+		}
+	}
+}
+
 static bool resource_is_resolved(struct resource *res)
 {
 	return !res || res->resolved;
@@ -603,6 +1056,7 @@ static bool __attribute__((used)) boot_option_is_resolved(
 	return resource_is_resolved(opt->boot_image) &&
 		resource_is_resolved(opt->initrd) &&
 		resource_is_resolved(opt->dtb) &&
+		resource_is_resolved(opt->args_sig_file) &&
 		resource_is_resolved(opt->icon);
 }
 
@@ -628,6 +1082,8 @@ static bool boot_option_resolve(struct discover_boot_option *opt,
 	return resource_resolve(opt->boot_image, "boot_image", opt, handler) &&
 		resource_resolve(opt->initrd, "initrd", opt, handler) &&
 		resource_resolve(opt->dtb, "dtb", opt, handler) &&
+		resource_resolve(opt->args_sig_file, "args_sig_file", opt,
+			handler) &&
 		resource_resolve(opt->icon, "icon", opt, handler);
 }
 
@@ -642,6 +1098,7 @@ static void boot_option_finalise(struct device_handler *handler,
 	assert(!opt->option->dtb_file);
 	assert(!opt->option->icon_file);
 	assert(!opt->option->device_id);
+	assert(!opt->option->args_sig_file);
 
 	if (opt->boot_image)
 		opt->option->boot_image_file = opt->boot_image->url->full;
@@ -651,6 +1108,8 @@ static void boot_option_finalise(struct device_handler *handler,
 		opt->option->dtb_file = opt->dtb->url->full;
 	if (opt->icon)
 		opt->option->icon_file = opt->icon->url->full;
+	if (opt->args_sig_file)
+		opt->option->args_sig_file = opt->args_sig_file->url->full;
 
 	opt->option->device_id = opt->device->device->id;
 
@@ -700,57 +1159,13 @@ struct discover_context *device_handler_discover_context_create(
 	struct discover_context *ctx;
 
 	ctx = talloc_zero(handler, struct discover_context);
+	ctx->handler = handler;
 	ctx->device = device;
-	ctx->network = handler->network;
 	list_init(&ctx->boot_options);
 
 	return ctx;
 }
 
-/**
- * context_commit - Commit a temporary discovery context to the handler,
- * and notify the clients about any new options / devices
- */
-void device_handler_discover_context_commit(struct device_handler *handler,
-		struct discover_context *ctx)
-{
-	struct discover_device *dev = ctx->device;
-	struct discover_boot_option *opt, *tmp;
-
-	if (!device_lookup_by_id(handler, dev->device->id))
-		device_handler_add_device(handler, dev);
-
-	/* move boot options from the context to the device */
-	list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
-		list_remove(&opt->list);
-
-		if (boot_option_resolve(opt, handler)) {
-			pb_log("boot option %s is resolved, "
-					"sending to clients\n",
-					opt->option->id);
-			list_add_tail(&dev->boot_options, &opt->list);
-			talloc_steal(dev, opt);
-			boot_option_finalise(handler, opt);
-			notify_boot_option(handler, opt);
-		} else {
-			if (!opt->source->resolve_resource) {
-				pb_log("parser %s gave us an unresolved "
-					"resource (%s), but no way to "
-					"resolve it\n",
-					opt->source->name, opt->option->id);
-				talloc_free(opt);
-			} else {
-				pb_log("boot option %s is unresolved, "
-						"adding to queue\n",
-						opt->option->id);
-				list_add(&handler->unresolved_boot_options,
-						&opt->list);
-				talloc_steal(handler, opt);
-			}
-		}
-	}
-}
-
 void device_handler_add_device(struct device_handler *handler,
 		struct discover_device *device)
 {
@@ -852,33 +1267,136 @@ void device_handler_release_ramdisk(struct discover_device *device)
 	device->ramdisk = NULL;
 }
 
-/* Start discovery on a hotplugged device. The device will be in our devices
- * array, but has only just been initialised by the hotplug source.
+/*
+ * Check if a device name matches the name of an encrypted device that has been
+ * opened. If it matches remove it from the list and remove the original crypt
+ * discover device.
  */
-int device_handler_discover(struct device_handler *handler,
-		struct discover_device *dev)
+bool device_handler_found_crypt_device(struct device_handler *handler,
+		const char *name)
 {
-	struct discover_context *ctx;
-	struct boot_status *status;
-	int rc;
+	struct crypt_info *crypt, *c;
 
-	status = talloc_zero(handler, struct boot_status);
-	status->type = BOOT_STATUS_INFO;
-	/*
-	 * TRANSLATORS: this string will be passed the type and identifier
-	 * of the device. For example, the first parameter could be "Disk",
-	 * (which will be translated accordingly) and the second a Linux device
-	 * identifier like 'sda1' (which will not be translated)
-	 */
-	status->message = talloc_asprintf(status, _("Processing %s device %s"),
-				device_type_display_name(dev->device->type),
-				dev->device->id);
-	boot_status(handler, status);
+	list_for_each_entry_safe(&handler->crypt_devices, crypt, c, list) {
+		if (!strncmp(crypt->dm_name, name, strlen(crypt->dm_name))) {
+			device_handler_remove(handler, crypt->source_device);
+			list_remove(&crypt->list);
+			talloc_free(crypt);
+			return true;
+		}
+	}
 
-	process_boot_option_queue(handler);
+	return false;
+}
 
-	/* create our context */
-	ctx = device_handler_discover_context_create(handler, dev);
+static void cryptsetup_cb(struct process *process)
+{
+	struct device_handler *handler = process->data;
+	struct crypt_info *crypt, *c;
+
+	if (process->exit_status == 0)
+		return;
+	device_handler_status_err(handler,
+			_("Failed to open encrypted device %s"),
+			process->argv[2]);
+
+	/*
+	 * Failed to open the device; stop tracking it, but don't remove
+	 * the source device.
+	 */
+	list_for_each_entry_safe(&handler->crypt_devices, crypt, c, list) {
+		if (!strncmp(crypt->dm_name, process->argv[3],
+					strlen(crypt->dm_name))) {
+			list_remove(&crypt->list);
+			talloc_free(crypt);
+			break;
+		}
+	}
+}
+
+void device_handler_open_encrypted_dev(struct device_handler *handler,
+		char *password, char *device_id)
+{
+	struct discover_device *dev;
+	struct crypt_info *crypt;
+	const char *device_path, **argv;
+	struct process *p;
+	char *name;
+	int result;
+
+	dev = device_lookup_by_id(handler, device_id);
+	if (!dev) {
+		pb_log_fn("Can't find device %s\n", device_id);
+		device_handler_status_err(handler,
+				_("Encrypted device %s does not exist"),
+				device_id);
+		return;
+	}
+
+	device_path = dev->device_path;
+	name = talloc_asprintf(handler, "luks_%s", device_id);
+
+	p = process_create(handler);
+	/* talloc argv under the process so we can access it in cryptsetup_cb */
+	argv = talloc_zero_array(p, const char *, 6);
+	argv[0] = talloc_strdup(argv, pb_system_apps.cryptsetup);
+	argv[1] = talloc_asprintf(argv, "luksOpen");
+	argv[2] = talloc_strdup(argv, device_path);
+	argv[3] = talloc_strdup(argv, name);
+	argv[4] = talloc_asprintf(argv, "-");
+	argv[5] = NULL;
+
+	p->path = pb_system_apps.cryptsetup;
+	p->argv = (const char **)argv;
+	p->exit_cb = cryptsetup_cb;
+	p->data = handler;
+	p->keep_stdout = true;
+	p->pipe_stdin = talloc_asprintf(p, "%s\n", password);
+
+	result = process_run_async(p);
+	if (result) {
+		pb_log("Failed to run cryptsetup\n");
+		return;
+	}
+
+	crypt = talloc(handler, struct crypt_info);
+	crypt->source_device = dev;
+	crypt->dm_name = name;
+	talloc_steal(crypt, name);
+	list_add(&handler->crypt_devices, &crypt->list);
+}
+
+void device_handler_add_encrypted_dev(struct device_handler *handler,
+		struct discover_device *dev)
+{
+	system_info_register_blockdev(dev->device->id, dev->uuid, "");
+	discover_server_notify_device_add(handler->server,
+					  dev->device);
+	dev->notified = true;
+	if (!device_lookup_by_uuid(handler, dev->uuid))
+		device_handler_add_device(handler, dev);
+}
+
+/* Start discovery on a hotplugged device. The device will be in our devices
+ * array, but has only just been initialised by the hotplug source.
+ */
+int device_handler_discover(struct device_handler *handler,
+		struct discover_device *dev)
+{
+	struct discover_context *ctx;
+	int rc;
+
+	device_handler_status_dev_info(handler, dev,
+		/*
+		 * TRANSLATORS: this string will be passed the type of the
+		 * device (eg "disk" or "network"), which will be translated
+		 * accordingly.
+		 */
+		_("Processing new %s device"),
+		device_type_display_name(dev->device->type));
+
+	/* create our context */
+	ctx = device_handler_discover_context_create(handler, dev);
 
 	rc = mount_device(dev);
 	if (rc)
@@ -894,90 +1412,183 @@ int device_handler_discover(struct device_handler *handler,
 	/* add discovered stuff to the handler */
 	device_handler_discover_context_commit(handler, ctx);
 
-out:
-	/*
-	 * TRANSLATORS: the format specifier in this string is a Linux
-	 * device identifier, like 'sda1'
-	 */
-	status->message = talloc_asprintf(status,_("Processing %s complete"),
-				dev->device->id);
-	boot_status(handler, status);
+	process_boot_option_queue(handler);
 
-	talloc_free(status);
-	talloc_free(ctx);
+	/* Check this device for pb-plugins */
+	device_handler_plugin_scan_device(handler, dev);
+out:
+	talloc_unlink(handler, ctx);
 
 	return 0;
 }
 
-/* Incoming dhcp event */
-int device_handler_dhcp(struct device_handler *handler,
-		struct discover_device *dev, struct event *event)
+struct requery_data {
+	struct device_handler	*handler;
+	struct discover_device	*device;
+};
+
+static int device_handler_requery_timeout_fn(void *data)
 {
-	struct discover_context *ctx;
-	struct boot_status *status;
+	struct discover_boot_option *opt, *tmp;
+	struct requery_data *rqd = data;
+	struct device_handler *handler;
+	struct discover_device *device;
+	bool autoboot;
 
-	status = talloc_zero(handler, struct boot_status);
-	status->type = BOOT_STATUS_INFO;
-	/*
-	 * TRANSLATORS: this format specifier will be the name of a network
-	 * device, like 'eth0'.
-	 */
-	status->message = talloc_asprintf(status, _("Processing dhcp event on %s"),
-				dev->device->id);
-	boot_status(handler, status);
+	handler = rqd->handler;
+	device = rqd->device;
 
-	/* create our context */
-	ctx = device_handler_discover_context_create(handler, dev);
-	ctx->event = event;
+	talloc_free(rqd);
 
-	iterate_parsers(ctx);
+	/* network_requery_device may re-add a timeout, so clear the device
+	 * waiter here, so we can potentially start a new one. */
+	device->requery_waiter = NULL;
 
-	device_handler_discover_context_commit(handler, ctx);
+	/* We keep the device around, but get rid of the parsed boot
+	 * options on that device. That involves delaring out the lists,
+	 * and potentially cancelling a default.
+	 */
+	list_for_each_entry_safe(&handler->unresolved_boot_options,
+			opt, tmp, list) {
+		if (opt->device != device)
+			continue;
+		list_remove(&opt->list);
+		talloc_free(opt);
+	}
 
-	/*
-	 * TRANSLATORS: this format specifier will be the name of a network
-	 * device, like 'eth0'.
+	/* Track whether autoboot was enabled, if we cancel a default option
+	 * it will be switched off.
 	 */
-	status->message = talloc_asprintf(status,_("Processing %s complete"),
-				dev->device->id);
-	boot_status(handler, status);
+	autoboot = handler->autoboot_enabled;
+
+	list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
+		if (opt == handler->default_boot_option) {
+			pb_log("Default option %s cancelled since device is being requeried\n",
+					opt->option->name);
+			device_handler_cancel_default(handler);
+		}
+		list_remove(&opt->list);
+		talloc_free(opt);
+	}
+
+	handler->autoboot_enabled = autoboot;
 
-	talloc_free(status);
-	talloc_free(ctx);
+	discover_server_notify_device_remove(handler->server, device->device);
+	device->notified = false;
+
+	network_requery_device(handler->network, device);
 
 	return 0;
 }
 
-/* incoming conf event */
-int device_handler_conf(struct device_handler *handler,
-		struct discover_device *dev, struct pb_url *url)
+/* Schedule a requery in timeout (seconds).
+ *
+ * Special values of timeout:
+ *   0: no requery
+ *  -1: use default
+ */
+void device_handler_start_requery_timeout( struct device_handler *handler,
+		struct discover_device *dev, int timeout)
+{
+	struct requery_data *rqd;
+
+	if (dev->requery_waiter)
+		return;
+
+	if (timeout == -1)
+		timeout = default_rescan_timeout;
+	else if (timeout == 0)
+		return;
+
+	rqd = talloc(dev, struct requery_data);
+	rqd->handler = handler;
+	rqd->device = dev;
+
+	pb_debug("starting requery timeout for device %s, in %d sec\n",
+			dev->device->id, timeout);
+
+	dev->requery_waiter = waiter_register_timeout(handler->waitset,
+			timeout * 1000, device_handler_requery_timeout_fn, rqd);
+}
+
+static int event_requery_timeout(struct event *event)
+{
+	int timeout = -1;
+	unsigned long x;
+	const char *str;
+	char *endp;
+
+	if (!event)
+		return timeout;
+
+	str = event_get_param(event, "reboottime");
+	if (!str)
+		return timeout;
+
+	x = strtoul(str, &endp, 0);
+	if (endp != str)
+		timeout = x;
+
+	return timeout;
+}
+
+
+/* Incoming dhcp event */
+int device_handler_dhcp(struct device_handler *handler,
+		struct discover_device *dev, struct event *event)
 {
 	struct discover_context *ctx;
-	struct boot_status *status;
+	const char *ip;
+
+	if (event_get_param(event, "ipv6"))
+		ip = event_get_param(event, "ipv6");
+	else
+		ip = event_get_param(event, "ip");
+
+	device_handler_status_dev_info(handler, dev,
+			_("Processing DHCP lease response (ip: %s)"), ip);
 
-	status = talloc_zero(handler, struct boot_status);
-	status->type = BOOT_STATUS_INFO;
-	status->message = talloc_asprintf(status, _("Processing user config"));
-	boot_status(handler, status);
+	pending_network_jobs_start();
 
 	/* create our context */
 	ctx = device_handler_discover_context_create(handler, dev);
-	ctx->conf_url = url;
+	talloc_steal(ctx, event);
+	ctx->event = event;
+
+	device_handler_start_requery_timeout(handler, dev,
+			event_requery_timeout(event));
 
 	iterate_parsers(ctx);
 
 	device_handler_discover_context_commit(handler, ctx);
 
-	status->message = talloc_asprintf(status,
-				_("Processing user config complete"));
-	boot_status(handler, status);
-
-	talloc_free(status);
-	talloc_free(ctx);
+	talloc_unlink(handler, ctx);
 
 	return 0;
 }
 
+struct discover_boot_option *device_handler_find_option_by_name(
+		struct device_handler *handler, const char *device,
+		const char *name)
+{
+	size_t len = strlen(name);
+	unsigned int i;
+
+	for (i = 0; i < handler->n_devices; i++) {
+		struct discover_device *dev = handler->devices[i];
+		struct discover_boot_option *opt;
+
+		list_for_each_entry(&dev->boot_options, opt, list)
+			/* Match exactly, partial matches can be quite common */
+			if (strlen(opt->option->name) == len &&
+					!strcmp(opt->option->name, name))
+				if (!dev || !strcmp(opt->option->device_id, device))
+					return opt;
+	}
+
+	return NULL;
+}
+
 static struct discover_boot_option *find_boot_option_by_id(
 		struct device_handler *handler, const char *id)
 {
@@ -996,27 +1607,34 @@ static struct discover_boot_option *find_boot_option_by_id(
 }
 
 void device_handler_boot(struct device_handler *handler,
-		struct boot_command *cmd)
+		bool change_default, struct boot_command *cmd)
 {
 	struct discover_boot_option *opt = NULL;
 
 	if (cmd->option_id && strlen(cmd->option_id))
 		opt = find_boot_option_by_id(handler, cmd->option_id);
 
+	/* Don't allow a normal client to change the default */
+	if (!change_default && handler->last_boot_option &&
+			opt != handler->last_boot_option) {
+		pb_log("Non-root user tried to change boot option\n");
+		device_handler_status_err(handler,
+				"Must be root to change default boot option\n");
+		return;
+	}
+
 	if (handler->pending_boot)
 		boot_cancel(handler->pending_boot);
 
 	platform_pre_boot();
 
 	handler->pending_boot = boot(handler, opt, cmd, handler->dry_run,
-			boot_status, handler);
+			device_handler_boot_status_cb, handler);
 	handler->pending_boot_is_default = false;
 }
 
 void device_handler_cancel_default(struct device_handler *handler)
 {
-	struct boot_status status;
-
 	if (handler->timeout_waiter)
 		waiter_remove(handler->timeout_waiter);
 
@@ -1037,12 +1655,7 @@ void device_handler_cancel_default(struct device_handler *handler)
 
 	handler->default_boot_option = NULL;
 
-	status.type = BOOT_STATUS_INFO;
-	status.progress = -1;
-	status.detail = NULL;
-	status.message = _("Default boot cancelled");
-
-	discover_server_notify_boot_status(handler->server, &status);
+	device_handler_status_info(handler, _("Default boot cancelled"));
 }
 
 void device_handler_update_config(struct device_handler *handler,
@@ -1051,8 +1664,11 @@ void device_handler_update_config(struct device_handler *handler,
 	int rc;
 
 	rc = config_set(config);
-	if (rc)
+	if (rc) {
+		device_handler_status_err(handler,
+				"Failed to update configuration!");
 		return;
+	}
 
 	discover_server_notify_config(handler->server, config);
 	device_handler_update_lang(config->lang);
@@ -1062,32 +1678,44 @@ void device_handler_update_config(struct device_handler *handler,
 static char *device_from_addr(void *ctx, struct pb_url *url)
 {
 	char *ipaddr, *buf, *tok, *dev = NULL;
+	bool ipv6_route;
 	const char *delim = " ";
-	struct sockaddr_in *ip;
-	struct sockaddr_in si;
+	struct sockaddr_in *ipv4;
+	struct sockaddr_in6 *ipv6;
 	struct addrinfo *res;
 	struct process *p;
 	int rc;
 
-	/* Note: IPv4 only */
-	rc = inet_pton(AF_INET, url->host, &(si.sin_addr));
-	if (rc > 0) {
-		ipaddr = url->host;
-	} else {
-		/* need to turn hostname into a valid IP */
-		rc = getaddrinfo(url->host, NULL, NULL, &res);
-		if (rc) {
-			pb_debug("%s: Invalid URL\n",__func__);
-			return NULL;
-		}
+	/* Confirm url->host is either a valid hostname, or a
+	 * valid IPv4 or IPv6 address */
+	rc = getaddrinfo(url->host, NULL, NULL, &res);
+	if (rc) {
+		pb_debug("%s: Invalid URL\n",__func__);
+		return NULL;
+	}
+
+	switch (res->ai_family) {
+	case AF_INET:	/* ipv4 */
 		ipaddr = talloc_array(ctx,char,INET_ADDRSTRLEN);
-		ip = (struct sockaddr_in *) res->ai_addr;
-		inet_ntop(AF_INET, &(ip->sin_addr), ipaddr, INET_ADDRSTRLEN);
+		ipv4 = (struct sockaddr_in *) res->ai_addr;
+		inet_ntop(AF_INET, &(ipv4->sin_addr), ipaddr, INET_ADDRSTRLEN);
+		ipv6_route = false;
+		break;
+	case AF_INET6:	/* ipv6 */
+		ipaddr = talloc_array(ctx,char,INET6_ADDRSTRLEN);
+		ipv6 = (struct sockaddr_in6 *) res->ai_addr;
+		inet_ntop(AF_INET6, &(ipv6->sin6_addr), ipaddr, INET6_ADDRSTRLEN);
+		ipv6_route = true;
+		break;
+	default:	/* error */
 		freeaddrinfo(res);
+		return NULL;
 	}
+	freeaddrinfo(res);
 
 	const char *argv[] = {
 		pb_system_apps.ip,
+		ipv6_route ? "-6" : "-4",
 		"route", "show", "to", "match",
 		ipaddr,
 		NULL
@@ -1129,94 +1757,253 @@ static char *device_from_addr(void *ctx, struct pb_url *url)
 	return dev;
 }
 
+static void process_url_cb(struct load_url_result *result, void *data)
+{
+	struct device_handler *handler;
+	struct discover_context *ctx;
+	struct discover_device *dev;
+	struct event *event = data;
+	const char *mac;
+
+	if (result->status != LOAD_OK) {
+		pb_log_fn("Load failed for %s\n", result->url->full);
+		return;
+	}
+
+	if (!event)
+		return;
+
+	handler = talloc_parent(event);
+	if (!handler)
+		return;
+
+	event->device = device_from_addr(event, result->url);
+	if (!event->device) {
+		pb_log("Downloaded a file but can't find its interface - pretending it was local\n");
+		event->device = talloc_asprintf(event, "local");
+	}
+
+	mac = event_get_param(event, "mac");
+	char *url = talloc_asprintf(event, "file://%s", result->local);
+	event_set_param(event, "pxeconffile-local", url);
+
+	dev = discover_device_create(handler, mac, event->device);
+	ctx = device_handler_discover_context_create(handler, dev);
+	talloc_steal(ctx, event);
+	ctx->event = event;
+
+	iterate_parsers(ctx);
+
+	device_handler_discover_context_commit(handler, ctx);
+
+	talloc_unlink(handler, ctx);
+}
+
 void device_handler_process_url(struct device_handler *handler,
 		const char *url, const char *mac, const char *ip)
 {
 	struct discover_context *ctx;
 	struct discover_device *dev;
-	struct boot_status *status;
+	bool allow_async = false;
 	struct pb_url *pb_url;
 	struct event *event;
-	struct param *param;
-
-	status = talloc(handler, struct boot_status);
 
-	status->type = BOOT_STATUS_ERROR;
-	status->progress = 0;
-	status->detail = talloc_asprintf(status,
-			_("Received config URL %s"), url);
+	event = talloc_zero(handler, struct event);
+	event->type = EVENT_TYPE_USER;
+	event->action = EVENT_ACTION_URL;
 
-	if (!handler->network) {
-		status->message = talloc_asprintf(handler,
-					_("No network configured"));
-		goto msg;
+	pb_url = pb_url_parse(event, url);
+	if (!pb_url || (pb_url->scheme != pb_url_file && !pb_url->host)) {
+		device_handler_status_err(handler, _("Invalid config URL!"));
+		talloc_free(event);
+		return;
 	}
 
-	event = talloc(handler, struct event);
-	event->type = EVENT_TYPE_USER;
-	event->action = EVENT_ACTION_CONF;
-
 	if (url[strlen(url) - 1] == '/') {
-		event->params = talloc_array(event, struct param, 3);
-		param = &event->params[0];
-		param->name = talloc_strdup(event, "pxepathprefix");
-		param->value = talloc_strdup(event, url);
-		param = &event->params[1];
-		param->name = talloc_strdup(event, "mac");
-		param->value = talloc_strdup(event, mac);
-		param = &event->params[2];
-		param->name = talloc_strdup(event, "ip");
-		param->value = talloc_strdup(event, ip);
-		event->n_params = 3;
+		event_set_param(event, "pxepathprefix", url);
+		event_set_param(event, "mac", mac);
+		event_set_param(event, "ip", ip);
+		event->device = device_from_addr(event, pb_url);
+		if (!event->device) {
+			device_handler_status_err(handler,
+					_("Unable to route to host %s"),
+					pb_url->host);
+			talloc_free(event);
+			return;
+		}
 	} else {
-		event->params = talloc_array(event, struct param, 1);
-		param = &event->params[0];
-		param->name = talloc_strdup(event, "pxeconffile");
-		param->value = talloc_strdup(event, url);
-		event->n_params = 1;
-	}
-
-	pb_url = pb_url_parse(event, event->params->value);
-	if (!pb_url || (pb_url->scheme != pb_url_file && !pb_url->host)) {
-		status->message = talloc_asprintf(handler,
-					_("Invalid config URL!"));
-		goto msg;
+		event_set_param(event, "pxeconffile", url);
+		allow_async = true;
 	}
 
 	if (pb_url->scheme == pb_url_file)
 		event->device = talloc_asprintf(event, "local");
-	else
-		event->device = device_from_addr(event, pb_url);
-
-	if (!event->device) {
-		status->message = talloc_asprintf(status,
-					_("Unable to route to host %s"),
-					pb_url->host);
-		goto msg;
+	else if (allow_async) {
+		/* If file is remote load asynchronously before passing to
+		 * parser. This allows us to wait for network to be available */
+		if (!load_url_async(handler, pb_url, process_url_cb, event,
+					NULL, handler)) {
+			pb_log("Failed to load url %s\n", pb_url->full);
+			device_handler_status_err(handler, _("Failed to load URL!"));
+			talloc_free(event);
+		}
+		return;
 	}
 
-	dev = discover_device_create(handler, event->device);
+	/* If path is local we can parse straight away */
+
+	dev = discover_device_create(handler, mac, event->device);
 	if (pb_url->scheme == pb_url_file)
 		dev->device->type = DEVICE_TYPE_ANY;
 	ctx = device_handler_discover_context_create(handler, dev);
+	talloc_steal(ctx, event);
 	ctx->event = event;
 
 	iterate_parsers(ctx);
 
 	device_handler_discover_context_commit(handler, ctx);
 
-	talloc_free(ctx);
+	talloc_unlink(handler, ctx);
+}
+
+static void plugin_install_cb(struct process *process)
+{
+	struct device_handler *handler = process->data;
+
+	if (!handler) {
+		pb_log_fn("Missing data!\n");
+		return;
+	}
+
+	handler->plugin_installing = false;
+	if (process->exit_status) {
+		device_handler_status_err(handler, "Plugin failed to install!");
+		pb_log("Failed to install plugin:\n%s\n", process->stdout_buf);
+	}
+}
+
+void device_handler_install_plugin(struct device_handler *handler,
+		const char *plugin_file)
+{
+	struct process *p;
+	int result;
+
+	if (handler->plugin_installing) {
+		pb_log("Plugin install cancelled - install already running");
+		return;
+	}
+
+	p = process_create(handler);
+	if (!p) {
+		pb_log("install_plugin: Failed to create process\n");
+		return;
+	}
+
+	const char *argv[] = {
+		pb_system_apps.pb_plugin,
+		"install",
+		"auto",
+		plugin_file,
+		NULL
+	};
+
+	p->path = pb_system_apps.pb_plugin;
+	p->argv = argv;
+	p->exit_cb = plugin_install_cb;
+	p->data = handler;
+	p->keep_stdout = true;
+
+	result = process_run_async(p);
 
-	status->type = BOOT_STATUS_INFO;
-	status->message = talloc_asprintf(status, _("Config file %s parsed"),
-					pb_url->file);
-msg:
-	boot_status(handler, status);
-	talloc_free(status);
+	if (result)
+		device_handler_status_err(handler, "Could not install plugin");
+	else
+		handler->plugin_installing = true;
 }
 
 #ifndef PETITBOOT_TEST
 
+/**
+ * context_commit - Commit a temporary discovery context to the handler,
+ * and notify the clients about any new options / devices
+ */
+void device_handler_discover_context_commit(struct device_handler *handler,
+		struct discover_context *ctx)
+{
+	struct discover_device *dev = ctx->device;
+	struct discover_boot_option *opt, *tmp;
+
+	if (!device_lookup_by_uuid(handler, dev->uuid))
+		device_handler_add_device(handler, dev);
+
+	/* move boot options from the context to the device */
+	list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
+		list_remove(&opt->list);
+
+		/* All boot options need at least a kernel image */
+		if (!opt->boot_image || !opt->boot_image->url) {
+			pb_log("boot option %s is missing boot image, ignoring\n",
+				opt->option->id);
+			talloc_free(opt);
+			continue;
+		}
+
+		if (boot_option_resolve(opt, handler)) {
+			pb_log("boot option %s is resolved, "
+					"sending to clients\n",
+					opt->option->id);
+			list_add_tail(&dev->boot_options, &opt->list);
+			talloc_steal(dev, opt);
+			boot_option_finalise(handler, opt);
+			notify_boot_option(handler, opt);
+		} else {
+			if (!opt->source->resolve_resource) {
+				pb_log("parser %s gave us an unresolved "
+					"resource (%s), but no way to "
+					"resolve it\n",
+					opt->source->name, opt->option->id);
+				talloc_free(opt);
+			} else {
+				pb_log("boot option %s is unresolved, "
+						"adding to queue\n",
+						opt->option->id);
+				list_add(&handler->unresolved_boot_options,
+						&opt->list);
+				talloc_steal(handler, opt);
+			}
+		}
+	}
+}
+
+void device_handler_add_plugin_option(struct device_handler *handler,
+		struct plugin_option *opt)
+{
+	struct plugin_option *tmp;
+	unsigned int i;
+
+	for (i = 0; i < handler->n_plugins; i++) {
+		tmp = handler->plugins[i];
+		/* If both id and version match, ignore */
+		if (strncmp(opt->id, tmp->id, strlen(opt->id)) == 0 &&
+				strcmp(opt->version, tmp->version) == 0) {
+			pb_log("discover: Plugin '%s' already exists, ignoring\n",
+					opt->id);
+			return;
+		}
+	}
+
+	handler->plugins = talloc_realloc(handler, handler->plugins,
+			struct plugin_option *, handler->n_plugins + 1);
+	if (!handler->plugins) {
+		pb_log("Failed to allocate memory for new plugin\n");
+		handler->n_plugins = 0;
+		return;
+	}
+
+	handler->plugins[handler->n_plugins++] = opt;
+	discover_server_notify_plugin_option_add(handler->server, opt);
+}
+
 static void device_handler_update_lang(const char *lang)
 {
 	const char *cur_lang;
@@ -1234,8 +2021,8 @@ static void device_handler_update_lang(const char *lang)
 static int device_handler_init_sources(struct device_handler *handler)
 {
 	/* init our device sources: udev, network and user events */
-	handler->udev = udev_init(handler, handler->waitset);
-	if (!handler->udev)
+	handler->user_event = user_event_init(handler, handler->waitset);
+	if (!handler->user_event)
 		return -1;
 
 	handler->network = network_init(handler, handler->waitset,
@@ -1243,8 +2030,8 @@ static int device_handler_init_sources(struct device_handler *handler)
 	if (!handler->network)
 		return -1;
 
-	handler->user_event = user_event_init(handler, handler->waitset);
-	if (!handler->user_event)
+	handler->udev = udev_init(handler, handler->waitset);
+	if (!handler->udev)
 		return -1;
 
 	return 0;
@@ -1259,11 +2046,13 @@ static void device_handler_reinit_sources(struct device_handler *handler)
 		return;
 	}
 
-	udev_reinit(handler->udev);
+	system_info_reinit();
 
 	network_shutdown(handler->network);
 	handler->network = network_init(handler, handler->waitset,
 			handler->dry_run);
+
+	udev_reinit(handler->udev);
 }
 
 static inline const char *get_device_path(struct discover_device *dev)
@@ -1431,6 +2220,20 @@ static int mount_device(struct discover_device *dev)
 	rc = try_mount(device_path, dev->mount_path, fstype,
 		       MS_RDONLY | MS_SILENT, dev->ramdisk);
 
+	/* If mount fails clean up any snapshot and try again */
+	if (rc && dev->ramdisk) {
+		pb_log("couldn't mount snapshot for %s: mount failed: %s\n",
+				device_path, strerror(errno));
+		pb_log("falling back to actual device\n");
+
+		devmapper_destroy_snapshot(dev);
+
+		device_path = get_device_path(dev);
+		pb_log("mounting device %s read-only\n", dev->device_path);
+		rc = try_mount(device_path, dev->mount_path, fstype,
+			       MS_RDONLY | MS_SILENT, dev->ramdisk);
+	}
+
 	if (!rc) {
 		dev->mounted = true;
 		dev->mounted_rw = false;
@@ -1442,9 +2245,6 @@ static int mount_device(struct discover_device *dev)
 	pb_log("couldn't mount device %s: mount failed: %s\n",
 			device_path, strerror(errno));
 
-	/* If mount fails clean up any snapshot */
-	devmapper_destroy_snapshot(dev);
-
 	pb_rmdir_recursive(mount_base(), dev->mount_path);
 err_free:
 	talloc_free(dev->mount_path);
@@ -1468,7 +2268,6 @@ static int umount_device(struct discover_device *dev)
 		return -1;
 
 	dev->mounted = false;
-	devmapper_destroy_snapshot(dev);
 
 	pb_rmdir_recursive(mount_base(), dev->mount_path);
 
@@ -1563,8 +2362,50 @@ void device_release_write(struct discover_device *dev, bool release)
 		dev->mounted = true;
 }
 
+void device_sync_snapshots(struct device_handler *handler, const char *device)
+{
+	struct discover_device *dev = NULL;
+	unsigned int i;
+
+	if (device) {
+		/* Find matching device and sync */
+		dev = device_lookup_by_name(handler, device);
+		if (!dev) {
+			pb_log("%s: device name '%s' unrecognised\n",
+				__func__, device);
+			return;
+		}
+		if (dev->ramdisk)
+			device_release_write(dev, true);
+		else
+			pb_log("%s has no snapshot to merge, skipping\n",
+				dev->device->id);
+		return;
+	}
+
+	/* Otherwise sync all relevant devices */
+	for (i = 0; i < handler->n_devices; i++) {
+		dev = handler->devices[i];
+		if (dev->device->type != DEVICE_TYPE_DISK &&
+			dev->device->type != DEVICE_TYPE_USB)
+			continue;
+		if (dev->ramdisk)
+			device_release_write(dev, true);
+		else
+			pb_log("%s has no snapshot to merge, skipping\n",
+				dev->device->id);
+	}
+}
+
 #else
 
+void device_handler_discover_context_commit(
+		struct device_handler *handler __attribute__((unused)),
+		struct discover_context *ctx __attribute__((unused)))
+{
+	pb_log_fn("stubbed out for test cases\n");
+}
+
 static void device_handler_update_lang(const char *lang __attribute__((unused)))
 {
 }
@@ -1603,5 +2444,10 @@ void device_release_write(struct discover_device *dev __attribute__((unused)),
 {
 }
 
-#endif
+void device_sync_snapshots(
+		struct device_handler *handler __attribute__((unused)),
+		const char *device __attribute__((unused)))
+{
+}
 
+#endif