]>
Commit | Line | Data |
---|---|---|
7ffbd7ca P |
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" | |
c04a9916 | 14 | #include "internal/numbers.h" |
7ffbd7ca | 15 | |
4e7991b4 | 16 | OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key) |
7ffbd7ca P |
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 | ||
4e7991b4 P |
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 | ||
7ffbd7ca | 30 | static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type, |
4e7991b4 | 31 | void *data, size_t data_size) |
7ffbd7ca P |
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; | |
4e7991b4 | 39 | res.return_size = 0; |
7ffbd7ca P |
40 | return res; |
41 | } | |
42 | ||
43 | int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val) | |
44 | { | |
863360fb | 45 | switch (sizeof(int)) { |
7ffbd7ca | 46 | case sizeof(int32_t): |
863360fb | 47 | return OSSL_PARAM_get_int32(p, (int32_t *)val); |
7ffbd7ca | 48 | case sizeof(int64_t): |
863360fb | 49 | return OSSL_PARAM_get_int64(p, (int64_t *)val); |
7ffbd7ca P |
50 | } |
51 | return 0; | |
52 | } | |
53 | ||
4e7991b4 | 54 | int OSSL_PARAM_set_int(OSSL_PARAM *p, int val) |
7ffbd7ca | 55 | { |
863360fb | 56 | switch (sizeof(int)) { |
7ffbd7ca | 57 | case sizeof(int32_t): |
863360fb | 58 | return OSSL_PARAM_set_int32(p, (int32_t)val); |
7ffbd7ca | 59 | case sizeof(int64_t): |
863360fb | 60 | return OSSL_PARAM_set_int64(p, (int64_t)val); |
7ffbd7ca P |
61 | } |
62 | return 0; | |
63 | } | |
64 | ||
4e7991b4 | 65 | OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf) |
7ffbd7ca | 66 | { |
4e7991b4 | 67 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int)); |
7ffbd7ca P |
68 | } |
69 | ||
70 | int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val) | |
71 | { | |
863360fb | 72 | switch (sizeof(unsigned int)) { |
7ffbd7ca | 73 | case sizeof(uint32_t): |
863360fb | 74 | return OSSL_PARAM_get_uint32(p, (uint32_t *)val); |
7ffbd7ca | 75 | case sizeof(uint64_t): |
863360fb | 76 | return OSSL_PARAM_get_uint64(p, (uint64_t *)val); |
7ffbd7ca P |
77 | } |
78 | return 0; | |
79 | } | |
80 | ||
4e7991b4 | 81 | int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val) |
7ffbd7ca | 82 | { |
863360fb | 83 | switch (sizeof(unsigned int)) { |
7ffbd7ca | 84 | case sizeof(uint32_t): |
863360fb | 85 | return OSSL_PARAM_set_uint32(p, (uint32_t)val); |
7ffbd7ca | 86 | case sizeof(uint64_t): |
863360fb | 87 | return OSSL_PARAM_set_uint64(p, (uint64_t)val); |
7ffbd7ca P |
88 | } |
89 | return 0; | |
90 | } | |
91 | ||
4e7991b4 | 92 | OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf) |
7ffbd7ca P |
93 | { |
94 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 | 95 | sizeof(unsigned int)); |
7ffbd7ca P |
96 | } |
97 | ||
98 | int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val) | |
99 | { | |
863360fb | 100 | switch (sizeof(long int)) { |
7ffbd7ca | 101 | case sizeof(int32_t): |
863360fb | 102 | return OSSL_PARAM_get_int32(p, (int32_t *)val); |
7ffbd7ca | 103 | case sizeof(int64_t): |
863360fb | 104 | return OSSL_PARAM_get_int64(p, (int64_t *)val); |
7ffbd7ca P |
105 | } |
106 | return 0; | |
107 | } | |
108 | ||
4e7991b4 | 109 | int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val) |
7ffbd7ca | 110 | { |
863360fb | 111 | switch (sizeof(long int)) { |
7ffbd7ca | 112 | case sizeof(int32_t): |
863360fb | 113 | return OSSL_PARAM_set_int32(p, (int32_t)val); |
7ffbd7ca | 114 | case sizeof(int64_t): |
863360fb | 115 | return OSSL_PARAM_set_int64(p, (int64_t)val); |
7ffbd7ca P |
116 | } |
117 | return 0; | |
118 | } | |
119 | ||
4e7991b4 | 120 | OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf) |
7ffbd7ca | 121 | { |
4e7991b4 | 122 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int)); |
7ffbd7ca P |
123 | } |
124 | ||
125 | int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val) | |
126 | { | |
863360fb | 127 | switch (sizeof(unsigned long int)) { |
7ffbd7ca | 128 | case sizeof(uint32_t): |
863360fb | 129 | return OSSL_PARAM_get_uint32(p, (uint32_t *)val); |
7ffbd7ca | 130 | case sizeof(uint64_t): |
863360fb | 131 | return OSSL_PARAM_get_uint64(p, (uint64_t *)val); |
7ffbd7ca P |
132 | } |
133 | return 0; | |
134 | } | |
135 | ||
4e7991b4 | 136 | int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val) |
7ffbd7ca | 137 | { |
863360fb | 138 | switch (sizeof(unsigned long int)) { |
7ffbd7ca | 139 | case sizeof(uint32_t): |
863360fb | 140 | return OSSL_PARAM_set_uint32(p, (uint32_t)val); |
7ffbd7ca | 141 | case sizeof(uint64_t): |
863360fb | 142 | return OSSL_PARAM_set_uint64(p, (uint64_t)val); |
7ffbd7ca P |
143 | } |
144 | return 0; | |
145 | } | |
146 | ||
4e7991b4 | 147 | OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf) |
7ffbd7ca P |
148 | { |
149 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 | 150 | sizeof(unsigned long int)); |
7ffbd7ca P |
151 | } |
152 | ||
153 | int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val) | |
154 | { | |
9830e7ea P |
155 | int64_t i64; |
156 | uint32_t u32; | |
157 | uint64_t u64; | |
158 | double d; | |
159 | ||
160 | if (val == NULL || p == NULL ) | |
7ffbd7ca P |
161 | return 0; |
162 | ||
9830e7ea P |
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 | } | |
7ffbd7ca P |
203 | } |
204 | return 0; | |
205 | } | |
206 | ||
4e7991b4 | 207 | int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val) |
7ffbd7ca P |
208 | { |
209 | if (p == NULL) | |
210 | return 0; | |
4e7991b4 | 211 | p->return_size = 0; |
9830e7ea | 212 | if (p->data_type == OSSL_PARAM_INTEGER) { |
4e7991b4 | 213 | p->return_size = sizeof(int32_t); /* Minimum expected size */ |
9830e7ea P |
214 | switch (p->data_size) { |
215 | case sizeof(int32_t): | |
216 | *(int32_t *)p->data = val; | |
217 | return 1; | |
218 | case sizeof(int64_t): | |
4e7991b4 | 219 | p->return_size = sizeof(int64_t); |
9830e7ea P |
220 | *(int64_t *)p->data = (int64_t)val; |
221 | return 1; | |
222 | } | |
223 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) { | |
4e7991b4 | 224 | p->return_size = sizeof(uint32_t); /* Minimum expected size */ |
9830e7ea P |
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): | |
4e7991b4 | 230 | p->return_size = sizeof(uint64_t); |
9830e7ea P |
231 | *(uint64_t *)p->data = (uint64_t)val; |
232 | return 1; | |
233 | } | |
234 | } else if (p->data_type == OSSL_PARAM_REAL) { | |
4e7991b4 | 235 | p->return_size = sizeof(double); |
9830e7ea P |
236 | switch (p->data_size) { |
237 | case sizeof(double): | |
238 | *(double *)p->data = (double)val; | |
239 | return 1; | |
240 | } | |
7ffbd7ca P |
241 | } |
242 | return 0; | |
243 | } | |
244 | ||
4e7991b4 | 245 | OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf) |
7ffbd7ca P |
246 | { |
247 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, | |
4e7991b4 | 248 | sizeof(int32_t)); |
7ffbd7ca P |
249 | } |
250 | ||
251 | int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val) | |
252 | { | |
9830e7ea P |
253 | int32_t i32; |
254 | int64_t i64; | |
255 | uint64_t u64; | |
256 | double d; | |
257 | ||
258 | if (val == NULL || p == NULL) | |
7ffbd7ca P |
259 | return 0; |
260 | ||
9830e7ea P |
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 | } | |
7ffbd7ca P |
301 | } |
302 | return 0; | |
303 | } | |
304 | ||
4e7991b4 | 305 | int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val) |
7ffbd7ca | 306 | { |
9830e7ea | 307 | if (p == NULL) |
7ffbd7ca | 308 | return 0; |
4e7991b4 | 309 | p->return_size = 0; |
7ffbd7ca | 310 | |
9830e7ea | 311 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
4e7991b4 | 312 | p->return_size = sizeof(uint32_t); /* Minimum expected size */ |
9830e7ea P |
313 | switch (p->data_size) { |
314 | case sizeof(uint32_t): | |
315 | *(uint32_t *)p->data = val; | |
316 | return 1; | |
317 | case sizeof(uint64_t): | |
4e7991b4 | 318 | p->return_size = sizeof(uint64_t); |
9830e7ea P |
319 | *(uint64_t *)p->data = val; |
320 | return 1; | |
321 | } | |
322 | } else if (p->data_type == OSSL_PARAM_INTEGER) { | |
4e7991b4 | 323 | p->return_size = sizeof(int32_t); /* Minimum expected size */ |
9830e7ea P |
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): | |
4e7991b4 | 332 | p->return_size = sizeof(int64_t); |
9830e7ea P |
333 | *(int64_t *)p->data = (int64_t)val; |
334 | return 1; | |
335 | } | |
336 | } else if (p->data_type == OSSL_PARAM_REAL) { | |
4e7991b4 | 337 | p->return_size = sizeof(double); |
9830e7ea P |
338 | switch (p->data_size) { |
339 | case sizeof(double): | |
340 | *(double *)p->data = (double)val; | |
341 | return 1; | |
342 | } | |
7ffbd7ca P |
343 | } |
344 | return 0; | |
345 | } | |
346 | ||
4e7991b4 | 347 | OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf) |
7ffbd7ca P |
348 | { |
349 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 | 350 | sizeof(uint32_t)); |
7ffbd7ca P |
351 | } |
352 | ||
353 | int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val) | |
354 | { | |
9830e7ea P |
355 | uint64_t u64; |
356 | double d; | |
357 | ||
358 | if (val == NULL || p == NULL ) | |
7ffbd7ca P |
359 | return 0; |
360 | ||
9830e7ea P |
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 | } | |
7ffbd7ca P |
393 | } |
394 | return 0; | |
395 | } | |
396 | ||
4e7991b4 | 397 | int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val) |
7ffbd7ca | 398 | { |
9830e7ea P |
399 | uint64_t u64; |
400 | ||
7ffbd7ca P |
401 | if (p == NULL) |
402 | return 0; | |
4e7991b4 | 403 | p->return_size = 0; |
9830e7ea | 404 | if (p->data_type == OSSL_PARAM_INTEGER) { |
4e7991b4 | 405 | p->return_size = sizeof(int64_t); /* Expected size */ |
9830e7ea P |
406 | switch (p->data_size) { |
407 | case sizeof(int32_t): | |
408 | if (val >= INT32_MIN && val <= INT32_MAX) { | |
4e7991b4 | 409 | p->return_size = sizeof(int32_t); |
9830e7ea P |
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) { | |
4e7991b4 | 419 | p->return_size = sizeof(uint64_t); /* Expected size */ |
9830e7ea P |
420 | switch (p->data_size) { |
421 | case sizeof(uint32_t): | |
422 | if (val <= UINT32_MAX) { | |
4e7991b4 | 423 | p->return_size = sizeof(uint32_t); |
9830e7ea P |
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) { | |
4e7991b4 | 433 | p->return_size = sizeof(double); |
9830e7ea P |
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 | } | |
7ffbd7ca P |
443 | } |
444 | return 0; | |
445 | } | |
446 | ||
4e7991b4 | 447 | OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf) |
7ffbd7ca | 448 | { |
4e7991b4 | 449 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t)); |
7ffbd7ca P |
450 | } |
451 | ||
452 | int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val) | |
453 | { | |
9830e7ea P |
454 | int32_t i32; |
455 | int64_t i64; | |
456 | double d; | |
457 | ||
458 | if (val == NULL || p == NULL) | |
7ffbd7ca P |
459 | return 0; |
460 | ||
9830e7ea P |
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 | } | |
7ffbd7ca P |
497 | } |
498 | return 0; | |
499 | } | |
500 | ||
4e7991b4 | 501 | int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val) |
7ffbd7ca P |
502 | { |
503 | if (p == NULL) | |
504 | return 0; | |
4e7991b4 | 505 | p->return_size = 0; |
7ffbd7ca | 506 | |
9830e7ea | 507 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
4e7991b4 | 508 | p->return_size = sizeof(uint64_t); /* Expected size */ |
9830e7ea P |
509 | switch (p->data_size) { |
510 | case sizeof(uint32_t): | |
511 | if (val <= UINT32_MAX) { | |
4e7991b4 | 512 | p->return_size = sizeof(uint32_t); |
9830e7ea P |
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) { | |
4e7991b4 | 522 | p->return_size = sizeof(int64_t); /* Expected size */ |
9830e7ea P |
523 | switch (p->data_size) { |
524 | case sizeof(int32_t): | |
525 | if (val <= INT32_MAX) { | |
4e7991b4 | 526 | p->return_size = sizeof(int32_t); |
9830e7ea P |
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) { | |
4e7991b4 | 539 | p->return_size = sizeof(double); |
9830e7ea P |
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 | } | |
7ffbd7ca P |
548 | } |
549 | return 0; | |
550 | } | |
551 | ||
4e7991b4 P |
552 | OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf) |
553 | { | |
7ffbd7ca | 554 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, |
4e7991b4 | 555 | sizeof(uint64_t)); |
7ffbd7ca P |
556 | } |
557 | ||
558 | int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val) | |
559 | { | |
863360fb | 560 | switch (sizeof(size_t)) { |
7ffbd7ca | 561 | case sizeof(uint32_t): |
863360fb | 562 | return OSSL_PARAM_get_uint32(p, (uint32_t *)val); |
7ffbd7ca | 563 | case sizeof(uint64_t): |
863360fb | 564 | return OSSL_PARAM_get_uint64(p, (uint64_t *)val); |
7ffbd7ca P |
565 | } |
566 | return 0; | |
567 | } | |
568 | ||
4e7991b4 | 569 | int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val) |
7ffbd7ca | 570 | { |
863360fb | 571 | switch (sizeof(size_t)) { |
7ffbd7ca | 572 | case sizeof(uint32_t): |
863360fb | 573 | return OSSL_PARAM_set_uint32(p, (uint32_t)val); |
7ffbd7ca | 574 | case sizeof(uint64_t): |
863360fb | 575 | return OSSL_PARAM_set_uint64(p, (uint64_t)val); |
7ffbd7ca P |
576 | } |
577 | return 0; | |
578 | } | |
579 | ||
4e7991b4 | 580 | OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf) |
7ffbd7ca P |
581 | { |
582 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 P |
583 | sizeof(size_t)); |
584 | } | |
7ffbd7ca P |
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 | ||
4e7991b4 | 603 | int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val) |
7ffbd7ca P |
604 | { |
605 | size_t bytes; | |
606 | ||
607 | if (p == NULL) | |
608 | return 0; | |
4e7991b4 | 609 | p->return_size = 0; |
7ffbd7ca P |
610 | if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER) |
611 | return 0; | |
612 | ||
6ce84e64 P |
613 | /* For the moment, only positive values are permitted */ |
614 | if (BN_is_negative(val)) | |
615 | return 0; | |
616 | ||
7ffbd7ca | 617 | bytes = (size_t)BN_num_bytes(val); |
4e7991b4 | 618 | p->return_size = bytes; |
7ffbd7ca P |
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, | |
4e7991b4 | 624 | size_t bsize) |
7ffbd7ca P |
625 | { |
626 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, | |
4e7991b4 | 627 | buf, bsize); |
7ffbd7ca P |
628 | } |
629 | ||
630 | int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val) | |
631 | { | |
9830e7ea P |
632 | int64_t i64; |
633 | uint64_t u64; | |
634 | ||
635 | if (val == NULL || p == NULL) | |
7ffbd7ca P |
636 | return 0; |
637 | ||
9830e7ea P |
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 | } | |
7ffbd7ca P |
671 | } |
672 | return 0; | |
673 | } | |
674 | ||
4e7991b4 | 675 | int OSSL_PARAM_set_double(OSSL_PARAM *p, double val) |
7ffbd7ca P |
676 | { |
677 | if (p == NULL) | |
678 | return 0; | |
4e7991b4 | 679 | p->return_size = 0; |
7ffbd7ca | 680 | |
9830e7ea | 681 | if (p->data_type == OSSL_PARAM_REAL) { |
4e7991b4 | 682 | p->return_size = sizeof(double); |
9830e7ea P |
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 | |
c04a9916 | 689 | && val == (ossl_uintmax_t)val) { |
4e7991b4 | 690 | p->return_size = sizeof(double); |
9830e7ea P |
691 | switch (p->data_size) { |
692 | case sizeof(uint32_t): | |
693 | if (val >= 0 && val <= UINT32_MAX) { | |
4e7991b4 | 694 | p->return_size = sizeof(uint32_t); |
9830e7ea P |
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) { | |
4e7991b4 | 701 | p->return_size = sizeof(uint64_t); |
9830e7ea P |
702 | *(uint64_t *)p->data = (uint64_t)val; |
703 | return 1; | |
704 | } | |
705 | break; } | |
c04a9916 | 706 | } else if (p->data_type == OSSL_PARAM_INTEGER && val == (ossl_intmax_t)val) { |
4e7991b4 | 707 | p->return_size = sizeof(double); |
9830e7ea P |
708 | switch (p->data_size) { |
709 | case sizeof(int32_t): | |
710 | if (val >= INT32_MIN && val <= INT32_MAX) { | |
4e7991b4 | 711 | p->return_size = sizeof(int32_t); |
9830e7ea P |
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) { | |
4e7991b4 | 718 | p->return_size = sizeof(int64_t); |
9830e7ea P |
719 | *(int64_t *)p->data = (int64_t)val; |
720 | return 1; | |
721 | } | |
722 | break; | |
723 | } | |
7ffbd7ca P |
724 | } |
725 | return 0; | |
726 | } | |
727 | ||
4e7991b4 | 728 | OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf) |
7ffbd7ca | 729 | { |
4e7991b4 | 730 | return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double)); |
7ffbd7ca P |
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 | ||
4e7991b4 | 774 | static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len, |
7ffbd7ca P |
775 | unsigned int type) |
776 | { | |
4e7991b4 | 777 | p->return_size = len; |
7ffbd7ca P |
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 | ||
4e7991b4 | 785 | int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val) |
7ffbd7ca P |
786 | { |
787 | if (p == NULL) | |
788 | return 0; | |
789 | ||
4e7991b4 | 790 | p->return_size = 0; |
7ffbd7ca P |
791 | if (val == NULL) |
792 | return 0; | |
793 | return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING); | |
794 | } | |
795 | ||
4e7991b4 | 796 | int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, |
7ffbd7ca P |
797 | size_t len) |
798 | { | |
799 | if (p == NULL) | |
800 | return 0; | |
801 | ||
4e7991b4 | 802 | p->return_size = 0; |
7ffbd7ca P |
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, | |
4e7991b4 | 809 | size_t bsize) |
7ffbd7ca | 810 | { |
7f588d20 P |
811 | if (buf != NULL && bsize == 0) |
812 | bsize = strlen(buf) + 1; | |
4e7991b4 | 813 | return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize); |
7ffbd7ca P |
814 | } |
815 | ||
816 | OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf, | |
4e7991b4 | 817 | size_t bsize) |
7ffbd7ca | 818 | { |
4e7991b4 | 819 | return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize); |
7ffbd7ca P |
820 | } |
821 | ||
822 | static int get_ptr_internal(const OSSL_PARAM *p, const void **val, | |
823 | size_t *used_len, unsigned int type) | |
824 | { | |
825 | if (val == NULL || p == NULL || p->data_type != type) | |
826 | return 0; | |
827 | if (used_len != NULL) | |
828 | *used_len = p->data_size; | |
829 | *val = *(const void **)p->data; | |
830 | return 1; | |
831 | } | |
832 | ||
833 | int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val) | |
834 | { | |
835 | return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR); | |
836 | } | |
837 | ||
838 | int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val, | |
839 | size_t *used_len) | |
840 | { | |
841 | return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR); | |
842 | } | |
843 | ||
4e7991b4 | 844 | static int set_ptr_internal(OSSL_PARAM *p, const void *val, |
7ffbd7ca P |
845 | unsigned int type, size_t len) |
846 | { | |
4e7991b4 | 847 | p->return_size = len; |
7ffbd7ca P |
848 | if (p->data_type != type) |
849 | return 0; | |
850 | *(const void **)p->data = val; | |
851 | return 1; | |
852 | } | |
853 | ||
4e7991b4 | 854 | int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val) |
7ffbd7ca P |
855 | { |
856 | if (p == NULL) | |
857 | return 0; | |
4e7991b4 | 858 | p->return_size = 0; |
7ffbd7ca P |
859 | if (val == NULL) |
860 | return 0; | |
861 | return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1); | |
862 | } | |
863 | ||
4e7991b4 | 864 | int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val, |
7ffbd7ca P |
865 | size_t used_len) |
866 | { | |
867 | if (p == NULL) | |
868 | return 0; | |
4e7991b4 | 869 | p->return_size = 0; |
7ffbd7ca P |
870 | if (val == NULL) |
871 | return 0; | |
872 | return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len); | |
873 | } | |
874 | ||
875 | OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf, | |
4e7991b4 | 876 | size_t bsize) |
7ffbd7ca | 877 | { |
4e7991b4 | 878 | return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize); |
7ffbd7ca P |
879 | } |
880 | ||
881 | OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf, | |
4e7991b4 | 882 | size_t bsize) |
7ffbd7ca | 883 | { |
4e7991b4 | 884 | return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize); |
7ffbd7ca | 885 | } |
195852fe RL |
886 | |
887 | OSSL_PARAM OSSL_PARAM_construct_end(void) | |
888 | { | |
889 | OSSL_PARAM end = OSSL_PARAM_END; | |
890 | ||
891 | return end; | |
892 | } |