/src/openssl/providers/implementations/keymgmt/mac_legacy_kmgmt.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 mac_import_list
static const OSSL_PARAM mac_import_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mac_import_st
struct mac_import_st {
    OSSL_PARAM *key;
    OSSL_PARAM *propq;
};
#endif

#ifndef mac_import_decoder
static int mac_import_decoder
    (const OSSL_PARAM *p, struct mac_import_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 'p':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    switch(s[2]) {
                    default:
                        break;
                    case 'i':
                        if (ossl_likely(strcmp("v", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_PRIV_KEY */
                            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 'o':
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
                            /* OSSL_PKEY_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;
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef cmac_import_list
static const OSSL_PARAM cmac_import_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef cmac_import_st
struct cmac_import_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *key;
    OSSL_PARAM *propq;
};
#endif

#ifndef cmac_import_decoder
static int cmac_import_decoder
    (const OSSL_PARAM *p, struct cmac_import_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_PKEY_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 'i':
                        if (ossl_likely(strcmp("v", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_PRIV_KEY */
                            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 'o':
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
                            /* OSSL_PKEY_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;
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef mac_get_params_list
static const OSSL_PARAM mac_get_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mac_get_params_st
struct mac_get_params_st {
    OSSL_PARAM *key;
};
#endif

#ifndef mac_get_params_decoder
static int mac_get_params_decoder
    (const OSSL_PARAM *p, struct mac_get_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("priv", s + 0) == 0)) {
                /* OSSL_PKEY_PARAM_PRIV_KEY */
                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;
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef cmac_get_params_list
static const OSSL_PARAM cmac_get_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef cmac_get_params_st
struct cmac_get_params_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *key;
};
#endif

#ifndef cmac_get_params_decoder
static int cmac_get_params_decoder
    (const OSSL_PARAM *p, struct cmac_get_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_PKEY_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':
                if (ossl_likely(strcmp("riv", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_PRIV_KEY */
                    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;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef mac_set_params_list
static const OSSL_PARAM mac_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mac_set_params_st
struct mac_set_params_st {
    OSSL_PARAM *key;
};
#endif

#ifndef mac_set_params_decoder
static int mac_set_params_decoder
    (const OSSL_PARAM *p, struct mac_set_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("priv", s + 0) == 0)) {
                /* OSSL_PKEY_PARAM_PRIV_KEY */
                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;
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef mac_gen_set_params_list
static const OSSL_PARAM mac_gen_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mac_gen_set_params_st
struct mac_gen_set_params_st {
    OSSL_PARAM *key;
};
#endif

#ifndef mac_gen_set_params_decoder
static int mac_gen_set_params_decoder
    (const OSSL_PARAM *p, struct mac_gen_set_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("priv", s + 0) == 0)) {
                /* OSSL_PKEY_PARAM_PRIV_KEY */
                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;
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef cmac_gen_set_params_list
static const OSSL_PARAM cmac_gen_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef cmac_gen_set_params_st
struct cmac_gen_set_params_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *key;
    OSSL_PARAM *propq;
};
#endif

#ifndef cmac_gen_set_params_decoder
static int cmac_gen_set_params_decoder
    (const OSSL_PARAM *p, struct cmac_gen_set_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_PKEY_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 'i':
                        if (ossl_likely(strcmp("v", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_PRIV_KEY */
                            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 'o':
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
                            /* OSSL_PKEY_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;
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2025-12-10 06:24

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 mac_import_list
14		static const OSSL_PARAM mac_import_list[] = {
15		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
16		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
17		OSSL_PARAM_END
18		};
19		#endif
20
21		#ifndef mac_import_st
22		struct mac_import_st {
23		OSSL_PARAM *key;
24		OSSL_PARAM *propq;
25		};
26		#endif
27
28		#ifndef mac_import_decoder
29		static int mac_import_decoder
30		(const OSSL_PARAM p, struct mac_import_st r)
31	0	{
32	0	const char *s;
33
34	0	memset(r, 0, sizeof(*r));
35	0	if (p != NULL)
36	0	for (; (s = p->key) != NULL; p++)
37	0	switch(s[0]) {
38	0	default:
39	0	break;
40	0	case 'p':
41	0	switch(s[1]) {
42	0	default:
43	0	break;
44	0	case 'r':
45	0	switch(s[2]) {
46	0	default:
47	0	break;
48	0	case 'i':
49	0	if (ossl_likely(strcmp("v", s + 3) == 0)) {
50		/* OSSL_PKEY_PARAM_PRIV_KEY */
51	0	if (ossl_unlikely(r->key != NULL)) {
52	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
53	0	"param %s is repeated", s);
54	0	return 0;
55	0	}
56	0	r->key = (OSSL_PARAM *)p;
57	0	}
58	0	break;
59	0	case 'o':
60	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
61		/* OSSL_PKEY_PARAM_PROPERTIES */
62	0	if (ossl_unlikely(r->propq != NULL)) {
63	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
64	0	"param %s is repeated", s);
65	0	return 0;
66	0	}
67	0	r->propq = (OSSL_PARAM *)p;
68	0	}
69	0	}
70	0	}
71	0	}
72	0	return 1;
73	0	}
74		#endif
75		/* End of machine generated */
76
77		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
78		#ifndef cmac_import_list
79		static const OSSL_PARAM cmac_import_list[] = {
80		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
81		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
82		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
83		OSSL_PARAM_END
84		};
85		#endif
86
87		#ifndef cmac_import_st
88		struct cmac_import_st {
89		OSSL_PARAM *cipher;
90		OSSL_PARAM *key;
91		OSSL_PARAM *propq;
92		};
93		#endif
94
95		#ifndef cmac_import_decoder
96		static int cmac_import_decoder
97		(const OSSL_PARAM p, struct cmac_import_st r)
98	0	{
99	0	const char *s;
100
101	0	memset(r, 0, sizeof(*r));
102	0	if (p != NULL)
103	0	for (; (s = p->key) != NULL; p++)
104	0	switch(s[0]) {
105	0	default:
106	0	break;
107	0	case 'c':
108	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
109		/* OSSL_PKEY_PARAM_CIPHER */
110	0	if (ossl_unlikely(r->cipher != NULL)) {
111	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
112	0	"param %s is repeated", s);
113	0	return 0;
114	0	}
115	0	r->cipher = (OSSL_PARAM *)p;
116	0	}
117	0	break;
118	0	case 'p':
119	0	switch(s[1]) {
120	0	default:
121	0	break;
122	0	case 'r':
123	0	switch(s[2]) {
124	0	default:
125	0	break;
126	0	case 'i':
127	0	if (ossl_likely(strcmp("v", s + 3) == 0)) {
128		/* OSSL_PKEY_PARAM_PRIV_KEY */
129	0	if (ossl_unlikely(r->key != NULL)) {
130	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
131	0	"param %s is repeated", s);
132	0	return 0;
133	0	}
134	0	r->key = (OSSL_PARAM *)p;
135	0	}
136	0	break;
137	0	case 'o':
138	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
139		/* OSSL_PKEY_PARAM_PROPERTIES */
140	0	if (ossl_unlikely(r->propq != NULL)) {
141	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
142	0	"param %s is repeated", s);
143	0	return 0;
144	0	}
145	0	r->propq = (OSSL_PARAM *)p;
146	0	}
147	0	}
148	0	}
149	0	}
150	0	return 1;
151	0	}
152		#endif
153		/* End of machine generated */
154
155		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
156		#ifndef mac_get_params_list
157		static const OSSL_PARAM mac_get_params_list[] = {
158		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
159		OSSL_PARAM_END
160		};
161		#endif
162
163		#ifndef mac_get_params_st
164		struct mac_get_params_st {
165		OSSL_PARAM *key;
166		};
167		#endif
168
169		#ifndef mac_get_params_decoder
170		static int mac_get_params_decoder
171		(const OSSL_PARAM p, struct mac_get_params_st r)
172	0	{
173	0	const char *s;
174
175	0	memset(r, 0, sizeof(*r));
176	0	if (p != NULL)
177	0	for (; (s = p->key) != NULL; p++)
178	0	if (ossl_likely(strcmp("priv", s + 0) == 0)) {
179		/* OSSL_PKEY_PARAM_PRIV_KEY */
180	0	if (ossl_unlikely(r->key != NULL)) {
181	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
182	0	"param %s is repeated", s);
183	0	return 0;
184	0	}
185	0	r->key = (OSSL_PARAM *)p;
186	0	}
187	0	return 1;
188	0	}
189		#endif
190		/* End of machine generated */
191
192		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
193		#ifndef cmac_get_params_list
194		static const OSSL_PARAM cmac_get_params_list[] = {
195		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
196		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
197		OSSL_PARAM_END
198		};
199		#endif
200
201		#ifndef cmac_get_params_st
202		struct cmac_get_params_st {
203		OSSL_PARAM *cipher;
204		OSSL_PARAM *key;
205		};
206		#endif
207
208		#ifndef cmac_get_params_decoder
209		static int cmac_get_params_decoder
210		(const OSSL_PARAM p, struct cmac_get_params_st r)
211	0	{
212	0	const char *s;
213
214	0	memset(r, 0, sizeof(*r));
215	0	if (p != NULL)
216	0	for (; (s = p->key) != NULL; p++)
217	0	switch(s[0]) {
218	0	default:
219	0	break;
220	0	case 'c':
221	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
222		/* OSSL_PKEY_PARAM_CIPHER */
223	0	if (ossl_unlikely(r->cipher != NULL)) {
224	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
225	0	"param %s is repeated", s);
226	0	return 0;
227	0	}
228	0	r->cipher = (OSSL_PARAM *)p;
229	0	}
230	0	break;
231	0	case 'p':
232	0	if (ossl_likely(strcmp("riv", s + 1) == 0)) {
233		/* OSSL_PKEY_PARAM_PRIV_KEY */
234	0	if (ossl_unlikely(r->key != NULL)) {
235	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
236	0	"param %s is repeated", s);
237	0	return 0;
238	0	}
239	0	r->key = (OSSL_PARAM *)p;
240	0	}
241	0	}
242	0	return 1;
243	0	}
244		#endif
245		/* End of machine generated */
246
247		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
248		#ifndef mac_set_params_list
249		static const OSSL_PARAM mac_set_params_list[] = {
250		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
251		OSSL_PARAM_END
252		};
253		#endif
254
255		#ifndef mac_set_params_st
256		struct mac_set_params_st {
257		OSSL_PARAM *key;
258		};
259		#endif
260
261		#ifndef mac_set_params_decoder
262		static int mac_set_params_decoder
263		(const OSSL_PARAM p, struct mac_set_params_st r)
264	0	{
265	0	const char *s;
266
267	0	memset(r, 0, sizeof(*r));
268	0	if (p != NULL)
269	0	for (; (s = p->key) != NULL; p++)
270	0	if (ossl_likely(strcmp("priv", s + 0) == 0)) {
271		/* OSSL_PKEY_PARAM_PRIV_KEY */
272	0	if (ossl_unlikely(r->key != NULL)) {
273	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
274	0	"param %s is repeated", s);
275	0	return 0;
276	0	}
277	0	r->key = (OSSL_PARAM *)p;
278	0	}
279	0	return 1;
280	0	}
281		#endif
282		/* End of machine generated */
283
284		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
285		#ifndef mac_gen_set_params_list
286		static const OSSL_PARAM mac_gen_set_params_list[] = {
287		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
288		OSSL_PARAM_END
289		};
290		#endif
291
292		#ifndef mac_gen_set_params_st
293		struct mac_gen_set_params_st {
294		OSSL_PARAM *key;
295		};
296		#endif
297
298		#ifndef mac_gen_set_params_decoder
299		static int mac_gen_set_params_decoder
300		(const OSSL_PARAM p, struct mac_gen_set_params_st r)
301	0	{
302	0	const char *s;
303
304	0	memset(r, 0, sizeof(*r));
305	0	if (p != NULL)
306	0	for (; (s = p->key) != NULL; p++)
307	0	if (ossl_likely(strcmp("priv", s + 0) == 0)) {
308		/* OSSL_PKEY_PARAM_PRIV_KEY */
309	0	if (ossl_unlikely(r->key != NULL)) {
310	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
311	0	"param %s is repeated", s);
312	0	return 0;
313	0	}
314	0	r->key = (OSSL_PARAM *)p;
315	0	}
316	0	return 1;
317	0	}
318		#endif
319		/* End of machine generated */
320
321		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
322		#ifndef cmac_gen_set_params_list
323		static const OSSL_PARAM cmac_gen_set_params_list[] = {
324		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
325		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
326		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
327		OSSL_PARAM_END
328		};
329		#endif
330
331		#ifndef cmac_gen_set_params_st
332		struct cmac_gen_set_params_st {
333		OSSL_PARAM *cipher;
334		OSSL_PARAM *key;
335		OSSL_PARAM *propq;
336		};
337		#endif
338
339		#ifndef cmac_gen_set_params_decoder
340		static int cmac_gen_set_params_decoder
341		(const OSSL_PARAM p, struct cmac_gen_set_params_st r)
342	0	{
343	0	const char *s;
344
345	0	memset(r, 0, sizeof(*r));
346	0	if (p != NULL)
347	0	for (; (s = p->key) != NULL; p++)
348	0	switch(s[0]) {
349	0	default:
350	0	break;
351	0	case 'c':
352	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
353		/* OSSL_PKEY_PARAM_CIPHER */
354	0	if (ossl_unlikely(r->cipher != NULL)) {
355	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
356	0	"param %s is repeated", s);
357	0	return 0;
358	0	}
359	0	r->cipher = (OSSL_PARAM *)p;
360	0	}
361	0	break;
362	0	case 'p':
363	0	switch(s[1]) {
364	0	default:
365	0	break;
366	0	case 'r':
367	0	switch(s[2]) {
368	0	default:
369	0	break;
370	0	case 'i':
371	0	if (ossl_likely(strcmp("v", s + 3) == 0)) {
372		/* OSSL_PKEY_PARAM_PRIV_KEY */
373	0	if (ossl_unlikely(r->key != NULL)) {
374	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
375	0	"param %s is repeated", s);
376	0	return 0;
377	0	}
378	0	r->key = (OSSL_PARAM *)p;
379	0	}
380	0	break;
381	0	case 'o':
382	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
383		/* OSSL_PKEY_PARAM_PROPERTIES */
384	0	if (ossl_unlikely(r->propq != NULL)) {
385	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
386	0	"param %s is repeated", s);
387	0	return 0;
388	0	}
389	0	r->propq = (OSSL_PARAM *)p;
390	0	}
391	0	}
392	0	}
393	0	}
394	0	return 1;
395	0	}
396		#endif
397		/* End of machine generated */