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