test/parser: Add parser_is_unique

[petitboot] / test / parser / utils.c

diff --git a/test/parser/utils.c b/test/parser/utils.c
index 2891969791c882da1df1fe6742eb5f1bf0cfcece..d8499a47689ab2115065a005aca6d5b957755603 100644 (file)
--- a/test/parser/utils.c
+++ b/test/parser/utils.c
@@ -17,6 +17,8 @@
 #include "resource.h"
 #include "event.h"
 #include "platform.h"
+#include "paths.h"
+#include "parser-conf.h"
 
 #include "parser-test.h"
 
@@ -71,7 +73,7 @@ struct discover_device *test_create_device(struct parser_test *test,
 {
        struct discover_device *dev;
 
-       dev = discover_device_create(test->handler, name);
+       dev = discover_device_create(test->handler, NULL, name);
 
        dev->device->id = talloc_strdup(dev, name);
        dev->device_path = talloc_asprintf(dev, "/dev/%s", name);
@@ -91,6 +93,7 @@ static struct discover_context *test_create_context(struct parser_test *test)
        list_init(&ctx->boot_options);
        ctx->device = test_create_device_simple(test);
        ctx->test_data = test;
+       ctx->handler = test->handler;
        device_handler_add_device(test->handler, ctx->device);
 
        return ctx;
@@ -282,7 +285,7 @@ int parser_replace_file(struct discover_context *ctx,
                char *buf, int len)
 {
        struct parser_test *test = ctx->test_data;
-       struct test_file *f, *file;
+       struct test_file *f, *file = NULL;
 
        list_for_each_entry(&test->files, f, list) {
                if (f->dev != dev)
@@ -306,6 +309,141 @@ int parser_replace_file(struct discover_context *ctx,
        return 0;
 }
 
+int parser_scandir(struct discover_context *ctx, const char *dirname,
+                  struct dirent ***files, int (*filter)(const struct dirent *)
+                  __attribute__((unused)),
+                  int (*comp)(const struct dirent **, const struct dirent **)
+                  __attribute__((unused)))
+{
+       struct parser_test *test = ctx->test_data;
+       struct test_file *f;
+       char *filename;
+       struct dirent **dirents = NULL, **new_dirents;
+       int n = 0, namelen;
+
+       list_for_each_entry(&test->files, f, list) {
+               if (f->dev != ctx->device)
+                       continue;
+
+               if (strlen(f->name) <= strlen(dirname))
+                       continue;
+
+               filename = strrchr(f->name, '/');
+               if (!filename)
+                       continue;
+
+               namelen = strlen(filename);
+
+               if (strncmp(f->name, dirname, strlen(f->name) - namelen))
+                       continue;
+
+               if (!dirents) {
+                       dirents = malloc(sizeof(struct dirent *));
+               } else {
+                       new_dirents = realloc(dirents, sizeof(struct dirent *)
+                                             * (n + 1));
+                       if (!new_dirents)
+                               goto err_cleanup;
+
+                       dirents = new_dirents;
+               }
+
+               dirents[n] = malloc(sizeof(struct dirent) + namelen + 1);
+
+               if (!dirents[n])
+                       goto err_cleanup;
+
+               strcpy(dirents[n]->d_name, filename + 1);
+               n++;
+       }
+
+       *files = dirents;
+
+       return n;
+
+err_cleanup:
+       do {
+               free(dirents[n]);
+       } while (n-- > 0);
+
+       free(dirents);
+
+       return -1;
+}
+
+bool parser_is_unique(struct discover_context *ctx, struct discover_device *dev,
+       const char *filename, struct list *found_list)
+{
+       (void)ctx;
+       (void)dev;
+       (void)filename;
+       (void)found_list;
+
+       /* Just let the parser process everything. */
+       return true;
+}
+
+struct load_url_result *load_url_async(void *ctx, struct pb_url *url,
+               load_url_complete async_cb, void *async_data,
+               waiter_cb stdout_cb, void *stdout_data)
+{
+       struct conf_context *conf = async_data;
+       struct parser_test *test = conf->dc->test_data;
+       struct load_url_result *result;
+       char tmp[] = "/tmp/pb-XXXXXX";
+       ssize_t rc = -1, sz = 0;
+       struct test_file *file;
+       int fd;
+
+       /* Ignore the stdout callback for tests */
+       (void)stdout_cb;
+       (void)stdout_data;
+
+       fd = mkstemp(tmp);
+
+       if (fd < 0)
+               return NULL;
+
+       /* Some parsers will expect to need to read a file, so write the
+        * specified file to a temporary file */
+       list_for_each_entry(&test->files, file, list) {
+               if (file->dev)
+                       continue;
+
+               if (strcmp(file->name, url->full))
+                       continue;
+
+               while (sz < file->size) {
+                       rc = write(fd, file->data, file->size);
+                       if (rc < 0) {
+                               fprintf(stderr,
+                                       "Failed to write to tmpfile, %m\n");
+                               break;
+                       }
+                       sz += rc;
+               }
+               break;
+       }
+
+       close(fd);
+
+       result = talloc_zero(ctx, struct load_url_result);
+       if (!result)
+               return NULL;
+
+       result->local = talloc_strdup(result, tmp);
+       result->url = url;
+       if (rc < 0)
+               result->status = LOAD_ERROR;
+       else
+               result->status = result->local ? LOAD_OK : LOAD_ERROR;
+       result->cleanup_local = true;
+
+       async_cb(result, conf);
+
+       return result;
+}
+
 int parser_request_url(struct discover_context *ctx, struct pb_url *url,
                char **buf, int *len)
 {