/src/openssl41/providers/implementations/signature/sm2_sig.inc

Source
/*
 * Copyright 2025-2026 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 sm2sig_get_ctx_params_list
static ossl_unused const OSSL_PARAM sm2sig_get_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
    OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
    OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef sm2sig_get_ctx_params_st
struct sm2sig_get_ctx_params_st {
    OSSL_PARAM *algid;
    OSSL_PARAM *digest;
    OSSL_PARAM *size;
};
#endif

#ifndef sm2sig_get_ctx_params_decoder
static ossl_unused int sm2sig_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct sm2sig_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'a':
                if (ossl_likely(strcmp("lgorithm-id", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_ALGORITHM_ID */
                    if (ossl_unlikely(r->algid != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->algid = (OSSL_PARAM *)p;
                }
                break;
            case 'd':
                switch(s[1]) {
                default:
                    break;
                case 'i':
                    switch(s[2]) {
                    default:
                        break;
                    case 'g':
                        switch(s[3]) {
                        default:
                            break;
                        case 'e':
                            switch(s[4]) {
                            default:
                                break;
                            case 's':
                                switch(s[5]) {
                                default:
                                    break;
                                case 't':
                                    switch(s[6]) {
                                    default:
                                        break;
                                    case '-':
                                        if (ossl_likely(strcmp("size", s + 7) == 0)) {
                                            /* OSSL_SIGNATURE_PARAM_DIGEST_SIZE */
                                            if (ossl_unlikely(r->size != NULL)) {
                                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                               "param %s is repeated", s);
                                                return 0;
                                            }
                                            r->size = (OSSL_PARAM *)p;
                                        }
                                        break;
                                    case '\0':
                                        if (ossl_unlikely(r->digest != NULL)) {
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                           "param %s is repeated", s);
                                            return 0;
                                        }
                                        r->digest = (OSSL_PARAM *)p;
                                    }
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef sm2sig_set_ctx_params_list
static ossl_unused const OSSL_PARAM sm2sig_set_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
    OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_DIST_ID, NULL, 0),
    OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_TLS_VERSION, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef sm2sig_set_ctx_params_st
struct sm2sig_set_ctx_params_st {
    OSSL_PARAM *digest;
    OSSL_PARAM *distid;
    OSSL_PARAM *size;
    OSSL_PARAM *tlsver;
};
#endif

#ifndef sm2sig_set_ctx_params_decoder
static ossl_unused int sm2sig_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct sm2sig_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'd':
                switch(s[1]) {
                default:
                    break;
                case 'i':
                    switch(s[2]) {
                    default:
                        break;
                    case 'g':
                        switch(s[3]) {
                        default:
                            break;
                        case 'e':
                            switch(s[4]) {
                            default:
                                break;
                            case 's':
                                switch(s[5]) {
                                default:
                                    break;
                                case 't':
                                    switch(s[6]) {
                                    default:
                                        break;
                                    case '-':
                                        if (ossl_likely(strcmp("size", s + 7) == 0)) {
                                            /* OSSL_SIGNATURE_PARAM_DIGEST_SIZE */
                                            if (ossl_unlikely(r->size != NULL)) {
                                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                               "param %s is repeated", s);
                                                return 0;
                                            }
                                            r->size = (OSSL_PARAM *)p;
                                        }
                                        break;
                                    case '\0':
                                        if (ossl_unlikely(r->digest != NULL)) {
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                           "param %s is repeated", s);
                                            return 0;
                                        }
                                        r->digest = (OSSL_PARAM *)p;
                                    }
                                }
                            }
                        }
                        break;
                    case 's':
                        if (ossl_likely(strcmp("tid", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_DIST_ID */
                            if (ossl_unlikely(r->distid != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->distid = (OSSL_PARAM *)p;
                        }
                    }
                }
                break;
            case 't':
                if (ossl_likely(strcmp("ls-version", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_TLS_VERSION */
                    if (ossl_unlikely(r->tlsver != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->tlsver = (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-2026 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 sm2sig_get_ctx_params_list
21		static ossl_unused const OSSL_PARAM sm2sig_get_ctx_params_list[] = {
22		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
23		OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
24		OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
25		OSSL_PARAM_END
26		};
27		#endif
28
29		#ifndef sm2sig_get_ctx_params_st
30		struct sm2sig_get_ctx_params_st {
31		OSSL_PARAM *algid;
32		OSSL_PARAM *digest;
33		OSSL_PARAM *size;
34		};
35		#endif
36
37		#ifndef sm2sig_get_ctx_params_decoder
38		static ossl_unused int sm2sig_get_ctx_params_decoder
39		(const OSSL_PARAM p, struct sm2sig_get_ctx_params_st r)
40	0	{
41	0	const char *s;
42
43	0	memset(r, 0, sizeof(*r));
44	0	if (p != NULL)
45	0	for (; (s = p->key) != NULL; p++)
46	0	switch(s[0]) {
47	0	default:
48	0	break;
49	0	case 'a':
50	0	if (ossl_likely(strcmp("lgorithm-id", s + 1) == 0)) {
51		/* OSSL_SIGNATURE_PARAM_ALGORITHM_ID */
52	0	if (ossl_unlikely(r->algid != NULL)) {
53	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
54	0	"param %s is repeated", s);
55	0	return 0;
56	0	}
57	0	r->algid = (OSSL_PARAM *)p;
58	0	}
59	0	break;
60	0	case 'd':
61	0	switch(s[1]) {
62	0	default:
63	0	break;
64	0	case 'i':
65	0	switch(s[2]) {
66	0	default:
67	0	break;
68	0	case 'g':
69	0	switch(s[3]) {
70	0	default:
71	0	break;
72	0	case 'e':
73	0	switch(s[4]) {
74	0	default:
75	0	break;
76	0	case 's':
77	0	switch(s[5]) {
78	0	default:
79	0	break;
80	0	case 't':
81	0	switch(s[6]) {
82	0	default:
83	0	break;
84	0	case '-':
85	0	if (ossl_likely(strcmp("size", s + 7) == 0)) {
86		/* OSSL_SIGNATURE_PARAM_DIGEST_SIZE */
87	0	if (ossl_unlikely(r->size != NULL)) {
88	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
89	0	"param %s is repeated", s);
90	0	return 0;
91	0	}
92	0	r->size = (OSSL_PARAM *)p;
93	0	}
94	0	break;
95	0	case '\0':
96	0	if (ossl_unlikely(r->digest != NULL)) {
97	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
98	0	"param %s is repeated", s);
99	0	return 0;
100	0	}
101	0	r->digest = (OSSL_PARAM *)p;
102	0	}
103	0	}
104	0	}
105	0	}
106	0	}
107	0	}
108	0	}
109	0	return 1;
110	0	}
111		#endif
112		/* End of machine generated */
113
114		/* Machine generated */
115		#ifndef sm2sig_set_ctx_params_list
116		static ossl_unused const OSSL_PARAM sm2sig_set_ctx_params_list[] = {
117		OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
118		OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
119		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_DIST_ID, NULL, 0),
120		OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_TLS_VERSION, NULL),
121		OSSL_PARAM_END
122		};
123		#endif
124
125		#ifndef sm2sig_set_ctx_params_st
126		struct sm2sig_set_ctx_params_st {
127		OSSL_PARAM *digest;
128		OSSL_PARAM *distid;
129		OSSL_PARAM *size;
130		OSSL_PARAM *tlsver;
131		};
132		#endif
133
134		#ifndef sm2sig_set_ctx_params_decoder
135		static ossl_unused int sm2sig_set_ctx_params_decoder
136		(const OSSL_PARAM p, struct sm2sig_set_ctx_params_st r)
137	0	{
138	0	const char *s;
139
140	0	memset(r, 0, sizeof(*r));
141	0	if (p != NULL)
142	0	for (; (s = p->key) != NULL; p++)
143	0	switch(s[0]) {
144	0	default:
145	0	break;
146	0	case 'd':
147	0	switch(s[1]) {
148	0	default:
149	0	break;
150	0	case 'i':
151	0	switch(s[2]) {
152	0	default:
153	0	break;
154	0	case 'g':
155	0	switch(s[3]) {
156	0	default:
157	0	break;
158	0	case 'e':
159	0	switch(s[4]) {
160	0	default:
161	0	break;
162	0	case 's':
163	0	switch(s[5]) {
164	0	default:
165	0	break;
166	0	case 't':
167	0	switch(s[6]) {
168	0	default:
169	0	break;
170	0	case '-':
171	0	if (ossl_likely(strcmp("size", s + 7) == 0)) {
172		/* OSSL_SIGNATURE_PARAM_DIGEST_SIZE */
173	0	if (ossl_unlikely(r->size != NULL)) {
174	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
175	0	"param %s is repeated", s);
176	0	return 0;
177	0	}
178	0	r->size = (OSSL_PARAM *)p;
179	0	}
180	0	break;
181	0	case '\0':
182	0	if (ossl_unlikely(r->digest != NULL)) {
183	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
184	0	"param %s is repeated", s);
185	0	return 0;
186	0	}
187	0	r->digest = (OSSL_PARAM *)p;
188	0	}
189	0	}
190	0	}
191	0	}
192	0	break;
193	0	case 's':
194	0	if (ossl_likely(strcmp("tid", s + 3) == 0)) {
195		/* OSSL_PKEY_PARAM_DIST_ID */
196	0	if (ossl_unlikely(r->distid != NULL)) {
197	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
198	0	"param %s is repeated", s);
199	0	return 0;
200	0	}
201	0	r->distid = (OSSL_PARAM *)p;
202	0	}
203	0	}
204	0	}
205	0	break;
206	0	case 't':
207	0	if (ossl_likely(strcmp("ls-version", s + 1) == 0)) {
208		/* OSSL_SIGNATURE_PARAM_TLS_VERSION */
209	0	if (ossl_unlikely(r->tlsver != NULL)) {
210	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
211	0	"param %s is repeated", s);
212	0	return 0;
213	0	}
214	0	r->tlsver = (OSSL_PARAM *)p;
215	0	}
216	0	}
217	0	return 1;
218	0	}
219		#endif
220		/* End of machine generated */