Change OSSL_PARAM return size to not be a pointer.

Instead of referencing the return size from the OSSL_PARAM structure, make the
size a field within the structure.

Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/9135)

1 files changed, 97 insertions, 110 deletions

diff --git a/crypto/params.c b/crypto/params.c
index 183884fa79..0c9e6f3ef7 100644
--- a/crypto/params.c
+++ b/crypto/params.c
@@ -12,11 +12,7 @@
 #include <openssl/params.h>
 #include "internal/thread_once.h"
 
-#define SET_RETURN_SIZE(p, sz) \
-    if ((p)->return_size != NULL) \
-        *(p)->return_size = (sz)
-
-const OSSL_PARAM *OSSL_PARAM_locate(const OSSL_PARAM *p, const char *key)
+OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key)
 {
     if (p != NULL && key != NULL)
         for (; p->key != NULL; p++)
@@ -25,9 +21,13 @@ const OSSL_PARAM *OSSL_PARAM_locate(const OSSL_PARAM *p, const char *key)
     return NULL;
 }
 
+const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key)
+{
+    return OSSL_PARAM_locate((OSSL_PARAM *)p, key);
+}
+
 static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
-                                       void *data, size_t data_size,
-                                       size_t *return_size)
+                                       void *data, size_t data_size)
 {
     OSSL_PARAM res;
 
@@ -35,7 +35,7 @@ static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
     res.data_type = data_type;
     res.data = data;
     res.data_size = data_size;
-    res.return_size = return_size;
+    res.return_size = 0;
     return res;
 }
 
@@ -50,7 +50,7 @@ int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val)
     return 0;
 }
 
-int OSSL_PARAM_set_int(const OSSL_PARAM *p, int val)
+int OSSL_PARAM_set_int(OSSL_PARAM *p, int val)
 {
     switch (sizeof(int)) {
     case sizeof(int32_t):
@@ -61,10 +61,9 @@ int OSSL_PARAM_set_int(const OSSL_PARAM *p, int val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf, size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
 {
-    return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int),
-                                rsize);
+    return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int));
 }
 
 int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
@@ -78,7 +77,7 @@ int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
     return 0;
 }
 
-int OSSL_PARAM_set_uint(const OSSL_PARAM *p, unsigned int val)
+int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val)
 {
     switch (sizeof(unsigned int)) {
     case sizeof(uint32_t):
@@ -89,11 +88,10 @@ int OSSL_PARAM_set_uint(const OSSL_PARAM *p, unsigned int val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf,
-                                     size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
 {
     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
-                                sizeof(unsigned int), rsize);
+                                sizeof(unsigned int));
 }
 
 int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
@@ -107,7 +105,7 @@ int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
     return 0;
 }
 
-int OSSL_PARAM_set_long(const OSSL_PARAM *p, long int val)
+int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val)
 {
     switch (sizeof(long int)) {
     case sizeof(int32_t):
@@ -118,11 +116,9 @@ int OSSL_PARAM_set_long(const OSSL_PARAM *p, long int val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf,
-                                     size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
 {
-    return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int),
-                                rsize);
+    return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int));
 }
 
 int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
@@ -136,7 +132,7 @@ int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
     return 0;
 }
 
-int OSSL_PARAM_set_ulong(const OSSL_PARAM *p, unsigned long int val)
+int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val)
 {
     switch (sizeof(unsigned long int)) {
     case sizeof(uint32_t):
@@ -147,11 +143,10 @@ int OSSL_PARAM_set_ulong(const OSSL_PARAM *p, unsigned long int val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf,
-                                      size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
 {
     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
-                                sizeof(unsigned long int), rsize);
+                                sizeof(unsigned long int));
 }
 
 int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
@@ -208,35 +203,35 @@ int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
     return 0;
 }
 
-int OSSL_PARAM_set_int32(const OSSL_PARAM *p, int32_t val)
+int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
 {
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (p->data_type == OSSL_PARAM_INTEGER) {
-        SET_RETURN_SIZE(p, sizeof(int32_t)); /* Minimum expected size */
+        p->return_size = sizeof(int32_t); /* Minimum expected size */
         switch (p->data_size) {
         case sizeof(int32_t):
             *(int32_t *)p->data = val;
             return 1;
         case sizeof(int64_t):
-            SET_RETURN_SIZE(p, sizeof(int64_t));
+            p->return_size = sizeof(int64_t);
             *(int64_t *)p->data = (int64_t)val;
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
-        SET_RETURN_SIZE(p, sizeof(uint32_t)); /* Minimum expected size */
+        p->return_size = sizeof(uint32_t); /* Minimum expected size */
         switch (p->data_size) {
         case sizeof(uint32_t):
             *(uint32_t *)p->data = (uint32_t)val;
             return 1;
         case sizeof(uint64_t):
-            SET_RETURN_SIZE(p, sizeof(uint64_t));
+            p->return_size = sizeof(uint64_t);
             *(uint64_t *)p->data = (uint64_t)val;
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_REAL) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(double):
             *(double *)p->data = (double)val;
@@ -246,11 +241,10 @@ int OSSL_PARAM_set_int32(const OSSL_PARAM *p, int32_t val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf,
-                                      size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
 {
     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf,
-                                sizeof(int32_t), rsize);
+                                sizeof(int32_t));
 }
 
 int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
@@ -307,25 +301,25 @@ int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
     return 0;
 }
 
-int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val)
+int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
 {
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
 
     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
-        SET_RETURN_SIZE(p, sizeof(uint32_t)); /* Minimum expected size */
+        p->return_size = sizeof(uint32_t); /* Minimum expected size */
         switch (p->data_size) {
         case sizeof(uint32_t):
             *(uint32_t *)p->data = val;
             return 1;
         case sizeof(uint64_t):
-            SET_RETURN_SIZE(p, sizeof(uint64_t));
+            p->return_size = sizeof(uint64_t);
             *(uint64_t *)p->data = val;
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_INTEGER) {
-        SET_RETURN_SIZE(p, sizeof(int32_t)); /* Minimum expected size */
+        p->return_size = sizeof(int32_t); /* Minimum expected size */
         switch (p->data_size) {
         case sizeof(int32_t):
             if (val <= INT32_MAX) {
@@ -334,12 +328,12 @@ int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val)
             }
             break;
         case sizeof(int64_t):
-            SET_RETURN_SIZE(p, sizeof(int64_t));
+            p->return_size = sizeof(int64_t);
             *(int64_t *)p->data = (int64_t)val;
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_REAL) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(double):
             *(double *)p->data = (double)val;
@@ -349,11 +343,10 @@ int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf,
-                                       size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
 {
     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
-                                sizeof(uint32_t), rsize);
+                                sizeof(uint32_t));
 }
 
 int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
@@ -400,19 +393,19 @@ int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
     return 0;
 }
 
-int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
+int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
 {
     uint64_t u64;
 
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (p->data_type == OSSL_PARAM_INTEGER) {
-        SET_RETURN_SIZE(p, sizeof(int64_t)); /* Expected size */
+        p->return_size = sizeof(int64_t); /* Expected size */
         switch (p->data_size) {
         case sizeof(int32_t):
             if (val >= INT32_MIN && val <= INT32_MAX) {
-                SET_RETURN_SIZE(p, sizeof(int32_t));
+                p->return_size = sizeof(int32_t);
                 *(int32_t *)p->data = (int32_t)val;
                 return 1;
             }
@@ -422,11 +415,11 @@ int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
-        SET_RETURN_SIZE(p, sizeof(uint64_t)); /* Expected size */
+        p->return_size = sizeof(uint64_t); /* Expected size */
         switch (p->data_size) {
         case sizeof(uint32_t):
             if (val <= UINT32_MAX) {
-                SET_RETURN_SIZE(p, sizeof(uint32_t));
+                p->return_size = sizeof(uint32_t);
                 *(uint32_t *)p->data = (uint32_t)val;
                 return 1;
             }
@@ -436,7 +429,7 @@ int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_REAL) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(double):
             u64 = val < 0 ? -val : val;
@@ -450,11 +443,9 @@ int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf,
-                                      size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
 {
-    return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t),
-                                rsize);
+    return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t));
 }
 
 int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
@@ -506,18 +497,18 @@ int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
     return 0;
 }
 
-int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
+int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
 {
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
 
     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
-        SET_RETURN_SIZE(p, sizeof(uint64_t)); /* Expected size */
+        p->return_size = sizeof(uint64_t); /* Expected size */
         switch (p->data_size) {
         case sizeof(uint32_t):
             if (val <= UINT32_MAX) {
-                SET_RETURN_SIZE(p, sizeof(uint32_t));
+                p->return_size = sizeof(uint32_t);
                 *(uint32_t *)p->data = (uint32_t)val;
                 return 1;
             }
@@ -527,11 +518,11 @@ int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
             return 1;
         }
     } else if (p->data_type == OSSL_PARAM_INTEGER) {
-        SET_RETURN_SIZE(p, sizeof(int64_t)); /* Expected size */
+        p->return_size = sizeof(int64_t); /* Expected size */
         switch (p->data_size) {
         case sizeof(int32_t):
             if (val <= INT32_MAX) {
-                SET_RETURN_SIZE(p, sizeof(int32_t));
+                p->return_size = sizeof(int32_t);
                 *(int32_t *)p->data = (int32_t)val;
                 return 1;
             }
@@ -544,7 +535,7 @@ int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
             break;
         }
     } else if (p->data_type == OSSL_PARAM_REAL) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(double):
             if ((val >> 53) == 0) { /* 53 significant bits in the mantissa */
@@ -557,10 +548,10 @@ int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf,
-                                       size_t *rsize) {
+OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
+{
     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
-                                sizeof(uint64_t), rsize);
+                                sizeof(uint64_t));
 }
 
 int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
@@ -574,7 +565,7 @@ int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
     return 0;
 }
 
-int OSSL_PARAM_set_size_t(const OSSL_PARAM *p, size_t val)
+int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
 {
     switch (sizeof(size_t)) {
     case sizeof(uint32_t):
@@ -585,11 +576,11 @@ int OSSL_PARAM_set_size_t(const OSSL_PARAM *p, size_t val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf,
-                                       size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
 {
     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
-                                sizeof(size_t), rsize); }
+                                sizeof(size_t));
+}
 
 #ifndef FIPS_MODE
 /*
@@ -615,13 +606,13 @@ int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val)
     return 0;
 }
 
-int OSSL_PARAM_set_BN(const OSSL_PARAM *p, const BIGNUM *val)
+int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val)
 {
     size_t bytes;
 
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
         return 0;
 
@@ -630,16 +621,16 @@ int OSSL_PARAM_set_BN(const OSSL_PARAM *p, const BIGNUM *val)
         return 0;
 
     bytes = (size_t)BN_num_bytes(val);
-    SET_RETURN_SIZE(p, bytes);
+    p->return_size = bytes;
     return p->data_size >= bytes
         && BN_bn2nativepad(val, p->data, bytes) >= 0;
 }
 
 OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
-                                   size_t bsize, size_t *rsize)
+                                   size_t bsize)
 {
     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER,
-                                buf, bsize, rsize);
+                                buf, bsize);
 }
 #endif
 
@@ -688,14 +679,14 @@ int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val)
     return 0;
 }
 
-int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val)
+int OSSL_PARAM_set_double(OSSL_PARAM *p, double val)
 {
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
 
     if (p->data_type == OSSL_PARAM_REAL) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(double):
             *(double *)p->data = val;
@@ -703,35 +694,35 @@ int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val)
         }
     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER
                && val == (uintmax_t)val) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(uint32_t):
             if (val >= 0 && val <= UINT32_MAX) {
-                SET_RETURN_SIZE(p, sizeof(uint32_t));
+                p->return_size = sizeof(uint32_t);
                 *(uint32_t *)p->data = (uint32_t)val;
                 return 1;
             }
             break;
         case sizeof(uint64_t):
             if (val >= 0 && val <= UINT64_MAX) {
-                SET_RETURN_SIZE(p, sizeof(uint64_t));
+                p->return_size = sizeof(uint64_t);
                 *(uint64_t *)p->data = (uint64_t)val;
                 return 1;
             }
             break;            }
     } else if (p->data_type == OSSL_PARAM_INTEGER && val == (intmax_t)val) {
-        SET_RETURN_SIZE(p, sizeof(double));
+        p->return_size = sizeof(double);
         switch (p->data_size) {
         case sizeof(int32_t):
             if (val >= INT32_MIN && val <= INT32_MAX) {
-                SET_RETURN_SIZE(p, sizeof(int32_t));
+                p->return_size = sizeof(int32_t);
                 *(int32_t *)p->data = (int32_t)val;
                 return 1;
             }
             break;
         case sizeof(int64_t):
             if (val >= INT64_MIN && val <= INT64_MAX) {
-                SET_RETURN_SIZE(p, sizeof(int64_t));
+                p->return_size = sizeof(int64_t);
                 *(int64_t *)p->data = (int64_t)val;
                 return 1;
             }
@@ -741,11 +732,9 @@ int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val)
     return 0;
 }
 
-OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf,
-                                       size_t *rsize)
+OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf)
 {
-    return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double),
-                                rsize);
+    return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double));
 }
 
 static int get_string_internal(const OSSL_PARAM *p, void **val, size_t max_len,
@@ -789,10 +778,10 @@ int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
                                OSSL_PARAM_OCTET_STRING);
 }
 
-static int set_string_internal(const OSSL_PARAM *p, const void *val, size_t len,
+static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
                                unsigned int type)
 {
-    SET_RETURN_SIZE(p, len);
+    p->return_size = len;
     if (p->data_type != type || p->data_size < len)
         return 0;
 
@@ -800,41 +789,39 @@ static int set_string_internal(const OSSL_PARAM *p, const void *val, size_t len,
     return 1;
 }
 
-int OSSL_PARAM_set_utf8_string(const OSSL_PARAM *p, const char *val)
+int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
 {
     if (p == NULL)
         return 0;
 
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (val == NULL)
         return 0;
     return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING);
 }
 
-int OSSL_PARAM_set_octet_string(const OSSL_PARAM *p, const void *val,
+int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
                                 size_t len)
 {
     if (p == NULL)
         return 0;
 
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (val == NULL)
         return 0;
     return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
 }
 
 OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
-                                            size_t bsize, size_t *rsize)
+                                            size_t bsize)
 {
-    return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize,
-                                rsize);
+    return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
 }
 
 OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
-                                             size_t bsize, size_t *rsize)
+                                             size_t bsize)
 {
-    return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize,
-                                rsize);
+    return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
 }
 
 static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
@@ -859,47 +846,47 @@ int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
     return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
 }
 
-static int set_ptr_internal(const OSSL_PARAM *p, const void *val,
+static int set_ptr_internal(OSSL_PARAM *p, const void *val,
                             unsigned int type, size_t len)
 {
-    SET_RETURN_SIZE(p, len);
+    p->return_size = len;
     if (p->data_type != type)
         return 0;
     *(const void **)p->data = val;
     return 1;
 }
 
-int OSSL_PARAM_set_utf8_ptr(const OSSL_PARAM *p, const char *val)
+int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
 {
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (val == NULL)
         return 0;
     return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1);
 }
 
-int OSSL_PARAM_set_octet_ptr(const OSSL_PARAM *p, const void *val,
+int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
                              size_t used_len)
 {
     if (p == NULL)
         return 0;
-    SET_RETURN_SIZE(p, 0);
+    p->return_size = 0;
     if (val == NULL)
         return 0;
     return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len);
 }
 
 OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
-                                         size_t bsize, size_t *rsize)
+                                         size_t bsize)
 {
-    return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize, rsize);
+    return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize);
 }
 
 OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
-                                          size_t bsize, size_t *rsize)
+                                          size_t bsize)
 {
-    return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize, rsize);
+    return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize);
 }
 
 OSSL_PARAM OSSL_PARAM_construct_end(void)