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

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