/src/openssl/providers/implementations/kdfs/kbkdf.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 */
#ifndef kbkdf_set_ctx_params_list
static const OSSL_PARAM kbkdf_set_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SEED, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MAC, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_L, NULL),
    OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR, NULL),
    OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_R, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef kbkdf_set_ctx_params_st
struct kbkdf_set_ctx_params_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *digest;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind_k;
# endif
    OSSL_PARAM *info[KBKDF_MAX_INFOS];
    int num_info;
    OSSL_PARAM *key;
    OSSL_PARAM *mac;
    OSSL_PARAM *mode;
    OSSL_PARAM *propq;
    OSSL_PARAM *r;
    OSSL_PARAM *salt;
    OSSL_PARAM *seed;
    OSSL_PARAM *sep;
    OSSL_PARAM *use_l;
};
#endif

#ifndef kbkdf_set_ctx_params_decoder
static int kbkdf_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct kbkdf_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_KDF_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 'd':
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_DIGEST */
                    if (ossl_unlikely(r->digest != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->digest = (OSSL_PARAM *)p;
                }
                break;
            case 'i':
                if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_INFO */
                    if (ossl_unlikely(r->num_info >= KBKDF_MAX_INFOS)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS,
                                       "param %s present >%d times", s, KBKDF_MAX_INFOS);
                        return 0;
                    }
                    r->info[r->num_info++] = (OSSL_PARAM *)p;
                }
                break;
            case 'k':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'y':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
# if defined(FIPS_MODULE)
                            if (ossl_likely(strcmp("check", s + 4) == 0)) {
                                /* OSSL_KDF_PARAM_FIPS_KEY_CHECK */
                                if (ossl_unlikely(r->ind_k != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->ind_k = (OSSL_PARAM *)p;
                            }
# endif
                            break;
                        case '\0':
                            if (ossl_unlikely(r->key != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->key = (OSSL_PARAM *)p;
                        }
                    }
                }
                break;
            case 'm':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("c", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_MAC */
                        if (ossl_unlikely(r->mac != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->mac = (OSSL_PARAM *)p;
                    }
                    break;
                case 'o':
                    if (ossl_likely(strcmp("de", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_MODE */
                        if (ossl_unlikely(r->mode != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->mode = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_KDF_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 'r':
                switch(s[1]) {
                default:
                    break;
                case '\0':
                    if (ossl_unlikely(r->r != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->r = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("lt", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_SALT */
                        if (ossl_unlikely(r->salt != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->salt = (OSSL_PARAM *)p;
                    }
                    break;
                case 'e':
                    if (ossl_likely(strcmp("ed", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_SEED */
                        if (ossl_unlikely(r->seed != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->seed = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'u':
                switch(s[1]) {
                default:
                    break;
                case 's':
                    switch(s[2]) {
                    default:
                        break;
                    case 'e':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
                            switch(s[4]) {
                            default:
                                break;
                            case 'l':
                                switch(s[5]) {
                                default:
                                    break;
                                case '\0':
                                    if (ossl_unlikely(r->use_l != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->use_l = (OSSL_PARAM *)p;
                                }
                                break;
                            case 's':
                                if (ossl_likely(strcmp("eparator", s + 5) == 0)) {
                                    /* OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR */
                                    if (ossl_unlikely(r->sep != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->sep = (OSSL_PARAM *)p;
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef kbkdf_get_ctx_params_list
static const OSSL_PARAM kbkdf_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef kbkdf_get_ctx_params_st
struct kbkdf_get_ctx_params_st {
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *size;
};
#endif

#ifndef kbkdf_get_ctx_params_decoder
static int kbkdf_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct kbkdf_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_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 's':
                if (ossl_likely(strcmp("ize", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_SIZE */
                    if (ossl_unlikely(r->size != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->size = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2025-12-08 06:22

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		#ifndef kbkdf_set_ctx_params_list
14		static const OSSL_PARAM kbkdf_set_ctx_params_list[] = {
15		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
16		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
17		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
18		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SEED, NULL, 0),
19		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
20		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_CIPHER, NULL, 0),
21		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MAC, NULL, 0),
22		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
23		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
24		OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_L, NULL),
25		OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR, NULL),
26		OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_R, NULL),
27		# if defined(FIPS_MODULE)
28		OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
29		# endif
30		OSSL_PARAM_END
31		};
32		#endif
33
34		#ifndef kbkdf_set_ctx_params_st
35		struct kbkdf_set_ctx_params_st {
36		OSSL_PARAM *cipher;
37		OSSL_PARAM *digest;
38		# if defined(FIPS_MODULE)
39		OSSL_PARAM *ind_k;
40		# endif
41		OSSL_PARAM *info[KBKDF_MAX_INFOS];
42		int num_info;
43		OSSL_PARAM *key;
44		OSSL_PARAM *mac;
45		OSSL_PARAM *mode;
46		OSSL_PARAM *propq;
47		OSSL_PARAM *r;
48		OSSL_PARAM *salt;
49		OSSL_PARAM *seed;
50		OSSL_PARAM *sep;
51		OSSL_PARAM *use_l;
52		};
53		#endif
54
55		#ifndef kbkdf_set_ctx_params_decoder
56		static int kbkdf_set_ctx_params_decoder
57		(const OSSL_PARAM p, struct kbkdf_set_ctx_params_st r)
58	0	{
59	0	const char *s;
60
61	0	memset(r, 0, sizeof(*r));
62	0	if (p != NULL)
63	0	for (; (s = p->key) != NULL; p++)
64	0	switch(s[0]) {
65	0	default:
66	0	break;
67	0	case 'c':
68	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
69		/* OSSL_KDF_PARAM_CIPHER */
70	0	if (ossl_unlikely(r->cipher != NULL)) {
71	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
72	0	"param %s is repeated", s);
73	0	return 0;
74	0	}
75	0	r->cipher = (OSSL_PARAM *)p;
76	0	}
77	0	break;
78	0	case 'd':
79	0	if (ossl_likely(strcmp("igest", s + 1) == 0)) {
80		/* OSSL_KDF_PARAM_DIGEST */
81	0	if (ossl_unlikely(r->digest != NULL)) {
82	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
83	0	"param %s is repeated", s);
84	0	return 0;
85	0	}
86	0	r->digest = (OSSL_PARAM *)p;
87	0	}
88	0	break;
89	0	case 'i':
90	0	if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
91		/* OSSL_KDF_PARAM_INFO */
92	0	if (ossl_unlikely(r->num_info >= KBKDF_MAX_INFOS)) {
93	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS,
94	0	"param %s present >%d times", s, KBKDF_MAX_INFOS);
95	0	return 0;
96	0	}
97	0	r->info[r->num_info++] = (OSSL_PARAM *)p;
98	0	}
99	0	break;
100	0	case 'k':
101	0	switch(s[1]) {
102	0	default:
103	0	break;
104	0	case 'e':
105	0	switch(s[2]) {
106	0	default:
107	0	break;
108	0	case 'y':
109	0	switch(s[3]) {
110	0	default:
111	0	break;
112	0	case '-':
113		# if defined(FIPS_MODULE)
114		if (ossl_likely(strcmp("check", s + 4) == 0)) {
115		/* OSSL_KDF_PARAM_FIPS_KEY_CHECK */
116		if (ossl_unlikely(r->ind_k != NULL)) {
117		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
118		"param %s is repeated", s);
119		return 0;
120		}
121		r->ind_k = (OSSL_PARAM *)p;
122		}
123		# endif
124	0	break;
125	0	case '\0':
126	0	if (ossl_unlikely(r->key != 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->key = (OSSL_PARAM *)p;
132	0	}
133	0	}
134	0	}
135	0	break;
136	0	case 'm':
137	0	switch(s[1]) {
138	0	default:
139	0	break;
140	0	case 'a':
141	0	if (ossl_likely(strcmp("c", s + 2) == 0)) {
142		/* OSSL_KDF_PARAM_MAC */
143	0	if (ossl_unlikely(r->mac != NULL)) {
144	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
145	0	"param %s is repeated", s);
146	0	return 0;
147	0	}
148	0	r->mac = (OSSL_PARAM *)p;
149	0	}
150	0	break;
151	0	case 'o':
152	0	if (ossl_likely(strcmp("de", s + 2) == 0)) {
153		/* OSSL_KDF_PARAM_MODE */
154	0	if (ossl_unlikely(r->mode != NULL)) {
155	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
156	0	"param %s is repeated", s);
157	0	return 0;
158	0	}
159	0	r->mode = (OSSL_PARAM *)p;
160	0	}
161	0	}
162	0	break;
163	0	case 'p':
164	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
165		/* OSSL_KDF_PARAM_PROPERTIES */
166	0	if (ossl_unlikely(r->propq != 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	0	r->propq = (OSSL_PARAM *)p;
172	0	}
173	0	break;
174	0	case 'r':
175	0	switch(s[1]) {
176	0	default:
177	0	break;
178	0	case '\0':
179	0	if (ossl_unlikely(r->r != NULL)) {
180	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
181	0	"param %s is repeated", s);
182	0	return 0;
183	0	}
184	0	r->r = (OSSL_PARAM *)p;
185	0	}
186	0	break;
187	0	case 's':
188	0	switch(s[1]) {
189	0	default:
190	0	break;
191	0	case 'a':
192	0	if (ossl_likely(strcmp("lt", s + 2) == 0)) {
193		/* OSSL_KDF_PARAM_SALT */
194	0	if (ossl_unlikely(r->salt != NULL)) {
195	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
196	0	"param %s is repeated", s);
197	0	return 0;
198	0	}
199	0	r->salt = (OSSL_PARAM *)p;
200	0	}
201	0	break;
202	0	case 'e':
203	0	if (ossl_likely(strcmp("ed", s + 2) == 0)) {
204		/* OSSL_KDF_PARAM_SEED */
205	0	if (ossl_unlikely(r->seed != NULL)) {
206	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
207	0	"param %s is repeated", s);
208	0	return 0;
209	0	}
210	0	r->seed = (OSSL_PARAM *)p;
211	0	}
212	0	}
213	0	break;
214	0	case 'u':
215	0	switch(s[1]) {
216	0	default:
217	0	break;
218	0	case 's':
219	0	switch(s[2]) {
220	0	default:
221	0	break;
222	0	case 'e':
223	0	switch(s[3]) {
224	0	default:
225	0	break;
226	0	case '-':
227	0	switch(s[4]) {
228	0	default:
229	0	break;
230	0	case 'l':
231	0	switch(s[5]) {
232	0	default:
233	0	break;
234	0	case '\0':
235	0	if (ossl_unlikely(r->use_l != NULL)) {
236	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
237	0	"param %s is repeated", s);
238	0	return 0;
239	0	}
240	0	r->use_l = (OSSL_PARAM *)p;
241	0	}
242	0	break;
243	0	case 's':
244	0	if (ossl_likely(strcmp("eparator", s + 5) == 0)) {
245		/* OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR */
246	0	if (ossl_unlikely(r->sep != 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	0	r->sep = (OSSL_PARAM *)p;
252	0	}
253	0	}
254	0	}
255	0	}
256	0	}
257	0	}
258	0	return 1;
259	0	}
260		#endif
261		/* End of machine generated */
262
263		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
264		#ifndef kbkdf_get_ctx_params_list
265		static const OSSL_PARAM kbkdf_get_ctx_params_list[] = {
266		OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
267		# if defined(FIPS_MODULE)
268		OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
269		# endif
270		OSSL_PARAM_END
271		};
272		#endif
273
274		#ifndef kbkdf_get_ctx_params_st
275		struct kbkdf_get_ctx_params_st {
276		# if defined(FIPS_MODULE)
277		OSSL_PARAM *ind;
278		# endif
279		OSSL_PARAM *size;
280		};
281		#endif
282
283		#ifndef kbkdf_get_ctx_params_decoder
284		static int kbkdf_get_ctx_params_decoder
285		(const OSSL_PARAM p, struct kbkdf_get_ctx_params_st r)
286	0	{
287	0	const char *s;
288
289	0	memset(r, 0, sizeof(*r));
290	0	if (p != NULL)
291	0	for (; (s = p->key) != NULL; p++)
292	0	switch(s[0]) {
293	0	default:
294	0	break;
295	0	case 'f':
296		# if defined(FIPS_MODULE)
297		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
298		/* OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR */
299		if (ossl_unlikely(r->ind != NULL)) {
300		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
301		"param %s is repeated", s);
302		return 0;
303		}
304		r->ind = (OSSL_PARAM *)p;
305		}
306		# endif
307	0	break;
308	0	case 's':
309	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
310		/* OSSL_KDF_PARAM_SIZE */
311	0	if (ossl_unlikely(r->size != NULL)) {
312	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
313	0	"param %s is repeated", s);
314	0	return 0;
315	0	}
316	0	r->size = (OSSL_PARAM *)p;
317	0	}
318	0	}
319	0	return 1;
320	0	}
321		#endif
322		/* End of machine generated */