/* General purpose get integer parameter call that handles odd sizes */
static int general_get_int(const OSSL_PARAM *p, void *val, size_t val_size)
{
+ if (p->data == NULL) {
+ err_null_argument;
+ return 0;
+ }
if (p->data_type == OSSL_PARAM_INTEGER)
return signed_from_signed(val, val_size, p->data, p->data_size);
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
/* General purpose get unsigned integer parameter call that handles odd sizes */
static int general_get_uint(const OSSL_PARAM *p, void *val, size_t val_size)
{
+
+ if (p->data == NULL) {
+ err_null_argument;
+ return 0;
+ }
if (p->data_type == OSSL_PARAM_INTEGER)
return unsigned_from_signed(val, val_size, p->data, p->data_size);
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
return 0;
}
+ if (p->data == NULL) {
+ err_null_argument;
+ return 0;
+ }
+
if (p->data_type == OSSL_PARAM_INTEGER) {
#ifndef OPENSSL_SMALL_FOOTPRINT
int64_t i64;
return 0;
}
+ if (p->data == NULL) {
+ err_null_argument;
+ return 0;
+ }
+
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
#ifndef OPENSSL_SMALL_FOOTPRINT
uint64_t u64;
return 0;
}
+ if (p->data == NULL) {
+ err_null_argument;
+ return 0;
+ }
+
if (p->data_type == OSSL_PARAM_INTEGER) {
#ifndef OPENSSL_SMALL_FOOTPRINT
switch (p->data_size) {
return 0;
}
+ if (p->data == NULL) {
+ err_null_argument;
+ return 0;
+ }
+
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
#ifndef OPENSSL_SMALL_FOOTPRINT
switch (p->data_size) {
{
BIGNUM *b = NULL;
- if (val == NULL || p == NULL) {
+ if (val == NULL || p == NULL || p->data == NULL) {
err_null_argument;
return 0;
}
int64_t i64;
uint64_t u64;
- if (val == NULL || p == NULL) {
+ if (val == NULL || p == NULL || p->data == NULL) {
err_null_argument;
return 0;
}
0x89, 0x67, 0xf2, 0x68, 0x33, 0xa0, 0x14, 0xb0 } },
};
+static int test_param_type_null(OSSL_PARAM *param)
+{
+ int rc = 0;
+ uint64_t intval;
+ double dval;
+ BIGNUM *bn;
+
+ switch(param->data_type) {
+ case OSSL_PARAM_INTEGER:
+ if (param->data_size == sizeof(int32_t))
+ rc = OSSL_PARAM_get_int32(param, (int32_t *)&intval);
+ else if (param->data_size == sizeof(uint64_t))
+ rc = OSSL_PARAM_get_int64(param, (int64_t *)&intval);
+ else
+ return 1;
+ break;
+ case OSSL_PARAM_UNSIGNED_INTEGER:
+ if (param->data_size == sizeof(uint32_t))
+ rc = OSSL_PARAM_get_uint32(param, (uint32_t *)&intval);
+ else if (param->data_size == sizeof(uint64_t))
+ rc = OSSL_PARAM_get_uint64(param, &intval);
+ else
+ rc = OSSL_PARAM_get_BN(param, &bn);
+ break;
+ case OSSL_PARAM_REAL:
+ rc = OSSL_PARAM_get_double(param, &dval);
+ break;
+ case OSSL_PARAM_UTF8_STRING:
+ case OSSL_PARAM_OCTET_STRING:
+ case OSSL_PARAM_UTF8_PTR:
+ case OSSL_PARAM_OCTET_PTR:
+ /* these are allowed to be null */
+ return 1;
+ break;
+ }
+
+ /*
+ * we expect the various OSSL_PARAM_get functions above
+ * to return failure when the data is set to NULL
+ */
+ return rc == 0;
+}
+
static int test_param_type_extra(OSSL_PARAM *param, const unsigned char *cmp,
size_t width)
{
sizeof(int) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_int("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(long int) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_long("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
const size_t len = raw_values[n].len >= sizeof(unsigned int) ? sizeof(unsigned int) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_uint("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(unsigned long int) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_ulong("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(int32_t) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_int32("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(uint32_t) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_uint32("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(int64_t) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_int64("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(uint64_t) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_uint64("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(size_t) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_size_t("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
? sizeof(time_t) : raw_values[n].len;
OSSL_PARAM param = OSSL_PARAM_time_t("a", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
memset(buf, 0, sizeof(buf));
le_copy(buf, sizeof(in), raw_values[n].value, sizeof(in));
memcpy(&in, buf, sizeof(in));
NULL, 0);
int ret = 0;
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
param.data = bnbuf;
param.data_size = sizeof(bnbuf);
OSSL_PARAM param = OSSL_PARAM_DEFN("bn", OSSL_PARAM_INTEGER, NULL, 0);
int ret = 0;
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
param.data = bnbuf;
param.data_size = sizeof(bnbuf);
double p;
OSSL_PARAM param = OSSL_PARAM_double("r", NULL);
+ if (!TEST_int_eq(test_param_type_null(¶m), 1))
+ return 0;
+
param.data = &p;
return TEST_true(OSSL_PARAM_set_double(¶m, 3.14159))
&& TEST_double_eq(p, 3.14159);