#include "parser.h"
#include "resource.h"
#include "event.h"
+#include "platform.h"
+#include "paths.h"
+#include "parser-conf.h"
#include "parser-test.h"
{
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);
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;
}
-extern struct config *test_config_init(struct parser_test *test);
+/* define our own test platform */
+static bool test_platform_probe(struct platform *p __attribute__((unused)),
+ void *ctx __attribute__((unused)))
+{
+ return true;
+}
+
+struct platform test_platform = {
+ .name = "test",
+ .probe = test_platform_probe,
+};
+
+register_platform(test_platform);
struct parser_test *test_init(void)
{
struct parser_test *test;
test = talloc_zero(NULL, struct parser_test);
- test->config = test_config_init(test);
+ platform_init(NULL);
test->handler = device_handler_init(NULL, NULL, 0);
test->ctx = test_create_context(test);
list_init(&test->files);
{
device_handler_destroy(test->handler);
talloc_free(test);
+ platform_fini();
}
void __test_read_conf_data(struct parser_test *test,
file->type = TEST_DIR;
file->dev = dev;
file->name = dirname;
+ /* Pick a non-zero size for directories so that "[ -s <dir
+ * path> ]" sees that the file has non-zero size. */
+ file->size = 1;
list_add(&test->files, &file->list);
}
event_set_param(event, name, value);
}
+void test_set_event_device(struct event *event, const char *dev)
+{
+ event->device = talloc_strdup(event, dev);
+}
+
int parser_request_file(struct discover_context *ctx,
struct discover_device *dev, const char *filename,
char **buf, int *len)
return -1;
}
-int parser_check_dir(struct discover_context *ctx,
- struct discover_device *dev, const char *dirname)
+int parser_stat_path(struct discover_context *ctx,
+ struct discover_device *dev, const char *path,
+ struct stat *statbuf)
{
struct parser_test *test = ctx->test_data;
struct test_file *file;
- printf("%s: %s\n", __func__, dirname);
-
list_for_each_entry(&test->files, file, list) {
if (file->dev != dev)
continue;
- if (strcmp(file->name, dirname))
+ if (strcmp(file->name, path))
continue;
- return file->type == TEST_DIR ? 0 : -1;
+
+ statbuf->st_size = (off_t)file->size;
+ switch (file->type) {
+ case TEST_FILE:
+ statbuf->st_mode = S_IFREG;
+ break;
+ case TEST_DIR:
+ statbuf->st_mode = S_IFDIR;
+ break;
+ default:
+ fprintf(stderr, "%s: bad test file mode %d!", __func__,
+ file->type);
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
}
return -1;
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)
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)
{