2 * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
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
12 #include <openssl/params.h>
13 #include "internal/thread_once.h"
14 #include "internal/numbers.h"
16 OSSL_PARAM
*OSSL_PARAM_locate(OSSL_PARAM
*p
, const char *key
)
18 if (p
!= NULL
&& key
!= NULL
)
19 for (; p
->key
!= NULL
; p
++)
20 if (strcmp(key
, p
->key
) == 0)
25 const OSSL_PARAM
*OSSL_PARAM_locate_const(const OSSL_PARAM
*p
, const char *key
)
27 return OSSL_PARAM_locate((OSSL_PARAM
*)p
, key
);
30 static OSSL_PARAM
ossl_param_construct(const char *key
, unsigned int data_type
,
31 void *data
, size_t data_size
)
36 res
.data_type
= data_type
;
38 res
.data_size
= data_size
;
43 int OSSL_PARAM_get_int(const OSSL_PARAM
*p
, int *val
)
45 switch (sizeof(int)) {
47 return OSSL_PARAM_get_int32(p
, (int32_t *)val
);
49 return OSSL_PARAM_get_int64(p
, (int64_t *)val
);
54 int OSSL_PARAM_set_int(OSSL_PARAM
*p
, int val
)
56 switch (sizeof(int)) {
58 return OSSL_PARAM_set_int32(p
, (int32_t)val
);
60 return OSSL_PARAM_set_int64(p
, (int64_t)val
);
65 OSSL_PARAM
OSSL_PARAM_construct_int(const char *key
, int *buf
)
67 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
, sizeof(int));
70 int OSSL_PARAM_get_uint(const OSSL_PARAM
*p
, unsigned int *val
)
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
);
81 int OSSL_PARAM_set_uint(OSSL_PARAM
*p
, unsigned int val
)
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
);
92 OSSL_PARAM
OSSL_PARAM_construct_uint(const char *key
, unsigned int *buf
)
94 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
95 sizeof(unsigned int));
98 int OSSL_PARAM_get_long(const OSSL_PARAM
*p
, long int *val
)
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
);
109 int OSSL_PARAM_set_long(OSSL_PARAM
*p
, long int val
)
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
);
120 OSSL_PARAM
OSSL_PARAM_construct_long(const char *key
, long int *buf
)
122 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
, sizeof(long int));
125 int OSSL_PARAM_get_ulong(const OSSL_PARAM
*p
, unsigned long int *val
)
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
);
136 int OSSL_PARAM_set_ulong(OSSL_PARAM
*p
, unsigned long int val
)
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
);
147 OSSL_PARAM
OSSL_PARAM_construct_ulong(const char *key
, unsigned long int *buf
)
149 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
150 sizeof(unsigned long int));
153 int OSSL_PARAM_get_int32(const OSSL_PARAM
*p
, int32_t *val
)
160 if (val
== NULL
|| p
== NULL
)
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
;
168 case sizeof(int64_t):
169 i64
= *(const int64_t *)p
->data
;
170 if (i64
>= INT32_MIN
&& i64
<= INT32_MAX
) {
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
) {
185 case sizeof(uint64_t):
186 u64
= *(const uint64_t *)p
->data
;
187 if (u64
<= INT32_MAX
) {
193 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
194 switch (p
->data_size
) {
196 d
= *(const double *)p
->data
;
197 if (d
>= INT32_MIN
&& d
<= INT32_MAX
&& d
== (int32_t)d
) {
207 int OSSL_PARAM_set_int32(OSSL_PARAM
*p
, int32_t val
)
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
;
218 case sizeof(int64_t):
219 p
->return_size
= sizeof(int64_t);
220 *(int64_t *)p
->data
= (int64_t)val
;
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
;
229 case sizeof(uint64_t):
230 p
->return_size
= sizeof(uint64_t);
231 *(uint64_t *)p
->data
= (uint64_t)val
;
234 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
235 p
->return_size
= sizeof(double);
236 switch (p
->data_size
) {
238 *(double *)p
->data
= (double)val
;
245 OSSL_PARAM
OSSL_PARAM_construct_int32(const char *key
, int32_t *buf
)
247 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
,
251 int OSSL_PARAM_get_uint32(const OSSL_PARAM
*p
, uint32_t *val
)
258 if (val
== NULL
|| p
== NULL
)
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
;
266 case sizeof(uint64_t):
267 u64
= *(const uint64_t *)p
->data
;
268 if (u64
<= UINT32_MAX
) {
269 *val
= (uint32_t)u64
;
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
;
283 case sizeof(int64_t):
284 i64
= *(const int64_t *)p
->data
;
285 if (i64
>= 0 && i64
<= UINT32_MAX
) {
286 *val
= (uint32_t)i64
;
291 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
292 switch (p
->data_size
) {
294 d
= *(const double *)p
->data
;
295 if (d
>= 0 && d
<= UINT32_MAX
&& d
== (uint32_t)d
) {
305 int OSSL_PARAM_set_uint32(OSSL_PARAM
*p
, uint32_t val
)
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
;
317 case sizeof(uint64_t):
318 p
->return_size
= sizeof(uint64_t);
319 *(uint64_t *)p
->data
= val
;
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
;
331 case sizeof(int64_t):
332 p
->return_size
= sizeof(int64_t);
333 *(int64_t *)p
->data
= (int64_t)val
;
336 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
337 p
->return_size
= sizeof(double);
338 switch (p
->data_size
) {
340 *(double *)p
->data
= (double)val
;
347 OSSL_PARAM
OSSL_PARAM_construct_uint32(const char *key
, uint32_t *buf
)
349 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
353 int OSSL_PARAM_get_int64(const OSSL_PARAM
*p
, int64_t *val
)
358 if (val
== NULL
|| p
== NULL
)
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
;
366 case sizeof(int64_t):
367 *val
= *(const int64_t *)p
->data
;
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
;
375 case sizeof(uint64_t):
376 u64
= *(const uint64_t *)p
->data
;
377 if (u64
<= INT64_MAX
) {
383 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
384 switch (p
->data_size
) {
386 d
= *(const double *)p
->data
;
387 if (d
>= INT64_MIN
&& d
<= INT64_MAX
&& d
== (int64_t)d
) {
397 int OSSL_PARAM_set_int64(OSSL_PARAM
*p
, int64_t val
)
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
;
414 case sizeof(int64_t):
415 *(int64_t *)p
->data
= val
;
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
;
428 case sizeof(uint64_t):
429 *(uint64_t *)p
->data
= (uint64_t)val
;
432 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
433 p
->return_size
= sizeof(double);
434 switch (p
->data_size
) {
436 u64
= val
< 0 ? -val
: val
;
437 if ((u64
>> 53) == 0) { /* 53 significant bits in the mantissa */
438 *(double *)p
->data
= (double)val
;
447 OSSL_PARAM
OSSL_PARAM_construct_int64(const char *key
, int64_t *buf
)
449 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
, sizeof(int64_t));
452 int OSSL_PARAM_get_uint64(const OSSL_PARAM
*p
, uint64_t *val
)
458 if (val
== NULL
|| p
== NULL
)
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
;
466 case sizeof(uint64_t):
467 *val
= *(const uint64_t *)p
->data
;
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
;
475 *val
= (uint64_t)i32
;
479 case sizeof(int64_t):
480 i64
= *(const int64_t *)p
->data
;
482 *val
= (uint64_t)i64
;
487 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
488 switch (p
->data_size
) {
490 d
= *(const double *)p
->data
;
491 if (d
>= 0 && d
<= INT64_MAX
&& d
== (uint64_t)d
) {
501 int OSSL_PARAM_set_uint64(OSSL_PARAM
*p
, uint64_t val
)
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
;
517 case sizeof(uint64_t):
518 *(uint64_t *)p
->data
= val
;
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
;
531 case sizeof(int64_t):
532 if (val
<= INT64_MAX
) {
533 *(int64_t *)p
->data
= (int64_t)val
;
538 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
539 p
->return_size
= sizeof(double);
540 switch (p
->data_size
) {
542 if ((val
>> 53) == 0) { /* 53 significant bits in the mantissa */
543 *(double *)p
->data
= (double)val
;
552 OSSL_PARAM
OSSL_PARAM_construct_uint64(const char *key
, uint64_t *buf
)
554 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
558 int OSSL_PARAM_get_size_t(const OSSL_PARAM
*p
, size_t *val
)
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
);
569 int OSSL_PARAM_set_size_t(OSSL_PARAM
*p
, size_t val
)
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
);
580 OSSL_PARAM
OSSL_PARAM_construct_size_t(const char *key
, size_t *buf
)
582 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
586 int OSSL_PARAM_get_BN(const OSSL_PARAM
*p
, BIGNUM
**val
)
592 || p
->data_type
!= OSSL_PARAM_UNSIGNED_INTEGER
)
595 b
= BN_native2bn(p
->data
, (int)p
->data_size
, *val
);
603 int OSSL_PARAM_set_BN(OSSL_PARAM
*p
, const BIGNUM
*val
)
610 if (val
== NULL
|| p
->data_type
!= OSSL_PARAM_UNSIGNED_INTEGER
)
613 /* For the moment, only positive values are permitted */
614 if (BN_is_negative(val
))
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;
623 OSSL_PARAM
OSSL_PARAM_construct_BN(const char *key
, unsigned char *buf
,
626 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
,
630 int OSSL_PARAM_get_double(const OSSL_PARAM
*p
, double *val
)
635 if (val
== NULL
|| p
== NULL
)
638 if (p
->data_type
== OSSL_PARAM_REAL
) {
639 switch (p
->data_size
) {
641 *val
= *(const double *)p
->data
;
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
;
649 case sizeof(uint64_t):
650 u64
= *(const uint64_t *)p
->data
;
651 if ((u64
>> 53) == 0) { /* 53 significant bits in the mantissa */
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
;
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 */
675 int OSSL_PARAM_set_double(OSSL_PARAM
*p
, double val
)
681 if (p
->data_type
== OSSL_PARAM_REAL
) {
682 p
->return_size
= sizeof(double);
683 switch (p
->data_size
) {
685 *(double *)p
->data
= val
;
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
;
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
;
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
;
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
;
728 OSSL_PARAM
OSSL_PARAM_construct_double(const char *key
, double *buf
)
730 return ossl_param_construct(key
, OSSL_PARAM_REAL
, buf
, sizeof(double));
733 static int get_string_internal(const OSSL_PARAM
*p
, void **val
, size_t max_len
,
734 size_t *used_len
, unsigned int type
)
738 if (val
== NULL
|| p
== NULL
|| p
->data_type
!= type
)
743 if (used_len
!= NULL
)
747 char *const q
= OPENSSL_malloc(sz
);
752 memcpy(q
, p
->data
, sz
);
757 memcpy(*val
, p
->data
, sz
);
761 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM
*p
, char **val
, size_t max_len
)
763 return get_string_internal(p
, (void **)val
, max_len
, NULL
,
764 OSSL_PARAM_UTF8_STRING
);
767 int OSSL_PARAM_get_octet_string(const OSSL_PARAM
*p
, void **val
, size_t max_len
,
770 return get_string_internal(p
, val
, max_len
, used_len
,
771 OSSL_PARAM_OCTET_STRING
);
774 static int set_string_internal(OSSL_PARAM
*p
, const void *val
, size_t len
,
777 p
->return_size
= len
;
778 if (p
->data_type
!= type
|| p
->data_size
< len
)
781 memcpy(p
->data
, val
, len
);
785 int OSSL_PARAM_set_utf8_string(OSSL_PARAM
*p
, const char *val
)
793 return set_string_internal(p
, val
, strlen(val
) + 1, OSSL_PARAM_UTF8_STRING
);
796 int OSSL_PARAM_set_octet_string(OSSL_PARAM
*p
, const void *val
,
805 return set_string_internal(p
, val
, len
, OSSL_PARAM_OCTET_STRING
);
808 OSSL_PARAM
OSSL_PARAM_construct_utf8_string(const char *key
, char *buf
,
811 if (buf
!= NULL
&& bsize
== 0)
812 bsize
= strlen(buf
) + 1;
813 return ossl_param_construct(key
, OSSL_PARAM_UTF8_STRING
, buf
, bsize
);
816 OSSL_PARAM
OSSL_PARAM_construct_octet_string(const char *key
, void *buf
,
819 return ossl_param_construct(key
, OSSL_PARAM_OCTET_STRING
, buf
, bsize
);
822 static int get_ptr_internal(const OSSL_PARAM
*p
, const void **val
,
823 size_t *used_len
, unsigned int type
)
825 if (val
== NULL
|| p
== NULL
|| p
->data_type
!= type
)
827 if (used_len
!= NULL
)
828 *used_len
= p
->data_size
;
829 *val
= *(const void **)p
->data
;
833 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM
*p
, const char **val
)
835 return get_ptr_internal(p
, (const void **)val
, NULL
, OSSL_PARAM_UTF8_PTR
);
838 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM
*p
, const void **val
,
841 return get_ptr_internal(p
, val
, used_len
, OSSL_PARAM_OCTET_PTR
);
844 static int set_ptr_internal(OSSL_PARAM
*p
, const void *val
,
845 unsigned int type
, size_t len
)
847 p
->return_size
= len
;
848 if (p
->data_type
!= type
)
850 *(const void **)p
->data
= val
;
854 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM
*p
, const char *val
)
861 return set_ptr_internal(p
, val
, OSSL_PARAM_UTF8_PTR
, strlen(val
) + 1);
864 int OSSL_PARAM_set_octet_ptr(OSSL_PARAM
*p
, const void *val
,
872 return set_ptr_internal(p
, val
, OSSL_PARAM_OCTET_PTR
, used_len
);
875 OSSL_PARAM
OSSL_PARAM_construct_utf8_ptr(const char *key
, char **buf
,
878 return ossl_param_construct(key
, OSSL_PARAM_UTF8_PTR
, buf
, bsize
);
881 OSSL_PARAM
OSSL_PARAM_construct_octet_ptr(const char *key
, void **buf
,
884 return ossl_param_construct(key
, OSSL_PARAM_OCTET_PTR
, buf
, bsize
);
887 OSSL_PARAM
OSSL_PARAM_construct_end(void)
889 OSSL_PARAM end
= OSSL_PARAM_END
;