/src/openssl41/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 */
#include <string.h>
#include <openssl/params.h>
#include <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

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