X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fparser.c;h=54787201553010d808297eaf8cc8c1730540d0db;hp=641e06b1cb54e9bdf34d1547e8a3de465a2097f2;hb=c3dfc9b7b91045172d460651c0309b09b0ab121a;hpb=45e92aa32a80fdbbf5ad3ad64e34b1ac872018ef diff --git a/discover/parser.c b/discover/parser.c index 641e06b..5478720 100644 --- a/discover/parser.c +++ b/discover/parser.c @@ -1,10 +1,9 @@ #include #include -#include -#include #include "types/types.h" +#include #include #include @@ -13,110 +12,199 @@ #include "parser-utils.h" #include "paths.h" -static int n_parsers; -static struct parser **parsers; +struct p_item { + struct list_item list; + struct parser *parser; +}; -static const int max_file_size = 1024 * 1024; +STATIC_LIST(parsers); -static int read_file(struct discover_context *ctx, - const char *filename, char **bufp, int *lenp) +static char *local_path(struct discover_context *ctx, + struct discover_device *dev, + const char *filename) { - struct stat statbuf; - int rc, fd, i, len; - char *buf; + return join_paths(ctx, dev->root_path, filename); +} + +int parser_request_file(struct discover_context *ctx, + struct discover_device *dev, const char *filename, + char **buf, int *len) - fd = open(filename, O_RDONLY); - if (fd < 0) +{ + char *path; + int rc; + + /* we only support local files at present */ + if (!dev->mount_path) return -1; - rc = fstat(fd, &statbuf); - if (rc < 0) - goto err_close; + path = local_path(ctx, dev, filename); - len = statbuf.st_size; - if (len > max_file_size) - goto err_close; + rc = read_file(ctx, path, buf, len); - buf = talloc_array(ctx, char, len); - if (!buf) - goto err_close; + talloc_free(path); - for (i = 0; i < len; i += rc) { - rc = read(fd, buf + i, len - i); + return rc; +} - /* unexpected EOF: trim and return */ - if (rc == 0) { - len = i; - break; - } +int parser_stat_path(struct discover_context *ctx, + struct discover_device *dev, const char *path, + struct stat *statbuf) +{ + int rc = -1; + char *full_path; + + /* we only support local files at present */ + if (!dev->mount_path) + return -1; - if (rc < 0) - goto err_free; + full_path = local_path(ctx, dev, path); + rc = stat(full_path, statbuf); + if (rc) { + rc = -1; + goto out; } - close(fd); - *bufp = buf; - *lenp = len; - return 0; + rc = 0; +out: + talloc_free(full_path); -err_free: - talloc_free(buf); -err_close: - close(fd); - return -1; + return rc; } -static char *local_path(struct discover_context *ctx, - const char *filename) +bool parser_is_unique(struct discover_context *ctx, struct discover_device *dev, + const char *filename, struct list *found_list) { - return join_paths(ctx, ctx->device->mount_path, filename); + struct stat stat; + struct parser_found_file *found_file; + const struct parser_found_file *entry; + + if (parser_stat_path(ctx, dev, filename, &stat)) { + pb_debug("%s: Not found: '%s'\n", __func__, filename); + return false; + } + + list_for_each_entry(found_list, entry, list) { + if (entry->ino == stat.st_ino) { + pb_log("%s: Duplicate: '%s' = '%s'\n", + __func__, filename, entry->filename); + return false; + } + } + + pb_debug("%s: Found: '%s'\n", __func__, filename); + + found_file = talloc_zero(found_list, struct parser_found_file); + found_file->filename = talloc_strdup(found_file, filename); + found_file->ino = stat.st_ino; + list_add(found_list, &found_file->list); + + return true; } -static void iterate_parser_files(struct discover_context *ctx, - const struct parser *parser) +int parser_replace_file(struct discover_context *ctx, + struct discover_device *dev, const char *filename, + char *buf, int len) { - const char * const *filename; - const char *path; + bool release; + char *path; + int rc; - if (!parser->filenames) - return; + if (!dev->mounted) + return -1; - for (filename = parser->filenames; *filename; filename++) { - int rc, len; - char *buf; + rc = device_request_write(dev, &release); + if (rc) { + pb_log("Can't write file %s: device doesn't allow write\n", + dev->device_path); + return -1; + } - path = local_path(ctx, *filename); - if (!path) - continue; + path = local_path(ctx, dev, filename); - rc = read_file(ctx, path, &buf, &len); - if (!rc) { - parser->parse(ctx, buf, len); - talloc_free(buf); - } + rc = replace_file(path, buf, len); + + talloc_free(path); + + device_release_write(dev, release); + + return rc; +} + +int parser_request_url(struct discover_context *ctx, struct pb_url *url, + char **buf, int *len) +{ + struct load_url_result *result; + int rc; + + result = load_url(ctx, url); + if (!result) + goto out; + + rc = read_file(ctx, result->local, buf, len); + if (rc) { + pb_log("Read failed for the parser %s on file %s\n", + ctx->parser->name, result->local); + goto out_clean; } + + return 0; + +out_clean: + if (result->cleanup_local) + unlink(result->local); +out: + return -1; +} + +int parser_scandir(struct discover_context *ctx, const char *dirname, + struct dirent ***files, int (*filter)(const struct dirent *), + int (*comp)(const struct dirent **, const struct dirent **)) +{ + char *path; + int n; + + path = talloc_asprintf(ctx, "%s%s", ctx->device->mount_path, dirname); + if (!path) + return -1; + + n = scandir(path, files, filter, comp); + talloc_free(path); + return n; } void iterate_parsers(struct discover_context *ctx) { - int i; + struct p_item* i; pb_log("trying parsers for %s\n", ctx->device->device->id); - for (i = 0; i < n_parsers; i++) { - pb_log("\ttrying parser '%s'\n", parsers[i]->name); - ctx->parser = parsers[i]; - iterate_parser_files(ctx, parsers[i]); + list_for_each_entry(&parsers, i, list) { + pb_debug("\ttrying parser '%s'\n", i->parser->name); + ctx->parser = i->parser; + i->parser->parse(ctx); } ctx->parser = NULL; } +static void *parsers_ctx; + void __register_parser(struct parser *parser) { - parsers = talloc_realloc(NULL, parsers, struct parser *, n_parsers + 1); - parsers[n_parsers] = parser; - n_parsers++; + struct p_item *i; + + if (!parsers_ctx) + parsers_ctx = talloc_new(NULL); + + i = talloc(parsers_ctx, struct p_item); + i->parser = parser; + list_add(&parsers, &i->list); +} + +static __attribute__((destructor)) void cleanup_parsers(void) +{ + talloc_free(parsers_ctx); } void parser_init(void)