fix ERR_add_error_vdata() for use with multiple args/calls
[openssl.git] / crypto / params.c
1 /*
2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
4  *
5  * Licensed under the Apache License 2.0 (the "License").  You may not use
6  * this file except in compliance with the License.  You can obtain a copy
7  * in the file LICENSE in the source distribution or at
8  * https://www.openssl.org/source/license.html
9  */
10
11 #include <string.h>
12 #include <openssl/params.h>
13 #include "internal/thread_once.h"
14 #include "internal/numbers.h"
15
16 OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key)
17 {
18     if (p != NULL && key != NULL)
19         for (; p->key != NULL; p++)
20             if (strcmp(key, p->key) == 0)
21                 return p;
22     return NULL;
23 }
24
25 const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key)
26 {
27     return OSSL_PARAM_locate((OSSL_PARAM *)p, key);
28 }
29
30 static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
31                                        void *data, size_t data_size)
32 {
33     OSSL_PARAM res;
34
35     res.key = key;
36     res.data_type = data_type;
37     res.data = data;
38     res.data_size = data_size;
39     res.return_size = 0;
40     return res;
41 }
42
43 int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val)
44 {
45     switch (sizeof(int)) {
46     case sizeof(int32_t):
47         return OSSL_PARAM_get_int32(p, (int32_t *)val);
48     case sizeof(int64_t):
49         return OSSL_PARAM_get_int64(p, (int64_t *)val);
50     }
51     return 0;
52 }
53
54 int OSSL_PARAM_set_int(OSSL_PARAM *p, int val)
55 {
56     switch (sizeof(int)) {
57     case sizeof(int32_t):
58         return OSSL_PARAM_set_int32(p, (int32_t)val);
59     case sizeof(int64_t):
60         return OSSL_PARAM_set_int64(p, (int64_t)val);
61     }
62     return 0;
63 }
64
65 OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
66 {
67     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int));
68 }
69
70 int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
71 {
72     switch (sizeof(unsigned int)) {
73     case sizeof(uint32_t):
74         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
75     case sizeof(uint64_t):
76         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
77     }
78     return 0;
79 }
80
81 int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val)
82 {
83     switch (sizeof(unsigned int)) {
84     case sizeof(uint32_t):
85         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
86     case sizeof(uint64_t):
87         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
88     }
89     return 0;
90 }
91
92 OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
93 {
94     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
95                                 sizeof(unsigned int));
96 }
97
98 int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
99 {
100     switch (sizeof(long int)) {
101     case sizeof(int32_t):
102         return OSSL_PARAM_get_int32(p, (int32_t *)val);
103     case sizeof(int64_t):
104         return OSSL_PARAM_get_int64(p, (int64_t *)val);
105     }
106     return 0;
107 }
108
109 int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val)
110 {
111     switch (sizeof(long int)) {
112     case sizeof(int32_t):
113         return OSSL_PARAM_set_int32(p, (int32_t)val);
114     case sizeof(int64_t):
115         return OSSL_PARAM_set_int64(p, (int64_t)val);
116     }
117     return 0;
118 }
119
120 OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
121 {
122     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int));
123 }
124
125 int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
126 {
127     switch (sizeof(unsigned long int)) {
128     case sizeof(uint32_t):
129         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
130     case sizeof(uint64_t):
131         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
132     }
133     return 0;
134 }
135
136 int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val)
137 {
138     switch (sizeof(unsigned long int)) {
139     case sizeof(uint32_t):
140         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
141     case sizeof(uint64_t):
142         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
143     }
144     return 0;
145 }
146
147 OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
148 {
149     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
150                                 sizeof(unsigned long int));
151 }
152
153 int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
154 {
155     int64_t i64;
156     uint32_t u32;
157     uint64_t u64;
158     double d;
159
160     if (val == NULL || p == NULL )
161         return 0;
162
163     if (p->data_type == OSSL_PARAM_INTEGER) {
164         switch (p->data_size) {
165         case sizeof(int32_t):
166             *val = *(const int32_t *)p->data;
167             return 1;
168         case sizeof(int64_t):
169             i64 = *(const int64_t *)p->data;
170             if (i64 >= INT32_MIN && i64 <= INT32_MAX) {
171                 *val = (int32_t)i64;
172                 return 1;
173             }
174             break;
175         }
176     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
177         switch (p->data_size) {
178         case sizeof(uint32_t):
179             u32 = *(const uint32_t *)p->data;
180             if (u32 <= INT32_MAX) {
181                 *val = (int32_t)u32;
182                 return 1;
183             }
184             break;
185         case sizeof(uint64_t):
186             u64 = *(const uint64_t *)p->data;
187             if (u64 <= INT32_MAX) {
188                 *val = (int32_t)u64;
189                 return 1;
190             }
191             break;
192         }
193     } else if (p->data_type == OSSL_PARAM_REAL) {
194         switch (p->data_size) {
195         case sizeof(double):
196             d = *(const double *)p->data;
197             if (d >= INT32_MIN && d <= INT32_MAX && d == (int32_t)d) {
198                 *val = (int32_t)d;
199                 return 1;
200             }
201             break;
202         }
203     }
204     return 0;
205 }
206
207 int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
208 {
209     if (p == NULL)
210         return 0;
211     p->return_size = 0;
212     if (p->data_type == OSSL_PARAM_INTEGER) {
213         p->return_size = sizeof(int32_t); /* Minimum expected size */
214         switch (p->data_size) {
215         case sizeof(int32_t):
216             *(int32_t *)p->data = val;
217             return 1;
218         case sizeof(int64_t):
219             p->return_size = sizeof(int64_t);
220             *(int64_t *)p->data = (int64_t)val;
221             return 1;
222         }
223     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
224         p->return_size = sizeof(uint32_t); /* Minimum expected size */
225         switch (p->data_size) {
226         case sizeof(uint32_t):
227             *(uint32_t *)p->data = (uint32_t)val;
228             return 1;
229         case sizeof(uint64_t):
230             p->return_size = sizeof(uint64_t);
231             *(uint64_t *)p->data = (uint64_t)val;
232             return 1;
233         }
234     } else if (p->data_type == OSSL_PARAM_REAL) {
235         p->return_size = sizeof(double);
236         switch (p->data_size) {
237         case sizeof(double):
238             *(double *)p->data = (double)val;
239             return 1;
240         }
241     }
242     return 0;
243 }
244
245 OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
246 {
247     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf,
248                                 sizeof(int32_t));
249 }
250
251 int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
252 {
253     int32_t i32;
254     int64_t i64;
255     uint64_t u64;
256     double d;
257
258     if (val == NULL || p == NULL)
259         return 0;
260
261     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
262         switch (p->data_size) {
263         case sizeof(uint32_t):
264             *val = *(const uint32_t *)p->data;
265             return 1;
266         case sizeof(uint64_t):
267             u64 = *(const uint64_t *)p->data;
268             if (u64 <= UINT32_MAX) {
269                 *val = (uint32_t)u64;
270                 return 1;
271             }
272             break;
273         }
274     } else if (p->data_type == OSSL_PARAM_INTEGER) {
275         switch (p->data_size) {
276         case sizeof(int32_t):
277             i32 = *(const int32_t *)p->data;
278             if (i32 >= 0) {
279                 *val = i32;
280                 return 1;
281             }
282             break;
283         case sizeof(int64_t):
284             i64 = *(const int64_t *)p->data;
285             if (i64 >= 0 && i64 <= UINT32_MAX) {
286                 *val = (uint32_t)i64;
287                 return 1;
288             }
289             break;
290         }
291     } else if (p->data_type == OSSL_PARAM_REAL) {
292         switch (p->data_size) {
293         case sizeof(double):
294             d = *(const double *)p->data;
295             if (d >= 0 && d <= UINT32_MAX && d == (uint32_t)d) {
296                 *val = (uint32_t)d;
297                 return 1;
298             }
299             break;
300         }
301     }
302     return 0;
303 }
304
305 int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
306 {
307     if (p == NULL)
308         return 0;
309     p->return_size = 0;
310
311     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
312         p->return_size = sizeof(uint32_t); /* Minimum expected size */
313         switch (p->data_size) {
314         case sizeof(uint32_t):
315             *(uint32_t *)p->data = val;
316             return 1;
317         case sizeof(uint64_t):
318             p->return_size = sizeof(uint64_t);
319             *(uint64_t *)p->data = val;
320             return 1;
321         }
322     } else if (p->data_type == OSSL_PARAM_INTEGER) {
323         p->return_size = sizeof(int32_t); /* Minimum expected size */
324         switch (p->data_size) {
325         case sizeof(int32_t):
326             if (val <= INT32_MAX) {
327                 *(int32_t *)p->data = (int32_t)val;
328                 return 1;
329             }
330             break;
331         case sizeof(int64_t):
332             p->return_size = sizeof(int64_t);
333             *(int64_t *)p->data = (int64_t)val;
334             return 1;
335         }
336     } else if (p->data_type == OSSL_PARAM_REAL) {
337         p->return_size = sizeof(double);
338         switch (p->data_size) {
339         case sizeof(double):
340             *(double *)p->data = (double)val;
341             return 1;
342         }
343     }
344     return 0;
345 }
346
347 OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
348 {
349     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
350                                 sizeof(uint32_t));
351 }
352
353 int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
354 {
355     uint64_t u64;
356     double d;
357
358     if (val == NULL || p == NULL )
359         return 0;
360
361     if (p->data_type == OSSL_PARAM_INTEGER) {
362         switch (p->data_size) {
363         case sizeof(int32_t):
364             *val = *(const int32_t *)p->data;
365             return 1;
366         case sizeof(int64_t):
367             *val = *(const int64_t *)p->data;
368             return 1;
369         }
370     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
371         switch (p->data_size) {
372         case sizeof(uint32_t):
373             *val = *(const uint32_t *)p->data;
374             return 1;
375         case sizeof(uint64_t):
376             u64 = *(const uint64_t *)p->data;
377             if (u64 <= INT64_MAX) {
378                 *val = (int64_t)u64;
379                 return 1;
380             }
381             break;
382         }
383     } else if (p->data_type == OSSL_PARAM_REAL) {
384         switch (p->data_size) {
385         case sizeof(double):
386             d = *(const double *)p->data;
387             if (d >= INT64_MIN && d <= INT64_MAX && d == (int64_t)d) {
388                 *val = (int64_t)d;
389                 return 1;
390             }
391             break;
392         }
393     }
394     return 0;
395 }
396
397 int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
398 {
399     uint64_t u64;
400
401     if (p == NULL)
402         return 0;
403     p->return_size = 0;
404     if (p->data_type == OSSL_PARAM_INTEGER) {
405         p->return_size = sizeof(int64_t); /* Expected size */
406         switch (p->data_size) {
407         case sizeof(int32_t):
408             if (val >= INT32_MIN && val <= INT32_MAX) {
409                 p->return_size = sizeof(int32_t);
410                 *(int32_t *)p->data = (int32_t)val;
411                 return 1;
412             }
413             break;
414         case sizeof(int64_t):
415             *(int64_t *)p->data = val;
416             return 1;
417         }
418     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
419         p->return_size = sizeof(uint64_t); /* Expected size */
420         switch (p->data_size) {
421         case sizeof(uint32_t):
422             if (val <= UINT32_MAX) {
423                 p->return_size = sizeof(uint32_t);
424                 *(uint32_t *)p->data = (uint32_t)val;
425                 return 1;
426             }
427             break;
428         case sizeof(uint64_t):
429             *(uint64_t *)p->data = (uint64_t)val;
430             return 1;
431         }
432     } else if (p->data_type == OSSL_PARAM_REAL) {
433         p->return_size = sizeof(double);
434         switch (p->data_size) {
435         case sizeof(double):
436             u64 = val < 0 ? -val : val;
437             if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
438                 *(double *)p->data = (double)val;
439                 return 1;
440             }
441             break;
442         }
443     }
444     return 0;
445 }
446
447 OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
448 {
449     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t));
450 }
451
452 int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
453 {
454     int32_t i32;
455     int64_t i64;
456     double d;
457
458     if (val == NULL || p == NULL)
459         return 0;
460
461     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
462         switch (p->data_size) {
463         case sizeof(uint32_t):
464             *val = *(const uint32_t *)p->data;
465             return 1;
466         case sizeof(uint64_t):
467             *val = *(const uint64_t *)p->data;
468             return 1;
469         }
470     } else if (p->data_type == OSSL_PARAM_INTEGER) {
471         switch (p->data_size) {
472         case sizeof(int32_t):
473             i32 = *(const int32_t *)p->data;
474             if (i32 >= 0) {
475                 *val = (uint64_t)i32;
476                 return 1;
477             }
478             break;
479         case sizeof(int64_t):
480             i64 = *(const int64_t *)p->data;
481             if (i64 >= 0) {
482                 *val = (uint64_t)i64;
483                 return 1;
484             }
485             break;
486         }
487     } else if (p->data_type == OSSL_PARAM_REAL) {
488         switch (p->data_size) {
489         case sizeof(double):
490             d = *(const double *)p->data;
491             if (d >= 0 && d <= INT64_MAX && d == (uint64_t)d) {
492                 *val = (uint64_t)d;
493                 return 1;
494             }
495             break;
496         }
497     }
498     return 0;
499 }
500
501 int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
502 {
503     if (p == NULL)
504         return 0;
505     p->return_size = 0;
506
507     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
508         p->return_size = sizeof(uint64_t); /* Expected size */
509         switch (p->data_size) {
510         case sizeof(uint32_t):
511             if (val <= UINT32_MAX) {
512                 p->return_size = sizeof(uint32_t);
513                 *(uint32_t *)p->data = (uint32_t)val;
514                 return 1;
515             }
516             break;
517         case sizeof(uint64_t):
518             *(uint64_t *)p->data = val;
519             return 1;
520         }
521     } else if (p->data_type == OSSL_PARAM_INTEGER) {
522         p->return_size = sizeof(int64_t); /* Expected size */
523         switch (p->data_size) {
524         case sizeof(int32_t):
525             if (val <= INT32_MAX) {
526                 p->return_size = sizeof(int32_t);
527                 *(int32_t *)p->data = (int32_t)val;
528                 return 1;
529             }
530             break;
531         case sizeof(int64_t):
532             if (val <= INT64_MAX) {
533                 *(int64_t *)p->data = (int64_t)val;
534                 return 1;
535             }
536             break;
537         }
538     } else if (p->data_type == OSSL_PARAM_REAL) {
539         p->return_size = sizeof(double);
540         switch (p->data_size) {
541         case sizeof(double):
542             if ((val >> 53) == 0) { /* 53 significant bits in the mantissa */
543                 *(double *)p->data = (double)val;
544                 return 1;
545             }
546             break;
547         }
548     }
549     return 0;
550 }
551
552 OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
553 {
554     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
555                                 sizeof(uint64_t));
556 }
557
558 int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
559 {
560     switch (sizeof(size_t)) {
561     case sizeof(uint32_t):
562         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
563     case sizeof(uint64_t):
564         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
565     }
566     return 0;
567 }
568
569 int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
570 {
571     switch (sizeof(size_t)) {
572     case sizeof(uint32_t):
573         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
574     case sizeof(uint64_t):
575         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
576     }
577     return 0;
578 }
579
580 OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
581 {
582     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
583                                 sizeof(size_t));
584 }
585
586 int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val)
587 {
588     BIGNUM *b;
589
590     if (val == NULL
591         || p == NULL
592         || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
593         return 0;
594
595     b = BN_native2bn(p->data, (int)p->data_size, *val);
596     if (b != NULL) {
597         *val = b;
598         return 1;
599     }
600     return 0;
601 }
602
603 int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val)
604 {
605     size_t bytes;
606
607     if (p == NULL)
608         return 0;
609     p->return_size = 0;
610     if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
611         return 0;
612
613     /* For the moment, only positive values are permitted */
614     if (BN_is_negative(val))
615         return 0;
616
617     bytes = (size_t)BN_num_bytes(val);
618     p->return_size = bytes;
619     return p->data_size >= bytes
620         && BN_bn2nativepad(val, p->data, bytes) >= 0;
621 }
622
623 OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
624                                    size_t bsize)
625 {
626     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER,
627                                 buf, bsize);
628 }
629
630 int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val)
631 {
632     int64_t i64;
633     uint64_t u64;
634
635     if (val == NULL || p == NULL)
636         return 0;
637
638     if (p->data_type == OSSL_PARAM_REAL) {
639         switch (p->data_size) {
640         case sizeof(double):
641             *val = *(const double *)p->data;
642             return 1;
643         }
644     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
645         switch (p->data_size) {
646         case sizeof(uint32_t):
647             *val = *(const uint32_t *)p->data;
648             return 1;
649         case sizeof(uint64_t):
650             u64 = *(const uint64_t *)p->data;
651             if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
652                 *val = (double)u64;
653                 return 1;
654             }
655             break;
656         }
657     } else if (p->data_type == OSSL_PARAM_INTEGER) {
658         switch (p->data_size) {
659         case sizeof(int32_t):
660             *val = *(const int32_t *)p->data;
661             return 1;
662         case sizeof(int64_t):
663             i64 = *(const int64_t *)p->data;
664             u64 = i64 < 0 ? -i64 : i64;
665             if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
666                 *val = 0.0 + i64;
667                 return 1;
668             }
669             break;
670         }
671     }
672     return 0;
673 }
674
675 int OSSL_PARAM_set_double(OSSL_PARAM *p, double val)
676 {
677     if (p == NULL)
678         return 0;
679     p->return_size = 0;
680
681     if (p->data_type == OSSL_PARAM_REAL) {
682         p->return_size = sizeof(double);
683         switch (p->data_size) {
684         case sizeof(double):
685             *(double *)p->data = val;
686             return 1;
687         }
688     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER
689                && val == (ossl_uintmax_t)val) {
690         p->return_size = sizeof(double);
691         switch (p->data_size) {
692         case sizeof(uint32_t):
693             if (val >= 0 && val <= UINT32_MAX) {
694                 p->return_size = sizeof(uint32_t);
695                 *(uint32_t *)p->data = (uint32_t)val;
696                 return 1;
697             }
698             break;
699         case sizeof(uint64_t):
700             if (val >= 0 && val <= UINT64_MAX) {
701                 p->return_size = sizeof(uint64_t);
702                 *(uint64_t *)p->data = (uint64_t)val;
703                 return 1;
704             }
705             break;            }
706     } else if (p->data_type == OSSL_PARAM_INTEGER && val == (ossl_intmax_t)val) {
707         p->return_size = sizeof(double);
708         switch (p->data_size) {
709         case sizeof(int32_t):
710             if (val >= INT32_MIN && val <= INT32_MAX) {
711                 p->return_size = sizeof(int32_t);
712                 *(int32_t *)p->data = (int32_t)val;
713                 return 1;
714             }
715             break;
716         case sizeof(int64_t):
717             if (val >= INT64_MIN && val <= INT64_MAX) {
718                 p->return_size = sizeof(int64_t);
719                 *(int64_t *)p->data = (int64_t)val;
720                 return 1;
721             }
722             break;
723         }
724     }
725     return 0;
726 }
727
728 OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf)
729 {
730     return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double));
731 }
732
733 static int get_string_internal(const OSSL_PARAM *p, void **val, size_t max_len,
734                                size_t *used_len, unsigned int type)
735 {
736     size_t sz;
737
738     if (val == NULL || p == NULL || p->data_type != type)
739         return 0;
740
741     sz = p->data_size;
742
743     if (used_len != NULL)
744         *used_len = sz;
745
746     if (*val == NULL) {
747         char *const q = OPENSSL_malloc(sz);
748
749         if (q == NULL)
750             return 0;
751         *val = q;
752         memcpy(q, p->data, sz);
753         return 1;
754     }
755     if (max_len < sz)
756         return 0;
757     memcpy(*val, p->data, sz);
758     return 1;
759 }
760
761 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len)
762 {
763     return get_string_internal(p, (void **)val, max_len, NULL,
764                                OSSL_PARAM_UTF8_STRING);
765 }
766
767 int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
768                                 size_t *used_len)
769 {
770     return get_string_internal(p, val, max_len, used_len,
771                                OSSL_PARAM_OCTET_STRING);
772 }
773
774 static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
775                                unsigned int type)
776 {
777     p->return_size = len;
778     if (p->data_type != type || p->data_size < len)
779         return 0;
780
781     memcpy(p->data, val, len);
782     return 1;
783 }
784
785 int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
786 {
787     if (p == NULL)
788         return 0;
789
790     p->return_size = 0;
791     if (val == NULL)
792         return 0;
793     return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING);
794 }
795
796 int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
797                                 size_t len)
798 {
799     if (p == NULL)
800         return 0;
801
802     p->return_size = 0;
803     if (val == NULL)
804         return 0;
805     return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
806 }
807
808 OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
809                                             size_t bsize)
810 {
811     return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
812 }
813
814 OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
815                                              size_t bsize)
816 {
817     return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
818 }
819
820 static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
821                             size_t *used_len, unsigned int type)
822 {
823     if (val == NULL || p == NULL || p->data_type != type)
824         return 0;
825     if (used_len != NULL)
826         *used_len = p->data_size;
827     *val = *(const void **)p->data;
828     return 1;
829 }
830
831 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val)
832 {
833     return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR);
834 }
835
836 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
837                              size_t *used_len)
838 {
839     return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
840 }
841
842 static int set_ptr_internal(OSSL_PARAM *p, const void *val,
843                             unsigned int type, size_t len)
844 {
845     p->return_size = len;
846     if (p->data_type != type)
847         return 0;
848     *(const void **)p->data = val;
849     return 1;
850 }
851
852 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
853 {
854     if (p == NULL)
855         return 0;
856     p->return_size = 0;
857     if (val == NULL)
858         return 0;
859     return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1);
860 }
861
862 int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
863                              size_t used_len)
864 {
865     if (p == NULL)
866         return 0;
867     p->return_size = 0;
868     if (val == NULL)
869         return 0;
870     return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len);
871 }
872
873 OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
874                                          size_t bsize)
875 {
876     return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize);
877 }
878
879 OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
880                                           size_t bsize)
881 {
882     return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize);
883 }
884
885 OSSL_PARAM OSSL_PARAM_construct_end(void)
886 {
887     OSSL_PARAM end = OSSL_PARAM_END;
888
889     return end;
890 }