X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=e75f41232db072e2db2a1aae4e6346b3574bdd99;hp=87a46c72a0e2f8a5b0fa71309ee922ce28d07e78;hb=87017f0478536fcb927010618be483a5efe9260c;hpb=8ed7af65d5eaea57a62c26bef6267047cf3c95ea

diff --git a/discover/device-handler.c b/discover/device-handler.c
index 87a46c7..e75f412 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,23 @@
 #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 device_handler {
 	struct discover_server	*server;
 	int			dry_run;
@@ -64,14 +78,23 @@ 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;
 };
 
 static int mount_device(struct discover_device *dev);
@@ -114,6 +137,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)
@@ -294,6 +345,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)
 {
@@ -304,10 +371,12 @@ 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);
+
 	/* set up our mount point base */
 	pb_mkdir_recursive(mount_base());
 
@@ -316,6 +385,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);
@@ -329,9 +400,20 @@ void device_handler_reinit(struct device_handler *handler)
 {
 	struct discover_boot_option *opt, *tmp;
 	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,
@@ -341,10 +423,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);
 	}
 
@@ -355,6 +440,28 @@ 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);
+
+	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);
 }
 
@@ -364,6 +471,9 @@ 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",
@@ -413,6 +523,7 @@ void device_handler_remove(struct device_handler *handler,
 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);
 }
 
@@ -423,6 +534,8 @@ static void _device_handler_vstatus(struct device_handler *handler,
 
 	status.type = type;
 	status.message = talloc_vasprintf(handler, fmt, ap);
+	status.backlog = false;
+	status.boot_active = false;
 
 	device_handler_status(handler, &status);
 
@@ -481,9 +594,138 @@ void device_handler_status_err(struct device_handler *handler,
 	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)
 {
-	device_handler_status(arg, status);
+	struct device_handler *handler = arg;
+
+	/* 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,
@@ -493,7 +735,9 @@ static void countdown_status(struct device_handler *handler,
 
 	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;
 
 	device_handler_status(handler, &status);
 
@@ -513,6 +757,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--;
@@ -558,24 +804,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;
@@ -587,15 +840,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);
@@ -614,6 +879,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 */
@@ -632,7 +900,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)
@@ -662,6 +930,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;
@@ -672,6 +944,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;
@@ -788,8 +1122,8 @@ 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;
@@ -905,17 +1239,14 @@ int device_handler_discover(struct device_handler *handler,
 	struct discover_context *ctx;
 	int rc;
 
-	/*
-	 * 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)
-	 */
-	device_handler_status_info(handler, _("Processing %s device %s"),
-				device_type_display_name(dev->device->type),
-				dev->device->id);
-
-	process_boot_option_queue(handler);
+	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);
@@ -934,53 +1265,183 @@ int device_handler_discover(struct device_handler *handler,
 	/* add discovered stuff to the handler */
 	device_handler_discover_context_commit(handler, ctx);
 
+	process_boot_option_queue(handler);
+
+	/* Check this device for pb-plugins */
+	device_handler_plugin_scan_device(handler, dev);
 out:
-	/*
-	 * TRANSLATORS: the format specifier in this string is a Linux
-	 * device identifier, like 'sda1'
+	talloc_unlink(handler, ctx);
+
+	return 0;
+}
+
+struct requery_data {
+	struct device_handler	*handler;
+	struct discover_device	*device;
+};
+
+static int device_handler_requery_timeout_fn(void *data)
+{
+	struct discover_boot_option *opt, *tmp;
+	struct requery_data *rqd = data;
+	struct device_handler *handler;
+	struct discover_device *device;
+	bool autoboot;
+
+	handler = rqd->handler;
+	device = rqd->device;
+
+	talloc_free(rqd);
+
+	/* 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;
+
+	/* 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.
 	 */
-	device_handler_status_info(handler, _("Processing %s complete"),
-				dev->device->id);
+	list_for_each_entry_safe(&handler->unresolved_boot_options,
+			opt, tmp, list) {
+		if (opt->device != device)
+			continue;
+		list_remove(&opt->list);
+		talloc_free(opt);
+	}
 
-	talloc_unlink(handler, ctx);
+	/* Track whether autoboot was enabled, if we cancel a default option
+	 * it will be switched off.
+	 */
+	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;
+
+	discover_server_notify_device_remove(handler->server, device->device);
+	device->notified = false;
+
+	network_requery_device(handler->network, device);
 
 	return 0;
 }
 
+/* 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;
+	const char *ip;
 
-	/*
-	 * TRANSLATORS: this format specifier will be the name of a network
-	 * device, like 'eth0'.
-	 */
-	device_handler_status_info(handler, _("Processing dhcp event on %s"),
-				dev->device->id);
+	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);
+
+	pending_network_jobs_start();
 
 	/* create our context */
 	ctx = device_handler_discover_context_create(handler, dev);
 	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);
 
-	/*
-	 * TRANSLATORS: this format specifier will be the name of a network
-	 * device, like 'eth0'.
-	 */
-	device_handler_status_info(handler, _("Processing %s complete"),
-				dev->device->id);
-
 	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)
 {
@@ -999,13 +1460,22 @@ 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);
 
@@ -1047,8 +1517,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);
@@ -1058,32 +1531,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
@@ -1125,62 +1610,101 @@ 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;
+	bool allow_async = false;
 	struct pb_url *pb_url;
 	struct event *event;
-	struct param *param;
-
-	if (!handler->network) {
-		device_handler_status_err(handler, _("No network configured"));
-		return;
-	}
 
-	event = talloc(handler, struct event);
+	event = talloc_zero(handler, struct event);
 	event->type = EVENT_TYPE_USER;
 	event->action = EVENT_ACTION_URL;
 
-	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;
-	} 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);
+	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;
 	}
 
-	if (pb_url->scheme == pb_url_file)
-		event->device = talloc_asprintf(event, "local");
-	else
+	if (url[strlen(url) - 1] == '/') {
+		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,
+		if (!event->device) {
+			device_handler_status_err(handler,
 					_("Unable to route to host %s"),
 					pb_url->host);
+			talloc_free(event);
+			return;
+		}
+	} else {
+		event_set_param(event, "pxeconffile", url);
+		allow_async = true;
+	}
+
+	if (pb_url->scheme == pb_url_file)
+		event->device = talloc_asprintf(event, "local");
+	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;
 	}
 
+	/* 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;
@@ -1195,6 +1719,61 @@ void device_handler_process_url(struct device_handler *handler,
 	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);
+
+	if (result)
+		device_handler_status_err(handler, "Could not install plugin");
+	else
+		handler->plugin_installing = true;
+}
+
 #ifndef PETITBOOT_TEST
 
 /**
@@ -1249,6 +1828,35 @@ void device_handler_discover_context_commit(struct device_handler *handler,
 	}
 }
 
+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;
@@ -1266,8 +1874,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,
@@ -1275,8 +1883,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;
@@ -1291,11 +1899,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)
@@ -1463,6 +2073,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;
@@ -1474,9 +2098,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);
@@ -1636,7 +2257,7 @@ void device_handler_discover_context_commit(
 		struct device_handler *handler __attribute__((unused)),
 		struct discover_context *ctx __attribute__((unused)))
 {
-	pb_log("%s stubbed out for test cases\n", __func__);
+	pb_log_fn("stubbed out for test cases\n");
 }
 
 static void device_handler_update_lang(const char *lang __attribute__((unused)))