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

#ifndef sm2sig_get_ctx_params_list
static 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 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 by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#ifndef sm2sig_set_ctx_params_list
static 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 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-05-20 07:05

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