]>
Commit | Line | Data |
---|---|---|
7ffbd7ca | 1 | /* |
8020d79b | 2 | * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. |
7ffbd7ca P |
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" |
e9c5e642 | 15 | #include "internal/endian.h" |
7ffbd7ca | 16 | |
5b1d94c1 P |
17 | /* |
18 | * Return the number of bits in the mantissa of a double. This is used to | |
19 | * shift a larger integral value to determine if it will exactly fit into a | |
20 | * double. | |
21 | */ | |
22 | static unsigned int real_shift(void) | |
23 | { | |
24 | return sizeof(double) == 4 ? 24 : 53; | |
25 | } | |
26 | ||
4e7991b4 | 27 | OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key) |
7ffbd7ca P |
28 | { |
29 | if (p != NULL && key != NULL) | |
30 | for (; p->key != NULL; p++) | |
31 | if (strcmp(key, p->key) == 0) | |
32 | return p; | |
33 | return NULL; | |
34 | } | |
35 | ||
4e7991b4 P |
36 | const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key) |
37 | { | |
38 | return OSSL_PARAM_locate((OSSL_PARAM *)p, key); | |
39 | } | |
40 | ||
7ffbd7ca | 41 | static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type, |
4e7991b4 | 42 | void *data, size_t data_size) |
7ffbd7ca P |
43 | { |
44 | OSSL_PARAM res; | |
45 | ||
46 | res.key = key; | |
47 | res.data_type = data_type; | |
48 | res.data = data; | |
49 | res.data_size = data_size; | |
8d5fb648 | 50 | res.return_size = OSSL_PARAM_UNMODIFIED; |
7ffbd7ca P |
51 | return res; |
52 | } | |
53 | ||
8d5fb648 P |
54 | int OSSL_PARAM_modified(const OSSL_PARAM *p) |
55 | { | |
56 | return p != NULL && p->return_size != OSSL_PARAM_UNMODIFIED; | |
57 | } | |
58 | ||
3873887e | 59 | void OSSL_PARAM_set_all_unmodified(OSSL_PARAM *p) |
8d5fb648 P |
60 | { |
61 | if (p != NULL) | |
3873887e P |
62 | while (p->key != NULL) |
63 | p++->return_size = OSSL_PARAM_UNMODIFIED; | |
8d5fb648 P |
64 | } |
65 | ||
e9c5e642 P |
66 | /* Return non-zero if the signed number is negative */ |
67 | static int is_negative(const void *number, size_t s) | |
68 | { | |
69 | const unsigned char *n = number; | |
70 | DECLARE_IS_ENDIAN; | |
71 | ||
72 | return 0x80 & (IS_BIG_ENDIAN ? n[0] : n[s - 1]); | |
73 | } | |
74 | ||
75 | /* Check that all the bytes specified match the expected sign byte */ | |
76 | static int check_sign_bytes(const unsigned char *p, size_t n, unsigned char s) | |
77 | { | |
78 | size_t i; | |
79 | ||
80 | for (i = 0; i < n; i++) | |
81 | if (p[i] != s) | |
82 | return 0; | |
83 | return 1; | |
84 | } | |
85 | ||
86 | /* | |
87 | * Copy an integer to another integer. | |
88 | * Handle different length integers and signed and unsigned integers. | |
89 | * Both integers are in native byte ordering. | |
90 | */ | |
91 | static int copy_integer(unsigned char *dest, size_t dest_len, | |
92 | const unsigned char *src, size_t src_len, | |
93 | unsigned char pad, int signed_int) | |
94 | { | |
95 | size_t n; | |
96 | DECLARE_IS_ENDIAN; | |
97 | ||
98 | if (IS_BIG_ENDIAN) { | |
99 | if (src_len < dest_len) { | |
100 | n = dest_len - src_len; | |
101 | memset(dest, pad, n); | |
102 | memcpy(dest + n, src, src_len); | |
103 | } else { | |
104 | n = src_len - dest_len; | |
105 | if (!check_sign_bytes(src, n, pad) | |
106 | /* | |
107 | * Shortening a signed value must retain the correct sign. | |
108 | * Avoiding this kind of thing: -253 = 0xff03 -> 0x03 = 3 | |
109 | */ | |
110 | || (signed_int && ((pad ^ src[n]) & 0x80) != 0)) | |
111 | return 0; | |
112 | memcpy(dest, src + n, dest_len); | |
113 | } | |
114 | } else /* IS_LITTLE_ENDIAN */ { | |
115 | if (src_len < dest_len) { | |
116 | n = dest_len - src_len; | |
117 | memset(dest + src_len, pad, n); | |
118 | memcpy(dest, src, src_len); | |
119 | } else { | |
120 | n = src_len - dest_len; | |
121 | if (!check_sign_bytes(src + dest_len, n, pad) | |
122 | /* | |
123 | * Shortening a signed value must retain the correct sign. | |
124 | * Avoiding this kind of thing: 130 = 0x0082 -> 0x82 = -126 | |
125 | */ | |
126 | || (signed_int && ((pad ^ src[dest_len - 1]) & 0x80) != 0)) | |
127 | return 0; | |
128 | memcpy(dest, src, dest_len); | |
129 | } | |
130 | } | |
131 | return 1; | |
132 | } | |
133 | ||
134 | /* Copy a signed number to a signed number of possibly different length */ | |
135 | static int signed_from_signed(void *dest, size_t dest_len, | |
136 | const void *src, size_t src_len) | |
137 | { | |
138 | return copy_integer(dest, dest_len, src, src_len, | |
139 | is_negative(src, src_len) ? 0xff : 0, 1); | |
140 | } | |
141 | ||
142 | /* Copy an unsigned number to a signed number of possibly different length */ | |
143 | static int signed_from_unsigned(void *dest, size_t dest_len, | |
144 | const void *src, size_t src_len) | |
145 | { | |
146 | return copy_integer(dest, dest_len, src, src_len, 0, 1); | |
147 | } | |
148 | ||
149 | /* Copy a signed number to an unsigned number of possibly different length */ | |
150 | static int unsigned_from_signed(void *dest, size_t dest_len, | |
151 | const void *src, size_t src_len) | |
152 | { | |
153 | if (is_negative(src, src_len)) | |
154 | return 0; | |
155 | return copy_integer(dest, dest_len, src, src_len, 0, 0); | |
156 | } | |
157 | ||
158 | /* Copy an unsigned number to an unsigned number of possibly different length */ | |
159 | static int unsigned_from_unsigned(void *dest, size_t dest_len, | |
160 | const void *src, size_t src_len) | |
161 | { | |
162 | return copy_integer(dest, dest_len, src, src_len, 0, 0); | |
163 | } | |
164 | ||
165 | /* General purpose get integer parameter call that handles odd sizes */ | |
166 | static int general_get_int(const OSSL_PARAM *p, void *val, size_t val_size) | |
167 | { | |
168 | if (p->data_type == OSSL_PARAM_INTEGER) | |
169 | return signed_from_signed(val, val_size, p->data, p->data_size); | |
170 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) | |
171 | return signed_from_unsigned(val, val_size, p->data, p->data_size); | |
172 | return 0; | |
173 | } | |
174 | ||
175 | /* General purpose set integer parameter call that handles odd sizes */ | |
176 | static int general_set_int(OSSL_PARAM *p, void *val, size_t val_size) | |
177 | { | |
178 | int r = 0; | |
179 | ||
180 | p->return_size = val_size; /* Expected size */ | |
181 | if (p->data == NULL) | |
182 | return 1; | |
183 | if (p->data_type == OSSL_PARAM_INTEGER) | |
184 | r = signed_from_signed(p->data, p->data_size, val, val_size); | |
185 | else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) | |
186 | r = unsigned_from_signed(p->data, p->data_size, val, val_size); | |
187 | p->return_size = r ? p->data_size : val_size; | |
188 | return r; | |
189 | } | |
190 | ||
191 | /* General purpose get unsigned integer parameter call that handles odd sizes */ | |
192 | static int general_get_uint(const OSSL_PARAM *p, void *val, size_t val_size) | |
193 | { | |
194 | if (p->data_type == OSSL_PARAM_INTEGER) | |
195 | return unsigned_from_signed(val, val_size, p->data, p->data_size); | |
196 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) | |
197 | return unsigned_from_unsigned(val, val_size, p->data, p->data_size); | |
198 | return 0; | |
199 | } | |
200 | ||
201 | /* General purpose set unsigned integer parameter call that handles odd sizes */ | |
202 | static int general_set_uint(OSSL_PARAM *p, void *val, size_t val_size) | |
203 | { | |
204 | int r = 0; | |
205 | ||
206 | p->return_size = val_size; /* Expected size */ | |
207 | if (p->data == NULL) | |
208 | return 1; | |
209 | if (p->data_type == OSSL_PARAM_INTEGER) | |
210 | r = signed_from_unsigned(p->data, p->data_size, val, val_size); | |
211 | else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) | |
212 | r = unsigned_from_unsigned(p->data, p->data_size, val, val_size); | |
213 | p->return_size = r ? p->data_size : val_size; | |
214 | return r; | |
215 | } | |
216 | ||
7ffbd7ca P |
217 | int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val) |
218 | { | |
e9c5e642 | 219 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 220 | switch (sizeof(int)) { |
7ffbd7ca | 221 | case sizeof(int32_t): |
863360fb | 222 | return OSSL_PARAM_get_int32(p, (int32_t *)val); |
7ffbd7ca | 223 | case sizeof(int64_t): |
863360fb | 224 | return OSSL_PARAM_get_int64(p, (int64_t *)val); |
7ffbd7ca | 225 | } |
e9c5e642 P |
226 | #endif |
227 | return general_get_int(p, val, sizeof(*val)); | |
7ffbd7ca P |
228 | } |
229 | ||
4e7991b4 | 230 | int OSSL_PARAM_set_int(OSSL_PARAM *p, int val) |
7ffbd7ca | 231 | { |
e9c5e642 | 232 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 233 | switch (sizeof(int)) { |
7ffbd7ca | 234 | case sizeof(int32_t): |
863360fb | 235 | return OSSL_PARAM_set_int32(p, (int32_t)val); |
7ffbd7ca | 236 | case sizeof(int64_t): |
863360fb | 237 | return OSSL_PARAM_set_int64(p, (int64_t)val); |
7ffbd7ca | 238 | } |
e9c5e642 P |
239 | #endif |
240 | return general_set_int(p, &val, sizeof(val)); | |
7ffbd7ca P |
241 | } |
242 | ||
4e7991b4 | 243 | OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf) |
7ffbd7ca | 244 | { |
4e7991b4 | 245 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int)); |
7ffbd7ca P |
246 | } |
247 | ||
248 | int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val) | |
249 | { | |
e9c5e642 | 250 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 251 | switch (sizeof(unsigned int)) { |
7ffbd7ca | 252 | case sizeof(uint32_t): |
863360fb | 253 | return OSSL_PARAM_get_uint32(p, (uint32_t *)val); |
7ffbd7ca | 254 | case sizeof(uint64_t): |
863360fb | 255 | return OSSL_PARAM_get_uint64(p, (uint64_t *)val); |
7ffbd7ca | 256 | } |
e9c5e642 P |
257 | #endif |
258 | return general_get_uint(p, val, sizeof(*val)); | |
7ffbd7ca P |
259 | } |
260 | ||
4e7991b4 | 261 | int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val) |
7ffbd7ca | 262 | { |
e9c5e642 | 263 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 264 | switch (sizeof(unsigned int)) { |
7ffbd7ca | 265 | case sizeof(uint32_t): |
863360fb | 266 | return OSSL_PARAM_set_uint32(p, (uint32_t)val); |
7ffbd7ca | 267 | case sizeof(uint64_t): |
863360fb | 268 | return OSSL_PARAM_set_uint64(p, (uint64_t)val); |
7ffbd7ca | 269 | } |
e9c5e642 P |
270 | #endif |
271 | return general_set_uint(p, &val, sizeof(val)); | |
7ffbd7ca P |
272 | } |
273 | ||
4e7991b4 | 274 | OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf) |
7ffbd7ca P |
275 | { |
276 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 | 277 | sizeof(unsigned int)); |
7ffbd7ca P |
278 | } |
279 | ||
280 | int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val) | |
281 | { | |
e9c5e642 | 282 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 283 | switch (sizeof(long int)) { |
7ffbd7ca | 284 | case sizeof(int32_t): |
863360fb | 285 | return OSSL_PARAM_get_int32(p, (int32_t *)val); |
7ffbd7ca | 286 | case sizeof(int64_t): |
863360fb | 287 | return OSSL_PARAM_get_int64(p, (int64_t *)val); |
7ffbd7ca | 288 | } |
e9c5e642 P |
289 | #endif |
290 | return general_get_int(p, val, sizeof(*val)); | |
7ffbd7ca P |
291 | } |
292 | ||
4e7991b4 | 293 | int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val) |
7ffbd7ca | 294 | { |
e9c5e642 | 295 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 296 | switch (sizeof(long int)) { |
7ffbd7ca | 297 | case sizeof(int32_t): |
863360fb | 298 | return OSSL_PARAM_set_int32(p, (int32_t)val); |
7ffbd7ca | 299 | case sizeof(int64_t): |
863360fb | 300 | return OSSL_PARAM_set_int64(p, (int64_t)val); |
7ffbd7ca | 301 | } |
e9c5e642 P |
302 | #endif |
303 | return general_set_int(p, &val, sizeof(val)); | |
7ffbd7ca P |
304 | } |
305 | ||
4e7991b4 | 306 | OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf) |
7ffbd7ca | 307 | { |
4e7991b4 | 308 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int)); |
7ffbd7ca P |
309 | } |
310 | ||
311 | int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val) | |
312 | { | |
e9c5e642 | 313 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 314 | switch (sizeof(unsigned long int)) { |
7ffbd7ca | 315 | case sizeof(uint32_t): |
863360fb | 316 | return OSSL_PARAM_get_uint32(p, (uint32_t *)val); |
7ffbd7ca | 317 | case sizeof(uint64_t): |
863360fb | 318 | return OSSL_PARAM_get_uint64(p, (uint64_t *)val); |
7ffbd7ca | 319 | } |
e9c5e642 P |
320 | #endif |
321 | return general_get_uint(p, val, sizeof(*val)); | |
7ffbd7ca P |
322 | } |
323 | ||
4e7991b4 | 324 | int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val) |
7ffbd7ca | 325 | { |
e9c5e642 | 326 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 327 | switch (sizeof(unsigned long int)) { |
7ffbd7ca | 328 | case sizeof(uint32_t): |
863360fb | 329 | return OSSL_PARAM_set_uint32(p, (uint32_t)val); |
7ffbd7ca | 330 | case sizeof(uint64_t): |
863360fb | 331 | return OSSL_PARAM_set_uint64(p, (uint64_t)val); |
7ffbd7ca | 332 | } |
e9c5e642 P |
333 | #endif |
334 | return general_set_uint(p, &val, sizeof(val)); | |
7ffbd7ca P |
335 | } |
336 | ||
4e7991b4 | 337 | OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf) |
7ffbd7ca P |
338 | { |
339 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 | 340 | sizeof(unsigned long int)); |
7ffbd7ca P |
341 | } |
342 | ||
343 | int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val) | |
344 | { | |
9830e7ea P |
345 | double d; |
346 | ||
347 | if (val == NULL || p == NULL ) | |
7ffbd7ca P |
348 | return 0; |
349 | ||
9830e7ea | 350 | if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 P |
351 | #ifndef OPENSSL_SMALL_FOOTPRINT |
352 | int64_t i64; | |
353 | ||
9830e7ea P |
354 | switch (p->data_size) { |
355 | case sizeof(int32_t): | |
356 | *val = *(const int32_t *)p->data; | |
357 | return 1; | |
358 | case sizeof(int64_t): | |
359 | i64 = *(const int64_t *)p->data; | |
360 | if (i64 >= INT32_MIN && i64 <= INT32_MAX) { | |
361 | *val = (int32_t)i64; | |
362 | return 1; | |
363 | } | |
e9c5e642 | 364 | return 0; |
9830e7ea | 365 | } |
e9c5e642 P |
366 | #endif |
367 | return general_get_int(p, val, sizeof(*val)); | |
368 | ||
9830e7ea | 369 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
e9c5e642 P |
370 | #ifndef OPENSSL_SMALL_FOOTPRINT |
371 | uint32_t u32; | |
372 | uint64_t u64; | |
373 | ||
9830e7ea P |
374 | switch (p->data_size) { |
375 | case sizeof(uint32_t): | |
376 | u32 = *(const uint32_t *)p->data; | |
377 | if (u32 <= INT32_MAX) { | |
378 | *val = (int32_t)u32; | |
379 | return 1; | |
380 | } | |
e9c5e642 | 381 | return 0; |
9830e7ea P |
382 | case sizeof(uint64_t): |
383 | u64 = *(const uint64_t *)p->data; | |
384 | if (u64 <= INT32_MAX) { | |
385 | *val = (int32_t)u64; | |
386 | return 1; | |
387 | } | |
e9c5e642 | 388 | return 0; |
9830e7ea | 389 | } |
e9c5e642 P |
390 | #endif |
391 | return general_get_int(p, val, sizeof(*val)); | |
392 | ||
9830e7ea P |
393 | } else if (p->data_type == OSSL_PARAM_REAL) { |
394 | switch (p->data_size) { | |
395 | case sizeof(double): | |
396 | d = *(const double *)p->data; | |
397 | if (d >= INT32_MIN && d <= INT32_MAX && d == (int32_t)d) { | |
398 | *val = (int32_t)d; | |
399 | return 1; | |
400 | } | |
401 | break; | |
402 | } | |
7ffbd7ca P |
403 | } |
404 | return 0; | |
405 | } | |
406 | ||
4e7991b4 | 407 | int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val) |
7ffbd7ca P |
408 | { |
409 | if (p == NULL) | |
410 | return 0; | |
4e7991b4 | 411 | p->return_size = 0; |
9830e7ea | 412 | if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 | 413 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 414 | p->return_size = sizeof(int32_t); /* Minimum expected size */ |
8f3b8fd6 RL |
415 | if (p->data == NULL) |
416 | return 1; | |
9830e7ea P |
417 | switch (p->data_size) { |
418 | case sizeof(int32_t): | |
419 | *(int32_t *)p->data = val; | |
420 | return 1; | |
421 | case sizeof(int64_t): | |
4e7991b4 | 422 | p->return_size = sizeof(int64_t); |
9830e7ea P |
423 | *(int64_t *)p->data = (int64_t)val; |
424 | return 1; | |
425 | } | |
e9c5e642 P |
426 | #endif |
427 | return general_set_int(p, &val, sizeof(val)); | |
9830e7ea | 428 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) { |
e9c5e642 | 429 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 430 | p->return_size = sizeof(uint32_t); /* Minimum expected size */ |
8f3b8fd6 RL |
431 | if (p->data == NULL) |
432 | return 1; | |
9830e7ea P |
433 | switch (p->data_size) { |
434 | case sizeof(uint32_t): | |
435 | *(uint32_t *)p->data = (uint32_t)val; | |
436 | return 1; | |
437 | case sizeof(uint64_t): | |
4e7991b4 | 438 | p->return_size = sizeof(uint64_t); |
9830e7ea P |
439 | *(uint64_t *)p->data = (uint64_t)val; |
440 | return 1; | |
441 | } | |
e9c5e642 P |
442 | #endif |
443 | return general_set_int(p, &val, sizeof(val)); | |
9830e7ea | 444 | } else if (p->data_type == OSSL_PARAM_REAL) { |
4e7991b4 | 445 | p->return_size = sizeof(double); |
8f3b8fd6 RL |
446 | if (p->data == NULL) |
447 | return 1; | |
9830e7ea P |
448 | switch (p->data_size) { |
449 | case sizeof(double): | |
450 | *(double *)p->data = (double)val; | |
451 | return 1; | |
452 | } | |
7ffbd7ca P |
453 | } |
454 | return 0; | |
455 | } | |
456 | ||
4e7991b4 | 457 | OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf) |
7ffbd7ca P |
458 | { |
459 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, | |
4e7991b4 | 460 | sizeof(int32_t)); |
7ffbd7ca P |
461 | } |
462 | ||
463 | int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val) | |
464 | { | |
9830e7ea P |
465 | double d; |
466 | ||
467 | if (val == NULL || p == NULL) | |
7ffbd7ca P |
468 | return 0; |
469 | ||
9830e7ea | 470 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
e9c5e642 P |
471 | #ifndef OPENSSL_SMALL_FOOTPRINT |
472 | uint64_t u64; | |
473 | ||
9830e7ea P |
474 | switch (p->data_size) { |
475 | case sizeof(uint32_t): | |
476 | *val = *(const uint32_t *)p->data; | |
477 | return 1; | |
478 | case sizeof(uint64_t): | |
479 | u64 = *(const uint64_t *)p->data; | |
480 | if (u64 <= UINT32_MAX) { | |
481 | *val = (uint32_t)u64; | |
482 | return 1; | |
483 | } | |
e9c5e642 | 484 | return 0; |
9830e7ea | 485 | } |
e9c5e642 P |
486 | #endif |
487 | return general_get_uint(p, val, sizeof(*val)); | |
9830e7ea | 488 | } else if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 P |
489 | #ifndef OPENSSL_SMALL_FOOTPRINT |
490 | int32_t i32; | |
491 | int64_t i64; | |
492 | ||
9830e7ea P |
493 | switch (p->data_size) { |
494 | case sizeof(int32_t): | |
495 | i32 = *(const int32_t *)p->data; | |
496 | if (i32 >= 0) { | |
497 | *val = i32; | |
498 | return 1; | |
499 | } | |
e9c5e642 | 500 | return 0; |
9830e7ea P |
501 | case sizeof(int64_t): |
502 | i64 = *(const int64_t *)p->data; | |
503 | if (i64 >= 0 && i64 <= UINT32_MAX) { | |
504 | *val = (uint32_t)i64; | |
505 | return 1; | |
506 | } | |
e9c5e642 | 507 | return 0; |
9830e7ea | 508 | } |
e9c5e642 P |
509 | #endif |
510 | return general_get_uint(p, val, sizeof(*val)); | |
9830e7ea P |
511 | } else if (p->data_type == OSSL_PARAM_REAL) { |
512 | switch (p->data_size) { | |
513 | case sizeof(double): | |
514 | d = *(const double *)p->data; | |
515 | if (d >= 0 && d <= UINT32_MAX && d == (uint32_t)d) { | |
516 | *val = (uint32_t)d; | |
517 | return 1; | |
518 | } | |
519 | break; | |
520 | } | |
7ffbd7ca P |
521 | } |
522 | return 0; | |
523 | } | |
524 | ||
4e7991b4 | 525 | int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val) |
7ffbd7ca | 526 | { |
9830e7ea | 527 | if (p == NULL) |
7ffbd7ca | 528 | return 0; |
4e7991b4 | 529 | p->return_size = 0; |
7ffbd7ca | 530 | |
9830e7ea | 531 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
e9c5e642 | 532 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 533 | p->return_size = sizeof(uint32_t); /* Minimum expected size */ |
8f3b8fd6 RL |
534 | if (p->data == NULL) |
535 | return 1; | |
9830e7ea P |
536 | switch (p->data_size) { |
537 | case sizeof(uint32_t): | |
538 | *(uint32_t *)p->data = val; | |
539 | return 1; | |
540 | case sizeof(uint64_t): | |
4e7991b4 | 541 | p->return_size = sizeof(uint64_t); |
9830e7ea P |
542 | *(uint64_t *)p->data = val; |
543 | return 1; | |
544 | } | |
e9c5e642 P |
545 | #endif |
546 | return general_set_uint(p, &val, sizeof(val)); | |
9830e7ea | 547 | } else if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 | 548 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 549 | p->return_size = sizeof(int32_t); /* Minimum expected size */ |
8f3b8fd6 RL |
550 | if (p->data == NULL) |
551 | return 1; | |
9830e7ea P |
552 | switch (p->data_size) { |
553 | case sizeof(int32_t): | |
554 | if (val <= INT32_MAX) { | |
555 | *(int32_t *)p->data = (int32_t)val; | |
556 | return 1; | |
557 | } | |
e9c5e642 | 558 | return 0; |
9830e7ea | 559 | case sizeof(int64_t): |
4e7991b4 | 560 | p->return_size = sizeof(int64_t); |
9830e7ea P |
561 | *(int64_t *)p->data = (int64_t)val; |
562 | return 1; | |
563 | } | |
e9c5e642 P |
564 | #endif |
565 | return general_set_uint(p, &val, sizeof(val)); | |
9830e7ea | 566 | } else if (p->data_type == OSSL_PARAM_REAL) { |
4e7991b4 | 567 | p->return_size = sizeof(double); |
8f3b8fd6 RL |
568 | if (p->data == NULL) |
569 | return 1; | |
9830e7ea P |
570 | switch (p->data_size) { |
571 | case sizeof(double): | |
572 | *(double *)p->data = (double)val; | |
573 | return 1; | |
574 | } | |
7ffbd7ca P |
575 | } |
576 | return 0; | |
577 | } | |
578 | ||
4e7991b4 | 579 | OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf) |
7ffbd7ca P |
580 | { |
581 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 | 582 | sizeof(uint32_t)); |
7ffbd7ca P |
583 | } |
584 | ||
585 | int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val) | |
586 | { | |
9830e7ea P |
587 | double d; |
588 | ||
589 | if (val == NULL || p == NULL ) | |
7ffbd7ca P |
590 | return 0; |
591 | ||
9830e7ea | 592 | if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 | 593 | #ifndef OPENSSL_SMALL_FOOTPRINT |
9830e7ea P |
594 | switch (p->data_size) { |
595 | case sizeof(int32_t): | |
596 | *val = *(const int32_t *)p->data; | |
597 | return 1; | |
598 | case sizeof(int64_t): | |
599 | *val = *(const int64_t *)p->data; | |
600 | return 1; | |
601 | } | |
e9c5e642 P |
602 | #endif |
603 | return general_get_int(p, val, sizeof(*val)); | |
9830e7ea | 604 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
e9c5e642 P |
605 | #ifndef OPENSSL_SMALL_FOOTPRINT |
606 | uint64_t u64; | |
607 | ||
9830e7ea P |
608 | switch (p->data_size) { |
609 | case sizeof(uint32_t): | |
610 | *val = *(const uint32_t *)p->data; | |
611 | return 1; | |
612 | case sizeof(uint64_t): | |
613 | u64 = *(const uint64_t *)p->data; | |
614 | if (u64 <= INT64_MAX) { | |
615 | *val = (int64_t)u64; | |
616 | return 1; | |
617 | } | |
e9c5e642 | 618 | return 0; |
9830e7ea | 619 | } |
e9c5e642 P |
620 | #endif |
621 | return general_get_int(p, val, sizeof(*val)); | |
9830e7ea P |
622 | } else if (p->data_type == OSSL_PARAM_REAL) { |
623 | switch (p->data_size) { | |
624 | case sizeof(double): | |
625 | d = *(const double *)p->data; | |
5b1d94c1 P |
626 | if (d >= INT64_MIN |
627 | /* | |
628 | * By subtracting 65535 (2^16-1) we cancel the low order | |
629 | * 15 bits of INT64_MAX to avoid using imprecise floating | |
630 | * point values. | |
631 | */ | |
632 | && d < (double)(INT64_MAX - 65535) + 65536.0 | |
633 | && d == (int64_t)d) { | |
9830e7ea P |
634 | *val = (int64_t)d; |
635 | return 1; | |
636 | } | |
637 | break; | |
638 | } | |
7ffbd7ca P |
639 | } |
640 | return 0; | |
641 | } | |
642 | ||
4e7991b4 | 643 | int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val) |
7ffbd7ca | 644 | { |
9830e7ea P |
645 | uint64_t u64; |
646 | ||
7ffbd7ca P |
647 | if (p == NULL) |
648 | return 0; | |
4e7991b4 | 649 | p->return_size = 0; |
9830e7ea | 650 | if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 | 651 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 652 | p->return_size = sizeof(int64_t); /* Expected size */ |
8f3b8fd6 RL |
653 | if (p->data == NULL) |
654 | return 1; | |
9830e7ea P |
655 | switch (p->data_size) { |
656 | case sizeof(int32_t): | |
657 | if (val >= INT32_MIN && val <= INT32_MAX) { | |
4e7991b4 | 658 | p->return_size = sizeof(int32_t); |
9830e7ea P |
659 | *(int32_t *)p->data = (int32_t)val; |
660 | return 1; | |
661 | } | |
e9c5e642 | 662 | return 0; |
9830e7ea P |
663 | case sizeof(int64_t): |
664 | *(int64_t *)p->data = val; | |
665 | return 1; | |
666 | } | |
e9c5e642 P |
667 | #endif |
668 | return general_set_int(p, &val, sizeof(val)); | |
9830e7ea | 669 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) { |
e9c5e642 | 670 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 671 | p->return_size = sizeof(uint64_t); /* Expected size */ |
8f3b8fd6 RL |
672 | if (p->data == NULL) |
673 | return 1; | |
9830e7ea P |
674 | switch (p->data_size) { |
675 | case sizeof(uint32_t): | |
676 | if (val <= UINT32_MAX) { | |
4e7991b4 | 677 | p->return_size = sizeof(uint32_t); |
9830e7ea P |
678 | *(uint32_t *)p->data = (uint32_t)val; |
679 | return 1; | |
680 | } | |
e9c5e642 | 681 | return 0; |
9830e7ea P |
682 | case sizeof(uint64_t): |
683 | *(uint64_t *)p->data = (uint64_t)val; | |
684 | return 1; | |
685 | } | |
e9c5e642 P |
686 | #endif |
687 | return general_set_int(p, &val, sizeof(val)); | |
9830e7ea | 688 | } else if (p->data_type == OSSL_PARAM_REAL) { |
4e7991b4 | 689 | p->return_size = sizeof(double); |
8f3b8fd6 RL |
690 | if (p->data == NULL) |
691 | return 1; | |
9830e7ea P |
692 | switch (p->data_size) { |
693 | case sizeof(double): | |
694 | u64 = val < 0 ? -val : val; | |
5b1d94c1 | 695 | if ((u64 >> real_shift()) == 0) { |
9830e7ea P |
696 | *(double *)p->data = (double)val; |
697 | return 1; | |
698 | } | |
699 | break; | |
700 | } | |
7ffbd7ca P |
701 | } |
702 | return 0; | |
703 | } | |
704 | ||
4e7991b4 | 705 | OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf) |
7ffbd7ca | 706 | { |
4e7991b4 | 707 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t)); |
7ffbd7ca P |
708 | } |
709 | ||
710 | int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val) | |
711 | { | |
9830e7ea P |
712 | double d; |
713 | ||
714 | if (val == NULL || p == NULL) | |
7ffbd7ca P |
715 | return 0; |
716 | ||
9830e7ea | 717 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
e9c5e642 | 718 | #ifndef OPENSSL_SMALL_FOOTPRINT |
9830e7ea P |
719 | switch (p->data_size) { |
720 | case sizeof(uint32_t): | |
721 | *val = *(const uint32_t *)p->data; | |
722 | return 1; | |
723 | case sizeof(uint64_t): | |
724 | *val = *(const uint64_t *)p->data; | |
725 | return 1; | |
726 | } | |
e9c5e642 P |
727 | #endif |
728 | return general_get_uint(p, val, sizeof(*val)); | |
9830e7ea | 729 | } else if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 P |
730 | #ifndef OPENSSL_SMALL_FOOTPRINT |
731 | int32_t i32; | |
732 | int64_t i64; | |
733 | ||
9830e7ea P |
734 | switch (p->data_size) { |
735 | case sizeof(int32_t): | |
736 | i32 = *(const int32_t *)p->data; | |
737 | if (i32 >= 0) { | |
738 | *val = (uint64_t)i32; | |
739 | return 1; | |
740 | } | |
e9c5e642 | 741 | return 0; |
9830e7ea P |
742 | case sizeof(int64_t): |
743 | i64 = *(const int64_t *)p->data; | |
744 | if (i64 >= 0) { | |
745 | *val = (uint64_t)i64; | |
746 | return 1; | |
747 | } | |
e9c5e642 | 748 | return 0; |
9830e7ea | 749 | } |
e9c5e642 P |
750 | #endif |
751 | return general_get_uint(p, val, sizeof(*val)); | |
9830e7ea P |
752 | } else if (p->data_type == OSSL_PARAM_REAL) { |
753 | switch (p->data_size) { | |
754 | case sizeof(double): | |
755 | d = *(const double *)p->data; | |
5b1d94c1 P |
756 | if (d >= 0 |
757 | /* | |
758 | * By subtracting 65535 (2^16-1) we cancel the low order | |
759 | * 15 bits of UINT64_MAX to avoid using imprecise floating | |
760 | * point values. | |
761 | */ | |
762 | && d < (double)(UINT64_MAX - 65535) + 65536.0 | |
763 | && d == (uint64_t)d) { | |
9830e7ea P |
764 | *val = (uint64_t)d; |
765 | return 1; | |
766 | } | |
767 | break; | |
768 | } | |
7ffbd7ca P |
769 | } |
770 | return 0; | |
771 | } | |
772 | ||
4e7991b4 | 773 | int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val) |
7ffbd7ca P |
774 | { |
775 | if (p == NULL) | |
776 | return 0; | |
4e7991b4 | 777 | p->return_size = 0; |
7ffbd7ca | 778 | |
9830e7ea | 779 | if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { |
e9c5e642 | 780 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 781 | p->return_size = sizeof(uint64_t); /* Expected size */ |
8f3b8fd6 RL |
782 | if (p->data == NULL) |
783 | return 1; | |
9830e7ea P |
784 | switch (p->data_size) { |
785 | case sizeof(uint32_t): | |
786 | if (val <= UINT32_MAX) { | |
4e7991b4 | 787 | p->return_size = sizeof(uint32_t); |
9830e7ea P |
788 | *(uint32_t *)p->data = (uint32_t)val; |
789 | return 1; | |
790 | } | |
e9c5e642 | 791 | return 0; |
9830e7ea P |
792 | case sizeof(uint64_t): |
793 | *(uint64_t *)p->data = val; | |
794 | return 1; | |
795 | } | |
e9c5e642 P |
796 | #endif |
797 | return general_set_uint(p, &val, sizeof(val)); | |
9830e7ea | 798 | } else if (p->data_type == OSSL_PARAM_INTEGER) { |
e9c5e642 | 799 | #ifndef OPENSSL_SMALL_FOOTPRINT |
4e7991b4 | 800 | p->return_size = sizeof(int64_t); /* Expected size */ |
8f3b8fd6 RL |
801 | if (p->data == NULL) |
802 | return 1; | |
9830e7ea P |
803 | switch (p->data_size) { |
804 | case sizeof(int32_t): | |
805 | if (val <= INT32_MAX) { | |
4e7991b4 | 806 | p->return_size = sizeof(int32_t); |
9830e7ea P |
807 | *(int32_t *)p->data = (int32_t)val; |
808 | return 1; | |
809 | } | |
e9c5e642 | 810 | return 0; |
9830e7ea P |
811 | case sizeof(int64_t): |
812 | if (val <= INT64_MAX) { | |
813 | *(int64_t *)p->data = (int64_t)val; | |
814 | return 1; | |
815 | } | |
e9c5e642 | 816 | return 0; |
9830e7ea | 817 | } |
e9c5e642 P |
818 | #endif |
819 | return general_set_uint(p, &val, sizeof(val)); | |
9830e7ea | 820 | } else if (p->data_type == OSSL_PARAM_REAL) { |
4e7991b4 | 821 | p->return_size = sizeof(double); |
9830e7ea P |
822 | switch (p->data_size) { |
823 | case sizeof(double): | |
5b1d94c1 | 824 | if ((val >> real_shift()) == 0) { |
9830e7ea P |
825 | *(double *)p->data = (double)val; |
826 | return 1; | |
827 | } | |
828 | break; | |
829 | } | |
7ffbd7ca P |
830 | } |
831 | return 0; | |
832 | } | |
833 | ||
4e7991b4 P |
834 | OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf) |
835 | { | |
7ffbd7ca | 836 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, |
4e7991b4 | 837 | sizeof(uint64_t)); |
7ffbd7ca P |
838 | } |
839 | ||
840 | int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val) | |
841 | { | |
e9c5e642 | 842 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 843 | switch (sizeof(size_t)) { |
7ffbd7ca | 844 | case sizeof(uint32_t): |
863360fb | 845 | return OSSL_PARAM_get_uint32(p, (uint32_t *)val); |
7ffbd7ca | 846 | case sizeof(uint64_t): |
863360fb | 847 | return OSSL_PARAM_get_uint64(p, (uint64_t *)val); |
7ffbd7ca | 848 | } |
e9c5e642 P |
849 | #endif |
850 | return general_get_uint(p, val, sizeof(*val)); | |
7ffbd7ca P |
851 | } |
852 | ||
4e7991b4 | 853 | int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val) |
7ffbd7ca | 854 | { |
e9c5e642 | 855 | #ifndef OPENSSL_SMALL_FOOTPRINT |
863360fb | 856 | switch (sizeof(size_t)) { |
7ffbd7ca | 857 | case sizeof(uint32_t): |
863360fb | 858 | return OSSL_PARAM_set_uint32(p, (uint32_t)val); |
7ffbd7ca | 859 | case sizeof(uint64_t): |
863360fb | 860 | return OSSL_PARAM_set_uint64(p, (uint64_t)val); |
7ffbd7ca | 861 | } |
e9c5e642 P |
862 | #endif |
863 | return general_set_uint(p, &val, sizeof(val)); | |
7ffbd7ca P |
864 | } |
865 | ||
4e7991b4 | 866 | OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf) |
7ffbd7ca P |
867 | { |
868 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, | |
4e7991b4 P |
869 | sizeof(size_t)); |
870 | } | |
7ffbd7ca | 871 | |
5fdaa38f P |
872 | int OSSL_PARAM_get_time_t(const OSSL_PARAM *p, time_t *val) |
873 | { | |
e9c5e642 | 874 | #ifndef OPENSSL_SMALL_FOOTPRINT |
5fdaa38f P |
875 | switch (sizeof(time_t)) { |
876 | case sizeof(int32_t): | |
877 | return OSSL_PARAM_get_int32(p, (int32_t *)val); | |
878 | case sizeof(int64_t): | |
879 | return OSSL_PARAM_get_int64(p, (int64_t *)val); | |
880 | } | |
e9c5e642 P |
881 | #endif |
882 | return general_get_int(p, val, sizeof(*val)); | |
5fdaa38f P |
883 | } |
884 | ||
885 | int OSSL_PARAM_set_time_t(OSSL_PARAM *p, time_t val) | |
886 | { | |
e9c5e642 | 887 | #ifndef OPENSSL_SMALL_FOOTPRINT |
5fdaa38f P |
888 | switch (sizeof(time_t)) { |
889 | case sizeof(int32_t): | |
890 | return OSSL_PARAM_set_int32(p, (int32_t)val); | |
891 | case sizeof(int64_t): | |
892 | return OSSL_PARAM_set_int64(p, (int64_t)val); | |
893 | } | |
e9c5e642 P |
894 | #endif |
895 | return general_set_int(p, &val, sizeof(val)); | |
5fdaa38f P |
896 | } |
897 | ||
898 | OSSL_PARAM OSSL_PARAM_construct_time_t(const char *key, time_t *buf) | |
899 | { | |
900 | return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(time_t)); | |
901 | } | |
902 | ||
7ffbd7ca P |
903 | int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val) |
904 | { | |
905 | BIGNUM *b; | |
906 | ||
907 | if (val == NULL | |
908 | || p == NULL | |
909 | || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER) | |
910 | return 0; | |
911 | ||
912 | b = BN_native2bn(p->data, (int)p->data_size, *val); | |
913 | if (b != NULL) { | |
914 | *val = b; | |
915 | return 1; | |
916 | } | |
917 | return 0; | |
918 | } | |
919 | ||
4e7991b4 | 920 | int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val) |
7ffbd7ca P |
921 | { |
922 | size_t bytes; | |
923 | ||
924 | if (p == NULL) | |
925 | return 0; | |
4e7991b4 | 926 | p->return_size = 0; |
7ffbd7ca P |
927 | if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER) |
928 | return 0; | |
929 | ||
6ce84e64 P |
930 | /* For the moment, only positive values are permitted */ |
931 | if (BN_is_negative(val)) | |
932 | return 0; | |
933 | ||
7ffbd7ca | 934 | bytes = (size_t)BN_num_bytes(val); |
4e7991b4 | 935 | p->return_size = bytes; |
8f3b8fd6 RL |
936 | if (p->data == NULL) |
937 | return 1; | |
0f73e719 RL |
938 | if (p->data_size >= bytes) { |
939 | p->return_size = p->data_size; | |
940 | return BN_bn2nativepad(val, p->data, p->data_size) >= 0; | |
941 | } | |
942 | return 0; | |
7ffbd7ca P |
943 | } |
944 | ||
945 | OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf, | |
4e7991b4 | 946 | size_t bsize) |
7ffbd7ca P |
947 | { |
948 | return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, | |
4e7991b4 | 949 | buf, bsize); |
7ffbd7ca P |
950 | } |
951 | ||
952 | int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val) | |
953 | { | |
9830e7ea P |
954 | int64_t i64; |
955 | uint64_t u64; | |
956 | ||
957 | if (val == NULL || p == NULL) | |
7ffbd7ca P |
958 | return 0; |
959 | ||
9830e7ea P |
960 | if (p->data_type == OSSL_PARAM_REAL) { |
961 | switch (p->data_size) { | |
962 | case sizeof(double): | |
963 | *val = *(const double *)p->data; | |
964 | return 1; | |
965 | } | |
966 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { | |
967 | switch (p->data_size) { | |
968 | case sizeof(uint32_t): | |
969 | *val = *(const uint32_t *)p->data; | |
970 | return 1; | |
971 | case sizeof(uint64_t): | |
972 | u64 = *(const uint64_t *)p->data; | |
5b1d94c1 | 973 | if ((u64 >> real_shift()) == 0) { |
9830e7ea P |
974 | *val = (double)u64; |
975 | return 1; | |
976 | } | |
977 | break; | |
978 | } | |
979 | } else if (p->data_type == OSSL_PARAM_INTEGER) { | |
980 | switch (p->data_size) { | |
981 | case sizeof(int32_t): | |
982 | *val = *(const int32_t *)p->data; | |
983 | return 1; | |
984 | case sizeof(int64_t): | |
985 | i64 = *(const int64_t *)p->data; | |
986 | u64 = i64 < 0 ? -i64 : i64; | |
5b1d94c1 | 987 | if ((u64 >> real_shift()) == 0) { |
9830e7ea P |
988 | *val = 0.0 + i64; |
989 | return 1; | |
990 | } | |
991 | break; | |
992 | } | |
7ffbd7ca P |
993 | } |
994 | return 0; | |
995 | } | |
996 | ||
4e7991b4 | 997 | int OSSL_PARAM_set_double(OSSL_PARAM *p, double val) |
7ffbd7ca P |
998 | { |
999 | if (p == NULL) | |
1000 | return 0; | |
4e7991b4 | 1001 | p->return_size = 0; |
7ffbd7ca | 1002 | |
9830e7ea | 1003 | if (p->data_type == OSSL_PARAM_REAL) { |
4e7991b4 | 1004 | p->return_size = sizeof(double); |
8f3b8fd6 RL |
1005 | if (p->data == NULL) |
1006 | return 1; | |
9830e7ea P |
1007 | switch (p->data_size) { |
1008 | case sizeof(double): | |
1009 | *(double *)p->data = val; | |
1010 | return 1; | |
1011 | } | |
1012 | } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER | |
c04a9916 | 1013 | && val == (ossl_uintmax_t)val) { |
4e7991b4 | 1014 | p->return_size = sizeof(double); |
8f3b8fd6 RL |
1015 | if (p->data == NULL) |
1016 | return 1; | |
9830e7ea P |
1017 | switch (p->data_size) { |
1018 | case sizeof(uint32_t): | |
1019 | if (val >= 0 && val <= UINT32_MAX) { | |
4e7991b4 | 1020 | p->return_size = sizeof(uint32_t); |
9830e7ea P |
1021 | *(uint32_t *)p->data = (uint32_t)val; |
1022 | return 1; | |
1023 | } | |
1024 | break; | |
1025 | case sizeof(uint64_t): | |
5b1d94c1 P |
1026 | if (val >= 0 |
1027 | /* | |
1028 | * By subtracting 65535 (2^16-1) we cancel the low order | |
1029 | * 15 bits of UINT64_MAX to avoid using imprecise floating | |
1030 | * point values. | |
1031 | */ | |
1032 | && (double)(UINT64_MAX - 65535) + 65536.0) { | |
4e7991b4 | 1033 | p->return_size = sizeof(uint64_t); |
9830e7ea P |
1034 | *(uint64_t *)p->data = (uint64_t)val; |
1035 | return 1; | |
1036 | } | |
1037 | break; } | |
c04a9916 | 1038 | } else if (p->data_type == OSSL_PARAM_INTEGER && val == (ossl_intmax_t)val) { |
4e7991b4 | 1039 | p->return_size = sizeof(double); |
8f3b8fd6 RL |
1040 | if (p->data == NULL) |
1041 | return 1; | |
9830e7ea P |
1042 | switch (p->data_size) { |
1043 | case sizeof(int32_t): | |
1044 | if (val >= INT32_MIN && val <= INT32_MAX) { | |
4e7991b4 | 1045 | p->return_size = sizeof(int32_t); |
9830e7ea P |
1046 | *(int32_t *)p->data = (int32_t)val; |
1047 | return 1; | |
1048 | } | |
1049 | break; | |
1050 | case sizeof(int64_t): | |
5b1d94c1 P |
1051 | if (val >= INT64_MIN |
1052 | /* | |
1053 | * By subtracting 65535 (2^16-1) we cancel the low order | |
1054 | * 15 bits of INT64_MAX to avoid using imprecise floating | |
1055 | * point values. | |
1056 | */ | |
1057 | && val < (double)(INT64_MAX - 65535) + 65536.0) { | |
4e7991b4 | 1058 | p->return_size = sizeof(int64_t); |
9830e7ea P |
1059 | *(int64_t *)p->data = (int64_t)val; |
1060 | return 1; | |
1061 | } | |
1062 | break; | |
1063 | } | |
7ffbd7ca P |
1064 | } |
1065 | return 0; | |
1066 | } | |
1067 | ||
4e7991b4 | 1068 | OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf) |
7ffbd7ca | 1069 | { |
4e7991b4 | 1070 | return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double)); |
7ffbd7ca P |
1071 | } |
1072 | ||
247a1786 RL |
1073 | static int get_string_internal(const OSSL_PARAM *p, void **val, |
1074 | size_t *max_len, size_t *used_len, | |
1075 | unsigned int type) | |
7ffbd7ca | 1076 | { |
247a1786 | 1077 | size_t sz, alloc_sz; |
7ffbd7ca | 1078 | |
b756626a | 1079 | if ((val == NULL && used_len == NULL) || p == NULL || p->data_type != type) |
7ffbd7ca P |
1080 | return 0; |
1081 | ||
1082 | sz = p->data_size; | |
247a1786 RL |
1083 | /* |
1084 | * If the input size is 0, or the input string needs NUL byte | |
1085 | * termination, allocate an extra byte. | |
1086 | */ | |
1087 | alloc_sz = sz + (type == OSSL_PARAM_UTF8_STRING || sz == 0); | |
7ffbd7ca P |
1088 | |
1089 | if (used_len != NULL) | |
1090 | *used_len = sz; | |
1091 | ||
86f32187 P |
1092 | if (p->data == NULL) |
1093 | return 0; | |
46ef075a | 1094 | |
b756626a MC |
1095 | if (val == NULL) |
1096 | return 1; | |
1097 | ||
7ffbd7ca | 1098 | if (*val == NULL) { |
247a1786 | 1099 | char *const q = OPENSSL_malloc(alloc_sz); |
7ffbd7ca P |
1100 | |
1101 | if (q == NULL) | |
1102 | return 0; | |
1103 | *val = q; | |
247a1786 | 1104 | *max_len = alloc_sz; |
7ffbd7ca | 1105 | } |
247a1786 RL |
1106 | |
1107 | if (*max_len < sz) | |
7ffbd7ca P |
1108 | return 0; |
1109 | memcpy(*val, p->data, sz); | |
1110 | return 1; | |
1111 | } | |
1112 | ||
1113 | int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len) | |
1114 | { | |
247a1786 RL |
1115 | int ret = get_string_internal(p, (void **)val, &max_len, NULL, |
1116 | OSSL_PARAM_UTF8_STRING); | |
1117 | ||
1118 | /* | |
1119 | * We try to ensure that the copied string is terminated with a | |
1120 | * NUL byte. That should be easy, just place a NUL byte at | |
1121 | * |((char*)*val)[p->data_size]|. | |
1122 | * Unfortunately, we have seen cases where |p->data_size| doesn't | |
1123 | * correctly reflect the length of the string, and just happens | |
1124 | * to be out of bounds according to |max_len|, so in that case, we | |
1125 | * make the extra step of trying to find the true length of the | |
1126 | * string that |p->data| points at, and use that as an index to | |
1127 | * place the NUL byte in |*val|. | |
1128 | */ | |
1129 | size_t data_length = p->data_size; | |
1130 | ||
1131 | if (data_length >= max_len) | |
1132 | data_length = OPENSSL_strnlen(p->data, data_length); | |
1133 | if (data_length >= max_len) | |
1134 | return 0; /* No space for a terminating NUL byte */ | |
1135 | ((char *)*val)[data_length] = '\0'; | |
1136 | ||
1137 | return ret; | |
7ffbd7ca P |
1138 | } |
1139 | ||
1140 | int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len, | |
1141 | size_t *used_len) | |
1142 | { | |
247a1786 | 1143 | return get_string_internal(p, val, &max_len, used_len, |
7ffbd7ca P |
1144 | OSSL_PARAM_OCTET_STRING); |
1145 | } | |
1146 | ||
4e7991b4 | 1147 | static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len, |
7ffbd7ca P |
1148 | unsigned int type) |
1149 | { | |
4e7991b4 | 1150 | p->return_size = len; |
8f3b8fd6 RL |
1151 | if (p->data == NULL) |
1152 | return 1; | |
7ffbd7ca P |
1153 | if (p->data_type != type || p->data_size < len) |
1154 | return 0; | |
1155 | ||
1156 | memcpy(p->data, val, len); | |
247a1786 RL |
1157 | /* If possible within the size of p->data, add a NUL terminator byte */ |
1158 | if (type == OSSL_PARAM_UTF8_STRING && p->data_size > len) | |
1159 | ((char *)p->data)[len] = '\0'; | |
7ffbd7ca P |
1160 | return 1; |
1161 | } | |
1162 | ||
4e7991b4 | 1163 | int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val) |
7ffbd7ca P |
1164 | { |
1165 | if (p == NULL) | |
1166 | return 0; | |
1167 | ||
4e7991b4 | 1168 | p->return_size = 0; |
7ffbd7ca P |
1169 | if (val == NULL) |
1170 | return 0; | |
247a1786 | 1171 | return set_string_internal(p, val, strlen(val), OSSL_PARAM_UTF8_STRING); |
7ffbd7ca P |
1172 | } |
1173 | ||
4e7991b4 | 1174 | int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, |
7ffbd7ca P |
1175 | size_t len) |
1176 | { | |
1177 | if (p == NULL) | |
1178 | return 0; | |
1179 | ||
4e7991b4 | 1180 | p->return_size = 0; |
7ffbd7ca P |
1181 | if (val == NULL) |
1182 | return 0; | |
1183 | return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING); | |
1184 | } | |
1185 | ||
1186 | OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf, | |
4e7991b4 | 1187 | size_t bsize) |
7ffbd7ca | 1188 | { |
7f588d20 | 1189 | if (buf != NULL && bsize == 0) |
247a1786 | 1190 | bsize = strlen(buf); |
4e7991b4 | 1191 | return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize); |
7ffbd7ca P |
1192 | } |
1193 | ||
1194 | OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf, | |
4e7991b4 | 1195 | size_t bsize) |
7ffbd7ca | 1196 | { |
4e7991b4 | 1197 | return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize); |
7ffbd7ca P |
1198 | } |
1199 | ||
1200 | static int get_ptr_internal(const OSSL_PARAM *p, const void **val, | |
1201 | size_t *used_len, unsigned int type) | |
1202 | { | |
1203 | if (val == NULL || p == NULL || p->data_type != type) | |
1204 | return 0; | |
1205 | if (used_len != NULL) | |
1206 | *used_len = p->data_size; | |
1207 | *val = *(const void **)p->data; | |
1208 | return 1; | |
1209 | } | |
1210 | ||
1211 | int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val) | |
1212 | { | |
1213 | return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR); | |
1214 | } | |
1215 | ||
1216 | int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val, | |
1217 | size_t *used_len) | |
1218 | { | |
1219 | return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR); | |
1220 | } | |
1221 | ||
4e7991b4 | 1222 | static int set_ptr_internal(OSSL_PARAM *p, const void *val, |
7ffbd7ca P |
1223 | unsigned int type, size_t len) |
1224 | { | |
4e7991b4 | 1225 | p->return_size = len; |
7ffbd7ca P |
1226 | if (p->data_type != type) |
1227 | return 0; | |
8f3b8fd6 RL |
1228 | if (p->data != NULL) |
1229 | *(const void **)p->data = val; | |
7ffbd7ca P |
1230 | return 1; |
1231 | } | |
1232 | ||
4e7991b4 | 1233 | int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val) |
7ffbd7ca P |
1234 | { |
1235 | if (p == NULL) | |
1236 | return 0; | |
4e7991b4 | 1237 | p->return_size = 0; |
b3f3ba70 | 1238 | return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, |
247a1786 | 1239 | val == NULL ? 0 : strlen(val)); |
7ffbd7ca P |
1240 | } |
1241 | ||
4e7991b4 | 1242 | int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val, |
7ffbd7ca P |
1243 | size_t used_len) |
1244 | { | |
1245 | if (p == NULL) | |
1246 | return 0; | |
4e7991b4 | 1247 | p->return_size = 0; |
7ffbd7ca P |
1248 | return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len); |
1249 | } | |
1250 | ||
1251 | OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf, | |
4e7991b4 | 1252 | size_t bsize) |
7ffbd7ca | 1253 | { |
4e7991b4 | 1254 | return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize); |
7ffbd7ca P |
1255 | } |
1256 | ||
1257 | OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf, | |
4e7991b4 | 1258 | size_t bsize) |
7ffbd7ca | 1259 | { |
4e7991b4 | 1260 | return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize); |
7ffbd7ca | 1261 | } |
195852fe RL |
1262 | |
1263 | OSSL_PARAM OSSL_PARAM_construct_end(void) | |
1264 | { | |
1265 | OSSL_PARAM end = OSSL_PARAM_END; | |
1266 | ||
1267 | return end; | |
1268 | } | |
ab00ddb5 RL |
1269 | |
1270 | static int get_string_ptr_internal(const OSSL_PARAM *p, const void **val, | |
1271 | size_t *used_len, unsigned int type) | |
1272 | { | |
1273 | if (val == NULL || p == NULL || p->data_type != type) | |
1274 | return 0; | |
1275 | if (used_len != NULL) | |
1276 | *used_len = p->data_size; | |
1277 | *val = p->data; | |
1278 | return 1; | |
1279 | } | |
1280 | ||
1281 | int OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM *p, const char **val) | |
1282 | { | |
1283 | return OSSL_PARAM_get_utf8_ptr(p, val) | |
1284 | || get_string_ptr_internal(p, (const void **)val, NULL, | |
1285 | OSSL_PARAM_UTF8_STRING); | |
1286 | } | |
1287 | ||
1288 | int OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM *p, const void **val, | |
1289 | size_t *used_len) | |
1290 | { | |
1291 | return OSSL_PARAM_get_octet_ptr(p, val, used_len) | |
1292 | || get_string_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_STRING); | |
1293 | } |