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

Source
/*
 * Copyright 2025 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 test_rng_get_ctx_params_list
static ossl_unused const OSSL_PARAM test_rng_get_ctx_params_list[] = {
    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_uint(OSSL_RAND_PARAM_GENERATE, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef test_rng_get_ctx_params_st
struct test_rng_get_ctx_params_st {
    OSSL_PARAM *gen;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *maxreq;
    OSSL_PARAM *state;
    OSSL_PARAM *str;
};
#endif

#ifndef test_rng_get_ctx_params_decoder
static ossl_unused int test_rng_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct test_rng_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 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_RAND_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 'g':
                if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_GENERATE */
                    if (ossl_unlikely(r->gen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->gen = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ax_request", s + 1) == 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 '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;
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef test_rng_set_ctx_params_list
static ossl_unused const OSSL_PARAM test_rng_set_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
    OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
    OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
    OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef test_rng_set_ctx_params_st
struct test_rng_set_ctx_params_st {
    OSSL_PARAM *ent;
    OSSL_PARAM *gen;
    OSSL_PARAM *maxreq;
    OSSL_PARAM *nonce;
    OSSL_PARAM *str;
};
#endif

#ifndef test_rng_set_ctx_params_decoder
static ossl_unused int test_rng_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct test_rng_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 'g':
                if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
                    /* OSSL_RAND_PARAM_GENERATE */
                    if (ossl_unlikely(r->gen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->gen = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ax_request", s + 1) == 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 's':
                if (ossl_likely(strcmp("trength", s + 1) == 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 't':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case 't':
                            switch(s[4]) {
                            default:
                                break;
                            case '_':
                                switch(s[5]) {
                                default:
                                    break;
                                case 'e':
                                    if (ossl_likely(strcmp("ntropy", s + 6) == 0)) {
                                        /* OSSL_RAND_PARAM_TEST_ENTROPY */
                                        if (ossl_unlikely(r->ent != NULL)) {
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                           "param %s is repeated", s);
                                            return 0;
                                        }
                                        r->ent = (OSSL_PARAM *)p;
                                    }
                                    break;
                                case 'n':
                                    if (ossl_likely(strcmp("once", s + 6) == 0)) {
                                        /* OSSL_RAND_PARAM_TEST_NONCE */
                                        if (ossl_unlikely(r->nonce != NULL)) {
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                           "param %s is repeated", s);
                                            return 0;
                                        }
                                        r->nonce = (OSSL_PARAM *)p;
                                    }
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-12 06:55

Line	Count	Source
1		/*
2		* Copyright 2025 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 test_rng_get_ctx_params_list
21		static ossl_unused const OSSL_PARAM test_rng_get_ctx_params_list[] = {
22		OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
23		OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
24		OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
25		OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
26		# if defined(FIPS_MODULE)
27		OSSL_PARAM_int(OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR, NULL),
28		# endif
29		OSSL_PARAM_END
30		};
31		#endif
32
33		#ifndef test_rng_get_ctx_params_st
34		struct test_rng_get_ctx_params_st {
35		OSSL_PARAM *gen;
36		# if defined(FIPS_MODULE)
37		OSSL_PARAM *ind;
38		# endif
39		OSSL_PARAM *maxreq;
40		OSSL_PARAM *state;
41		OSSL_PARAM *str;
42		};
43		#endif
44
45		#ifndef test_rng_get_ctx_params_decoder
46		static ossl_unused int test_rng_get_ctx_params_decoder
47		(const OSSL_PARAM p, struct test_rng_get_ctx_params_st r)
48	139	{
49	139	const char *s;
50
51	139	memset(r, 0, sizeof(*r));
52	139	if (p != NULL)
53	278	for (; (s = p->key) != NULL; p++)
54	139	switch(s[0]) {
55	0	default:
56	0	break;
57	0	case 'f':
58		# if defined(FIPS_MODULE)
59		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
60		/* OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR */
61		if (ossl_unlikely(r->ind != NULL)) {
62		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
63		"param %s is repeated", s);
64		return 0;
65		}
66		r->ind = (OSSL_PARAM *)p;
67		}
68		# endif
69	0	break;
70	0	case 'g':
71	0	if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
72		/* OSSL_RAND_PARAM_GENERATE */
73	0	if (ossl_unlikely(r->gen != NULL)) {
74	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
75	0	"param %s is repeated", s);
76	0	return 0;
77	0	}
78	0	r->gen = (OSSL_PARAM *)p;
79	0	}
80	0	break;
81	139	case 'm':
82	139	if (ossl_likely(strcmp("ax_request", s + 1) == 0)) {
83		/* OSSL_RAND_PARAM_MAX_REQUEST */
84	139	if (ossl_unlikely(r->maxreq != NULL)) {
85	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
86	0	"param %s is repeated", s);
87	0	return 0;
88	0	}
89	139	r->maxreq = (OSSL_PARAM *)p;
90	139	}
91	139	break;
92	139	case 's':
93	0	switch(s[1]) {
94	0	default:
95	0	break;
96	0	case 't':
97	0	switch(s[2]) {
98	0	default:
99	0	break;
100	0	case 'a':
101	0	if (ossl_likely(strcmp("te", s + 3) == 0)) {
102		/* OSSL_RAND_PARAM_STATE */
103	0	if (ossl_unlikely(r->state != NULL)) {
104	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
105	0	"param %s is repeated", s);
106	0	return 0;
107	0	}
108	0	r->state = (OSSL_PARAM *)p;
109	0	}
110	0	break;
111	0	case 'r':
112	0	if (ossl_likely(strcmp("ength", s + 3) == 0)) {
113		/* OSSL_RAND_PARAM_STRENGTH */
114	0	if (ossl_unlikely(r->str != NULL)) {
115	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
116	0	"param %s is repeated", s);
117	0	return 0;
118	0	}
119	0	r->str = (OSSL_PARAM *)p;
120	0	}
121	0	}
122	0	}
123	139	}
124	139	return 1;
125	139	}
126		#endif
127		/* End of machine generated */
128
129		/* Machine generated */
130		#ifndef test_rng_set_ctx_params_list
131		static ossl_unused const OSSL_PARAM test_rng_set_ctx_params_list[] = {
132		OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
133		OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
134		OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
135		OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
136		OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
137		OSSL_PARAM_END
138		};
139		#endif
140
141		#ifndef test_rng_set_ctx_params_st
142		struct test_rng_set_ctx_params_st {
143		OSSL_PARAM *ent;
144		OSSL_PARAM *gen;
145		OSSL_PARAM *maxreq;
146		OSSL_PARAM *nonce;
147		OSSL_PARAM *str;
148		};
149		#endif
150
151		#ifndef test_rng_set_ctx_params_decoder
152		static ossl_unused int test_rng_set_ctx_params_decoder
153		(const OSSL_PARAM p, struct test_rng_set_ctx_params_st r)
154	139	{
155	139	const char *s;
156
157	139	memset(r, 0, sizeof(*r));
158	139	if (p != NULL)
159	834	for (; (s = p->key) != NULL; p++)
160	695	switch(s[0]) {
161	0	default:
162	0	break;
163	139	case 'g':
164	139	if (ossl_likely(strcmp("enerate", s + 1) == 0)) {
165		/* OSSL_RAND_PARAM_GENERATE */
166	139	if (ossl_unlikely(r->gen != 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	139	r->gen = (OSSL_PARAM *)p;
172	139	}
173	139	break;
174	139	case 'm':
175	139	if (ossl_likely(strcmp("ax_request", s + 1) == 0)) {
176		/* OSSL_RAND_PARAM_MAX_REQUEST */
177	139	if (ossl_unlikely(r->maxreq != NULL)) {
178	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
179	0	"param %s is repeated", s);
180	0	return 0;
181	0	}
182	139	r->maxreq = (OSSL_PARAM *)p;
183	139	}
184	139	break;
185	139	case 's':
186	139	if (ossl_likely(strcmp("trength", s + 1) == 0)) {
187		/* OSSL_RAND_PARAM_STRENGTH */
188	139	if (ossl_unlikely(r->str != NULL)) {
189	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
190	0	"param %s is repeated", s);
191	0	return 0;
192	0	}
193	139	r->str = (OSSL_PARAM *)p;
194	139	}
195	139	break;
196	278	case 't':
197	278	switch(s[1]) {
198	0	default:
199	0	break;
200	278	case 'e':
201	278	switch(s[2]) {
202	0	default:
203	0	break;
204	278	case 's':
205	278	switch(s[3]) {
206	0	default:
207	0	break;
208	278	case 't':
209	278	switch(s[4]) {
210	0	default:
211	0	break;
212	278	case '_':
213	278	switch(s[5]) {
214	0	default:
215	0	break;
216	139	case 'e':
217	139	if (ossl_likely(strcmp("ntropy", s + 6) == 0)) {
218		/* OSSL_RAND_PARAM_TEST_ENTROPY */
219	139	if (ossl_unlikely(r->ent != NULL)) {
220	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
221	0	"param %s is repeated", s);
222	0	return 0;
223	0	}
224	139	r->ent = (OSSL_PARAM *)p;
225	139	}
226	139	break;
227	139	case 'n':
228	139	if (ossl_likely(strcmp("once", s + 6) == 0)) {
229		/* OSSL_RAND_PARAM_TEST_NONCE */
230	139	if (ossl_unlikely(r->nonce != NULL)) {
231	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
232	0	"param %s is repeated", s);
233	0	return 0;
234	0	}
235	139	r->nonce = (OSSL_PARAM *)p;
236	139	}
237	278	}
238	278	}
239	278	}
240	278	}
241	278	}
242	695	}
243	139	return 1;
244	139	}
245		#endif
246		/* End of machine generated */