X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fpxe-parser.c;h=8237c4b46b2b29b8417fa661b8afacb70777b130;hp=95547c389799ab06ed7dc4f5a06f937e9ed4743e;hb=bdd5c29b008a4484ed141f934d97465d673a10b7;hpb=9c33c54f7b431074a7d0daddce34140044aaadf6 diff --git a/discover/pxe-parser.c b/discover/pxe-parser.c index 95547c3..8237c4b 100644 --- a/discover/pxe-parser.c +++ b/discover/pxe-parser.c @@ -8,6 +8,8 @@ #include #include #include +#include +#include #include "parser.h" #include "parser-conf.h" @@ -20,9 +22,14 @@ static const char *pxelinux_prefix = "pxelinux.cfg/"; +static void pxe_conf_parse_cb(struct load_url_result *result, void *data); + struct pxe_parser_info { - struct discover_boot_option *opt; - const char *default_name; + struct discover_boot_option *opt; + const char *default_name; + char **pxe_conf_files; + struct pb_url *pxe_base_url; + int current; }; static void pxe_finish(struct conf_context *conf) @@ -164,6 +171,13 @@ static void pxe_process_pair(struct conf_context *ctx, url = pxe_url_join(ctx->dc, ctx->dc->conf_url, value); opt->boot_image = create_url_resource(opt, url); + char* args_sigfile_default = talloc_asprintf(opt, + "%s.cmdline.sig", value); + url = pxe_url_join(ctx->dc, ctx->dc->conf_url, + args_sigfile_default); + opt->args_sig_file = create_url_resource(opt, url); + talloc_free(args_sigfile_default); + } else if (streq(name, "INITRD")) { url = pxe_url_join(ctx->dc, ctx->dc->conf_url, value); opt->initrd = create_url_resource(opt, url); @@ -189,91 +203,194 @@ static void pxe_process_pair(struct conf_context *ctx, type = strtoul(value, &end, 10); if (end != value && !(*end)) pxe_process_sysappend(ctx->dc, opt, type); + + } else if (streq(name, "DTB") || streq(name, "FDT")) { + url = pxe_url_join(ctx->dc, ctx->dc->conf_url, value); + opt->dtb = create_url_resource(opt, url); } } -static int pxe_parse(struct discover_context *dc) +static void pxe_load_next_filename(struct conf_context *conf) { - struct pb_url *pxe_base_url, *url; - struct pxe_parser_info *parser_info; - char **pxe_conf_files, **filename; - struct conf_context *conf; - bool complete_url; - int len, rc; - char *buf; + struct pxe_parser_info *info = conf->parser_info; + struct pb_url *url; - /* Expects dhcp event parameters to support network boot */ - if (!dc->event) - return -1; + if (!info->pxe_conf_files) + return; + + for (; info->pxe_conf_files[info->current]; info->current++) { + url = pb_url_join(conf->dc, info->pxe_base_url, + info->pxe_conf_files[info->current]); + if (!url) + continue; + + if (load_url_async(conf, url, pxe_conf_parse_cb, conf)) + break; + } + + return; +} + +/* + * Callback for asynchronous loads from pxe_parse() + * @param result Result of load_url_async() + * @param data Pointer to associated conf_context + */ +static void pxe_conf_parse_cb(struct load_url_result *result, void *data) +{ + struct conf_context *conf = data; + struct device_handler *handler; + struct pxe_parser_info *info; + char *buf = NULL; + int len, rc = 0; + + if (!data) + return; + + if (result && result->status == LOAD_OK) + rc = read_file(conf, result->local, &buf, &len); + if (!result || result->status != LOAD_OK || rc) { + /* This load failed so try the next available filename */ + info = conf->parser_info; + if (!info->pxe_conf_files) + return; + + info->current++; + pxe_load_next_filename(conf); + if (info->pxe_conf_files[info->current] == NULL) { + /* Nothing left to try */ + goto out_clean; + } + return; + } + + /* + * Parse the first successfully downloaded file. We only want to parse + * the first because otherwise we could parse options from both a + * machine-specific config and a 'fallback' default config + */ + + conf_parse_buf(conf, buf, len); + + /* We may be called well after the original caller of iterate_parsers(), + * commit any new boot options ourselves */ + handler = talloc_parent(conf); + device_handler_discover_context_commit(handler, conf->dc); + + /* + * TRANSLATORS: the format specifier in this string in an IP address, + * eg. 192.168.1.1 + */ + device_handler_status_dev_info(handler, conf->dc->device, + _("Parsed PXE config from %s"), + conf->dc->conf_url->host); + + talloc_free(buf); +out_clean: + if (result->cleanup_local) + unlink(result->local); + talloc_free(conf); +} + +/** + * Return a new conf_context and increment the talloc reference count on + * the discover_context struct. + * @param ctx Parent talloc context + * @param orig Original discover_context + * @return Pointer to new conf_context + */ +static struct conf_context *copy_context(void *ctx, struct discover_context *dc) +{ + struct pxe_parser_info *info; + struct conf_context *conf; - conf = talloc_zero(dc, struct conf_context); + conf = talloc_zero(ctx, struct conf_context); if (!conf) - goto out; + return NULL; - conf->dc = dc; conf->get_pair = conf_get_pair_space; conf->process_pair = pxe_process_pair; conf->finish = pxe_finish; + info = talloc_zero(conf, struct pxe_parser_info); + if (!info) { + talloc_free(conf); + return NULL; + } + conf->parser_info = info; + + /* + * The discover_context may be freed once pxe_parse() returns, but the + * callback will still need it. Take a reference so that that it will + * persist until the last callback completes. + */ + conf->dc = talloc_reference(conf, dc); - parser_info = talloc_zero(conf, struct pxe_parser_info); - conf->parser_info = parser_info; + return conf; +} + +static int pxe_parse(struct discover_context *dc) +{ + struct pb_url *pxe_base_url; + struct conf_context *conf = NULL; + struct load_url_result *result; + void *ctx = talloc_parent(dc); + struct pxe_parser_info *info; + char **pxe_conf_files; + bool complete_url; + + /* Expects dhcp event parameters to support network boot */ + if (!dc->event) + return -1; dc->conf_url = user_event_parse_conf_url(dc, dc->event, &complete_url); if (!dc->conf_url) - goto out_conf; + return -1; + + /* + * Retrieving PXE configs over the network can take some time depending + * on factors such as slow network, malformed paths, bad DNS, and + * overzealous firewalls. Instead of blocking the discover server while + * we wait for these, spawn an asynchronous job that will attempt to + * retrieve each possible URL until it successfully finds one, and + * parse and process the resulting file in a callback. + */ + conf = copy_context(ctx, dc); + if (!conf) + return -1; if (complete_url) { /* we have a complete URL; use this and we're done. */ - rc = parser_request_url(dc, dc->conf_url, &buf, &len); - if (rc) + result = load_url_async(conf->dc, conf->dc->conf_url, + pxe_conf_parse_cb, conf); + if (!result) { + pb_log("load_url_async fails for %s\n", + dc->conf_url->path); goto out_conf; + } } else { pxe_conf_files = user_event_parse_conf_filenames(dc, dc->event); if (!pxe_conf_files) goto out_conf; - rc = -1; - pxe_base_url = pb_url_join(dc, dc->conf_url, pxelinux_prefix); if (!pxe_base_url) goto out_pxe_conf; - for (filename = pxe_conf_files; *filename; filename++) { - url = pb_url_join(dc, pxe_base_url, *filename); - if (!url) - continue; - - rc = parser_request_url(dc, url, &buf, &len); - if (!rc) /* found one, just break */ - break; - - talloc_free(url); - } + info = conf->parser_info; + info->pxe_conf_files = pxe_conf_files; + info->pxe_base_url = pxe_base_url; - talloc_free(pxe_base_url); - - /* No configuration file found on the boot server */ - if (rc) - goto out_pxe_conf; - - talloc_free(pxe_conf_files); + pxe_load_next_filename(conf); } - /* Call the config file parser with the data read from the file */ - conf_parse_buf(conf, buf, len); - - talloc_free(buf); - talloc_free(conf); - return 0; out_pxe_conf: talloc_free(pxe_conf_files); out_conf: talloc_free(conf); -out: return -1; }