X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=e75f41232db072e2db2a1aae4e6346b3574bdd99;hp=d1fdffe14b3e7b3533324fa49dca63501fb8de06;hb=87017f0478536fcb927010618be483a5efe9260c;hpb=bfe0549660d297809cda489c6b09db8132007ea0 diff --git a/discover/device-handler.c b/discover/device-handler.c index d1fdffe..e75f412 100644 --- a/discover/device-handler.c +++ b/discover/device-handler.c @@ -43,8 +43,9 @@ #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, }; @@ -77,8 +78,10 @@ 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; @@ -520,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); } @@ -531,6 +535,7 @@ 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); @@ -673,7 +678,7 @@ void device_handler_status_download(struct device_handler *handler, } if (!update) { - pb_log("%s: failed to allocate new status\n", __func__); + pb_log_fn("failed to allocate new status\n"); } else { device_handler_status_info(handler, "%s\n", update); talloc_free(update); @@ -752,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--; @@ -833,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); @@ -881,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) @@ -911,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; @@ -921,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; @@ -1201,6 +1286,7 @@ static int device_handler_requery_timeout_fn(void *data) struct requery_data *rqd = data; struct device_handler *handler; struct discover_device *device; + bool autoboot; handler = rqd->handler; device = rqd->device; @@ -1223,9 +1309,14 @@ static int device_handler_requery_timeout_fn(void *data) talloc_free(opt); } + /* 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", + pb_log("Default option %s cancelled since device is being requeried\n", opt->option->name); device_handler_cancel_default(handler); } @@ -1233,6 +1324,8 @@ static int device_handler_requery_timeout_fn(void *data) talloc_free(opt); } + handler->autoboot_enabled = autoboot; + discover_server_notify_device_remove(handler->server, device->device); device->notified = false; @@ -1298,10 +1391,15 @@ int device_handler_dhcp(struct device_handler *handler, struct discover_device *dev, struct event *event) { struct discover_context *ctx; + 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)"), - event_get_param(event, "ip")); + _("Processing DHCP lease response (ip: %s)"), ip); pending_network_jobs_start(); @@ -1322,6 +1420,28 @@ int device_handler_dhcp(struct device_handler *handler, 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) { @@ -1340,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); @@ -1388,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); @@ -1399,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 @@ -1475,7 +1619,7 @@ static void process_url_cb(struct load_url_result *result, void *data) const char *mac; if (result->status != LOAD_OK) { - pb_log("%s: Load failed for %s\n", __func__, result->url->full); + pb_log_fn("Load failed for %s\n", result->url->full); return; } @@ -1580,7 +1724,7 @@ static void plugin_install_cb(struct process *process) struct device_handler *handler = process->data; if (!handler) { - pb_log("%s: Missing data!\n", __func__); + pb_log_fn("Missing data!\n"); return; } @@ -2113,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)))