122 lines
3.5 KiB
C
122 lines
3.5 KiB
C
#include "amduatd_fed.h"
|
|
|
|
#include "amduat/asl/ref_text.h"
|
|
#include "amduat/hash/asl1.h"
|
|
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static int failures = 0;
|
|
|
|
static void expect(bool cond, const char *msg) {
|
|
if (!cond) {
|
|
fprintf(stderr, "FAIL: %s\n", msg);
|
|
failures++;
|
|
}
|
|
}
|
|
|
|
int main(void) {
|
|
amduatd_fed_cfg_t cfg;
|
|
amduatd_space_t space;
|
|
amduat_octets_t scoped = amduat_octets(NULL, 0u);
|
|
uint8_t digest_bytes[32];
|
|
amduat_octets_t digest;
|
|
amduat_reference_t ref;
|
|
char *ref_hex = NULL;
|
|
const char *err = NULL;
|
|
int i;
|
|
|
|
memset(digest_bytes, 0x2a, sizeof(digest_bytes));
|
|
if (!amduat_octets_clone(amduat_octets(digest_bytes, sizeof(digest_bytes)),
|
|
&digest)) {
|
|
fprintf(stderr, "FAIL: digest clone\n");
|
|
return 1;
|
|
}
|
|
|
|
ref = amduat_reference(AMDUAT_HASH_ASL1_ID_SHA256, digest);
|
|
if (!amduat_asl_ref_encode_hex(ref, &ref_hex)) {
|
|
fprintf(stderr, "FAIL: ref encode\n");
|
|
amduat_reference_free(&ref);
|
|
return 1;
|
|
}
|
|
|
|
amduatd_fed_cfg_init(&cfg);
|
|
expect(!cfg.enabled, "default disabled");
|
|
expect(cfg.transport_kind == AMDUATD_FED_TRANSPORT_STUB, "default transport");
|
|
expect(!cfg.require_space, "default require_space");
|
|
|
|
{
|
|
char *argv[] = {
|
|
"amduatd",
|
|
"--fed-enable",
|
|
"--fed-transport",
|
|
"unix",
|
|
"--fed-unix-sock",
|
|
"amduatd.sock",
|
|
"--fed-domain-id",
|
|
"42",
|
|
"--fed-registry-ref",
|
|
ref_hex,
|
|
"--fed-require-space",
|
|
};
|
|
int argc = (int)(sizeof(argv) / sizeof(argv[0]));
|
|
for (i = 1; i < argc; ++i) {
|
|
amduatd_fed_parse_result_t rc;
|
|
rc = amduatd_fed_cfg_parse_arg(&cfg, argc, argv, &i, &err);
|
|
expect(rc == AMDUATD_FED_PARSE_OK, "fed parse ok");
|
|
}
|
|
}
|
|
|
|
expect(cfg.enabled, "parsed enabled");
|
|
expect(cfg.transport_kind == AMDUATD_FED_TRANSPORT_UNIX,
|
|
"parsed transport");
|
|
expect(cfg.unix_socket_set, "parsed unix socket");
|
|
expect(cfg.local_domain_id == 42u, "parsed domain id");
|
|
expect(cfg.registry_ref_set, "parsed registry ref");
|
|
expect(cfg.require_space, "parsed require space");
|
|
|
|
expect(!amduatd_fed_requirements_check(AMDUATD_STORE_BACKEND_FS,
|
|
&cfg,
|
|
&err),
|
|
"requirements reject fs backend");
|
|
expect(amduatd_fed_requirements_check(AMDUATD_STORE_BACKEND_INDEX,
|
|
&cfg,
|
|
&err),
|
|
"requirements accept index backend");
|
|
|
|
if (!amduatd_space_init(&space, NULL, false)) {
|
|
fprintf(stderr, "FAIL: space init\n");
|
|
amduatd_fed_cfg_free(&cfg);
|
|
amduat_reference_free(&ref);
|
|
free(ref_hex);
|
|
return 1;
|
|
}
|
|
expect(!amduatd_fed_scope_names(&cfg, &space, "fed", &scoped, &err),
|
|
"scope requires space");
|
|
amduat_octets_free(&scoped);
|
|
|
|
if (!amduatd_space_init(&space, "alpha", false)) {
|
|
fprintf(stderr, "FAIL: space init alpha\n");
|
|
amduatd_fed_cfg_free(&cfg);
|
|
amduat_reference_free(&ref);
|
|
free(ref_hex);
|
|
return 1;
|
|
}
|
|
expect(amduatd_fed_scope_names(&cfg, &space, "fed", &scoped, &err),
|
|
"scope with space");
|
|
expect(scoped.data != NULL &&
|
|
scoped.len == strlen("space/alpha/fed") &&
|
|
memcmp(scoped.data,
|
|
"space/alpha/fed",
|
|
scoped.len) == 0,
|
|
"scoped name");
|
|
amduat_octets_free(&scoped);
|
|
|
|
amduatd_fed_cfg_free(&cfg);
|
|
amduat_reference_free(&ref);
|
|
free(ref_hex);
|
|
return failures == 0 ? 0 : 1;
|
|
}
|