]> git.ozlabs.org Git - petitboot/blobdiff - discover/device-handler.c
discover: Handle and track plugin_options
[petitboot] / discover / device-handler.c
index 730be857f5e564fdfea8938dbfc134d1f3c679be..3ef48ada77394e2252249b4495af81c8efe94291 100644 (file)
@@ -84,6 +84,9 @@ struct device_handler {
 
        struct list             progress;
        unsigned int            n_progress;
+
+       struct plugin_option    **plugins;
+       unsigned int            n_plugins;
 };
 
 static int mount_device(struct discover_device *dev);
@@ -126,6 +129,28 @@ 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)
 {
@@ -385,6 +410,15 @@ 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);
+
        device_handler_reinit_sources(handler);
 }
 
@@ -628,7 +662,8 @@ 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);
@@ -1244,62 +1279,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("%s: Load failed for %s\n", __func__, 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", 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;
@@ -1368,6 +1442,36 @@ 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 &&
+                               strncmp(opt->version, tmp->version,
+                                       strlen(opt->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;
@@ -1385,15 +1489,15 @@ 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)
-               return -1;
-
        handler->network = network_init(handler, handler->waitset,
                        handler->dry_run);
        if (!handler->network)
                return -1;
 
+       handler->udev = udev_init(handler, handler->waitset);
+       if (!handler->udev)
+               return -1;
+
        handler->user_event = user_event_init(handler, handler->waitset);
        if (!handler->user_event)
                return -1;
@@ -1412,11 +1516,11 @@ static void device_handler_reinit_sources(struct device_handler *handler)
 
        system_info_reinit();
 
-       udev_reinit(handler->udev);
-
        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)