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

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

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

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

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

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

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

#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: 2026-05-30 06:06

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