#include "property_local.h"
#include "e_os.h"
-typedef enum {
- PROPERTY_TYPE_STRING, PROPERTY_TYPE_NUMBER,
- PROPERTY_TYPE_VALUE_UNDEFINED
-} PROPERTY_TYPE;
-
-typedef enum {
- PROPERTY_OPER_EQ, PROPERTY_OPER_NE, PROPERTY_OVERRIDE
-} PROPERTY_OPER;
-
-typedef struct {
- OSSL_PROPERTY_IDX name_idx;
- PROPERTY_TYPE type;
- PROPERTY_OPER oper;
- unsigned int optional : 1;
- union {
- int64_t int_val; /* Signed integer */
- OSSL_PROPERTY_IDX str_val; /* String */
- } v;
-} PROPERTY_DEFINITION;
-
-struct ossl_property_list_st {
- int n;
- unsigned int has_optional : 1;
- PROPERTY_DEFINITION properties[1];
-};
-
static OSSL_PROPERTY_IDX ossl_property_true, ossl_property_false;
-DEFINE_STACK_OF(PROPERTY_DEFINITION)
+DEFINE_STACK_OF(OSSL_PROPERTY_DEFINITION)
static const char *skip_space(const char *s)
{
return 1;
}
-static int parse_number(const char *t[], PROPERTY_DEFINITION *res)
+static int parse_number(const char *t[], OSSL_PROPERTY_DEFINITION *res)
{
const char *s = *t;
int64_t v = 0;
return 0;
}
*t = skip_space(s);
- res->type = PROPERTY_TYPE_NUMBER;
+ res->type = OSSL_PROPERTY_TYPE_NUMBER;
res->v.int_val = v;
return 1;
}
-static int parse_hex(const char *t[], PROPERTY_DEFINITION *res)
+static int parse_hex(const char *t[], OSSL_PROPERTY_DEFINITION *res)
{
const char *s = *t;
int64_t v = 0;
return 0;
}
*t = skip_space(s);
- res->type = PROPERTY_TYPE_NUMBER;
+ res->type = OSSL_PROPERTY_TYPE_NUMBER;
res->v.int_val = v;
return 1;
}
-static int parse_oct(const char *t[], PROPERTY_DEFINITION *res)
+static int parse_oct(const char *t[], OSSL_PROPERTY_DEFINITION *res)
{
const char *s = *t;
int64_t v = 0;
return 0;
}
*t = skip_space(s);
- res->type = PROPERTY_TYPE_NUMBER;
+ res->type = OSSL_PROPERTY_TYPE_NUMBER;
res->v.int_val = v;
return 1;
}
static int parse_string(OSSL_LIB_CTX *ctx, const char *t[], char delim,
- PROPERTY_DEFINITION *res, const int create)
+ OSSL_PROPERTY_DEFINITION *res, const int create)
{
char v[1000];
const char *s = *t;
res->v.str_val = ossl_property_value(ctx, v, create);
}
*t = skip_space(s + 1);
- res->type = PROPERTY_TYPE_STRING;
+ res->type = OSSL_PROPERTY_TYPE_STRING;
return !err;
}
static int parse_unquoted(OSSL_LIB_CTX *ctx, const char *t[],
- PROPERTY_DEFINITION *res, const int create)
+ OSSL_PROPERTY_DEFINITION *res, const int create)
{
char v[1000];
const char *s = *t;
res->v.str_val = ossl_property_value(ctx, v, create);
}
*t = skip_space(s);
- res->type = PROPERTY_TYPE_STRING;
+ res->type = OSSL_PROPERTY_TYPE_STRING;
return !err;
}
static int parse_value(OSSL_LIB_CTX *ctx, const char *t[],
- PROPERTY_DEFINITION *res, int create)
+ OSSL_PROPERTY_DEFINITION *res, int create)
{
const char *s = *t;
int r = 0;
return r;
}
-static int pd_compare(const PROPERTY_DEFINITION *const *p1,
- const PROPERTY_DEFINITION *const *p2)
+static int pd_compare(const OSSL_PROPERTY_DEFINITION *const *p1,
+ const OSSL_PROPERTY_DEFINITION *const *p2)
{
- const PROPERTY_DEFINITION *pd1 = *p1;
- const PROPERTY_DEFINITION *pd2 = *p2;
+ const OSSL_PROPERTY_DEFINITION *pd1 = *p1;
+ const OSSL_PROPERTY_DEFINITION *pd2 = *p2;
if (pd1->name_idx < pd2->name_idx)
return -1;
return 0;
}
-static void pd_free(PROPERTY_DEFINITION *pd)
+static void pd_free(OSSL_PROPERTY_DEFINITION *pd)
{
OPENSSL_free(pd);
}
* Convert a stack of property definitions and queries into a fixed array.
* The items are sorted for efficient query. The stack is not freed.
*/
-static OSSL_PROPERTY_LIST *stack_to_property_list(STACK_OF(PROPERTY_DEFINITION)
- *sk)
+static OSSL_PROPERTY_LIST *
+stack_to_property_list(STACK_OF(OSSL_PROPERTY_DEFINITION) *sk)
{
- const int n = sk_PROPERTY_DEFINITION_num(sk);
+ const int n = sk_OSSL_PROPERTY_DEFINITION_num(sk);
OSSL_PROPERTY_LIST *r;
int i;
r = OPENSSL_malloc(sizeof(*r)
+ (n <= 0 ? 0 : n - 1) * sizeof(r->properties[0]));
if (r != NULL) {
- sk_PROPERTY_DEFINITION_sort(sk);
+ sk_OSSL_PROPERTY_DEFINITION_sort(sk);
r->has_optional = 0;
for (i = 0; i < n; i++) {
- r->properties[i] = *sk_PROPERTY_DEFINITION_value(sk, i);
+ r->properties[i] = *sk_OSSL_PROPERTY_DEFINITION_value(sk, i);
r->has_optional |= r->properties[i].optional;
}
r->n = n;
OSSL_PROPERTY_LIST *ossl_parse_property(OSSL_LIB_CTX *ctx, const char *defn)
{
- PROPERTY_DEFINITION *prop = NULL;
+ OSSL_PROPERTY_DEFINITION *prop = NULL;
OSSL_PROPERTY_LIST *res = NULL;
- STACK_OF(PROPERTY_DEFINITION) *sk;
+ STACK_OF(OSSL_PROPERTY_DEFINITION) *sk;
const char *s = defn;
int done;
- if (s == NULL || (sk = sk_PROPERTY_DEFINITION_new(&pd_compare)) == NULL)
+ if (s == NULL || (sk = sk_OSSL_PROPERTY_DEFINITION_new(&pd_compare)) == NULL)
return NULL;
s = skip_space(s);
prop->optional = 0;
if (!parse_name(ctx, &s, 1, &prop->name_idx))
goto err;
- prop->oper = PROPERTY_OPER_EQ;
+ prop->oper = OSSL_PROPERTY_OPER_EQ;
if (prop->name_idx == 0) {
ERR_raise_data(ERR_LIB_PROP, PROP_R_PARSE_FAILED,
"Unknown name HERE-->%s", start);
}
} else {
/* A name alone means a true Boolean */
- prop->type = PROPERTY_TYPE_STRING;
+ prop->type = OSSL_PROPERTY_TYPE_STRING;
prop->v.str_val = ossl_property_true;
}
- if (!sk_PROPERTY_DEFINITION_push(sk, prop))
+ if (!sk_OSSL_PROPERTY_DEFINITION_push(sk, prop))
goto err;
prop = NULL;
done = !match_ch(&s, ',');
err:
OPENSSL_free(prop);
- sk_PROPERTY_DEFINITION_pop_free(sk, &pd_free);
+ sk_OSSL_PROPERTY_DEFINITION_pop_free(sk, &pd_free);
return res;
}
OSSL_PROPERTY_LIST *ossl_parse_query(OSSL_LIB_CTX *ctx, const char *s,
int create_values)
{
- STACK_OF(PROPERTY_DEFINITION) *sk;
+ STACK_OF(OSSL_PROPERTY_DEFINITION) *sk;
OSSL_PROPERTY_LIST *res = NULL;
- PROPERTY_DEFINITION *prop = NULL;
+ OSSL_PROPERTY_DEFINITION *prop = NULL;
int done;
- if (s == NULL || (sk = sk_PROPERTY_DEFINITION_new(&pd_compare)) == NULL)
+ if (s == NULL || (sk = sk_OSSL_PROPERTY_DEFINITION_new(&pd_compare)) == NULL)
return NULL;
s = skip_space(s);
memset(&prop->v, 0, sizeof(prop->v));
if (match_ch(&s, '-')) {
- prop->oper = PROPERTY_OVERRIDE;
+ prop->oper = OSSL_PROPERTY_OVERRIDE;
prop->optional = 0;
if (!parse_name(ctx, &s, 1, &prop->name_idx))
goto err;
goto err;
if (match_ch(&s, '=')) {
- prop->oper = PROPERTY_OPER_EQ;
+ prop->oper = OSSL_PROPERTY_OPER_EQ;
} else if (MATCH(&s, "!=")) {
- prop->oper = PROPERTY_OPER_NE;
+ prop->oper = OSSL_PROPERTY_OPER_NE;
} else {
/* A name alone is a Boolean comparison for true */
- prop->oper = PROPERTY_OPER_EQ;
- prop->type = PROPERTY_TYPE_STRING;
+ prop->oper = OSSL_PROPERTY_OPER_EQ;
+ prop->type = OSSL_PROPERTY_TYPE_STRING;
prop->v.str_val = ossl_property_true;
goto skip_value;
}
if (!parse_value(ctx, &s, prop, create_values))
- prop->type = PROPERTY_TYPE_VALUE_UNDEFINED;
+ prop->type = OSSL_PROPERTY_TYPE_VALUE_UNDEFINED;
skip_value:
- if (!sk_PROPERTY_DEFINITION_push(sk, prop))
+ if (!sk_OSSL_PROPERTY_DEFINITION_push(sk, prop))
goto err;
prop = NULL;
done = !match_ch(&s, ',');
err:
OPENSSL_free(prop);
- sk_PROPERTY_DEFINITION_pop_free(sk, &pd_free);
+ sk_OSSL_PROPERTY_DEFINITION_pop_free(sk, &pd_free);
return res;
}
{
int i;
OSSL_PROPERTY_IDX name_id;
- const PROPERTY_DEFINITION *prop = NULL;
+ const OSSL_PROPERTY_DEFINITION *prop = NULL;
if (prop_list == NULL)
return 0;
for (i = 0; i < prop_list->n; ++i) {
if (prop[i].name_idx == name_id) {
/* Do a separate check for override as it does not set type */
- if (prop[i].optional || prop[i].oper == PROPERTY_OVERRIDE)
+ if (prop[i].optional || prop[i].oper == OSSL_PROPERTY_OVERRIDE)
return 0;
- return (prop[i].type == PROPERTY_TYPE_STRING
- && ((prop[i].oper == PROPERTY_OPER_EQ
+ return (prop[i].type == OSSL_PROPERTY_TYPE_STRING
+ && ((prop[i].oper == OSSL_PROPERTY_OPER_EQ
&& prop[i].v.str_val == ossl_property_true)
- || (prop[i].oper == PROPERTY_OPER_NE
+ || (prop[i].oper == OSSL_PROPERTY_OPER_NE
&& prop[i].v.str_val != ossl_property_true)));
}
}
int ossl_property_match_count(const OSSL_PROPERTY_LIST *query,
const OSSL_PROPERTY_LIST *defn)
{
- const PROPERTY_DEFINITION *const q = query->properties;
- const PROPERTY_DEFINITION *const d = defn->properties;
+ const OSSL_PROPERTY_DEFINITION *const q = query->properties;
+ const OSSL_PROPERTY_DEFINITION *const d = defn->properties;
int i = 0, j = 0, matches = 0;
- PROPERTY_OPER oper;
+ OSSL_PROPERTY_OPER oper;
while (i < query->n) {
- if ((oper = q[i].oper) == PROPERTY_OVERRIDE) {
+ if ((oper = q[i].oper) == OSSL_PROPERTY_OVERRIDE) {
i++;
continue;
}
const int eq = q[i].type == d[j].type
&& memcmp(&q[i].v, &d[j].v, sizeof(q[i].v)) == 0;
- if ((eq && oper == PROPERTY_OPER_EQ)
- || (!eq && oper == PROPERTY_OPER_NE))
+ if ((eq && oper == OSSL_PROPERTY_OPER_EQ)
+ || (!eq && oper == OSSL_PROPERTY_OPER_NE))
matches++;
else if (!q[i].optional)
return -1;
* definition. The former fails for any comparison except inequality,
* the latter is treated as a comparison against the Boolean false.
*/
- if (q[i].type == PROPERTY_TYPE_VALUE_UNDEFINED) {
- if (oper == PROPERTY_OPER_NE)
+ if (q[i].type == OSSL_PROPERTY_TYPE_VALUE_UNDEFINED) {
+ if (oper == OSSL_PROPERTY_OPER_NE)
matches++;
else if (!q[i].optional)
return -1;
- } else if (q[i].type != PROPERTY_TYPE_STRING
- || (oper == PROPERTY_OPER_EQ
+ } else if (q[i].type != OSSL_PROPERTY_TYPE_STRING
+ || (oper == OSSL_PROPERTY_OPER_EQ
&& q[i].v.str_val != ossl_property_false)
- || (oper == PROPERTY_OPER_NE
+ || (oper == OSSL_PROPERTY_OPER_NE
&& q[i].v.str_val == ossl_property_false)) {
if (!q[i].optional)
return -1;
OSSL_PROPERTY_LIST *ossl_property_merge(const OSSL_PROPERTY_LIST *a,
const OSSL_PROPERTY_LIST *b)
{
- const PROPERTY_DEFINITION *const ap = a->properties;
- const PROPERTY_DEFINITION *const bp = b->properties;
- const PROPERTY_DEFINITION *copy;
+ const OSSL_PROPERTY_DEFINITION *const ap = a->properties;
+ const OSSL_PROPERTY_DEFINITION *const bp = b->properties;
+ const OSSL_PROPERTY_DEFINITION *copy;
OSSL_PROPERTY_LIST *r;
int i, j, n;
const int t = a->n + b->n;
size_t bufsize)
{
int i;
- const PROPERTY_DEFINITION *prop = NULL;
+ const OSSL_PROPERTY_DEFINITION *prop = NULL;
size_t needed = 0;
const char *val;
if (prop->optional)
put_char('?', &buf, &bufsize, &needed);
- else if (prop->oper == PROPERTY_OVERRIDE)
+ else if (prop->oper == OSSL_PROPERTY_OVERRIDE)
put_char('-', &buf, &bufsize, &needed);
val = ossl_property_name_str(ctx, prop->name_idx);
put_str(val, &buf, &bufsize, &needed);
switch (prop->oper) {
- case PROPERTY_OPER_NE:
+ case OSSL_PROPERTY_OPER_NE:
put_char('!', &buf, &bufsize, &needed);
/* fall through */
- case PROPERTY_OPER_EQ:
+ case OSSL_PROPERTY_OPER_EQ:
put_char('=', &buf, &bufsize, &needed);
/* put value */
switch (prop->type) {
- case PROPERTY_TYPE_STRING:
+ case OSSL_PROPERTY_TYPE_STRING:
val = ossl_property_value_str(ctx, prop->v.str_val);
if (val == NULL)
return 0;
put_str(val, &buf, &bufsize, &needed);
break;
- case PROPERTY_TYPE_NUMBER:
+ case OSSL_PROPERTY_TYPE_NUMBER:
put_num(prop->v.int_val, &buf, &bufsize, &needed);
break;