/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 *engine;
    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 'e':
                if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ENGINE */
                    if (ossl_unlikely(r->engine != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->engine = (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 *engine;
    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 'e':
                if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ENGINE */
                    if (ossl_unlikely(r->engine != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->engine = (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 *engine;
    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 'e':
                if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ENGINE */
                    if (ossl_unlikely(r->engine != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->engine = (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-11-07 06:58

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 *engine;
91		OSSL_PARAM *key;
92		OSSL_PARAM *propq;
93		};
94		#endif
95
96		#ifndef cmac_import_decoder
97		static int cmac_import_decoder
98		(const OSSL_PARAM p, struct cmac_import_st r)
99	0	{
100	0	const char *s;
101
102	0	memset(r, 0, sizeof(*r));
103	0	if (p != NULL)
104	0	for (; (s = p->key) != NULL; p++)
105	0	switch(s[0]) {
106	0	default:
107	0	break;
108	0	case 'c':
109	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
110		/* OSSL_PKEY_PARAM_CIPHER */
111	0	if (ossl_unlikely(r->cipher != NULL)) {
112	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
113	0	"param %s is repeated", s);
114	0	return 0;
115	0	}
116	0	r->cipher = (OSSL_PARAM *)p;
117	0	}
118	0	break;
119	0	case 'e':
120	0	if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
121		/* OSSL_PKEY_PARAM_ENGINE */
122	0	if (ossl_unlikely(r->engine != NULL)) {
123	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
124	0	"param %s is repeated", s);
125	0	return 0;
126	0	}
127	0	r->engine = (OSSL_PARAM *)p;
128	0	}
129	0	break;
130	0	case 'p':
131	0	switch(s[1]) {
132	0	default:
133	0	break;
134	0	case 'r':
135	0	switch(s[2]) {
136	0	default:
137	0	break;
138	0	case 'i':
139	0	if (ossl_likely(strcmp("v", s + 3) == 0)) {
140		/* OSSL_PKEY_PARAM_PRIV_KEY */
141	0	if (ossl_unlikely(r->key != NULL)) {
142	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
143	0	"param %s is repeated", s);
144	0	return 0;
145	0	}
146	0	r->key = (OSSL_PARAM *)p;
147	0	}
148	0	break;
149	0	case 'o':
150	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
151		/* OSSL_PKEY_PARAM_PROPERTIES */
152	0	if (ossl_unlikely(r->propq != NULL)) {
153	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
154	0	"param %s is repeated", s);
155	0	return 0;
156	0	}
157	0	r->propq = (OSSL_PARAM *)p;
158	0	}
159	0	}
160	0	}
161	0	}
162	0	return 1;
163	0	}
164		#endif
165		/* End of machine generated */
166
167		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
168		#ifndef mac_get_params_list
169		static const OSSL_PARAM mac_get_params_list[] = {
170		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
171		OSSL_PARAM_END
172		};
173		#endif
174
175		#ifndef mac_get_params_st
176		struct mac_get_params_st {
177		OSSL_PARAM *key;
178		};
179		#endif
180
181		#ifndef mac_get_params_decoder
182		static int mac_get_params_decoder
183		(const OSSL_PARAM p, struct mac_get_params_st r)
184	0	{
185	0	const char *s;
186
187	0	memset(r, 0, sizeof(*r));
188	0	if (p != NULL)
189	0	for (; (s = p->key) != NULL; p++)
190	0	if (ossl_likely(strcmp("priv", s + 0) == 0)) {
191		/* OSSL_PKEY_PARAM_PRIV_KEY */
192	0	if (ossl_unlikely(r->key != NULL)) {
193	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
194	0	"param %s is repeated", s);
195	0	return 0;
196	0	}
197	0	r->key = (OSSL_PARAM *)p;
198	0	}
199	0	return 1;
200	0	}
201		#endif
202		/* End of machine generated */
203
204		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
205		#ifndef cmac_get_params_list
206		static const OSSL_PARAM cmac_get_params_list[] = {
207		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
208		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
209		OSSL_PARAM_END
210		};
211		#endif
212
213		#ifndef cmac_get_params_st
214		struct cmac_get_params_st {
215		OSSL_PARAM *cipher;
216		OSSL_PARAM *engine;
217		OSSL_PARAM *key;
218		};
219		#endif
220
221		#ifndef cmac_get_params_decoder
222		static int cmac_get_params_decoder
223		(const OSSL_PARAM p, struct cmac_get_params_st r)
224	0	{
225	0	const char *s;
226
227	0	memset(r, 0, sizeof(*r));
228	0	if (p != NULL)
229	0	for (; (s = p->key) != NULL; p++)
230	0	switch(s[0]) {
231	0	default:
232	0	break;
233	0	case 'c':
234	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
235		/* OSSL_PKEY_PARAM_CIPHER */
236	0	if (ossl_unlikely(r->cipher != NULL)) {
237	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
238	0	"param %s is repeated", s);
239	0	return 0;
240	0	}
241	0	r->cipher = (OSSL_PARAM *)p;
242	0	}
243	0	break;
244	0	case 'e':
245	0	if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
246		/* OSSL_PKEY_PARAM_ENGINE */
247	0	if (ossl_unlikely(r->engine != NULL)) {
248	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
249	0	"param %s is repeated", s);
250	0	return 0;
251	0	}
252	0	r->engine = (OSSL_PARAM *)p;
253	0	}
254	0	break;
255	0	case 'p':
256	0	if (ossl_likely(strcmp("riv", s + 1) == 0)) {
257		/* OSSL_PKEY_PARAM_PRIV_KEY */
258	0	if (ossl_unlikely(r->key != NULL)) {
259	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
260	0	"param %s is repeated", s);
261	0	return 0;
262	0	}
263	0	r->key = (OSSL_PARAM *)p;
264	0	}
265	0	}
266	0	return 1;
267	0	}
268		#endif
269		/* End of machine generated */
270
271		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
272		#ifndef mac_set_params_list
273		static const OSSL_PARAM mac_set_params_list[] = {
274		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
275		OSSL_PARAM_END
276		};
277		#endif
278
279		#ifndef mac_set_params_st
280		struct mac_set_params_st {
281		OSSL_PARAM *key;
282		};
283		#endif
284
285		#ifndef mac_set_params_decoder
286		static int mac_set_params_decoder
287		(const OSSL_PARAM p, struct mac_set_params_st r)
288	0	{
289	0	const char *s;
290
291	0	memset(r, 0, sizeof(*r));
292	0	if (p != NULL)
293	0	for (; (s = p->key) != NULL; p++)
294	0	if (ossl_likely(strcmp("priv", s + 0) == 0)) {
295		/* OSSL_PKEY_PARAM_PRIV_KEY */
296	0	if (ossl_unlikely(r->key != NULL)) {
297	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
298	0	"param %s is repeated", s);
299	0	return 0;
300	0	}
301	0	r->key = (OSSL_PARAM *)p;
302	0	}
303	0	return 1;
304	0	}
305		#endif
306		/* End of machine generated */
307
308		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
309		#ifndef mac_gen_set_params_list
310		static const OSSL_PARAM mac_gen_set_params_list[] = {
311		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
312		OSSL_PARAM_END
313		};
314		#endif
315
316		#ifndef mac_gen_set_params_st
317		struct mac_gen_set_params_st {
318		OSSL_PARAM *key;
319		};
320		#endif
321
322		#ifndef mac_gen_set_params_decoder
323		static int mac_gen_set_params_decoder
324		(const OSSL_PARAM p, struct mac_gen_set_params_st r)
325	0	{
326	0	const char *s;
327
328	0	memset(r, 0, sizeof(*r));
329	0	if (p != NULL)
330	0	for (; (s = p->key) != NULL; p++)
331	0	if (ossl_likely(strcmp("priv", s + 0) == 0)) {
332		/* OSSL_PKEY_PARAM_PRIV_KEY */
333	0	if (ossl_unlikely(r->key != NULL)) {
334	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
335	0	"param %s is repeated", s);
336	0	return 0;
337	0	}
338	0	r->key = (OSSL_PARAM *)p;
339	0	}
340	0	return 1;
341	0	}
342		#endif
343		/* End of machine generated */
344
345		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
346		#ifndef cmac_gen_set_params_list
347		static const OSSL_PARAM cmac_gen_set_params_list[] = {
348		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
349		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_CIPHER, NULL, 0),
350		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
351		OSSL_PARAM_END
352		};
353		#endif
354
355		#ifndef cmac_gen_set_params_st
356		struct cmac_gen_set_params_st {
357		OSSL_PARAM *cipher;
358		OSSL_PARAM *engine;
359		OSSL_PARAM *key;
360		OSSL_PARAM *propq;
361		};
362		#endif
363
364		#ifndef cmac_gen_set_params_decoder
365		static int cmac_gen_set_params_decoder
366		(const OSSL_PARAM p, struct cmac_gen_set_params_st r)
367	0	{
368	0	const char *s;
369
370	0	memset(r, 0, sizeof(*r));
371	0	if (p != NULL)
372	0	for (; (s = p->key) != NULL; p++)
373	0	switch(s[0]) {
374	0	default:
375	0	break;
376	0	case 'c':
377	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
378		/* OSSL_PKEY_PARAM_CIPHER */
379	0	if (ossl_unlikely(r->cipher != NULL)) {
380	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
381	0	"param %s is repeated", s);
382	0	return 0;
383	0	}
384	0	r->cipher = (OSSL_PARAM *)p;
385	0	}
386	0	break;
387	0	case 'e':
388	0	if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
389		/* OSSL_PKEY_PARAM_ENGINE */
390	0	if (ossl_unlikely(r->engine != NULL)) {
391	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
392	0	"param %s is repeated", s);
393	0	return 0;
394	0	}
395	0	r->engine = (OSSL_PARAM *)p;
396	0	}
397	0	break;
398	0	case 'p':
399	0	switch(s[1]) {
400	0	default:
401	0	break;
402	0	case 'r':
403	0	switch(s[2]) {
404	0	default:
405	0	break;
406	0	case 'i':
407	0	if (ossl_likely(strcmp("v", s + 3) == 0)) {
408		/* OSSL_PKEY_PARAM_PRIV_KEY */
409	0	if (ossl_unlikely(r->key != NULL)) {
410	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
411	0	"param %s is repeated", s);
412	0	return 0;
413	0	}
414	0	r->key = (OSSL_PARAM *)p;
415	0	}
416	0	break;
417	0	case 'o':
418	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
419		/* OSSL_PKEY_PARAM_PROPERTIES */
420	0	if (ossl_unlikely(r->propq != NULL)) {
421	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
422	0	"param %s is repeated", s);
423	0	return 0;
424	0	}
425	0	r->propq = (OSSL_PARAM *)p;
426	0	}
427	0	}
428	0	}
429	0	}
430	0	return 1;
431	0	}
432		#endif
433		/* End of machine generated */