X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fpxe-parser.c;h=4aae8b14bf2eccf27cd209fd8870218e4345d2d6;hp=810396a6c88dc370552d8fff575234b2ac922044;hb=86c9d34380b0074dab1ba89a569a94280d6999c4;hpb=ec80a0397adc1fd405dedce961a17d164241851a diff --git a/discover/pxe-parser.c b/discover/pxe-parser.c index 810396a..4aae8b1 100644 --- a/discover/pxe-parser.c +++ b/discover/pxe-parser.c @@ -1,25 +1,129 @@ -#define _GNU_SOURCE +#if defined(HAVE_CONFIG_H) +#include "config.h" +#endif +#include #include #include #include +#include +#include +#include #include "parser.h" #include "parser-conf.h" #include "parser-utils.h" #include "resource.h" +#include "paths.h" +#include "event.h" +#include "user-event.h" +#include "network.h" + +static const char *pxelinux_prefix = "pxelinux.cfg/"; + +struct pxe_parser_info { + struct discover_boot_option *opt; + const char *default_name; +}; static void pxe_finish(struct conf_context *conf) { - printf("%s\n", __func__); - discover_context_add_boot_option(conf->dc, conf->parser_info); + struct pxe_parser_info *info = conf->parser_info; + if (info->opt) + discover_context_add_boot_option(conf->dc, info->opt); +} + +/* We need a slightly modified version of pb_url_join, to allow for the + * pxelinux "::filename" syntax for absolute URLs + */ +static struct pb_url *pxe_url_join(void *ctx, const struct pb_url *url, + const char *s) +{ + struct pb_url *new_url; + int len; + + len = strlen(s); + + if (len > 2 && s[0] == ':' && s[1] == ':') { + char *tmp; + + if (s[2] == '/') { + /* ::/path -> /path */ + tmp = talloc_strdup(ctx, s+2); + } else { + /* ::path -> /path */ + tmp = talloc_strdup(ctx, s+1); + tmp[0] = '/'; + } + + new_url = pb_url_join(ctx, url, tmp); + + talloc_free(tmp); + + } else { + const char *tmp; + /* strip leading slashes */ + for (tmp = s; *tmp == '/'; tmp++) + ; + new_url = pb_url_join(ctx, url, tmp); + } + + return new_url; +} + +static void pxe_append_string(struct discover_boot_option *opt, + const char *str) +{ + if (opt->option->boot_args) + opt->option->boot_args = talloc_asprintf_append( + opt->option->boot_args, " %s", str); + else + opt->option->boot_args = talloc_strdup(opt->option, str); +} + +static char *pxe_sysappend_mac(void *ctx, uint8_t *mac) +{ + if (!mac) + return NULL; + + return talloc_asprintf(ctx, + "BOOTIF=01-%02x-%02x-%02x-%02x-%02x-%02x", + mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); +} + +static void pxe_process_sysappend(struct discover_context *ctx, + struct discover_boot_option *opt, + unsigned long val) +{ + struct event *event = ctx->event; + char *str = NULL; + + if (!event) + return; + + if (val & 0x2) { + uint8_t *mac = find_mac_by_name(ctx, ctx->network, + event->device); + str = pxe_sysappend_mac(ctx, mac); + if (str) { + pxe_append_string(opt, str); + talloc_free(str); + } + val &= ~0x2; + } + + if (val) + pb_log("pxe: unsupported features requested in " + "ipappend/sysappend: 0x%04lx", val); + } static void pxe_process_pair(struct conf_context *ctx, const char *name, char *value) { - struct discover_boot_option *opt = ctx->parser_info; + struct pxe_parser_info *parser_info = ctx->parser_info; + struct discover_boot_option *opt = parser_info->opt; struct pb_url *url; /* quirk in the syslinux config format: initrd can be separated @@ -32,16 +136,25 @@ static void pxe_process_pair(struct conf_context *ctx, if (!name) return; + if (streq(name, "DEFAULT")) { + parser_info->default_name = talloc_strdup(parser_info, value); + return; + } + if (streq(name, "LABEL")) { if (opt) pxe_finish(ctx); opt = discover_boot_option_create(ctx->dc, ctx->dc->device); - ctx->parser_info = opt; opt->option->name = talloc_strdup(opt, value); opt->option->id = talloc_asprintf(opt, "%s@%p", ctx->dc->device->device->id, opt); + + opt->option->is_default = parser_info->default_name && + streq(parser_info->default_name, value); + + parser_info->opt = opt; return; } @@ -50,17 +163,24 @@ static void pxe_process_pair(struct conf_context *ctx, return; if (streq(name, "KERNEL")) { - url = pb_url_join(ctx->dc, ctx->dc->conf_url, value); + 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 = pb_url_join(ctx->dc, ctx->dc->conf_url, value); + url = pxe_url_join(ctx->dc, ctx->dc->conf_url, value); opt->initrd = create_url_resource(opt, url); } else if (streq(name, "APPEND")) { char *str, *end; - opt->option->boot_args = talloc_strdup(opt->option, value); + pxe_append_string(opt, value); str = strcasestr(value, "INITRD="); if (str) { @@ -68,37 +188,192 @@ static void pxe_process_pair(struct conf_context *ctx, end = strchrnul(str, ' '); *end = '\0'; - url = pb_url_join(ctx->dc, ctx->dc->conf_url, str); + url = pxe_url_join(ctx->dc, ctx->dc->conf_url, str); opt->initrd = create_url_resource(opt, url); } + } else if (streq(name, "SYSAPPEND") || streq(name, "IPAPPEND")) { + unsigned long type; + char *end; + + 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, char *buf, int len) +/* + * 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 boot_status status = {0}; + char *buf = NULL; + int len, rc; + + if (!data) + return; + + if (!result || result->status != LOAD_OK) { + talloc_free(conf); + return; + } + + rc = read_file(conf, result->local, &buf, &len); + if (rc) { + pb_log("Read failed during pxe callback for %s\n", result->local); + goto out_clean; + } + + 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); + + status.type = BOOT_STATUS_INFO; + /* + * TRANSLATORS: the format specifier in this string in an IP address, + * eg. 192.168.1.1 + */ + status.message = talloc_asprintf(conf, _("pxe: parsed config for %s"), + conf->dc->conf_url->host); + device_handler_boot_status(handler, &status); + + 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) - return 0; + 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; - conf_parse_buf(conf, buf, len); + /* + * 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); + + return conf; +} + +static int pxe_parse(struct discover_context *dc) +{ + struct pb_url *pxe_base_url, *url; + char **pxe_conf_files, **filename; + struct conf_context *conf = NULL; + struct load_url_result *result; + void *ctx = talloc_parent(dc); + 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) + 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 for each URL we can + * parse and process the resulting files in a callback. A separate + * conf_context is created for each job. + */ + conf = copy_context(ctx, dc); + if (!conf) + return -1; + + if (complete_url) { + /* we have a complete URL; use this and we're done. */ + 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; + + 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++) { + if (!conf) { + conf = copy_context(ctx, dc); + } + url = pb_url_join(conf->dc, pxe_base_url, *filename); + if (!url) + continue; + result = load_url_async(conf, url, pxe_conf_parse_cb, + conf); + if (!result) { + pb_log("load_url_async fails for %s\n", + conf->dc->conf_url->path); + talloc_free(conf); + } + /* conf now needed by callback, don't reuse */ + conf = NULL; + } + + talloc_free(pxe_base_url); + talloc_free(pxe_conf_files); + } + + return 0; +out_pxe_conf: + talloc_free(pxe_conf_files); +out_conf: talloc_free(conf); - return 1; + return -1; } static struct parser pxe_parser = { .name = "pxe", .parse = pxe_parse, - .method = CONF_METHOD_DHCP, }; register_parser(pxe_parser);