X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fuser-event.c;h=1257796494e5211f01d210a11565c9539a6bffca;hp=8cad1a91a624f5f55cd17d49858edfab3820133c;hb=c78f9ec47ba92b74698dacdae963dbbefd9b676f;hpb=999fd1a2053421b55cdd876049c40beb2921807f diff --git a/discover/user-event.c b/discover/user-event.c index 8cad1a9..1257796 100644 --- a/discover/user-event.c +++ b/discover/user-event.c @@ -37,6 +37,7 @@ #include "resource.h" #include "event.h" #include "user-event.h" +#include "sysinfo.h" #define MAC_ADDR_SIZE 6 @@ -58,6 +59,12 @@ static const char *event_action_name(enum event_action action) return "url"; case EVENT_ACTION_DHCP: return "dhcp"; + case EVENT_ACTION_BOOT: + return "boot"; + case EVENT_ACTION_SYNC: + return "sync"; + case EVENT_ACTION_PLUGIN: + return "plugin"; default: break; } @@ -78,7 +85,7 @@ static void user_event_print_event(struct event __attribute__((unused)) *event) } static struct resource *user_event_resource(struct discover_boot_option *opt, - struct event *event) + struct event *event, bool gen_boot_args_sigfile) { const char *siaddr, *boot_file; struct resource *res; @@ -87,17 +94,26 @@ static struct resource *user_event_resource(struct discover_boot_option *opt, siaddr = event_get_param(event, "siaddr"); if (!siaddr) { - pb_log("%s: next server option not found\n", __func__); + pb_log_fn("next server option not found\n"); return NULL; } boot_file = event_get_param(event, "bootfile"); if (!boot_file) { - pb_log("%s: bootfile not found\n", __func__); + pb_log_fn("bootfile not found\n"); return NULL; } - url_str = talloc_asprintf(opt, "%s%s/%s", "tftp://", siaddr, boot_file); + if (gen_boot_args_sigfile) { + char* args_sigfile_default = talloc_asprintf(opt, + "%s.cmdline.sig", boot_file); + url_str = talloc_asprintf(opt, "%s%s/%s", "tftp://", siaddr, + args_sigfile_default); + talloc_free(args_sigfile_default); + } + else + url_str = talloc_asprintf(opt, "%s%s/%s", "tftp://", siaddr, + boot_file); url = pb_url_parse(opt, url_str); talloc_free(url_str); @@ -132,19 +148,20 @@ static int parse_user_event(struct discover_context *ctx, struct event *event) val = event_get_param(event, "name"); if (!val) { - pb_log("%s: no name found\n", __func__); + pb_log_fn("no name found\n"); goto fail_opt; } opt->id = talloc_asprintf(opt, "%s#%s", dev->id, val); opt->name = talloc_strdup(opt, val); - d_opt->boot_image = user_event_resource(d_opt, event); + d_opt->boot_image = user_event_resource(d_opt, event, false); if (!d_opt->boot_image) { - pb_log("%s: no boot image found for %s!\n", __func__, + pb_log_fn("no boot image found for %s!\n", opt->name); goto fail_opt; } + d_opt->args_sig_file = user_event_resource(d_opt, event, true); val = event_get_param(event, "rootpath"); if (val) { @@ -234,13 +251,14 @@ static char *parse_ip_addr(struct discover_context *ctx, const char *ip) struct pb_url *user_event_parse_conf_url(struct discover_context *ctx, struct event *event, bool *is_complete) { - const char *conffile, *pathprefix, *host, *bootfile; + const char *conffile, *pathprefix, *host, *bootfile, *bootfile_url; char *p, *basedir, *url_str; struct pb_url *url; conffile = event_get_param(event, "pxeconffile"); pathprefix = event_get_param(event, "pxepathprefix"); bootfile = event_get_param(event, "bootfile"); + bootfile_url = event_get_param(event, "bootfile_url"); /* If we're given a conf file, we're able to generate a complete URL to * the configuration file, and the parser doesn't need to do any @@ -270,7 +288,13 @@ struct pb_url *user_event_parse_conf_url(struct discover_context *ctx, host = parse_host_addr(event); if (!host) { - pb_log("%s: host address not found\n", __func__); + pb_log_fn("host address not found\n"); + + /* No full URLs and no host address? Check for DHCPv6 options */ + if (bootfile_url && is_url(bootfile_url)) { + *is_complete = true; + return pb_url_parse(ctx, bootfile_url); + } return NULL; } @@ -338,7 +362,7 @@ char **user_event_parse_conf_filenames( } if (!mac_addr && !ip_hex) { - pb_log("%s: neither mac nor ip parameter found\n", __func__); + pb_log_fn("neither mac nor ip parameter found\n"); return NULL; } @@ -371,31 +395,29 @@ static int user_event_dhcp(struct user_event *uev, struct event *event) struct device_handler *handler = uev->handler; struct discover_device *dev; - dev = discover_device_create(handler, event->device); - - device_handler_dhcp(handler, dev, event); - - return 0; -} + uint8_t hwaddr[MAC_ADDR_SIZE]; -static int user_event_conf(struct user_event *uev, struct event *event) -{ - struct device_handler *handler = uev->handler; - struct discover_device *dev; - struct pb_url *url; - const char *val; + if (!event_get_param(event, "mac")) + return -1; + if (!event_get_param(event, "ip") && !event_get_param(event, "ipv6")) + return -1; - val = event_get_param(event, "url"); - if (!val) - return 0; + sscanf(event_get_param(event, "mac"), + "%hhX:%hhX:%hhX:%hhX:%hhX:%hhX", + hwaddr, hwaddr + 1, hwaddr + 2, + hwaddr + 3, hwaddr + 4, hwaddr + 5); - url = pb_url_parse(event, val); - if (!url) - return 0; + if (event_get_param(event, "ipv6")) + system_info_set_interface_address(sizeof(hwaddr), hwaddr, + event_get_param(event, "ipv6")); + else + system_info_set_interface_address(sizeof(hwaddr), hwaddr, + event_get_param(event, "ip")); - dev = discover_device_create(handler, event->device); + dev = discover_device_create(handler, event_get_param(event, "mac"), + event->device); - device_handler_conf(handler, dev, url); + device_handler_dhcp(handler, dev, event); return 0; } @@ -405,11 +427,19 @@ static int user_event_add(struct user_event *uev, struct event *event) struct device_handler *handler = uev->handler; struct discover_context *ctx; struct discover_device *dev; + int rc; - dev = discover_device_create(handler, event->device); + /* In case this is a network interface, try to refer to it by UUID */ + dev = discover_device_create(handler, event_get_param(event, "mac"), + event->device); + dev->device->id = talloc_strdup(dev, event->device); ctx = device_handler_discover_context_create(handler, dev); - parse_user_event(ctx, event); + rc = parse_user_event(ctx, event); + if (rc) { + pb_log("parse_user_event returned %d\n", rc); + return rc; + } device_handler_discover_context_commit(handler, ctx); @@ -422,8 +452,13 @@ static int user_event_remove(struct user_event *uev, struct event *event) { struct device_handler *handler = uev->handler; struct discover_device *dev; + const char *mac = event_get_param(event, "mac"); + + if (mac) + dev = device_lookup_by_uuid(handler, event_get_param(event, "mac")); + else + dev = device_lookup_by_id(handler, event->device); - dev = device_lookup_by_id(handler, event->device); if (!dev) return 0; @@ -439,7 +474,142 @@ static int user_event_url(struct user_event *uev, struct event *event) url = event_get_param(event, "url"); if (url) - device_handler_process_url(handler, url); + device_handler_process_url(handler, url, NULL, NULL); + + return 0; +} + +static int user_event_boot(struct user_event *uev, struct event *event) +{ + struct device_handler *handler = uev->handler; + struct boot_command *cmd = talloc(handler, struct boot_command); + + cmd->option_id = talloc_strdup(cmd, event_get_param(event, "id")); + cmd->boot_image_file = talloc_strdup(cmd, event_get_param(event, "image")); + cmd->initrd_file = talloc_strdup(cmd, event_get_param(event, "initrd")); + cmd->dtb_file = talloc_strdup(cmd, event_get_param(event, "dtb")); + cmd->boot_args = talloc_strdup(cmd, event_get_param(event, "args")); + + device_handler_boot(handler, cmd); + + talloc_free(cmd); + + return 0; +} + +static int user_event_sync(struct user_event *uev, struct event *event) +{ + struct device_handler *handler = uev->handler; + + if (strncasecmp(event->device, "all", strlen("all")) != 0) + device_sync_snapshots(handler, event->device); + else + device_sync_snapshots(handler, NULL); + + return 0; +} + +static int process_uninstalled_plugin(struct user_event *uev, + struct event *event) +{ + struct device_handler *handler = uev->handler; + struct discover_boot_option *file_opt; + struct discover_device *device; + struct discover_context *ctx; + const char *path; + struct resource *res; + + if (!event_get_param(event, "path")) { + pb_log("Uninstalled pb-plugin event missing path param\n"); + return -1; + } + + device = device_lookup_by_name(handler, event->device); + if (!device) { + pb_log("Couldn't find device matching %s for plugin\n", + event->device); + return -1; + } + + ctx = device_handler_discover_context_create(handler, device); + file_opt = discover_boot_option_create(ctx, device); + file_opt->option->name = talloc_strdup(file_opt, + event_get_param(event, "name")); + file_opt->option->id = talloc_asprintf(file_opt, "%s@%p", + device->device->id, file_opt); + file_opt->option->type = DISCOVER_PLUGIN_OPTION; + + + path = event_get_param(event, "path"); + /* path may be relative to root */ + if (strncmp(device->mount_path, path, strlen(device->mount_path)) == 0) { + path += strlen(device->mount_path) + 1; + } + + res = talloc(file_opt, struct resource); + resolve_resource_against_device(res, device, path); + file_opt->boot_image = res; + + discover_context_add_boot_option(ctx, file_opt); + device_handler_discover_context_commit(handler, ctx); + + return 0; +} + +/* + * Notification of a plugin event. This can either be for an uninstalled plugin + * that pb-plugin has scanned, or the result of a plugin that pb-plugin has + * installed. + */ +static int user_event_plugin(struct user_event *uev, struct event *event) +{ + struct device_handler *handler = uev->handler; + char *executable, *executables, *saveptr; + struct plugin_option *opt; + const char *installed; + + installed = event_get_param(event, "installed"); + if (!installed || strncmp(installed, "no", strlen("no")) == 0) + return process_uninstalled_plugin(uev, event); + + opt = talloc_zero(handler, struct plugin_option); + if (!opt) + return -1; + opt->name = talloc_strdup(opt, event_get_param(event, "name")); + opt->id = talloc_strdup(opt, event_get_param(event, "id")); + opt->version = talloc_strdup(opt, event_get_param(event, "version")); + opt->vendor = talloc_strdup(opt, event_get_param(event, "vendor")); + opt->vendor_id = talloc_strdup(opt, event_get_param(event, "vendor_id")); + opt->date = talloc_strdup(opt, event_get_param(event, "date")); + opt->plugin_file = talloc_strdup(opt, + event_get_param(event, "source_file")); + + executables = talloc_strdup(opt, event_get_param(event, "executables")); + if (!executables) { + talloc_free(opt); + return -1; + } + + /* + * The 'executables' parameter is a space-delimited list of installed + * executables + */ + executable = strtok_r(executables, " ", &saveptr); + while (executable) { + opt->executables = talloc_realloc(opt, opt->executables, + char *, opt->n_executables + 1); + if (!opt->executables) { + talloc_free(opt); + return -1; + } + opt->executables[opt->n_executables++] = talloc_strdup(opt, + executable); + executable = strtok_r(NULL, " ", &saveptr); + } + + device_handler_add_plugin_option(handler, opt); + + talloc_free(executables); return 0; } @@ -469,19 +639,27 @@ static void user_event_handle_message(struct user_event *uev, char *buf, break; case EVENT_ACTION_URL: result = user_event_url(uev, event); - break; - case EVENT_ACTION_CONF: - result = user_event_conf(uev, event); - break; + goto out; case EVENT_ACTION_DHCP: result = user_event_dhcp(uev, event); + goto out; + case EVENT_ACTION_BOOT: + result = user_event_boot(uev, event); + break; + case EVENT_ACTION_SYNC: + result = user_event_sync(uev, event); + break; + case EVENT_ACTION_PLUGIN: + result = user_event_plugin(uev, event); break; default: break; } + /* user_event_url() and user_event_dhcp() will steal the event context, + * but all others still need to free */ talloc_free(event); - +out: return; } @@ -494,12 +672,12 @@ static int user_event_process(void *arg) len = recvfrom(uev->socket, buf, PBOOT_USER_EVENT_SIZE, 0, NULL, NULL); if (len < 0) { - pb_log("%s: socket read failed: %s", __func__, strerror(errno)); + pb_log_fn("socket read failed: %s\n", strerror(errno)); return 0; } if (len == 0) { - pb_log("%s: empty", __func__); + pb_log_fn("empty\n"); return 0; }