/src/openssl41/providers/implementations/rands/drbg_ctr.inc

Source
/*
 * Copyright 2025-2026 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the \"License\").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */



/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

/* Machine generated */
#ifndef drbg_ctr_get_ctx_params_list
static ossl_unused const OSSL_PARAM drbg_ctr_get_ctx_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_int(OSSL_DRBG_PARAM_USE_DF, NULL),
    OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
    OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
    OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_ENTROPYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ENTROPYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_NONCELEN, NULL),
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_NONCELEN, NULL),
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_PERSLEN, NULL),
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ADINLEN, NULL),
    OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_COUNTER, NULL),
    OSSL_PARAM_time_t(OSSL_DRBG_PARAM_RESEED_TIME, NULL),
    OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS, NULL),
    OSSL_PARAM_uint64(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef drbg_ctr_get_ctx_params_st
struct drbg_ctr_get_ctx_params_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *df;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *maxadlen;
    OSSL_PARAM *maxentlen;
    OSSL_PARAM *maxnonlen;
    OSSL_PARAM *maxperlen;
    OSSL_PARAM *maxreq;
    OSSL_PARAM *minentlen;
    OSSL_PARAM *minnonlen;
    OSSL_PARAM *reseed_cnt;
    OSSL_PARAM *reseed_int;
    OSSL_PARAM *reseed_req;
    OSSL_PARAM *reseed_time;
    OSSL_PARAM *state;
    OSSL_PARAM *str;
};
#endif

#ifndef drbg_ctr_get_ctx_params_decoder
static ossl_unused int drbg_ctr_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct drbg_ctr_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'c':
                if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
                    /* OSSL_DRBG_PARAM_CIPHER */
                    if (ossl_unlikely(r->cipher != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->cipher = (OSSL_PARAM *)p;
                }
                break;
            case 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR */
                    if (ossl_unlikely(r->ind != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind = (OSSL_PARAM *)p;
                }
# endif
                break;
            case 'm':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    switch(s[2]) {
                    default:
                        break;
                    case 'x':
                        switch(s[3]) {
                        default:
                            break;
                        case '_':
                            switch(s[4]) {
                            default:
                                break;
                            case 'a':
                                if (ossl_likely(strcmp("dinlen", s + 5) == 0)) {
                                    /* OSSL_DRBG_PARAM_MAX_ADINLEN */
                                    if (ossl_unlikely(r->maxadlen != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->maxadlen = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'e':
                                if (ossl_likely(strcmp("ntropylen", s + 5) == 0)) {
                                    /* OSSL_DRBG_PARAM_MAX_ENTROPYLEN */
                                    if (ossl_unlikely(r->maxentlen != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->maxentlen = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'n':
                                if (ossl_likely(strcmp("oncelen", s + 5) == 0)) {
                                    /* OSSL_DRBG_PARAM_MAX_NONCELEN */
                                    if (ossl_unlikely(r->maxnonlen != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->maxnonlen = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'p':
                                if (ossl_likely(strcmp("erslen", s + 5) == 0)) {
                                    /* OSSL_DRBG_PARAM_MAX_PERSLEN */
                                    if (ossl_unlikely(r->maxperlen != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->maxperlen = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'r':
                                if (ossl_likely(strcmp("equest", s + 5) == 0)) {
                                    /* OSSL_RAND_PARAM_MAX_REQUEST */
                                    if (ossl_unlikely(r->maxreq != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->maxreq = (OSSL_PARAM *)p;
                                }
                            }
                        }
                    }
                    break;
                case 'i':
                    switch(s[2]) {
                    default:
                        break;
                    case 'n':
                        switch(s[3]) {
                        default:
                            break;
                        case '_':
                            switch(s[4]) {
                            default:
                                break;
                            case 'e':
                                if (ossl_likely(strcmp("ntropylen", s + 5) == 0)) {
                                    /* OSSL_DRBG_PARAM_MIN_ENTROPYLEN */
                                    if (ossl_unlikely(r->minentlen != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->minentlen = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'n':
                                if (ossl_likely(strcmp("oncelen", s + 5) == 0)) {
                                    /* OSSL_DRBG_PARAM_MIN_NONCELEN */
                                    if (ossl_unlikely(r->minnonlen != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->minnonlen = (OSSL_PARAM *)p;
                                }
                            }
                        }
                    }
                }
                break;
            case 'r':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case 'e':
                            switch(s[4]) {
                            default:
                                break;
                            case 'e':
                                switch(s[5]) {
                                default:
                                    break;
                                case 'd':
                                    switch(s[6]) {
                                    default:
                                        break;
                                    case '_':
                                        switch(s[7]) {
                                        default:
                                            break;
                                        case 'c':
                                            if (ossl_likely(strcmp("ounter", s + 8) == 0)) {
                                                /* OSSL_DRBG_PARAM_RESEED_COUNTER */
                                                if (ossl_unlikely(r->reseed_cnt != NULL)) {
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                   "param %s is repeated", s);
                                                    return 0;
                                                }
                                                r->reseed_cnt = (OSSL_PARAM *)p;
                                            }
                                            break;
                                        case 'r':
                                            if (ossl_likely(strcmp("equests", s + 8) == 0)) {
                                                /* OSSL_DRBG_PARAM_RESEED_REQUESTS */
                                                if (ossl_unlikely(r->reseed_req != NULL)) {
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                   "param %s is repeated", s);
                                                    return 0;
                                                }
                                                r->reseed_req = (OSSL_PARAM *)p;
                                            }
                                            break;
                                        case 't':
                                            switch(s[8]) {
                                            default:
                                                break;
                                            case 'i':
                                                switch(s[9]) {
                                                default:
                                                    break;
                                                case 'm':
                                                    switch(s[10]) {
                                                    default:
                                                        break;
                                                    case 'e':
                                                        switch(s[11]) {
                                                        default:
                                                            break;
                                                        case '_':
                                                            if (ossl_likely(strcmp("interval", s + 12) == 0)) {
                                                                /* OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL */
                                                                if (ossl_unlikely(r->reseed_int != NULL)) {
                                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                                   "param %s is repeated", s);
                                                                    return 0;
                                                                }
                                                                r->reseed_int = (OSSL_PARAM *)p;
                                                            }
                                                            break;
                                                        case '\0':
                                                            if (ossl_unlikely(r->reseed_time != NULL)) {
                                                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                               "param %s is repeated", s);
                                                                return 0;
                                                            }
                                                            r->reseed_time = (OSSL_PARAM *)p;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                break;
            case 's':
                switch(s[1]) {
                default:
                    break;
                case 't':
                    switch(s[2]) {
                    default:
                        break;
                    case 'a':
                        if (ossl_likely(strcmp("te", s + 3) == 0)) {
                            /* OSSL_RAND_PARAM_STATE */
                            if (ossl_unlikely(r->state != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->state = (OSSL_PARAM *)p;
                        }
                        break;
                    case 'r':
                        if (ossl_likely(strcmp("ength", s + 3) == 0)) {
                            /* OSSL_RAND_PARAM_STRENGTH */
                            if (ossl_unlikely(r->str != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->str = (OSSL_PARAM *)p;
                        }
                    }
                }
                break;
            case 'u':
                if (ossl_likely(strcmp("se_derivation_function", s + 1) == 0)) {
                    /* OSSL_DRBG_PARAM_USE_DF */
                    if (ossl_unlikely(r->df != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->df = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef drbg_ctr_set_ctx_params_list
static ossl_unused const OSSL_PARAM drbg_ctr_set_ctx_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_CIPHER, NULL, 0),
# if !defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_DRBG_PARAM_USE_DF, NULL),
# endif
    OSSL_PARAM_utf8_string(OSSL_PROV_PARAM_CORE_PROV_NAME, NULL, 0),
    OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS, NULL),
    OSSL_PARAM_uint64(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef drbg_ctr_set_ctx_params_st
struct drbg_ctr_set_ctx_params_st {
    OSSL_PARAM *cipher;
# if !defined(FIPS_MODULE)
    OSSL_PARAM *df;
# endif
    OSSL_PARAM *propq;
    OSSL_PARAM *prov;
    OSSL_PARAM *reseed_req;
    OSSL_PARAM *reseed_time;
};
#endif

#ifndef drbg_ctr_set_ctx_params_decoder
static ossl_unused int drbg_ctr_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct drbg_ctr_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'c':
                if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
                    /* OSSL_DRBG_PARAM_CIPHER */
                    if (ossl_unlikely(r->cipher != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->cipher = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    switch(s[2]) {
                    default:
                        break;
                    case 'o':
                        switch(s[3]) {
                        default:
                            break;
                        case 'p':
                            if (ossl_likely(strcmp("erties", s + 4) == 0)) {
                                /* OSSL_DRBG_PARAM_PROPERTIES */
                                if (ossl_unlikely(r->propq != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->propq = (OSSL_PARAM *)p;
                            }
                            break;
                        case 'v':
                            if (ossl_likely(strcmp("ider-name", s + 4) == 0)) {
                                /* OSSL_PROV_PARAM_CORE_PROV_NAME */
                                if (ossl_unlikely(r->prov != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->prov = (OSSL_PARAM *)p;
                            }
                        }
                    }
                }
                break;
            case 'r':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case 'e':
                            switch(s[4]) {
                            default:
                                break;
                            case 'e':
                                switch(s[5]) {
                                default:
                                    break;
                                case 'd':
                                    switch(s[6]) {
                                    default:
                                        break;
                                    case '_':
                                        switch(s[7]) {
                                        default:
                                            break;
                                        case 'r':
                                            if (ossl_likely(strcmp("equests", s + 8) == 0)) {
                                                /* OSSL_DRBG_PARAM_RESEED_REQUESTS */
                                                if (ossl_unlikely(r->reseed_req != NULL)) {
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                   "param %s is repeated", s);
                                                    return 0;
                                                }
                                                r->reseed_req = (OSSL_PARAM *)p;
                                            }
                                            break;
                                        case 't':
                                            if (ossl_likely(strcmp("ime_interval", s + 8) == 0)) {
                                                /* OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL */
                                                if (ossl_unlikely(r->reseed_time != NULL)) {
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                   "param %s is repeated", s);
                                                    return 0;
                                                }
                                                r->reseed_time = (OSSL_PARAM *)p;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                break;
            case 'u':
# if !defined(FIPS_MODULE)
                if (ossl_likely(strcmp("se_derivation_function", s + 1) == 0)) {
                    /* OSSL_DRBG_PARAM_USE_DF */
                    if (ossl_unlikely(r->df != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->df = (OSSL_PARAM *)p;
                }
# endif
                break;
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-12 06:55

Line	Count	Source
1		/*
2		* Copyright 2025-2026 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the \"License\"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10
11
12		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
13		#include <string.h>
14		#include <openssl/params.h>
15		#include <openssl/e_os2.h>
16		#include "internal/common.h"
17		#include "prov/proverr.h"
18
19		/* Machine generated */
20		#ifndef drbg_ctr_get_ctx_params_list
21		static ossl_unused const OSSL_PARAM drbg_ctr_get_ctx_params_list[] = {
22		OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_CIPHER, NULL, 0),
23		OSSL_PARAM_int(OSSL_DRBG_PARAM_USE_DF, NULL),
24		OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
25		OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
26		OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
27		OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_ENTROPYLEN, NULL),
28		OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ENTROPYLEN, NULL),
29		OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_NONCELEN, NULL),
30		OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_NONCELEN, NULL),
31		OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_PERSLEN, NULL),
32		OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ADINLEN, NULL),
33		OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_COUNTER, NULL),
34		OSSL_PARAM_time_t(OSSL_DRBG_PARAM_RESEED_TIME, NULL),
35		OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS, NULL),
36		OSSL_PARAM_uint64(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL, NULL),
37		# if defined(FIPS_MODULE)
38		OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
39		# endif
40		OSSL_PARAM_END
41		};
42		#endif
43
44		#ifndef drbg_ctr_get_ctx_params_st
45		struct drbg_ctr_get_ctx_params_st {
46		OSSL_PARAM *cipher;
47		OSSL_PARAM *df;
48		# if defined(FIPS_MODULE)
49		OSSL_PARAM *ind;
50		# endif
51		OSSL_PARAM *maxadlen;
52		OSSL_PARAM *maxentlen;
53		OSSL_PARAM *maxnonlen;
54		OSSL_PARAM *maxperlen;
55		OSSL_PARAM *maxreq;
56		OSSL_PARAM *minentlen;
57		OSSL_PARAM *minnonlen;
58		OSSL_PARAM *reseed_cnt;
59		OSSL_PARAM *reseed_int;
60		OSSL_PARAM *reseed_req;
61		OSSL_PARAM *reseed_time;
62		OSSL_PARAM *state;
63		OSSL_PARAM *str;
64		};
65		#endif
66
67		#ifndef drbg_ctr_get_ctx_params_decoder
68		static ossl_unused int drbg_ctr_get_ctx_params_decoder
69		(const OSSL_PARAM p, struct drbg_ctr_get_ctx_params_st r)
70	172k	{
71	172k	const char *s;
72
73	172k	memset(r, 0, sizeof(*r));
74	172k	if (p != NULL)
75	345k	for (; (s = p->key) != NULL; p++)
76	172k	switch(s[0]) {
77	0	default:
78	0	break;
79	0	case 'c':
80	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
81		/* OSSL_DRBG_PARAM_CIPHER */
82	0	if (ossl_unlikely(r->cipher != NULL)) {
83	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
84	0	"param %s is repeated", s);
85	0	return 0;
86	0	}
87	0	r->cipher = (OSSL_PARAM *)p;
88	0	}
89	0	break;
90	0	case 'f':
91		# if defined(FIPS_MODULE)
92		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
93		/* OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR */
94		if (ossl_unlikely(r->ind != NULL)) {
95		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
96		"param %s is repeated", s);
97		return 0;
98		}
99		r->ind = (OSSL_PARAM *)p;
100		}
101		# endif
102	0	break;
103	86.3k	case 'm':
104	86.3k	switch(s[1]) {
105	0	default:
106	0	break;
107	86.3k	case 'a':
108	86.3k	switch(s[2]) {
109	0	default:
110	0	break;
111	86.3k	case 'x':
112	86.3k	switch(s[3]) {
113	0	default:
114	0	break;
115	86.3k	case '_':
116	86.3k	switch(s[4]) {
117	0	default:
118	0	break;
119	0	case 'a':
120	0	if (ossl_likely(strcmp("dinlen", s + 5) == 0)) {
121		/* OSSL_DRBG_PARAM_MAX_ADINLEN */
122	0	if (ossl_unlikely(r->maxadlen != NULL)) {
123	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
124	0	"param %s is repeated", s);
125	0	return 0;
126	0	}
127	0	r->maxadlen = (OSSL_PARAM *)p;
128	0	}
129	0	break;
130	0	case 'e':
131	0	if (ossl_likely(strcmp("ntropylen", s + 5) == 0)) {
132		/* OSSL_DRBG_PARAM_MAX_ENTROPYLEN */
133	0	if (ossl_unlikely(r->maxentlen != NULL)) {
134	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
135	0	"param %s is repeated", s);
136	0	return 0;
137	0	}
138	0	r->maxentlen = (OSSL_PARAM *)p;
139	0	}
140	0	break;
141	0	case 'n':
142	0	if (ossl_likely(strcmp("oncelen", s + 5) == 0)) {
143		/* OSSL_DRBG_PARAM_MAX_NONCELEN */
144	0	if (ossl_unlikely(r->maxnonlen != NULL)) {
145	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
146	0	"param %s is repeated", s);
147	0	return 0;
148	0	}
149	0	r->maxnonlen = (OSSL_PARAM *)p;
150	0	}
151	0	break;
152	0	case 'p':
153	0	if (ossl_likely(strcmp("erslen", s + 5) == 0)) {
154		/* OSSL_DRBG_PARAM_MAX_PERSLEN */
155	0	if (ossl_unlikely(r->maxperlen != NULL)) {
156	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
157	0	"param %s is repeated", s);
158	0	return 0;
159	0	}
160	0	r->maxperlen = (OSSL_PARAM *)p;
161	0	}
162	0	break;
163	86.3k	case 'r':
164	86.3k	if (ossl_likely(strcmp("equest", s + 5) == 0)) {
165		/* OSSL_RAND_PARAM_MAX_REQUEST */
166	86.3k	if (ossl_unlikely(r->maxreq != NULL)) {
167	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
168	0	"param %s is repeated", s);
169	0	return 0;
170	0	}
171	86.3k	r->maxreq = (OSSL_PARAM *)p;
172	86.3k	}
173	86.3k	}
174	86.3k	}
175	86.3k	}
176	86.3k	break;
177	86.3k	case 'i':
178	0	switch(s[2]) {
179	0	default:
180	0	break;
181	0	case 'n':
182	0	switch(s[3]) {
183	0	default:
184	0	break;
185	0	case '_':
186	0	switch(s[4]) {
187	0	default:
188	0	break;
189	0	case 'e':
190	0	if (ossl_likely(strcmp("ntropylen", s + 5) == 0)) {
191		/* OSSL_DRBG_PARAM_MIN_ENTROPYLEN */
192	0	if (ossl_unlikely(r->minentlen != NULL)) {
193	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
194	0	"param %s is repeated", s);
195	0	return 0;
196	0	}
197	0	r->minentlen = (OSSL_PARAM *)p;
198	0	}
199	0	break;
200	0	case 'n':
201	0	if (ossl_likely(strcmp("oncelen", s + 5) == 0)) {
202		/* OSSL_DRBG_PARAM_MIN_NONCELEN */
203	0	if (ossl_unlikely(r->minnonlen != NULL)) {
204	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
205	0	"param %s is repeated", s);
206	0	return 0;
207	0	}
208	0	r->minnonlen = (OSSL_PARAM *)p;
209	0	}
210	0	}
211	0	}
212	0	}
213	86.3k	}
214	86.3k	break;
215	86.4k	case 'r':
216	86.4k	switch(s[1]) {
217	0	default:
218	0	break;
219	86.4k	case 'e':
220	86.4k	switch(s[2]) {
221	0	default:
222	0	break;
223	86.4k	case 's':
224	86.4k	switch(s[3]) {
225	0	default:
226	0	break;
227	86.4k	case 'e':
228	86.4k	switch(s[4]) {
229	0	default:
230	0	break;
231	86.4k	case 'e':
232	86.4k	switch(s[5]) {
233	0	default:
234	0	break;
235	86.4k	case 'd':
236	86.4k	switch(s[6]) {
237	0	default:
238	0	break;
239	86.4k	case '_':
240	86.4k	switch(s[7]) {
241	0	default:
242	0	break;
243	86.4k	case 'c':
244	86.4k	if (ossl_likely(strcmp("ounter", s + 8) == 0)) {
245		/* OSSL_DRBG_PARAM_RESEED_COUNTER */
246	86.4k	if (ossl_unlikely(r->reseed_cnt != NULL)) {
247	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
248	0	"param %s is repeated", s);
249	0	return 0;
250	0	}
251	86.4k	r->reseed_cnt = (OSSL_PARAM *)p;
252	86.4k	}
253	86.4k	break;
254	86.4k	case 'r':
255	0	if (ossl_likely(strcmp("equests", s + 8) == 0)) {
256		/* OSSL_DRBG_PARAM_RESEED_REQUESTS */
257	0	if (ossl_unlikely(r->reseed_req != NULL)) {
258	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
259	0	"param %s is repeated", s);
260	0	return 0;
261	0	}
262	0	r->reseed_req = (OSSL_PARAM *)p;
263	0	}
264	0	break;
265	0	case 't':
266	0	switch(s[8]) {
267	0	default:
268	0	break;
269	0	case 'i':
270	0	switch(s[9]) {
271	0	default:
272	0	break;
273	0	case 'm':
274	0	switch(s[10]) {
275	0	default:
276	0	break;
277	0	case 'e':
278	0	switch(s[11]) {
279	0	default:
280	0	break;
281	0	case '_':
282	0	if (ossl_likely(strcmp("interval", s + 12) == 0)) {
283		/* OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL */
284	0	if (ossl_unlikely(r->reseed_int != NULL)) {
285	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
286	0	"param %s is repeated", s);
287	0	return 0;
288	0	}
289	0	r->reseed_int = (OSSL_PARAM *)p;
290	0	}
291	0	break;
292	0	case '\0':
293	0	if (ossl_unlikely(r->reseed_time != NULL)) {
294	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
295	0	"param %s is repeated", s);
296	0	return 0;
297	0	}
298	0	r->reseed_time = (OSSL_PARAM *)p;
299	0	}
300	0	}
301	0	}
302	0	}
303	86.4k	}
304	86.4k	}
305	86.4k	}
306	86.4k	}
307	86.4k	}
308	86.4k	}
309	86.4k	}
310	86.4k	break;
311	86.4k	case 's':
312	69	switch(s[1]) {
313	0	default:
314	0	break;
315	69	case 't':
316	69	switch(s[2]) {
317	0	default:
318	0	break;
319	0	case 'a':
320	0	if (ossl_likely(strcmp("te", s + 3) == 0)) {
321		/* OSSL_RAND_PARAM_STATE */
322	0	if (ossl_unlikely(r->state != NULL)) {
323	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
324	0	"param %s is repeated", s);
325	0	return 0;
326	0	}
327	0	r->state = (OSSL_PARAM *)p;
328	0	}
329	0	break;
330	69	case 'r':
331	69	if (ossl_likely(strcmp("ength", s + 3) == 0)) {
332		/* OSSL_RAND_PARAM_STRENGTH */
333	69	if (ossl_unlikely(r->str != NULL)) {
334	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
335	0	"param %s is repeated", s);
336	0	return 0;
337	0	}
338	69	r->str = (OSSL_PARAM *)p;
339	69	}
340	69	}
341	69	}
342	69	break;
343	69	case 'u':
344	0	if (ossl_likely(strcmp("se_derivation_function", s + 1) == 0)) {
345		/* OSSL_DRBG_PARAM_USE_DF */
346	0	if (ossl_unlikely(r->df != NULL)) {
347	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
348	0	"param %s is repeated", s);
349	0	return 0;
350	0	}
351	0	r->df = (OSSL_PARAM *)p;
352	0	}
353	172k	}
354	172k	return 1;
355	172k	}
356		#endif
357		/* End of machine generated */
358
359		/* Machine generated */
360		#ifndef drbg_ctr_set_ctx_params_list
361		static ossl_unused const OSSL_PARAM drbg_ctr_set_ctx_params_list[] = {
362		OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_PROPERTIES, NULL, 0),
363		OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_CIPHER, NULL, 0),
364		# if !defined(FIPS_MODULE)
365		OSSL_PARAM_int(OSSL_DRBG_PARAM_USE_DF, NULL),
366		# endif
367		OSSL_PARAM_utf8_string(OSSL_PROV_PARAM_CORE_PROV_NAME, NULL, 0),
368		OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS, NULL),
369		OSSL_PARAM_uint64(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL, NULL),
370		OSSL_PARAM_END
371		};
372		#endif
373
374		#ifndef drbg_ctr_set_ctx_params_st
375		struct drbg_ctr_set_ctx_params_st {
376		OSSL_PARAM *cipher;
377		# if !defined(FIPS_MODULE)
378		OSSL_PARAM *df;
379		# endif
380		OSSL_PARAM *propq;
381		OSSL_PARAM *prov;
382		OSSL_PARAM *reseed_req;
383		OSSL_PARAM *reseed_time;
384		};
385		#endif
386
387		#ifndef drbg_ctr_set_ctx_params_decoder
388		static ossl_unused int drbg_ctr_set_ctx_params_decoder
389		(const OSSL_PARAM p, struct drbg_ctr_set_ctx_params_st r)
390	77	{
391	77	const char *s;
392
393	77	memset(r, 0, sizeof(*r));
394	77	if (p != NULL)
395	487	for (; (s = p->key) != NULL; p++)
396	410	switch(s[0]) {
397	0	default:
398	0	break;
399	77	case 'c':
400	77	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
401		/* OSSL_DRBG_PARAM_CIPHER */
402	77	if (ossl_unlikely(r->cipher != NULL)) {
403	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
404	0	"param %s is repeated", s);
405	0	return 0;
406	0	}
407	77	r->cipher = (OSSL_PARAM *)p;
408	77	}
409	77	break;
410	102	case 'p':
411	102	switch(s[1]) {
412	0	default:
413	0	break;
414	102	case 'r':
415	102	switch(s[2]) {
416	0	default:
417	0	break;
418	102	case 'o':
419	102	switch(s[3]) {
420	0	default:
421	0	break;
422	51	case 'p':
423	51	if (ossl_likely(strcmp("erties", s + 4) == 0)) {
424		/* OSSL_DRBG_PARAM_PROPERTIES */
425	51	if (ossl_unlikely(r->propq != NULL)) {
426	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
427	0	"param %s is repeated", s);
428	0	return 0;
429	0	}
430	51	r->propq = (OSSL_PARAM *)p;
431	51	}
432	51	break;
433	51	case 'v':
434	51	if (ossl_likely(strcmp("ider-name", s + 4) == 0)) {
435		/* OSSL_PROV_PARAM_CORE_PROV_NAME */
436	51	if (ossl_unlikely(r->prov != NULL)) {
437	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
438	0	"param %s is repeated", s);
439	0	return 0;
440	0	}
441	51	r->prov = (OSSL_PARAM *)p;
442	51	}
443	102	}
444	102	}
445	102	}
446	102	break;
447	154	case 'r':
448	154	switch(s[1]) {
449	0	default:
450	0	break;
451	154	case 'e':
452	154	switch(s[2]) {
453	0	default:
454	0	break;
455	154	case 's':
456	154	switch(s[3]) {
457	0	default:
458	0	break;
459	154	case 'e':
460	154	switch(s[4]) {
461	0	default:
462	0	break;
463	154	case 'e':
464	154	switch(s[5]) {
465	0	default:
466	0	break;
467	154	case 'd':
468	154	switch(s[6]) {
469	0	default:
470	0	break;
471	154	case '_':
472	154	switch(s[7]) {
473	0	default:
474	0	break;
475	77	case 'r':
476	77	if (ossl_likely(strcmp("equests", s + 8) == 0)) {
477		/* OSSL_DRBG_PARAM_RESEED_REQUESTS */
478	77	if (ossl_unlikely(r->reseed_req != NULL)) {
479	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
480	0	"param %s is repeated", s);
481	0	return 0;
482	0	}
483	77	r->reseed_req = (OSSL_PARAM *)p;
484	77	}
485	77	break;
486	77	case 't':
487	77	if (ossl_likely(strcmp("ime_interval", s + 8) == 0)) {
488		/* OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL */
489	77	if (ossl_unlikely(r->reseed_time != NULL)) {
490	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
491	0	"param %s is repeated", s);
492	0	return 0;
493	0	}
494	77	r->reseed_time = (OSSL_PARAM *)p;
495	77	}
496	154	}
497	154	}
498	154	}
499	154	}
500	154	}
501	154	}
502	154	}
503	154	break;
504	154	case 'u':
505	77	# if !defined(FIPS_MODULE)
506	77	if (ossl_likely(strcmp("se_derivation_function", s + 1) == 0)) {
507		/* OSSL_DRBG_PARAM_USE_DF */
508	77	if (ossl_unlikely(r->df != NULL)) {
509	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
510	0	"param %s is repeated", s);
511	0	return 0;
512	0	}
513	77	r->df = (OSSL_PARAM *)p;
514	77	}
515	77	# endif
516	77	break;
517	410	}
518	77	return 1;
519	77	}
520		#endif
521		/* End of machine generated */