Esempio n. 1
0
static int
test_create_eval_req_nogroups_teardown(void **state)
{
    struct eval_req_test_ctx *test_ctx = *state;

    ph_free_user(test_ctx->user);
    ph_free_hbac_eval_req(test_ctx->req);
    return 0;
}
Esempio n. 2
0
static int
test_create_eval_req_invalid_groups_teardown(void **state)
{
    struct eval_req_test_ctx *test_ctx = *state;

    ph_attr_free(test_ctx->targethost->attrs[PH_MAP_HOST_MEMBEROF]);
    test_ctx->targethost->attrs[PH_MAP_HOST_MEMBEROF] = NULL;

    ph_attr_free(test_ctx->service->attrs[PH_MAP_SVC_MEMBEROF]);
    test_ctx->service->attrs[PH_MAP_SVC_MEMBEROF] = NULL;

    ph_free_hbac_eval_req(test_ctx->req);
    ph_free_user(test_ctx->user);
    return 0;
}
Esempio n. 3
0
int
ph_create_hbac_eval_req(struct ph_user *user,
                        struct ph_entry *targethost,
                        struct ph_entry *service,
                        const char *basedn,
                        struct hbac_eval_req **_req)
{
    int ret;
    struct hbac_eval_req *req;

    if (user == NULL || targethost == NULL || service == NULL
            || _req == NULL) {
        return EINVAL;
    }

    req = calloc(1, sizeof(struct hbac_eval_req));
    if (req == NULL) {
        return ENOMEM;
    }

    req->user = user_to_eval_req_el(user, basedn);
    if (req->user == NULL) {
        ret = ENOMEM;
        goto fail;
    }

    req->service = svc_to_eval_req_el(service, basedn);
    if (req->service == NULL) {
        ret = ENOMEM;
        goto fail;
    }

    req->targethost = tgt_host_to_eval_req_el(targethost, basedn);
    if (req->targethost == NULL) {
        ret = ENOMEM;
        goto fail;
    }

    req->request_time = time(NULL);

    *_req = req;
    return 0;

fail:
    ph_free_hbac_eval_req(req);
    return ret;
}