1 /*
2 * Query Mbed TLS compile time configurations from mbedtls_config.h
3 *
4 * Copyright The Mbed TLS Contributors
5 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #include "mbedtls/build_info.h"
21
22 #include "query_config.h"
23
24 #if defined(MBEDTLS_PLATFORM_C)
25 #include "mbedtls/platform.h"
26 #else
27 #include <stdio.h>
28 #define mbedtls_printf printf
29 #endif /* MBEDTLS_PLATFORM_C */
30
31 /*
32 * Include all the headers with public APIs in case they define a macro to its
33 * default value when that configuration is not set in the mbedtls_config.h.
34 */
35 #include "mbedtls/aes.h"
36 #include "mbedtls/aria.h"
37 #include "mbedtls/asn1.h"
38 #include "mbedtls/asn1write.h"
39 #include "mbedtls/base64.h"
40 #include "mbedtls/bignum.h"
41 #include "mbedtls/camellia.h"
42 #include "mbedtls/ccm.h"
43 #include "mbedtls/chacha20.h"
44 #include "mbedtls/chachapoly.h"
45 #include "mbedtls/cipher.h"
46 #include "mbedtls/cmac.h"
47 #include "mbedtls/ctr_drbg.h"
48 #include "mbedtls/debug.h"
49 #include "mbedtls/des.h"
50 #include "mbedtls/dhm.h"
51 #include "mbedtls/ecdh.h"
52 #include "mbedtls/ecdsa.h"
53 #include "mbedtls/ecjpake.h"
54 #include "mbedtls/ecp.h"
55 #include "mbedtls/entropy.h"
56 #include "mbedtls/error.h"
57 #include "mbedtls/gcm.h"
58 #include "mbedtls/hkdf.h"
59 #include "mbedtls/hmac_drbg.h"
60 #include "mbedtls/md.h"
61 #include "mbedtls/md5.h"
62 #include "mbedtls/memory_buffer_alloc.h"
63 #include "mbedtls/net_sockets.h"
64 #include "mbedtls/nist_kw.h"
65 #include "mbedtls/oid.h"
66 #include "mbedtls/pem.h"
67 #include "mbedtls/pk.h"
68 #include "mbedtls/pkcs12.h"
69 #include "mbedtls/pkcs5.h"
70 #include "mbedtls/platform_time.h"
71 #include "mbedtls/platform_util.h"
72 #include "mbedtls/poly1305.h"
73 #include "mbedtls/ripemd160.h"
74 #include "mbedtls/rsa.h"
75 #include "mbedtls/sha1.h"
76 #include "mbedtls/sha256.h"
77 #include "mbedtls/sha512.h"
78 #include "mbedtls/ssl.h"
79 #include "mbedtls/ssl_cache.h"
80 #include "mbedtls/ssl_ciphersuites.h"
81 #include "mbedtls/ssl_cookie.h"
82 #include "mbedtls/ssl_ticket.h"
83 #include "mbedtls/threading.h"
84 #include "mbedtls/timing.h"
85 #include "mbedtls/version.h"
86 #include "mbedtls/x509.h"
87 #include "mbedtls/x509_crl.h"
88 #include "mbedtls/x509_crt.h"
89 #include "mbedtls/x509_csr.h"
90
91 #include <string.h>
92
93 /*
94 * Helper macros to convert a macro or its expansion into a string
95 * WARNING: This does not work for expanding function-like macros. However,
96 * Mbed TLS does not currently have configuration options used in this fashion.
97 */
98 #define MACRO_EXPANSION_TO_STR(macro) MACRO_NAME_TO_STR(macro)
99 #define MACRO_NAME_TO_STR(macro) \
100 mbedtls_printf( "%s", strlen( #macro "" ) > 0 ? #macro "\n" : "" )
101
102 #define STRINGIFY(macro) #macro
103 #define OUTPUT_MACRO_NAME_VALUE(macro) mbedtls_printf( #macro "%s\n", \
104 ( STRINGIFY(macro) "" )[0] != 0 ? "=" STRINGIFY(macro) : "" )
105
106 #if defined(_MSC_VER)
107 /*
108 * Visual Studio throws the warning 4003 because many Mbed TLS feature macros
109 * are defined empty. This means that from the preprocessor's point of view
110 * the macro MBEDTLS_EXPANSION_TO_STR is being invoked without arguments as
111 * some macros expand to nothing. We suppress that specific warning to get a
112 * clean build and to ensure that tests treating warnings as errors do not
113 * fail.
114 */
115 #pragma warning(push)
116 #pragma warning(disable:4003)
117 #endif /* _MSC_VER */
118
query_config(const char * config)119 int query_config( const char *config )
120 {
121 #if defined(MBEDTLS_CONFIG_VERSION)
122 if( strcmp( "MBEDTLS_CONFIG_VERSION", config ) == 0 )
123 {
124 MACRO_EXPANSION_TO_STR( MBEDTLS_CONFIG_VERSION );
125 return( 0 );
126 }
127 #endif /* MBEDTLS_CONFIG_VERSION */
128
129 #if defined(MBEDTLS_HAVE_ASM)
130 if( strcmp( "MBEDTLS_HAVE_ASM", config ) == 0 )
131 {
132 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_ASM );
133 return( 0 );
134 }
135 #endif /* MBEDTLS_HAVE_ASM */
136
137 #if defined(MBEDTLS_NO_UDBL_DIVISION)
138 if( strcmp( "MBEDTLS_NO_UDBL_DIVISION", config ) == 0 )
139 {
140 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_UDBL_DIVISION );
141 return( 0 );
142 }
143 #endif /* MBEDTLS_NO_UDBL_DIVISION */
144
145 #if defined(MBEDTLS_NO_64BIT_MULTIPLICATION)
146 if( strcmp( "MBEDTLS_NO_64BIT_MULTIPLICATION", config ) == 0 )
147 {
148 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_64BIT_MULTIPLICATION );
149 return( 0 );
150 }
151 #endif /* MBEDTLS_NO_64BIT_MULTIPLICATION */
152
153 #if defined(MBEDTLS_HAVE_SSE2)
154 if( strcmp( "MBEDTLS_HAVE_SSE2", config ) == 0 )
155 {
156 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_SSE2 );
157 return( 0 );
158 }
159 #endif /* MBEDTLS_HAVE_SSE2 */
160
161 #if defined(MBEDTLS_HAVE_TIME)
162 if( strcmp( "MBEDTLS_HAVE_TIME", config ) == 0 )
163 {
164 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_TIME );
165 return( 0 );
166 }
167 #endif /* MBEDTLS_HAVE_TIME */
168
169 #if defined(MBEDTLS_HAVE_TIME_DATE)
170 if( strcmp( "MBEDTLS_HAVE_TIME_DATE", config ) == 0 )
171 {
172 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_TIME_DATE );
173 return( 0 );
174 }
175 #endif /* MBEDTLS_HAVE_TIME_DATE */
176
177 #if defined(MBEDTLS_PLATFORM_MEMORY)
178 if( strcmp( "MBEDTLS_PLATFORM_MEMORY", config ) == 0 )
179 {
180 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_MEMORY );
181 return( 0 );
182 }
183 #endif /* MBEDTLS_PLATFORM_MEMORY */
184
185 #if defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
186 if( strcmp( "MBEDTLS_PLATFORM_NO_STD_FUNCTIONS", config ) == 0 )
187 {
188 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NO_STD_FUNCTIONS );
189 return( 0 );
190 }
191 #endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
192
193 #if defined(MBEDTLS_PLATFORM_EXIT_ALT)
194 if( strcmp( "MBEDTLS_PLATFORM_EXIT_ALT", config ) == 0 )
195 {
196 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_EXIT_ALT );
197 return( 0 );
198 }
199 #endif /* MBEDTLS_PLATFORM_EXIT_ALT */
200
201 #if defined(MBEDTLS_PLATFORM_TIME_ALT)
202 if( strcmp( "MBEDTLS_PLATFORM_TIME_ALT", config ) == 0 )
203 {
204 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_TIME_ALT );
205 return( 0 );
206 }
207 #endif /* MBEDTLS_PLATFORM_TIME_ALT */
208
209 #if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
210 if( strcmp( "MBEDTLS_PLATFORM_FPRINTF_ALT", config ) == 0 )
211 {
212 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_FPRINTF_ALT );
213 return( 0 );
214 }
215 #endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
216
217 #if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
218 if( strcmp( "MBEDTLS_PLATFORM_PRINTF_ALT", config ) == 0 )
219 {
220 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_PRINTF_ALT );
221 return( 0 );
222 }
223 #endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
224
225 #if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
226 if( strcmp( "MBEDTLS_PLATFORM_SNPRINTF_ALT", config ) == 0 )
227 {
228 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_SNPRINTF_ALT );
229 return( 0 );
230 }
231 #endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
232
233 #if defined(MBEDTLS_PLATFORM_VSNPRINTF_ALT)
234 if( strcmp( "MBEDTLS_PLATFORM_VSNPRINTF_ALT", config ) == 0 )
235 {
236 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_VSNPRINTF_ALT );
237 return( 0 );
238 }
239 #endif /* MBEDTLS_PLATFORM_VSNPRINTF_ALT */
240
241 #if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
242 if( strcmp( "MBEDTLS_PLATFORM_NV_SEED_ALT", config ) == 0 )
243 {
244 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NV_SEED_ALT );
245 return( 0 );
246 }
247 #endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
248
249 #if defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)
250 if( strcmp( "MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT", config ) == 0 )
251 {
252 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT );
253 return( 0 );
254 }
255 #endif /* MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */
256
257 #if defined(MBEDTLS_DEPRECATED_WARNING)
258 if( strcmp( "MBEDTLS_DEPRECATED_WARNING", config ) == 0 )
259 {
260 MACRO_EXPANSION_TO_STR( MBEDTLS_DEPRECATED_WARNING );
261 return( 0 );
262 }
263 #endif /* MBEDTLS_DEPRECATED_WARNING */
264
265 #if defined(MBEDTLS_DEPRECATED_REMOVED)
266 if( strcmp( "MBEDTLS_DEPRECATED_REMOVED", config ) == 0 )
267 {
268 MACRO_EXPANSION_TO_STR( MBEDTLS_DEPRECATED_REMOVED );
269 return( 0 );
270 }
271 #endif /* MBEDTLS_DEPRECATED_REMOVED */
272
273 #if defined(MBEDTLS_TIMING_ALT)
274 if( strcmp( "MBEDTLS_TIMING_ALT", config ) == 0 )
275 {
276 MACRO_EXPANSION_TO_STR( MBEDTLS_TIMING_ALT );
277 return( 0 );
278 }
279 #endif /* MBEDTLS_TIMING_ALT */
280
281 #if defined(MBEDTLS_AES_ALT)
282 if( strcmp( "MBEDTLS_AES_ALT", config ) == 0 )
283 {
284 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_ALT );
285 return( 0 );
286 }
287 #endif /* MBEDTLS_AES_ALT */
288
289 #if defined(MBEDTLS_ARIA_ALT)
290 if( strcmp( "MBEDTLS_ARIA_ALT", config ) == 0 )
291 {
292 MACRO_EXPANSION_TO_STR( MBEDTLS_ARIA_ALT );
293 return( 0 );
294 }
295 #endif /* MBEDTLS_ARIA_ALT */
296
297 #if defined(MBEDTLS_CAMELLIA_ALT)
298 if( strcmp( "MBEDTLS_CAMELLIA_ALT", config ) == 0 )
299 {
300 MACRO_EXPANSION_TO_STR( MBEDTLS_CAMELLIA_ALT );
301 return( 0 );
302 }
303 #endif /* MBEDTLS_CAMELLIA_ALT */
304
305 #if defined(MBEDTLS_CCM_ALT)
306 if( strcmp( "MBEDTLS_CCM_ALT", config ) == 0 )
307 {
308 MACRO_EXPANSION_TO_STR( MBEDTLS_CCM_ALT );
309 return( 0 );
310 }
311 #endif /* MBEDTLS_CCM_ALT */
312
313 #if defined(MBEDTLS_CHACHA20_ALT)
314 if( strcmp( "MBEDTLS_CHACHA20_ALT", config ) == 0 )
315 {
316 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHA20_ALT );
317 return( 0 );
318 }
319 #endif /* MBEDTLS_CHACHA20_ALT */
320
321 #if defined(MBEDTLS_CHACHAPOLY_ALT)
322 if( strcmp( "MBEDTLS_CHACHAPOLY_ALT", config ) == 0 )
323 {
324 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHAPOLY_ALT );
325 return( 0 );
326 }
327 #endif /* MBEDTLS_CHACHAPOLY_ALT */
328
329 #if defined(MBEDTLS_CMAC_ALT)
330 if( strcmp( "MBEDTLS_CMAC_ALT", config ) == 0 )
331 {
332 MACRO_EXPANSION_TO_STR( MBEDTLS_CMAC_ALT );
333 return( 0 );
334 }
335 #endif /* MBEDTLS_CMAC_ALT */
336
337 #if defined(MBEDTLS_DES_ALT)
338 if( strcmp( "MBEDTLS_DES_ALT", config ) == 0 )
339 {
340 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_ALT );
341 return( 0 );
342 }
343 #endif /* MBEDTLS_DES_ALT */
344
345 #if defined(MBEDTLS_DHM_ALT)
346 if( strcmp( "MBEDTLS_DHM_ALT", config ) == 0 )
347 {
348 MACRO_EXPANSION_TO_STR( MBEDTLS_DHM_ALT );
349 return( 0 );
350 }
351 #endif /* MBEDTLS_DHM_ALT */
352
353 #if defined(MBEDTLS_ECJPAKE_ALT)
354 if( strcmp( "MBEDTLS_ECJPAKE_ALT", config ) == 0 )
355 {
356 MACRO_EXPANSION_TO_STR( MBEDTLS_ECJPAKE_ALT );
357 return( 0 );
358 }
359 #endif /* MBEDTLS_ECJPAKE_ALT */
360
361 #if defined(MBEDTLS_GCM_ALT)
362 if( strcmp( "MBEDTLS_GCM_ALT", config ) == 0 )
363 {
364 MACRO_EXPANSION_TO_STR( MBEDTLS_GCM_ALT );
365 return( 0 );
366 }
367 #endif /* MBEDTLS_GCM_ALT */
368
369 #if defined(MBEDTLS_NIST_KW_ALT)
370 if( strcmp( "MBEDTLS_NIST_KW_ALT", config ) == 0 )
371 {
372 MACRO_EXPANSION_TO_STR( MBEDTLS_NIST_KW_ALT );
373 return( 0 );
374 }
375 #endif /* MBEDTLS_NIST_KW_ALT */
376
377 #if defined(MBEDTLS_MD5_ALT)
378 if( strcmp( "MBEDTLS_MD5_ALT", config ) == 0 )
379 {
380 MACRO_EXPANSION_TO_STR( MBEDTLS_MD5_ALT );
381 return( 0 );
382 }
383 #endif /* MBEDTLS_MD5_ALT */
384
385 #if defined(MBEDTLS_POLY1305_ALT)
386 if( strcmp( "MBEDTLS_POLY1305_ALT", config ) == 0 )
387 {
388 MACRO_EXPANSION_TO_STR( MBEDTLS_POLY1305_ALT );
389 return( 0 );
390 }
391 #endif /* MBEDTLS_POLY1305_ALT */
392
393 #if defined(MBEDTLS_RIPEMD160_ALT)
394 if( strcmp( "MBEDTLS_RIPEMD160_ALT", config ) == 0 )
395 {
396 MACRO_EXPANSION_TO_STR( MBEDTLS_RIPEMD160_ALT );
397 return( 0 );
398 }
399 #endif /* MBEDTLS_RIPEMD160_ALT */
400
401 #if defined(MBEDTLS_RSA_ALT)
402 if( strcmp( "MBEDTLS_RSA_ALT", config ) == 0 )
403 {
404 MACRO_EXPANSION_TO_STR( MBEDTLS_RSA_ALT );
405 return( 0 );
406 }
407 #endif /* MBEDTLS_RSA_ALT */
408
409 #if defined(MBEDTLS_SHA1_ALT)
410 if( strcmp( "MBEDTLS_SHA1_ALT", config ) == 0 )
411 {
412 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA1_ALT );
413 return( 0 );
414 }
415 #endif /* MBEDTLS_SHA1_ALT */
416
417 #if defined(MBEDTLS_SHA256_ALT)
418 if( strcmp( "MBEDTLS_SHA256_ALT", config ) == 0 )
419 {
420 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_ALT );
421 return( 0 );
422 }
423 #endif /* MBEDTLS_SHA256_ALT */
424
425 #if defined(MBEDTLS_SHA512_ALT)
426 if( strcmp( "MBEDTLS_SHA512_ALT", config ) == 0 )
427 {
428 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_ALT );
429 return( 0 );
430 }
431 #endif /* MBEDTLS_SHA512_ALT */
432
433 #if defined(MBEDTLS_ECP_ALT)
434 if( strcmp( "MBEDTLS_ECP_ALT", config ) == 0 )
435 {
436 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_ALT );
437 return( 0 );
438 }
439 #endif /* MBEDTLS_ECP_ALT */
440
441 #if defined(MBEDTLS_MD5_PROCESS_ALT)
442 if( strcmp( "MBEDTLS_MD5_PROCESS_ALT", config ) == 0 )
443 {
444 MACRO_EXPANSION_TO_STR( MBEDTLS_MD5_PROCESS_ALT );
445 return( 0 );
446 }
447 #endif /* MBEDTLS_MD5_PROCESS_ALT */
448
449 #if defined(MBEDTLS_RIPEMD160_PROCESS_ALT)
450 if( strcmp( "MBEDTLS_RIPEMD160_PROCESS_ALT", config ) == 0 )
451 {
452 MACRO_EXPANSION_TO_STR( MBEDTLS_RIPEMD160_PROCESS_ALT );
453 return( 0 );
454 }
455 #endif /* MBEDTLS_RIPEMD160_PROCESS_ALT */
456
457 #if defined(MBEDTLS_SHA1_PROCESS_ALT)
458 if( strcmp( "MBEDTLS_SHA1_PROCESS_ALT", config ) == 0 )
459 {
460 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA1_PROCESS_ALT );
461 return( 0 );
462 }
463 #endif /* MBEDTLS_SHA1_PROCESS_ALT */
464
465 #if defined(MBEDTLS_SHA256_PROCESS_ALT)
466 if( strcmp( "MBEDTLS_SHA256_PROCESS_ALT", config ) == 0 )
467 {
468 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_PROCESS_ALT );
469 return( 0 );
470 }
471 #endif /* MBEDTLS_SHA256_PROCESS_ALT */
472
473 #if defined(MBEDTLS_SHA512_PROCESS_ALT)
474 if( strcmp( "MBEDTLS_SHA512_PROCESS_ALT", config ) == 0 )
475 {
476 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_PROCESS_ALT );
477 return( 0 );
478 }
479 #endif /* MBEDTLS_SHA512_PROCESS_ALT */
480
481 #if defined(MBEDTLS_DES_SETKEY_ALT)
482 if( strcmp( "MBEDTLS_DES_SETKEY_ALT", config ) == 0 )
483 {
484 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_SETKEY_ALT );
485 return( 0 );
486 }
487 #endif /* MBEDTLS_DES_SETKEY_ALT */
488
489 #if defined(MBEDTLS_DES_CRYPT_ECB_ALT)
490 if( strcmp( "MBEDTLS_DES_CRYPT_ECB_ALT", config ) == 0 )
491 {
492 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_CRYPT_ECB_ALT );
493 return( 0 );
494 }
495 #endif /* MBEDTLS_DES_CRYPT_ECB_ALT */
496
497 #if defined(MBEDTLS_DES3_CRYPT_ECB_ALT)
498 if( strcmp( "MBEDTLS_DES3_CRYPT_ECB_ALT", config ) == 0 )
499 {
500 MACRO_EXPANSION_TO_STR( MBEDTLS_DES3_CRYPT_ECB_ALT );
501 return( 0 );
502 }
503 #endif /* MBEDTLS_DES3_CRYPT_ECB_ALT */
504
505 #if defined(MBEDTLS_AES_SETKEY_ENC_ALT)
506 if( strcmp( "MBEDTLS_AES_SETKEY_ENC_ALT", config ) == 0 )
507 {
508 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_SETKEY_ENC_ALT );
509 return( 0 );
510 }
511 #endif /* MBEDTLS_AES_SETKEY_ENC_ALT */
512
513 #if defined(MBEDTLS_AES_SETKEY_DEC_ALT)
514 if( strcmp( "MBEDTLS_AES_SETKEY_DEC_ALT", config ) == 0 )
515 {
516 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_SETKEY_DEC_ALT );
517 return( 0 );
518 }
519 #endif /* MBEDTLS_AES_SETKEY_DEC_ALT */
520
521 #if defined(MBEDTLS_AES_ENCRYPT_ALT)
522 if( strcmp( "MBEDTLS_AES_ENCRYPT_ALT", config ) == 0 )
523 {
524 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_ENCRYPT_ALT );
525 return( 0 );
526 }
527 #endif /* MBEDTLS_AES_ENCRYPT_ALT */
528
529 #if defined(MBEDTLS_AES_DECRYPT_ALT)
530 if( strcmp( "MBEDTLS_AES_DECRYPT_ALT", config ) == 0 )
531 {
532 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_DECRYPT_ALT );
533 return( 0 );
534 }
535 #endif /* MBEDTLS_AES_DECRYPT_ALT */
536
537 #if defined(MBEDTLS_ECDH_GEN_PUBLIC_ALT)
538 if( strcmp( "MBEDTLS_ECDH_GEN_PUBLIC_ALT", config ) == 0 )
539 {
540 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_GEN_PUBLIC_ALT );
541 return( 0 );
542 }
543 #endif /* MBEDTLS_ECDH_GEN_PUBLIC_ALT */
544
545 #if defined(MBEDTLS_ECDH_COMPUTE_SHARED_ALT)
546 if( strcmp( "MBEDTLS_ECDH_COMPUTE_SHARED_ALT", config ) == 0 )
547 {
548 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_COMPUTE_SHARED_ALT );
549 return( 0 );
550 }
551 #endif /* MBEDTLS_ECDH_COMPUTE_SHARED_ALT */
552
553 #if defined(MBEDTLS_ECDSA_VERIFY_ALT)
554 if( strcmp( "MBEDTLS_ECDSA_VERIFY_ALT", config ) == 0 )
555 {
556 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_VERIFY_ALT );
557 return( 0 );
558 }
559 #endif /* MBEDTLS_ECDSA_VERIFY_ALT */
560
561 #if defined(MBEDTLS_ECDSA_SIGN_ALT)
562 if( strcmp( "MBEDTLS_ECDSA_SIGN_ALT", config ) == 0 )
563 {
564 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_SIGN_ALT );
565 return( 0 );
566 }
567 #endif /* MBEDTLS_ECDSA_SIGN_ALT */
568
569 #if defined(MBEDTLS_ECDSA_GENKEY_ALT)
570 if( strcmp( "MBEDTLS_ECDSA_GENKEY_ALT", config ) == 0 )
571 {
572 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_GENKEY_ALT );
573 return( 0 );
574 }
575 #endif /* MBEDTLS_ECDSA_GENKEY_ALT */
576
577 #if defined(MBEDTLS_ECP_INTERNAL_ALT)
578 if( strcmp( "MBEDTLS_ECP_INTERNAL_ALT", config ) == 0 )
579 {
580 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_INTERNAL_ALT );
581 return( 0 );
582 }
583 #endif /* MBEDTLS_ECP_INTERNAL_ALT */
584
585 #if defined(MBEDTLS_ECP_NO_FALLBACK)
586 if( strcmp( "MBEDTLS_ECP_NO_FALLBACK", config ) == 0 )
587 {
588 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NO_FALLBACK );
589 return( 0 );
590 }
591 #endif /* MBEDTLS_ECP_NO_FALLBACK */
592
593 #if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT)
594 if( strcmp( "MBEDTLS_ECP_RANDOMIZE_JAC_ALT", config ) == 0 )
595 {
596 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_RANDOMIZE_JAC_ALT );
597 return( 0 );
598 }
599 #endif /* MBEDTLS_ECP_RANDOMIZE_JAC_ALT */
600
601 #if defined(MBEDTLS_ECP_ADD_MIXED_ALT)
602 if( strcmp( "MBEDTLS_ECP_ADD_MIXED_ALT", config ) == 0 )
603 {
604 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_ADD_MIXED_ALT );
605 return( 0 );
606 }
607 #endif /* MBEDTLS_ECP_ADD_MIXED_ALT */
608
609 #if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT)
610 if( strcmp( "MBEDTLS_ECP_DOUBLE_JAC_ALT", config ) == 0 )
611 {
612 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DOUBLE_JAC_ALT );
613 return( 0 );
614 }
615 #endif /* MBEDTLS_ECP_DOUBLE_JAC_ALT */
616
617 #if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT)
618 if( strcmp( "MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT", config ) == 0 )
619 {
620 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT );
621 return( 0 );
622 }
623 #endif /* MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT */
624
625 #if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT)
626 if( strcmp( "MBEDTLS_ECP_NORMALIZE_JAC_ALT", config ) == 0 )
627 {
628 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NORMALIZE_JAC_ALT );
629 return( 0 );
630 }
631 #endif /* MBEDTLS_ECP_NORMALIZE_JAC_ALT */
632
633 #if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT)
634 if( strcmp( "MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT", config ) == 0 )
635 {
636 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT );
637 return( 0 );
638 }
639 #endif /* MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT */
640
641 #if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT)
642 if( strcmp( "MBEDTLS_ECP_RANDOMIZE_MXZ_ALT", config ) == 0 )
643 {
644 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_RANDOMIZE_MXZ_ALT );
645 return( 0 );
646 }
647 #endif /* MBEDTLS_ECP_RANDOMIZE_MXZ_ALT */
648
649 #if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT)
650 if( strcmp( "MBEDTLS_ECP_NORMALIZE_MXZ_ALT", config ) == 0 )
651 {
652 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NORMALIZE_MXZ_ALT );
653 return( 0 );
654 }
655 #endif /* MBEDTLS_ECP_NORMALIZE_MXZ_ALT */
656
657 #if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
658 if( strcmp( "MBEDTLS_ENTROPY_HARDWARE_ALT", config ) == 0 )
659 {
660 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_HARDWARE_ALT );
661 return( 0 );
662 }
663 #endif /* MBEDTLS_ENTROPY_HARDWARE_ALT */
664
665 #if defined(MBEDTLS_AES_ROM_TABLES)
666 if( strcmp( "MBEDTLS_AES_ROM_TABLES", config ) == 0 )
667 {
668 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_ROM_TABLES );
669 return( 0 );
670 }
671 #endif /* MBEDTLS_AES_ROM_TABLES */
672
673 #if defined(MBEDTLS_AES_FEWER_TABLES)
674 if( strcmp( "MBEDTLS_AES_FEWER_TABLES", config ) == 0 )
675 {
676 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_FEWER_TABLES );
677 return( 0 );
678 }
679 #endif /* MBEDTLS_AES_FEWER_TABLES */
680
681 #if defined(MBEDTLS_CAMELLIA_SMALL_MEMORY)
682 if( strcmp( "MBEDTLS_CAMELLIA_SMALL_MEMORY", config ) == 0 )
683 {
684 MACRO_EXPANSION_TO_STR( MBEDTLS_CAMELLIA_SMALL_MEMORY );
685 return( 0 );
686 }
687 #endif /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
688
689 #if defined(MBEDTLS_CHECK_RETURN_WARNING)
690 if( strcmp( "MBEDTLS_CHECK_RETURN_WARNING", config ) == 0 )
691 {
692 MACRO_EXPANSION_TO_STR( MBEDTLS_CHECK_RETURN_WARNING );
693 return( 0 );
694 }
695 #endif /* MBEDTLS_CHECK_RETURN_WARNING */
696
697 #if defined(MBEDTLS_CIPHER_MODE_CBC)
698 if( strcmp( "MBEDTLS_CIPHER_MODE_CBC", config ) == 0 )
699 {
700 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_CBC );
701 return( 0 );
702 }
703 #endif /* MBEDTLS_CIPHER_MODE_CBC */
704
705 #if defined(MBEDTLS_CIPHER_MODE_CFB)
706 if( strcmp( "MBEDTLS_CIPHER_MODE_CFB", config ) == 0 )
707 {
708 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_CFB );
709 return( 0 );
710 }
711 #endif /* MBEDTLS_CIPHER_MODE_CFB */
712
713 #if defined(MBEDTLS_CIPHER_MODE_CTR)
714 if( strcmp( "MBEDTLS_CIPHER_MODE_CTR", config ) == 0 )
715 {
716 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_CTR );
717 return( 0 );
718 }
719 #endif /* MBEDTLS_CIPHER_MODE_CTR */
720
721 #if defined(MBEDTLS_CIPHER_MODE_OFB)
722 if( strcmp( "MBEDTLS_CIPHER_MODE_OFB", config ) == 0 )
723 {
724 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_OFB );
725 return( 0 );
726 }
727 #endif /* MBEDTLS_CIPHER_MODE_OFB */
728
729 #if defined(MBEDTLS_CIPHER_MODE_XTS)
730 if( strcmp( "MBEDTLS_CIPHER_MODE_XTS", config ) == 0 )
731 {
732 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_XTS );
733 return( 0 );
734 }
735 #endif /* MBEDTLS_CIPHER_MODE_XTS */
736
737 #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
738 if( strcmp( "MBEDTLS_CIPHER_NULL_CIPHER", config ) == 0 )
739 {
740 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_NULL_CIPHER );
741 return( 0 );
742 }
743 #endif /* MBEDTLS_CIPHER_NULL_CIPHER */
744
745 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
746 if( strcmp( "MBEDTLS_CIPHER_PADDING_PKCS7", config ) == 0 )
747 {
748 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_PKCS7 );
749 return( 0 );
750 }
751 #endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
752
753 #if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
754 if( strcmp( "MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS", config ) == 0 )
755 {
756 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS );
757 return( 0 );
758 }
759 #endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
760
761 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
762 if( strcmp( "MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN", config ) == 0 )
763 {
764 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN );
765 return( 0 );
766 }
767 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
768
769 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
770 if( strcmp( "MBEDTLS_CIPHER_PADDING_ZEROS", config ) == 0 )
771 {
772 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_ZEROS );
773 return( 0 );
774 }
775 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
776
777 #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
778 if( strcmp( "MBEDTLS_CTR_DRBG_USE_128_BIT_KEY", config ) == 0 )
779 {
780 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_USE_128_BIT_KEY );
781 return( 0 );
782 }
783 #endif /* MBEDTLS_CTR_DRBG_USE_128_BIT_KEY */
784
785 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
786 if( strcmp( "MBEDTLS_ECP_DP_SECP192R1_ENABLED", config ) == 0 )
787 {
788 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP192R1_ENABLED );
789 return( 0 );
790 }
791 #endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
792
793 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
794 if( strcmp( "MBEDTLS_ECP_DP_SECP224R1_ENABLED", config ) == 0 )
795 {
796 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP224R1_ENABLED );
797 return( 0 );
798 }
799 #endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
800
801 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
802 if( strcmp( "MBEDTLS_ECP_DP_SECP256R1_ENABLED", config ) == 0 )
803 {
804 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP256R1_ENABLED );
805 return( 0 );
806 }
807 #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
808
809 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
810 if( strcmp( "MBEDTLS_ECP_DP_SECP384R1_ENABLED", config ) == 0 )
811 {
812 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP384R1_ENABLED );
813 return( 0 );
814 }
815 #endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
816
817 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
818 if( strcmp( "MBEDTLS_ECP_DP_SECP521R1_ENABLED", config ) == 0 )
819 {
820 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP521R1_ENABLED );
821 return( 0 );
822 }
823 #endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
824
825 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
826 if( strcmp( "MBEDTLS_ECP_DP_SECP192K1_ENABLED", config ) == 0 )
827 {
828 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP192K1_ENABLED );
829 return( 0 );
830 }
831 #endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
832
833 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
834 if( strcmp( "MBEDTLS_ECP_DP_SECP224K1_ENABLED", config ) == 0 )
835 {
836 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP224K1_ENABLED );
837 return( 0 );
838 }
839 #endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
840
841 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
842 if( strcmp( "MBEDTLS_ECP_DP_SECP256K1_ENABLED", config ) == 0 )
843 {
844 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP256K1_ENABLED );
845 return( 0 );
846 }
847 #endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
848
849 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
850 if( strcmp( "MBEDTLS_ECP_DP_BP256R1_ENABLED", config ) == 0 )
851 {
852 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_BP256R1_ENABLED );
853 return( 0 );
854 }
855 #endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
856
857 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
858 if( strcmp( "MBEDTLS_ECP_DP_BP384R1_ENABLED", config ) == 0 )
859 {
860 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_BP384R1_ENABLED );
861 return( 0 );
862 }
863 #endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
864
865 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
866 if( strcmp( "MBEDTLS_ECP_DP_BP512R1_ENABLED", config ) == 0 )
867 {
868 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_BP512R1_ENABLED );
869 return( 0 );
870 }
871 #endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
872
873 #if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
874 if( strcmp( "MBEDTLS_ECP_DP_CURVE25519_ENABLED", config ) == 0 )
875 {
876 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_CURVE25519_ENABLED );
877 return( 0 );
878 }
879 #endif /* MBEDTLS_ECP_DP_CURVE25519_ENABLED */
880
881 #if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
882 if( strcmp( "MBEDTLS_ECP_DP_CURVE448_ENABLED", config ) == 0 )
883 {
884 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_CURVE448_ENABLED );
885 return( 0 );
886 }
887 #endif /* MBEDTLS_ECP_DP_CURVE448_ENABLED */
888
889 #if defined(MBEDTLS_ECP_NIST_OPTIM)
890 if( strcmp( "MBEDTLS_ECP_NIST_OPTIM", config ) == 0 )
891 {
892 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NIST_OPTIM );
893 return( 0 );
894 }
895 #endif /* MBEDTLS_ECP_NIST_OPTIM */
896
897 #if defined(MBEDTLS_ECP_RESTARTABLE)
898 if( strcmp( "MBEDTLS_ECP_RESTARTABLE", config ) == 0 )
899 {
900 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_RESTARTABLE );
901 return( 0 );
902 }
903 #endif /* MBEDTLS_ECP_RESTARTABLE */
904
905 #if defined(MBEDTLS_ECDSA_DETERMINISTIC)
906 if( strcmp( "MBEDTLS_ECDSA_DETERMINISTIC", config ) == 0 )
907 {
908 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_DETERMINISTIC );
909 return( 0 );
910 }
911 #endif /* MBEDTLS_ECDSA_DETERMINISTIC */
912
913 #if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
914 if( strcmp( "MBEDTLS_KEY_EXCHANGE_PSK_ENABLED", config ) == 0 )
915 {
916 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_PSK_ENABLED );
917 return( 0 );
918 }
919 #endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
920
921 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
922 if( strcmp( "MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED", config ) == 0 )
923 {
924 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED );
925 return( 0 );
926 }
927 #endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
928
929 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
930 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED", config ) == 0 )
931 {
932 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED );
933 return( 0 );
934 }
935 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
936
937 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
938 if( strcmp( "MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED", config ) == 0 )
939 {
940 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED );
941 return( 0 );
942 }
943 #endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
944
945 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
946 if( strcmp( "MBEDTLS_KEY_EXCHANGE_RSA_ENABLED", config ) == 0 )
947 {
948 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_RSA_ENABLED );
949 return( 0 );
950 }
951 #endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
952
953 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
954 if( strcmp( "MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED", config ) == 0 )
955 {
956 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED );
957 return( 0 );
958 }
959 #endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
960
961 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
962 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED", config ) == 0 )
963 {
964 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED );
965 return( 0 );
966 }
967 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
968
969 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
970 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED", config ) == 0 )
971 {
972 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED );
973 return( 0 );
974 }
975 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
976
977 #if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
978 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED", config ) == 0 )
979 {
980 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED );
981 return( 0 );
982 }
983 #endif /* MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
984
985 #if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED)
986 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED", config ) == 0 )
987 {
988 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED );
989 return( 0 );
990 }
991 #endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED */
992
993 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
994 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED", config ) == 0 )
995 {
996 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED );
997 return( 0 );
998 }
999 #endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
1000
1001 #if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
1002 if( strcmp( "MBEDTLS_PK_PARSE_EC_EXTENDED", config ) == 0 )
1003 {
1004 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_PARSE_EC_EXTENDED );
1005 return( 0 );
1006 }
1007 #endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
1008
1009 #if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
1010 if( strcmp( "MBEDTLS_ERROR_STRERROR_DUMMY", config ) == 0 )
1011 {
1012 MACRO_EXPANSION_TO_STR( MBEDTLS_ERROR_STRERROR_DUMMY );
1013 return( 0 );
1014 }
1015 #endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
1016
1017 #if defined(MBEDTLS_GENPRIME)
1018 if( strcmp( "MBEDTLS_GENPRIME", config ) == 0 )
1019 {
1020 MACRO_EXPANSION_TO_STR( MBEDTLS_GENPRIME );
1021 return( 0 );
1022 }
1023 #endif /* MBEDTLS_GENPRIME */
1024
1025 #if defined(MBEDTLS_FS_IO)
1026 if( strcmp( "MBEDTLS_FS_IO", config ) == 0 )
1027 {
1028 MACRO_EXPANSION_TO_STR( MBEDTLS_FS_IO );
1029 return( 0 );
1030 }
1031 #endif /* MBEDTLS_FS_IO */
1032
1033 #if defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
1034 if( strcmp( "MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES", config ) == 0 )
1035 {
1036 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES );
1037 return( 0 );
1038 }
1039 #endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
1040
1041 #if defined(MBEDTLS_NO_PLATFORM_ENTROPY)
1042 if( strcmp( "MBEDTLS_NO_PLATFORM_ENTROPY", config ) == 0 )
1043 {
1044 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_PLATFORM_ENTROPY );
1045 return( 0 );
1046 }
1047 #endif /* MBEDTLS_NO_PLATFORM_ENTROPY */
1048
1049 #if defined(MBEDTLS_ENTROPY_FORCE_SHA256)
1050 if( strcmp( "MBEDTLS_ENTROPY_FORCE_SHA256", config ) == 0 )
1051 {
1052 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_FORCE_SHA256 );
1053 return( 0 );
1054 }
1055 #endif /* MBEDTLS_ENTROPY_FORCE_SHA256 */
1056
1057 #if defined(MBEDTLS_ENTROPY_NV_SEED)
1058 if( strcmp( "MBEDTLS_ENTROPY_NV_SEED", config ) == 0 )
1059 {
1060 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_NV_SEED );
1061 return( 0 );
1062 }
1063 #endif /* MBEDTLS_ENTROPY_NV_SEED */
1064
1065 #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
1066 if( strcmp( "MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER", config ) == 0 )
1067 {
1068 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER );
1069 return( 0 );
1070 }
1071 #endif /* MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */
1072
1073 #if defined(MBEDTLS_MEMORY_DEBUG)
1074 if( strcmp( "MBEDTLS_MEMORY_DEBUG", config ) == 0 )
1075 {
1076 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_DEBUG );
1077 return( 0 );
1078 }
1079 #endif /* MBEDTLS_MEMORY_DEBUG */
1080
1081 #if defined(MBEDTLS_MEMORY_BACKTRACE)
1082 if( strcmp( "MBEDTLS_MEMORY_BACKTRACE", config ) == 0 )
1083 {
1084 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_BACKTRACE );
1085 return( 0 );
1086 }
1087 #endif /* MBEDTLS_MEMORY_BACKTRACE */
1088
1089 #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
1090 if( strcmp( "MBEDTLS_PK_RSA_ALT_SUPPORT", config ) == 0 )
1091 {
1092 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_RSA_ALT_SUPPORT );
1093 return( 0 );
1094 }
1095 #endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
1096
1097 #if defined(MBEDTLS_PKCS1_V15)
1098 if( strcmp( "MBEDTLS_PKCS1_V15", config ) == 0 )
1099 {
1100 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS1_V15 );
1101 return( 0 );
1102 }
1103 #endif /* MBEDTLS_PKCS1_V15 */
1104
1105 #if defined(MBEDTLS_PKCS1_V21)
1106 if( strcmp( "MBEDTLS_PKCS1_V21", config ) == 0 )
1107 {
1108 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS1_V21 );
1109 return( 0 );
1110 }
1111 #endif /* MBEDTLS_PKCS1_V21 */
1112
1113 #if defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
1114 if( strcmp( "MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS", config ) == 0 )
1115 {
1116 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS );
1117 return( 0 );
1118 }
1119 #endif /* MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
1120
1121 #if defined(MBEDTLS_PSA_CRYPTO_CLIENT)
1122 if( strcmp( "MBEDTLS_PSA_CRYPTO_CLIENT", config ) == 0 )
1123 {
1124 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_CLIENT );
1125 return( 0 );
1126 }
1127 #endif /* MBEDTLS_PSA_CRYPTO_CLIENT */
1128
1129 #if defined(MBEDTLS_PSA_CRYPTO_DRIVERS)
1130 if( strcmp( "MBEDTLS_PSA_CRYPTO_DRIVERS", config ) == 0 )
1131 {
1132 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_DRIVERS );
1133 return( 0 );
1134 }
1135 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS */
1136
1137 #if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
1138 if( strcmp( "MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG", config ) == 0 )
1139 {
1140 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG );
1141 return( 0 );
1142 }
1143 #endif /* MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
1144
1145 #if defined(MBEDTLS_PSA_CRYPTO_SPM)
1146 if( strcmp( "MBEDTLS_PSA_CRYPTO_SPM", config ) == 0 )
1147 {
1148 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_SPM );
1149 return( 0 );
1150 }
1151 #endif /* MBEDTLS_PSA_CRYPTO_SPM */
1152
1153 #if defined(MBEDTLS_PSA_INJECT_ENTROPY)
1154 if( strcmp( "MBEDTLS_PSA_INJECT_ENTROPY", config ) == 0 )
1155 {
1156 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_INJECT_ENTROPY );
1157 return( 0 );
1158 }
1159 #endif /* MBEDTLS_PSA_INJECT_ENTROPY */
1160
1161 #if defined(MBEDTLS_RSA_NO_CRT)
1162 if( strcmp( "MBEDTLS_RSA_NO_CRT", config ) == 0 )
1163 {
1164 MACRO_EXPANSION_TO_STR( MBEDTLS_RSA_NO_CRT );
1165 return( 0 );
1166 }
1167 #endif /* MBEDTLS_RSA_NO_CRT */
1168
1169 #if defined(MBEDTLS_SELF_TEST)
1170 if( strcmp( "MBEDTLS_SELF_TEST", config ) == 0 )
1171 {
1172 MACRO_EXPANSION_TO_STR( MBEDTLS_SELF_TEST );
1173 return( 0 );
1174 }
1175 #endif /* MBEDTLS_SELF_TEST */
1176
1177 #if defined(MBEDTLS_SHA256_SMALLER)
1178 if( strcmp( "MBEDTLS_SHA256_SMALLER", config ) == 0 )
1179 {
1180 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_SMALLER );
1181 return( 0 );
1182 }
1183 #endif /* MBEDTLS_SHA256_SMALLER */
1184
1185 #if defined(MBEDTLS_SHA512_SMALLER)
1186 if( strcmp( "MBEDTLS_SHA512_SMALLER", config ) == 0 )
1187 {
1188 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_SMALLER );
1189 return( 0 );
1190 }
1191 #endif /* MBEDTLS_SHA512_SMALLER */
1192
1193 #if defined(MBEDTLS_SSL_ALL_ALERT_MESSAGES)
1194 if( strcmp( "MBEDTLS_SSL_ALL_ALERT_MESSAGES", config ) == 0 )
1195 {
1196 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ALL_ALERT_MESSAGES );
1197 return( 0 );
1198 }
1199 #endif /* MBEDTLS_SSL_ALL_ALERT_MESSAGES */
1200
1201 #if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
1202 if( strcmp( "MBEDTLS_SSL_DTLS_CONNECTION_ID", config ) == 0 )
1203 {
1204 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_CONNECTION_ID );
1205 return( 0 );
1206 }
1207 #endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
1208
1209 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
1210 if( strcmp( "MBEDTLS_SSL_ASYNC_PRIVATE", config ) == 0 )
1211 {
1212 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ASYNC_PRIVATE );
1213 return( 0 );
1214 }
1215 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
1216
1217 #if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
1218 if( strcmp( "MBEDTLS_SSL_CONTEXT_SERIALIZATION", config ) == 0 )
1219 {
1220 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CONTEXT_SERIALIZATION );
1221 return( 0 );
1222 }
1223 #endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
1224
1225 #if defined(MBEDTLS_SSL_DEBUG_ALL)
1226 if( strcmp( "MBEDTLS_SSL_DEBUG_ALL", config ) == 0 )
1227 {
1228 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DEBUG_ALL );
1229 return( 0 );
1230 }
1231 #endif /* MBEDTLS_SSL_DEBUG_ALL */
1232
1233 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1234 if( strcmp( "MBEDTLS_SSL_ENCRYPT_THEN_MAC", config ) == 0 )
1235 {
1236 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ENCRYPT_THEN_MAC );
1237 return( 0 );
1238 }
1239 #endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
1240
1241 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
1242 if( strcmp( "MBEDTLS_SSL_EXTENDED_MASTER_SECRET", config ) == 0 )
1243 {
1244 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_EXTENDED_MASTER_SECRET );
1245 return( 0 );
1246 }
1247 #endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
1248
1249 #if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
1250 if( strcmp( "MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", config ) == 0 )
1251 {
1252 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_KEEP_PEER_CERTIFICATE );
1253 return( 0 );
1254 }
1255 #endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
1256
1257 #if defined(MBEDTLS_SSL_RENEGOTIATION)
1258 if( strcmp( "MBEDTLS_SSL_RENEGOTIATION", config ) == 0 )
1259 {
1260 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_RENEGOTIATION );
1261 return( 0 );
1262 }
1263 #endif /* MBEDTLS_SSL_RENEGOTIATION */
1264
1265 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1266 if( strcmp( "MBEDTLS_SSL_MAX_FRAGMENT_LENGTH", config ) == 0 )
1267 {
1268 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_MAX_FRAGMENT_LENGTH );
1269 return( 0 );
1270 }
1271 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
1272
1273 #if defined(MBEDTLS_SSL_PROTO_TLS1_2)
1274 if( strcmp( "MBEDTLS_SSL_PROTO_TLS1_2", config ) == 0 )
1275 {
1276 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_TLS1_2 );
1277 return( 0 );
1278 }
1279 #endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
1280
1281 #if defined(MBEDTLS_SSL_PROTO_TLS1_3)
1282 if( strcmp( "MBEDTLS_SSL_PROTO_TLS1_3", config ) == 0 )
1283 {
1284 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_TLS1_3 );
1285 return( 0 );
1286 }
1287 #endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
1288
1289 #if defined(MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE)
1290 if( strcmp( "MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE", config ) == 0 )
1291 {
1292 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE );
1293 return( 0 );
1294 }
1295 #endif /* MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE */
1296
1297 #if defined(MBEDTLS_SSL_PROTO_DTLS)
1298 if( strcmp( "MBEDTLS_SSL_PROTO_DTLS", config ) == 0 )
1299 {
1300 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_DTLS );
1301 return( 0 );
1302 }
1303 #endif /* MBEDTLS_SSL_PROTO_DTLS */
1304
1305 #if defined(MBEDTLS_SSL_ALPN)
1306 if( strcmp( "MBEDTLS_SSL_ALPN", config ) == 0 )
1307 {
1308 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ALPN );
1309 return( 0 );
1310 }
1311 #endif /* MBEDTLS_SSL_ALPN */
1312
1313 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
1314 if( strcmp( "MBEDTLS_SSL_DTLS_ANTI_REPLAY", config ) == 0 )
1315 {
1316 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_ANTI_REPLAY );
1317 return( 0 );
1318 }
1319 #endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
1320
1321 #if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
1322 if( strcmp( "MBEDTLS_SSL_DTLS_HELLO_VERIFY", config ) == 0 )
1323 {
1324 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_HELLO_VERIFY );
1325 return( 0 );
1326 }
1327 #endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
1328
1329 #if defined(MBEDTLS_SSL_DTLS_SRTP)
1330 if( strcmp( "MBEDTLS_SSL_DTLS_SRTP", config ) == 0 )
1331 {
1332 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_SRTP );
1333 return( 0 );
1334 }
1335 #endif /* MBEDTLS_SSL_DTLS_SRTP */
1336
1337 #if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE)
1338 if( strcmp( "MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE", config ) == 0 )
1339 {
1340 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE );
1341 return( 0 );
1342 }
1343 #endif /* MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE */
1344
1345 #if defined(MBEDTLS_SSL_SESSION_TICKETS)
1346 if( strcmp( "MBEDTLS_SSL_SESSION_TICKETS", config ) == 0 )
1347 {
1348 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SESSION_TICKETS );
1349 return( 0 );
1350 }
1351 #endif /* MBEDTLS_SSL_SESSION_TICKETS */
1352
1353 #if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
1354 if( strcmp( "MBEDTLS_SSL_SERVER_NAME_INDICATION", config ) == 0 )
1355 {
1356 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SERVER_NAME_INDICATION );
1357 return( 0 );
1358 }
1359 #endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
1360
1361 #if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
1362 if( strcmp( "MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH", config ) == 0 )
1363 {
1364 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH );
1365 return( 0 );
1366 }
1367 #endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
1368
1369 #if defined(MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN)
1370 if( strcmp( "MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN", config ) == 0 )
1371 {
1372 MACRO_EXPANSION_TO_STR( MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN );
1373 return( 0 );
1374 }
1375 #endif /* MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN */
1376
1377 #if defined(MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND)
1378 if( strcmp( "MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND", config ) == 0 )
1379 {
1380 MACRO_EXPANSION_TO_STR( MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND );
1381 return( 0 );
1382 }
1383 #endif /* MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND */
1384
1385 #if defined(MBEDTLS_TEST_HOOKS)
1386 if( strcmp( "MBEDTLS_TEST_HOOKS", config ) == 0 )
1387 {
1388 MACRO_EXPANSION_TO_STR( MBEDTLS_TEST_HOOKS );
1389 return( 0 );
1390 }
1391 #endif /* MBEDTLS_TEST_HOOKS */
1392
1393 #if defined(MBEDTLS_THREADING_ALT)
1394 if( strcmp( "MBEDTLS_THREADING_ALT", config ) == 0 )
1395 {
1396 MACRO_EXPANSION_TO_STR( MBEDTLS_THREADING_ALT );
1397 return( 0 );
1398 }
1399 #endif /* MBEDTLS_THREADING_ALT */
1400
1401 #if defined(MBEDTLS_THREADING_PTHREAD)
1402 if( strcmp( "MBEDTLS_THREADING_PTHREAD", config ) == 0 )
1403 {
1404 MACRO_EXPANSION_TO_STR( MBEDTLS_THREADING_PTHREAD );
1405 return( 0 );
1406 }
1407 #endif /* MBEDTLS_THREADING_PTHREAD */
1408
1409 #if defined(MBEDTLS_USE_PSA_CRYPTO)
1410 if( strcmp( "MBEDTLS_USE_PSA_CRYPTO", config ) == 0 )
1411 {
1412 MACRO_EXPANSION_TO_STR( MBEDTLS_USE_PSA_CRYPTO );
1413 return( 0 );
1414 }
1415 #endif /* MBEDTLS_USE_PSA_CRYPTO */
1416
1417 #if defined(MBEDTLS_PSA_CRYPTO_CONFIG)
1418 if( strcmp( "MBEDTLS_PSA_CRYPTO_CONFIG", config ) == 0 )
1419 {
1420 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_CONFIG );
1421 return( 0 );
1422 }
1423 #endif /* MBEDTLS_PSA_CRYPTO_CONFIG */
1424
1425 #if defined(MBEDTLS_VERSION_FEATURES)
1426 if( strcmp( "MBEDTLS_VERSION_FEATURES", config ) == 0 )
1427 {
1428 MACRO_EXPANSION_TO_STR( MBEDTLS_VERSION_FEATURES );
1429 return( 0 );
1430 }
1431 #endif /* MBEDTLS_VERSION_FEATURES */
1432
1433 #if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
1434 if( strcmp( "MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK", config ) == 0 )
1435 {
1436 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK );
1437 return( 0 );
1438 }
1439 #endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
1440
1441 #if defined(MBEDTLS_X509_REMOVE_INFO)
1442 if( strcmp( "MBEDTLS_X509_REMOVE_INFO", config ) == 0 )
1443 {
1444 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_REMOVE_INFO );
1445 return( 0 );
1446 }
1447 #endif /* MBEDTLS_X509_REMOVE_INFO */
1448
1449 #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1450 if( strcmp( "MBEDTLS_X509_RSASSA_PSS_SUPPORT", config ) == 0 )
1451 {
1452 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_RSASSA_PSS_SUPPORT );
1453 return( 0 );
1454 }
1455 #endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1456
1457 #if defined(MBEDTLS_AESNI_C)
1458 if( strcmp( "MBEDTLS_AESNI_C", config ) == 0 )
1459 {
1460 MACRO_EXPANSION_TO_STR( MBEDTLS_AESNI_C );
1461 return( 0 );
1462 }
1463 #endif /* MBEDTLS_AESNI_C */
1464
1465 #if defined(MBEDTLS_AES_C)
1466 if( strcmp( "MBEDTLS_AES_C", config ) == 0 )
1467 {
1468 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_C );
1469 return( 0 );
1470 }
1471 #endif /* MBEDTLS_AES_C */
1472
1473 #if defined(MBEDTLS_ASN1_PARSE_C)
1474 if( strcmp( "MBEDTLS_ASN1_PARSE_C", config ) == 0 )
1475 {
1476 MACRO_EXPANSION_TO_STR( MBEDTLS_ASN1_PARSE_C );
1477 return( 0 );
1478 }
1479 #endif /* MBEDTLS_ASN1_PARSE_C */
1480
1481 #if defined(MBEDTLS_ASN1_WRITE_C)
1482 if( strcmp( "MBEDTLS_ASN1_WRITE_C", config ) == 0 )
1483 {
1484 MACRO_EXPANSION_TO_STR( MBEDTLS_ASN1_WRITE_C );
1485 return( 0 );
1486 }
1487 #endif /* MBEDTLS_ASN1_WRITE_C */
1488
1489 #if defined(MBEDTLS_BASE64_C)
1490 if( strcmp( "MBEDTLS_BASE64_C", config ) == 0 )
1491 {
1492 MACRO_EXPANSION_TO_STR( MBEDTLS_BASE64_C );
1493 return( 0 );
1494 }
1495 #endif /* MBEDTLS_BASE64_C */
1496
1497 #if defined(MBEDTLS_BIGNUM_C)
1498 if( strcmp( "MBEDTLS_BIGNUM_C", config ) == 0 )
1499 {
1500 MACRO_EXPANSION_TO_STR( MBEDTLS_BIGNUM_C );
1501 return( 0 );
1502 }
1503 #endif /* MBEDTLS_BIGNUM_C */
1504
1505 #if defined(MBEDTLS_CAMELLIA_C)
1506 if( strcmp( "MBEDTLS_CAMELLIA_C", config ) == 0 )
1507 {
1508 MACRO_EXPANSION_TO_STR( MBEDTLS_CAMELLIA_C );
1509 return( 0 );
1510 }
1511 #endif /* MBEDTLS_CAMELLIA_C */
1512
1513 #if defined(MBEDTLS_ARIA_C)
1514 if( strcmp( "MBEDTLS_ARIA_C", config ) == 0 )
1515 {
1516 MACRO_EXPANSION_TO_STR( MBEDTLS_ARIA_C );
1517 return( 0 );
1518 }
1519 #endif /* MBEDTLS_ARIA_C */
1520
1521 #if defined(MBEDTLS_CCM_C)
1522 if( strcmp( "MBEDTLS_CCM_C", config ) == 0 )
1523 {
1524 MACRO_EXPANSION_TO_STR( MBEDTLS_CCM_C );
1525 return( 0 );
1526 }
1527 #endif /* MBEDTLS_CCM_C */
1528
1529 #if defined(MBEDTLS_CHACHA20_C)
1530 if( strcmp( "MBEDTLS_CHACHA20_C", config ) == 0 )
1531 {
1532 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHA20_C );
1533 return( 0 );
1534 }
1535 #endif /* MBEDTLS_CHACHA20_C */
1536
1537 #if defined(MBEDTLS_CHACHAPOLY_C)
1538 if( strcmp( "MBEDTLS_CHACHAPOLY_C", config ) == 0 )
1539 {
1540 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHAPOLY_C );
1541 return( 0 );
1542 }
1543 #endif /* MBEDTLS_CHACHAPOLY_C */
1544
1545 #if defined(MBEDTLS_CIPHER_C)
1546 if( strcmp( "MBEDTLS_CIPHER_C", config ) == 0 )
1547 {
1548 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_C );
1549 return( 0 );
1550 }
1551 #endif /* MBEDTLS_CIPHER_C */
1552
1553 #if defined(MBEDTLS_CMAC_C)
1554 if( strcmp( "MBEDTLS_CMAC_C", config ) == 0 )
1555 {
1556 MACRO_EXPANSION_TO_STR( MBEDTLS_CMAC_C );
1557 return( 0 );
1558 }
1559 #endif /* MBEDTLS_CMAC_C */
1560
1561 #if defined(MBEDTLS_CTR_DRBG_C)
1562 if( strcmp( "MBEDTLS_CTR_DRBG_C", config ) == 0 )
1563 {
1564 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_C );
1565 return( 0 );
1566 }
1567 #endif /* MBEDTLS_CTR_DRBG_C */
1568
1569 #if defined(MBEDTLS_DEBUG_C)
1570 if( strcmp( "MBEDTLS_DEBUG_C", config ) == 0 )
1571 {
1572 MACRO_EXPANSION_TO_STR( MBEDTLS_DEBUG_C );
1573 return( 0 );
1574 }
1575 #endif /* MBEDTLS_DEBUG_C */
1576
1577 #if defined(MBEDTLS_DES_C)
1578 if( strcmp( "MBEDTLS_DES_C", config ) == 0 )
1579 {
1580 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_C );
1581 return( 0 );
1582 }
1583 #endif /* MBEDTLS_DES_C */
1584
1585 #if defined(MBEDTLS_DHM_C)
1586 if( strcmp( "MBEDTLS_DHM_C", config ) == 0 )
1587 {
1588 MACRO_EXPANSION_TO_STR( MBEDTLS_DHM_C );
1589 return( 0 );
1590 }
1591 #endif /* MBEDTLS_DHM_C */
1592
1593 #if defined(MBEDTLS_ECDH_C)
1594 if( strcmp( "MBEDTLS_ECDH_C", config ) == 0 )
1595 {
1596 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_C );
1597 return( 0 );
1598 }
1599 #endif /* MBEDTLS_ECDH_C */
1600
1601 #if defined(MBEDTLS_ECDSA_C)
1602 if( strcmp( "MBEDTLS_ECDSA_C", config ) == 0 )
1603 {
1604 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_C );
1605 return( 0 );
1606 }
1607 #endif /* MBEDTLS_ECDSA_C */
1608
1609 #if defined(MBEDTLS_ECJPAKE_C)
1610 if( strcmp( "MBEDTLS_ECJPAKE_C", config ) == 0 )
1611 {
1612 MACRO_EXPANSION_TO_STR( MBEDTLS_ECJPAKE_C );
1613 return( 0 );
1614 }
1615 #endif /* MBEDTLS_ECJPAKE_C */
1616
1617 #if defined(MBEDTLS_ECP_C)
1618 if( strcmp( "MBEDTLS_ECP_C", config ) == 0 )
1619 {
1620 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_C );
1621 return( 0 );
1622 }
1623 #endif /* MBEDTLS_ECP_C */
1624
1625 #if defined(MBEDTLS_ENTROPY_C)
1626 if( strcmp( "MBEDTLS_ENTROPY_C", config ) == 0 )
1627 {
1628 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_C );
1629 return( 0 );
1630 }
1631 #endif /* MBEDTLS_ENTROPY_C */
1632
1633 #if defined(MBEDTLS_ERROR_C)
1634 if( strcmp( "MBEDTLS_ERROR_C", config ) == 0 )
1635 {
1636 MACRO_EXPANSION_TO_STR( MBEDTLS_ERROR_C );
1637 return( 0 );
1638 }
1639 #endif /* MBEDTLS_ERROR_C */
1640
1641 #if defined(MBEDTLS_GCM_C)
1642 if( strcmp( "MBEDTLS_GCM_C", config ) == 0 )
1643 {
1644 MACRO_EXPANSION_TO_STR( MBEDTLS_GCM_C );
1645 return( 0 );
1646 }
1647 #endif /* MBEDTLS_GCM_C */
1648
1649 #if defined(MBEDTLS_HKDF_C)
1650 if( strcmp( "MBEDTLS_HKDF_C", config ) == 0 )
1651 {
1652 MACRO_EXPANSION_TO_STR( MBEDTLS_HKDF_C );
1653 return( 0 );
1654 }
1655 #endif /* MBEDTLS_HKDF_C */
1656
1657 #if defined(MBEDTLS_HMAC_DRBG_C)
1658 if( strcmp( "MBEDTLS_HMAC_DRBG_C", config ) == 0 )
1659 {
1660 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_C );
1661 return( 0 );
1662 }
1663 #endif /* MBEDTLS_HMAC_DRBG_C */
1664
1665 #if defined(MBEDTLS_NIST_KW_C)
1666 if( strcmp( "MBEDTLS_NIST_KW_C", config ) == 0 )
1667 {
1668 MACRO_EXPANSION_TO_STR( MBEDTLS_NIST_KW_C );
1669 return( 0 );
1670 }
1671 #endif /* MBEDTLS_NIST_KW_C */
1672
1673 #if defined(MBEDTLS_MD_C)
1674 if( strcmp( "MBEDTLS_MD_C", config ) == 0 )
1675 {
1676 MACRO_EXPANSION_TO_STR( MBEDTLS_MD_C );
1677 return( 0 );
1678 }
1679 #endif /* MBEDTLS_MD_C */
1680
1681 #if defined(MBEDTLS_MD5_C)
1682 if( strcmp( "MBEDTLS_MD5_C", config ) == 0 )
1683 {
1684 MACRO_EXPANSION_TO_STR( MBEDTLS_MD5_C );
1685 return( 0 );
1686 }
1687 #endif /* MBEDTLS_MD5_C */
1688
1689 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
1690 if( strcmp( "MBEDTLS_MEMORY_BUFFER_ALLOC_C", config ) == 0 )
1691 {
1692 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_BUFFER_ALLOC_C );
1693 return( 0 );
1694 }
1695 #endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
1696
1697 #if defined(MBEDTLS_NET_C)
1698 if( strcmp( "MBEDTLS_NET_C", config ) == 0 )
1699 {
1700 MACRO_EXPANSION_TO_STR( MBEDTLS_NET_C );
1701 return( 0 );
1702 }
1703 #endif /* MBEDTLS_NET_C */
1704
1705 #if defined(MBEDTLS_OID_C)
1706 if( strcmp( "MBEDTLS_OID_C", config ) == 0 )
1707 {
1708 MACRO_EXPANSION_TO_STR( MBEDTLS_OID_C );
1709 return( 0 );
1710 }
1711 #endif /* MBEDTLS_OID_C */
1712
1713 #if defined(MBEDTLS_PADLOCK_C)
1714 if( strcmp( "MBEDTLS_PADLOCK_C", config ) == 0 )
1715 {
1716 MACRO_EXPANSION_TO_STR( MBEDTLS_PADLOCK_C );
1717 return( 0 );
1718 }
1719 #endif /* MBEDTLS_PADLOCK_C */
1720
1721 #if defined(MBEDTLS_PEM_PARSE_C)
1722 if( strcmp( "MBEDTLS_PEM_PARSE_C", config ) == 0 )
1723 {
1724 MACRO_EXPANSION_TO_STR( MBEDTLS_PEM_PARSE_C );
1725 return( 0 );
1726 }
1727 #endif /* MBEDTLS_PEM_PARSE_C */
1728
1729 #if defined(MBEDTLS_PEM_WRITE_C)
1730 if( strcmp( "MBEDTLS_PEM_WRITE_C", config ) == 0 )
1731 {
1732 MACRO_EXPANSION_TO_STR( MBEDTLS_PEM_WRITE_C );
1733 return( 0 );
1734 }
1735 #endif /* MBEDTLS_PEM_WRITE_C */
1736
1737 #if defined(MBEDTLS_PK_C)
1738 if( strcmp( "MBEDTLS_PK_C", config ) == 0 )
1739 {
1740 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_C );
1741 return( 0 );
1742 }
1743 #endif /* MBEDTLS_PK_C */
1744
1745 #if defined(MBEDTLS_PK_PARSE_C)
1746 if( strcmp( "MBEDTLS_PK_PARSE_C", config ) == 0 )
1747 {
1748 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_PARSE_C );
1749 return( 0 );
1750 }
1751 #endif /* MBEDTLS_PK_PARSE_C */
1752
1753 #if defined(MBEDTLS_PK_WRITE_C)
1754 if( strcmp( "MBEDTLS_PK_WRITE_C", config ) == 0 )
1755 {
1756 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_WRITE_C );
1757 return( 0 );
1758 }
1759 #endif /* MBEDTLS_PK_WRITE_C */
1760
1761 #if defined(MBEDTLS_PKCS5_C)
1762 if( strcmp( "MBEDTLS_PKCS5_C", config ) == 0 )
1763 {
1764 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS5_C );
1765 return( 0 );
1766 }
1767 #endif /* MBEDTLS_PKCS5_C */
1768
1769 #if defined(MBEDTLS_PKCS12_C)
1770 if( strcmp( "MBEDTLS_PKCS12_C", config ) == 0 )
1771 {
1772 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS12_C );
1773 return( 0 );
1774 }
1775 #endif /* MBEDTLS_PKCS12_C */
1776
1777 #if defined(MBEDTLS_PLATFORM_C)
1778 if( strcmp( "MBEDTLS_PLATFORM_C", config ) == 0 )
1779 {
1780 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_C );
1781 return( 0 );
1782 }
1783 #endif /* MBEDTLS_PLATFORM_C */
1784
1785 #if defined(MBEDTLS_POLY1305_C)
1786 if( strcmp( "MBEDTLS_POLY1305_C", config ) == 0 )
1787 {
1788 MACRO_EXPANSION_TO_STR( MBEDTLS_POLY1305_C );
1789 return( 0 );
1790 }
1791 #endif /* MBEDTLS_POLY1305_C */
1792
1793 #if defined(MBEDTLS_PSA_CRYPTO_C)
1794 if( strcmp( "MBEDTLS_PSA_CRYPTO_C", config ) == 0 )
1795 {
1796 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_C );
1797 return( 0 );
1798 }
1799 #endif /* MBEDTLS_PSA_CRYPTO_C */
1800
1801 #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
1802 if( strcmp( "MBEDTLS_PSA_CRYPTO_SE_C", config ) == 0 )
1803 {
1804 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_SE_C );
1805 return( 0 );
1806 }
1807 #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
1808
1809 #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
1810 if( strcmp( "MBEDTLS_PSA_CRYPTO_STORAGE_C", config ) == 0 )
1811 {
1812 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_CRYPTO_STORAGE_C );
1813 return( 0 );
1814 }
1815 #endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
1816
1817 #if defined(MBEDTLS_PSA_ITS_FILE_C)
1818 if( strcmp( "MBEDTLS_PSA_ITS_FILE_C", config ) == 0 )
1819 {
1820 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_ITS_FILE_C );
1821 return( 0 );
1822 }
1823 #endif /* MBEDTLS_PSA_ITS_FILE_C */
1824
1825 #if defined(MBEDTLS_RIPEMD160_C)
1826 if( strcmp( "MBEDTLS_RIPEMD160_C", config ) == 0 )
1827 {
1828 MACRO_EXPANSION_TO_STR( MBEDTLS_RIPEMD160_C );
1829 return( 0 );
1830 }
1831 #endif /* MBEDTLS_RIPEMD160_C */
1832
1833 #if defined(MBEDTLS_RSA_C)
1834 if( strcmp( "MBEDTLS_RSA_C", config ) == 0 )
1835 {
1836 MACRO_EXPANSION_TO_STR( MBEDTLS_RSA_C );
1837 return( 0 );
1838 }
1839 #endif /* MBEDTLS_RSA_C */
1840
1841 #if defined(MBEDTLS_SHA1_C)
1842 if( strcmp( "MBEDTLS_SHA1_C", config ) == 0 )
1843 {
1844 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA1_C );
1845 return( 0 );
1846 }
1847 #endif /* MBEDTLS_SHA1_C */
1848
1849 #if defined(MBEDTLS_SHA224_C)
1850 if( strcmp( "MBEDTLS_SHA224_C", config ) == 0 )
1851 {
1852 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA224_C );
1853 return( 0 );
1854 }
1855 #endif /* MBEDTLS_SHA224_C */
1856
1857 #if defined(MBEDTLS_SHA256_C)
1858 if( strcmp( "MBEDTLS_SHA256_C", config ) == 0 )
1859 {
1860 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_C );
1861 return( 0 );
1862 }
1863 #endif /* MBEDTLS_SHA256_C */
1864
1865 #if defined(MBEDTLS_SHA384_C)
1866 if( strcmp( "MBEDTLS_SHA384_C", config ) == 0 )
1867 {
1868 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA384_C );
1869 return( 0 );
1870 }
1871 #endif /* MBEDTLS_SHA384_C */
1872
1873 #if defined(MBEDTLS_SHA512_C)
1874 if( strcmp( "MBEDTLS_SHA512_C", config ) == 0 )
1875 {
1876 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_C );
1877 return( 0 );
1878 }
1879 #endif /* MBEDTLS_SHA512_C */
1880
1881 #if defined(MBEDTLS_SSL_CACHE_C)
1882 if( strcmp( "MBEDTLS_SSL_CACHE_C", config ) == 0 )
1883 {
1884 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CACHE_C );
1885 return( 0 );
1886 }
1887 #endif /* MBEDTLS_SSL_CACHE_C */
1888
1889 #if defined(MBEDTLS_SSL_COOKIE_C)
1890 if( strcmp( "MBEDTLS_SSL_COOKIE_C", config ) == 0 )
1891 {
1892 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_COOKIE_C );
1893 return( 0 );
1894 }
1895 #endif /* MBEDTLS_SSL_COOKIE_C */
1896
1897 #if defined(MBEDTLS_SSL_TICKET_C)
1898 if( strcmp( "MBEDTLS_SSL_TICKET_C", config ) == 0 )
1899 {
1900 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TICKET_C );
1901 return( 0 );
1902 }
1903 #endif /* MBEDTLS_SSL_TICKET_C */
1904
1905 #if defined(MBEDTLS_SSL_CLI_C)
1906 if( strcmp( "MBEDTLS_SSL_CLI_C", config ) == 0 )
1907 {
1908 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CLI_C );
1909 return( 0 );
1910 }
1911 #endif /* MBEDTLS_SSL_CLI_C */
1912
1913 #if defined(MBEDTLS_SSL_SRV_C)
1914 if( strcmp( "MBEDTLS_SSL_SRV_C", config ) == 0 )
1915 {
1916 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SRV_C );
1917 return( 0 );
1918 }
1919 #endif /* MBEDTLS_SSL_SRV_C */
1920
1921 #if defined(MBEDTLS_SSL_TLS_C)
1922 if( strcmp( "MBEDTLS_SSL_TLS_C", config ) == 0 )
1923 {
1924 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TLS_C );
1925 return( 0 );
1926 }
1927 #endif /* MBEDTLS_SSL_TLS_C */
1928
1929 #if defined(MBEDTLS_THREADING_C)
1930 if( strcmp( "MBEDTLS_THREADING_C", config ) == 0 )
1931 {
1932 MACRO_EXPANSION_TO_STR( MBEDTLS_THREADING_C );
1933 return( 0 );
1934 }
1935 #endif /* MBEDTLS_THREADING_C */
1936
1937 #if defined(MBEDTLS_TIMING_C)
1938 if( strcmp( "MBEDTLS_TIMING_C", config ) == 0 )
1939 {
1940 MACRO_EXPANSION_TO_STR( MBEDTLS_TIMING_C );
1941 return( 0 );
1942 }
1943 #endif /* MBEDTLS_TIMING_C */
1944
1945 #if defined(MBEDTLS_VERSION_C)
1946 if( strcmp( "MBEDTLS_VERSION_C", config ) == 0 )
1947 {
1948 MACRO_EXPANSION_TO_STR( MBEDTLS_VERSION_C );
1949 return( 0 );
1950 }
1951 #endif /* MBEDTLS_VERSION_C */
1952
1953 #if defined(MBEDTLS_X509_USE_C)
1954 if( strcmp( "MBEDTLS_X509_USE_C", config ) == 0 )
1955 {
1956 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_USE_C );
1957 return( 0 );
1958 }
1959 #endif /* MBEDTLS_X509_USE_C */
1960
1961 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1962 if( strcmp( "MBEDTLS_X509_CRT_PARSE_C", config ) == 0 )
1963 {
1964 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CRT_PARSE_C );
1965 return( 0 );
1966 }
1967 #endif /* MBEDTLS_X509_CRT_PARSE_C */
1968
1969 #if defined(MBEDTLS_X509_CRL_PARSE_C)
1970 if( strcmp( "MBEDTLS_X509_CRL_PARSE_C", config ) == 0 )
1971 {
1972 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CRL_PARSE_C );
1973 return( 0 );
1974 }
1975 #endif /* MBEDTLS_X509_CRL_PARSE_C */
1976
1977 #if defined(MBEDTLS_X509_CSR_PARSE_C)
1978 if( strcmp( "MBEDTLS_X509_CSR_PARSE_C", config ) == 0 )
1979 {
1980 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CSR_PARSE_C );
1981 return( 0 );
1982 }
1983 #endif /* MBEDTLS_X509_CSR_PARSE_C */
1984
1985 #if defined(MBEDTLS_X509_CREATE_C)
1986 if( strcmp( "MBEDTLS_X509_CREATE_C", config ) == 0 )
1987 {
1988 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CREATE_C );
1989 return( 0 );
1990 }
1991 #endif /* MBEDTLS_X509_CREATE_C */
1992
1993 #if defined(MBEDTLS_X509_CRT_WRITE_C)
1994 if( strcmp( "MBEDTLS_X509_CRT_WRITE_C", config ) == 0 )
1995 {
1996 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CRT_WRITE_C );
1997 return( 0 );
1998 }
1999 #endif /* MBEDTLS_X509_CRT_WRITE_C */
2000
2001 #if defined(MBEDTLS_X509_CSR_WRITE_C)
2002 if( strcmp( "MBEDTLS_X509_CSR_WRITE_C", config ) == 0 )
2003 {
2004 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CSR_WRITE_C );
2005 return( 0 );
2006 }
2007 #endif /* MBEDTLS_X509_CSR_WRITE_C */
2008
2009 #if defined(MBEDTLS_MPI_WINDOW_SIZE)
2010 if( strcmp( "MBEDTLS_MPI_WINDOW_SIZE", config ) == 0 )
2011 {
2012 MACRO_EXPANSION_TO_STR( MBEDTLS_MPI_WINDOW_SIZE );
2013 return( 0 );
2014 }
2015 #endif /* MBEDTLS_MPI_WINDOW_SIZE */
2016
2017 #if defined(MBEDTLS_MPI_MAX_SIZE)
2018 if( strcmp( "MBEDTLS_MPI_MAX_SIZE", config ) == 0 )
2019 {
2020 MACRO_EXPANSION_TO_STR( MBEDTLS_MPI_MAX_SIZE );
2021 return( 0 );
2022 }
2023 #endif /* MBEDTLS_MPI_MAX_SIZE */
2024
2025 #if defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN)
2026 if( strcmp( "MBEDTLS_CTR_DRBG_ENTROPY_LEN", config ) == 0 )
2027 {
2028 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_ENTROPY_LEN );
2029 return( 0 );
2030 }
2031 #endif /* MBEDTLS_CTR_DRBG_ENTROPY_LEN */
2032
2033 #if defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL)
2034 if( strcmp( "MBEDTLS_CTR_DRBG_RESEED_INTERVAL", config ) == 0 )
2035 {
2036 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_RESEED_INTERVAL );
2037 return( 0 );
2038 }
2039 #endif /* MBEDTLS_CTR_DRBG_RESEED_INTERVAL */
2040
2041 #if defined(MBEDTLS_CTR_DRBG_MAX_INPUT)
2042 if( strcmp( "MBEDTLS_CTR_DRBG_MAX_INPUT", config ) == 0 )
2043 {
2044 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_MAX_INPUT );
2045 return( 0 );
2046 }
2047 #endif /* MBEDTLS_CTR_DRBG_MAX_INPUT */
2048
2049 #if defined(MBEDTLS_CTR_DRBG_MAX_REQUEST)
2050 if( strcmp( "MBEDTLS_CTR_DRBG_MAX_REQUEST", config ) == 0 )
2051 {
2052 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_MAX_REQUEST );
2053 return( 0 );
2054 }
2055 #endif /* MBEDTLS_CTR_DRBG_MAX_REQUEST */
2056
2057 #if defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT)
2058 if( strcmp( "MBEDTLS_CTR_DRBG_MAX_SEED_INPUT", config ) == 0 )
2059 {
2060 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_MAX_SEED_INPUT );
2061 return( 0 );
2062 }
2063 #endif /* MBEDTLS_CTR_DRBG_MAX_SEED_INPUT */
2064
2065 #if defined(MBEDTLS_HMAC_DRBG_RESEED_INTERVAL)
2066 if( strcmp( "MBEDTLS_HMAC_DRBG_RESEED_INTERVAL", config ) == 0 )
2067 {
2068 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_RESEED_INTERVAL );
2069 return( 0 );
2070 }
2071 #endif /* MBEDTLS_HMAC_DRBG_RESEED_INTERVAL */
2072
2073 #if defined(MBEDTLS_HMAC_DRBG_MAX_INPUT)
2074 if( strcmp( "MBEDTLS_HMAC_DRBG_MAX_INPUT", config ) == 0 )
2075 {
2076 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_MAX_INPUT );
2077 return( 0 );
2078 }
2079 #endif /* MBEDTLS_HMAC_DRBG_MAX_INPUT */
2080
2081 #if defined(MBEDTLS_HMAC_DRBG_MAX_REQUEST)
2082 if( strcmp( "MBEDTLS_HMAC_DRBG_MAX_REQUEST", config ) == 0 )
2083 {
2084 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_MAX_REQUEST );
2085 return( 0 );
2086 }
2087 #endif /* MBEDTLS_HMAC_DRBG_MAX_REQUEST */
2088
2089 #if defined(MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT)
2090 if( strcmp( "MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT", config ) == 0 )
2091 {
2092 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT );
2093 return( 0 );
2094 }
2095 #endif /* MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT */
2096
2097 #if defined(MBEDTLS_ECP_WINDOW_SIZE)
2098 if( strcmp( "MBEDTLS_ECP_WINDOW_SIZE", config ) == 0 )
2099 {
2100 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_WINDOW_SIZE );
2101 return( 0 );
2102 }
2103 #endif /* MBEDTLS_ECP_WINDOW_SIZE */
2104
2105 #if defined(MBEDTLS_ECP_FIXED_POINT_OPTIM)
2106 if( strcmp( "MBEDTLS_ECP_FIXED_POINT_OPTIM", config ) == 0 )
2107 {
2108 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_FIXED_POINT_OPTIM );
2109 return( 0 );
2110 }
2111 #endif /* MBEDTLS_ECP_FIXED_POINT_OPTIM */
2112
2113 #if defined(MBEDTLS_ENTROPY_MAX_SOURCES)
2114 if( strcmp( "MBEDTLS_ENTROPY_MAX_SOURCES", config ) == 0 )
2115 {
2116 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_MAX_SOURCES );
2117 return( 0 );
2118 }
2119 #endif /* MBEDTLS_ENTROPY_MAX_SOURCES */
2120
2121 #if defined(MBEDTLS_ENTROPY_MAX_GATHER)
2122 if( strcmp( "MBEDTLS_ENTROPY_MAX_GATHER", config ) == 0 )
2123 {
2124 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_MAX_GATHER );
2125 return( 0 );
2126 }
2127 #endif /* MBEDTLS_ENTROPY_MAX_GATHER */
2128
2129 #if defined(MBEDTLS_ENTROPY_MIN_HARDWARE)
2130 if( strcmp( "MBEDTLS_ENTROPY_MIN_HARDWARE", config ) == 0 )
2131 {
2132 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_MIN_HARDWARE );
2133 return( 0 );
2134 }
2135 #endif /* MBEDTLS_ENTROPY_MIN_HARDWARE */
2136
2137 #if defined(MBEDTLS_MEMORY_ALIGN_MULTIPLE)
2138 if( strcmp( "MBEDTLS_MEMORY_ALIGN_MULTIPLE", config ) == 0 )
2139 {
2140 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_ALIGN_MULTIPLE );
2141 return( 0 );
2142 }
2143 #endif /* MBEDTLS_MEMORY_ALIGN_MULTIPLE */
2144
2145 #if defined(MBEDTLS_PLATFORM_STD_MEM_HDR)
2146 if( strcmp( "MBEDTLS_PLATFORM_STD_MEM_HDR", config ) == 0 )
2147 {
2148 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_MEM_HDR );
2149 return( 0 );
2150 }
2151 #endif /* MBEDTLS_PLATFORM_STD_MEM_HDR */
2152
2153 #if defined(MBEDTLS_PLATFORM_STD_CALLOC)
2154 if( strcmp( "MBEDTLS_PLATFORM_STD_CALLOC", config ) == 0 )
2155 {
2156 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_CALLOC );
2157 return( 0 );
2158 }
2159 #endif /* MBEDTLS_PLATFORM_STD_CALLOC */
2160
2161 #if defined(MBEDTLS_PLATFORM_STD_FREE)
2162 if( strcmp( "MBEDTLS_PLATFORM_STD_FREE", config ) == 0 )
2163 {
2164 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_FREE );
2165 return( 0 );
2166 }
2167 #endif /* MBEDTLS_PLATFORM_STD_FREE */
2168
2169 #if defined(MBEDTLS_PLATFORM_STD_EXIT)
2170 if( strcmp( "MBEDTLS_PLATFORM_STD_EXIT", config ) == 0 )
2171 {
2172 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_EXIT );
2173 return( 0 );
2174 }
2175 #endif /* MBEDTLS_PLATFORM_STD_EXIT */
2176
2177 #if defined(MBEDTLS_PLATFORM_STD_TIME)
2178 if( strcmp( "MBEDTLS_PLATFORM_STD_TIME", config ) == 0 )
2179 {
2180 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_TIME );
2181 return( 0 );
2182 }
2183 #endif /* MBEDTLS_PLATFORM_STD_TIME */
2184
2185 #if defined(MBEDTLS_PLATFORM_STD_FPRINTF)
2186 if( strcmp( "MBEDTLS_PLATFORM_STD_FPRINTF", config ) == 0 )
2187 {
2188 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_FPRINTF );
2189 return( 0 );
2190 }
2191 #endif /* MBEDTLS_PLATFORM_STD_FPRINTF */
2192
2193 #if defined(MBEDTLS_PLATFORM_STD_PRINTF)
2194 if( strcmp( "MBEDTLS_PLATFORM_STD_PRINTF", config ) == 0 )
2195 {
2196 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_PRINTF );
2197 return( 0 );
2198 }
2199 #endif /* MBEDTLS_PLATFORM_STD_PRINTF */
2200
2201 #if defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
2202 if( strcmp( "MBEDTLS_PLATFORM_STD_SNPRINTF", config ) == 0 )
2203 {
2204 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_SNPRINTF );
2205 return( 0 );
2206 }
2207 #endif /* MBEDTLS_PLATFORM_STD_SNPRINTF */
2208
2209 #if defined(MBEDTLS_PLATFORM_STD_EXIT_SUCCESS)
2210 if( strcmp( "MBEDTLS_PLATFORM_STD_EXIT_SUCCESS", config ) == 0 )
2211 {
2212 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_EXIT_SUCCESS );
2213 return( 0 );
2214 }
2215 #endif /* MBEDTLS_PLATFORM_STD_EXIT_SUCCESS */
2216
2217 #if defined(MBEDTLS_PLATFORM_STD_EXIT_FAILURE)
2218 if( strcmp( "MBEDTLS_PLATFORM_STD_EXIT_FAILURE", config ) == 0 )
2219 {
2220 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_EXIT_FAILURE );
2221 return( 0 );
2222 }
2223 #endif /* MBEDTLS_PLATFORM_STD_EXIT_FAILURE */
2224
2225 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)
2226 if( strcmp( "MBEDTLS_PLATFORM_STD_NV_SEED_READ", config ) == 0 )
2227 {
2228 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_NV_SEED_READ );
2229 return( 0 );
2230 }
2231 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_READ */
2232
2233 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)
2234 if( strcmp( "MBEDTLS_PLATFORM_STD_NV_SEED_WRITE", config ) == 0 )
2235 {
2236 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_NV_SEED_WRITE );
2237 return( 0 );
2238 }
2239 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_WRITE */
2240
2241 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_FILE)
2242 if( strcmp( "MBEDTLS_PLATFORM_STD_NV_SEED_FILE", config ) == 0 )
2243 {
2244 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_NV_SEED_FILE );
2245 return( 0 );
2246 }
2247 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_FILE */
2248
2249 #if defined(MBEDTLS_PLATFORM_CALLOC_MACRO)
2250 if( strcmp( "MBEDTLS_PLATFORM_CALLOC_MACRO", config ) == 0 )
2251 {
2252 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_CALLOC_MACRO );
2253 return( 0 );
2254 }
2255 #endif /* MBEDTLS_PLATFORM_CALLOC_MACRO */
2256
2257 #if defined(MBEDTLS_PLATFORM_FREE_MACRO)
2258 if( strcmp( "MBEDTLS_PLATFORM_FREE_MACRO", config ) == 0 )
2259 {
2260 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_FREE_MACRO );
2261 return( 0 );
2262 }
2263 #endif /* MBEDTLS_PLATFORM_FREE_MACRO */
2264
2265 #if defined(MBEDTLS_PLATFORM_EXIT_MACRO)
2266 if( strcmp( "MBEDTLS_PLATFORM_EXIT_MACRO", config ) == 0 )
2267 {
2268 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_EXIT_MACRO );
2269 return( 0 );
2270 }
2271 #endif /* MBEDTLS_PLATFORM_EXIT_MACRO */
2272
2273 #if defined(MBEDTLS_PLATFORM_TIME_MACRO)
2274 if( strcmp( "MBEDTLS_PLATFORM_TIME_MACRO", config ) == 0 )
2275 {
2276 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_TIME_MACRO );
2277 return( 0 );
2278 }
2279 #endif /* MBEDTLS_PLATFORM_TIME_MACRO */
2280
2281 #if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO)
2282 if( strcmp( "MBEDTLS_PLATFORM_TIME_TYPE_MACRO", config ) == 0 )
2283 {
2284 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_TIME_TYPE_MACRO );
2285 return( 0 );
2286 }
2287 #endif /* MBEDTLS_PLATFORM_TIME_TYPE_MACRO */
2288
2289 #if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO)
2290 if( strcmp( "MBEDTLS_PLATFORM_FPRINTF_MACRO", config ) == 0 )
2291 {
2292 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_FPRINTF_MACRO );
2293 return( 0 );
2294 }
2295 #endif /* MBEDTLS_PLATFORM_FPRINTF_MACRO */
2296
2297 #if defined(MBEDTLS_PLATFORM_PRINTF_MACRO)
2298 if( strcmp( "MBEDTLS_PLATFORM_PRINTF_MACRO", config ) == 0 )
2299 {
2300 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_PRINTF_MACRO );
2301 return( 0 );
2302 }
2303 #endif /* MBEDTLS_PLATFORM_PRINTF_MACRO */
2304
2305 #if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO)
2306 if( strcmp( "MBEDTLS_PLATFORM_SNPRINTF_MACRO", config ) == 0 )
2307 {
2308 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_SNPRINTF_MACRO );
2309 return( 0 );
2310 }
2311 #endif /* MBEDTLS_PLATFORM_SNPRINTF_MACRO */
2312
2313 #if defined(MBEDTLS_PLATFORM_VSNPRINTF_MACRO)
2314 if( strcmp( "MBEDTLS_PLATFORM_VSNPRINTF_MACRO", config ) == 0 )
2315 {
2316 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_VSNPRINTF_MACRO );
2317 return( 0 );
2318 }
2319 #endif /* MBEDTLS_PLATFORM_VSNPRINTF_MACRO */
2320
2321 #if defined(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO)
2322 if( strcmp( "MBEDTLS_PLATFORM_NV_SEED_READ_MACRO", config ) == 0 )
2323 {
2324 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NV_SEED_READ_MACRO );
2325 return( 0 );
2326 }
2327 #endif /* MBEDTLS_PLATFORM_NV_SEED_READ_MACRO */
2328
2329 #if defined(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO)
2330 if( strcmp( "MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO", config ) == 0 )
2331 {
2332 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO );
2333 return( 0 );
2334 }
2335 #endif /* MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO */
2336
2337 #if defined(MBEDTLS_CHECK_RETURN)
2338 if( strcmp( "MBEDTLS_CHECK_RETURN", config ) == 0 )
2339 {
2340 MACRO_EXPANSION_TO_STR( MBEDTLS_CHECK_RETURN );
2341 return( 0 );
2342 }
2343 #endif /* MBEDTLS_CHECK_RETURN */
2344
2345 #if defined(MBEDTLS_IGNORE_RETURN)
2346 if( strcmp( "MBEDTLS_IGNORE_RETURN", config ) == 0 )
2347 {
2348 MACRO_EXPANSION_TO_STR( MBEDTLS_IGNORE_RETURN );
2349 return( 0 );
2350 }
2351 #endif /* MBEDTLS_IGNORE_RETURN */
2352
2353 #if defined(MBEDTLS_PSA_HMAC_DRBG_MD_TYPE)
2354 if( strcmp( "MBEDTLS_PSA_HMAC_DRBG_MD_TYPE", config ) == 0 )
2355 {
2356 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_HMAC_DRBG_MD_TYPE );
2357 return( 0 );
2358 }
2359 #endif /* MBEDTLS_PSA_HMAC_DRBG_MD_TYPE */
2360
2361 #if defined(MBEDTLS_PSA_KEY_SLOT_COUNT)
2362 if( strcmp( "MBEDTLS_PSA_KEY_SLOT_COUNT", config ) == 0 )
2363 {
2364 MACRO_EXPANSION_TO_STR( MBEDTLS_PSA_KEY_SLOT_COUNT );
2365 return( 0 );
2366 }
2367 #endif /* MBEDTLS_PSA_KEY_SLOT_COUNT */
2368
2369 #if defined(MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT)
2370 if( strcmp( "MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT", config ) == 0 )
2371 {
2372 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT );
2373 return( 0 );
2374 }
2375 #endif /* MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT */
2376
2377 #if defined(MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES)
2378 if( strcmp( "MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES", config ) == 0 )
2379 {
2380 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES );
2381 return( 0 );
2382 }
2383 #endif /* MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES */
2384
2385 #if defined(MBEDTLS_SSL_IN_CONTENT_LEN)
2386 if( strcmp( "MBEDTLS_SSL_IN_CONTENT_LEN", config ) == 0 )
2387 {
2388 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_IN_CONTENT_LEN );
2389 return( 0 );
2390 }
2391 #endif /* MBEDTLS_SSL_IN_CONTENT_LEN */
2392
2393 #if defined(MBEDTLS_SSL_CID_IN_LEN_MAX)
2394 if( strcmp( "MBEDTLS_SSL_CID_IN_LEN_MAX", config ) == 0 )
2395 {
2396 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CID_IN_LEN_MAX );
2397 return( 0 );
2398 }
2399 #endif /* MBEDTLS_SSL_CID_IN_LEN_MAX */
2400
2401 #if defined(MBEDTLS_SSL_CID_OUT_LEN_MAX)
2402 if( strcmp( "MBEDTLS_SSL_CID_OUT_LEN_MAX", config ) == 0 )
2403 {
2404 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CID_OUT_LEN_MAX );
2405 return( 0 );
2406 }
2407 #endif /* MBEDTLS_SSL_CID_OUT_LEN_MAX */
2408
2409 #if defined(MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY)
2410 if( strcmp( "MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY", config ) == 0 )
2411 {
2412 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY );
2413 return( 0 );
2414 }
2415 #endif /* MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY */
2416
2417 #if defined(MBEDTLS_SSL_OUT_CONTENT_LEN)
2418 if( strcmp( "MBEDTLS_SSL_OUT_CONTENT_LEN", config ) == 0 )
2419 {
2420 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_OUT_CONTENT_LEN );
2421 return( 0 );
2422 }
2423 #endif /* MBEDTLS_SSL_OUT_CONTENT_LEN */
2424
2425 #if defined(MBEDTLS_SSL_DTLS_MAX_BUFFERING)
2426 if( strcmp( "MBEDTLS_SSL_DTLS_MAX_BUFFERING", config ) == 0 )
2427 {
2428 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_MAX_BUFFERING );
2429 return( 0 );
2430 }
2431 #endif /* MBEDTLS_SSL_DTLS_MAX_BUFFERING */
2432
2433 #if defined(MBEDTLS_PSK_MAX_LEN)
2434 if( strcmp( "MBEDTLS_PSK_MAX_LEN", config ) == 0 )
2435 {
2436 MACRO_EXPANSION_TO_STR( MBEDTLS_PSK_MAX_LEN );
2437 return( 0 );
2438 }
2439 #endif /* MBEDTLS_PSK_MAX_LEN */
2440
2441 #if defined(MBEDTLS_SSL_COOKIE_TIMEOUT)
2442 if( strcmp( "MBEDTLS_SSL_COOKIE_TIMEOUT", config ) == 0 )
2443 {
2444 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_COOKIE_TIMEOUT );
2445 return( 0 );
2446 }
2447 #endif /* MBEDTLS_SSL_COOKIE_TIMEOUT */
2448
2449 #if defined(MBEDTLS_TLS_EXT_CID)
2450 if( strcmp( "MBEDTLS_TLS_EXT_CID", config ) == 0 )
2451 {
2452 MACRO_EXPANSION_TO_STR( MBEDTLS_TLS_EXT_CID );
2453 return( 0 );
2454 }
2455 #endif /* MBEDTLS_TLS_EXT_CID */
2456
2457 #if defined(MBEDTLS_X509_MAX_INTERMEDIATE_CA)
2458 if( strcmp( "MBEDTLS_X509_MAX_INTERMEDIATE_CA", config ) == 0 )
2459 {
2460 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_MAX_INTERMEDIATE_CA );
2461 return( 0 );
2462 }
2463 #endif /* MBEDTLS_X509_MAX_INTERMEDIATE_CA */
2464
2465 #if defined(MBEDTLS_X509_MAX_FILE_PATH_LEN)
2466 if( strcmp( "MBEDTLS_X509_MAX_FILE_PATH_LEN", config ) == 0 )
2467 {
2468 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_MAX_FILE_PATH_LEN );
2469 return( 0 );
2470 }
2471 #endif /* MBEDTLS_X509_MAX_FILE_PATH_LEN */
2472
2473 #if defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
2474 if( strcmp( "MBEDTLS_PLATFORM_ZEROIZE_ALT", config ) == 0 )
2475 {
2476 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_ZEROIZE_ALT );
2477 return( 0 );
2478 }
2479 #endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
2480
2481 #if defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
2482 if( strcmp( "MBEDTLS_PLATFORM_GMTIME_R_ALT", config ) == 0 )
2483 {
2484 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_GMTIME_R_ALT );
2485 return( 0 );
2486 }
2487 #endif /* MBEDTLS_PLATFORM_GMTIME_R_ALT */
2488
2489 #if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
2490 if( strcmp( "MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED", config ) == 0 )
2491 {
2492 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED );
2493 return( 0 );
2494 }
2495 #endif /* MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED */
2496
2497 /* If the symbol is not found, return an error */
2498 return( 1 );
2499 }
2500
list_config(void)2501 void list_config( void )
2502 {
2503 #if defined(MBEDTLS_CONFIG_VERSION)
2504 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CONFIG_VERSION);
2505 #endif /* MBEDTLS_CONFIG_VERSION */
2506
2507 #if defined(MBEDTLS_HAVE_ASM)
2508 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HAVE_ASM);
2509 #endif /* MBEDTLS_HAVE_ASM */
2510
2511 #if defined(MBEDTLS_NO_UDBL_DIVISION)
2512 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NO_UDBL_DIVISION);
2513 #endif /* MBEDTLS_NO_UDBL_DIVISION */
2514
2515 #if defined(MBEDTLS_NO_64BIT_MULTIPLICATION)
2516 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NO_64BIT_MULTIPLICATION);
2517 #endif /* MBEDTLS_NO_64BIT_MULTIPLICATION */
2518
2519 #if defined(MBEDTLS_HAVE_SSE2)
2520 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HAVE_SSE2);
2521 #endif /* MBEDTLS_HAVE_SSE2 */
2522
2523 #if defined(MBEDTLS_HAVE_TIME)
2524 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HAVE_TIME);
2525 #endif /* MBEDTLS_HAVE_TIME */
2526
2527 #if defined(MBEDTLS_HAVE_TIME_DATE)
2528 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HAVE_TIME_DATE);
2529 #endif /* MBEDTLS_HAVE_TIME_DATE */
2530
2531 #if defined(MBEDTLS_PLATFORM_MEMORY)
2532 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_MEMORY);
2533 #endif /* MBEDTLS_PLATFORM_MEMORY */
2534
2535 #if defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
2536 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS);
2537 #endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
2538
2539 #if defined(MBEDTLS_PLATFORM_EXIT_ALT)
2540 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_EXIT_ALT);
2541 #endif /* MBEDTLS_PLATFORM_EXIT_ALT */
2542
2543 #if defined(MBEDTLS_PLATFORM_TIME_ALT)
2544 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_TIME_ALT);
2545 #endif /* MBEDTLS_PLATFORM_TIME_ALT */
2546
2547 #if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
2548 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_FPRINTF_ALT);
2549 #endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
2550
2551 #if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
2552 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_PRINTF_ALT);
2553 #endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
2554
2555 #if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
2556 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_SNPRINTF_ALT);
2557 #endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
2558
2559 #if defined(MBEDTLS_PLATFORM_VSNPRINTF_ALT)
2560 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_VSNPRINTF_ALT);
2561 #endif /* MBEDTLS_PLATFORM_VSNPRINTF_ALT */
2562
2563 #if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
2564 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_NV_SEED_ALT);
2565 #endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
2566
2567 #if defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)
2568 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT);
2569 #endif /* MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */
2570
2571 #if defined(MBEDTLS_DEPRECATED_WARNING)
2572 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DEPRECATED_WARNING);
2573 #endif /* MBEDTLS_DEPRECATED_WARNING */
2574
2575 #if defined(MBEDTLS_DEPRECATED_REMOVED)
2576 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DEPRECATED_REMOVED);
2577 #endif /* MBEDTLS_DEPRECATED_REMOVED */
2578
2579 #if defined(MBEDTLS_TIMING_ALT)
2580 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_TIMING_ALT);
2581 #endif /* MBEDTLS_TIMING_ALT */
2582
2583 #if defined(MBEDTLS_AES_ALT)
2584 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_ALT);
2585 #endif /* MBEDTLS_AES_ALT */
2586
2587 #if defined(MBEDTLS_ARIA_ALT)
2588 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ARIA_ALT);
2589 #endif /* MBEDTLS_ARIA_ALT */
2590
2591 #if defined(MBEDTLS_CAMELLIA_ALT)
2592 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CAMELLIA_ALT);
2593 #endif /* MBEDTLS_CAMELLIA_ALT */
2594
2595 #if defined(MBEDTLS_CCM_ALT)
2596 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CCM_ALT);
2597 #endif /* MBEDTLS_CCM_ALT */
2598
2599 #if defined(MBEDTLS_CHACHA20_ALT)
2600 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CHACHA20_ALT);
2601 #endif /* MBEDTLS_CHACHA20_ALT */
2602
2603 #if defined(MBEDTLS_CHACHAPOLY_ALT)
2604 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CHACHAPOLY_ALT);
2605 #endif /* MBEDTLS_CHACHAPOLY_ALT */
2606
2607 #if defined(MBEDTLS_CMAC_ALT)
2608 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CMAC_ALT);
2609 #endif /* MBEDTLS_CMAC_ALT */
2610
2611 #if defined(MBEDTLS_DES_ALT)
2612 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DES_ALT);
2613 #endif /* MBEDTLS_DES_ALT */
2614
2615 #if defined(MBEDTLS_DHM_ALT)
2616 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DHM_ALT);
2617 #endif /* MBEDTLS_DHM_ALT */
2618
2619 #if defined(MBEDTLS_ECJPAKE_ALT)
2620 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECJPAKE_ALT);
2621 #endif /* MBEDTLS_ECJPAKE_ALT */
2622
2623 #if defined(MBEDTLS_GCM_ALT)
2624 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_GCM_ALT);
2625 #endif /* MBEDTLS_GCM_ALT */
2626
2627 #if defined(MBEDTLS_NIST_KW_ALT)
2628 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NIST_KW_ALT);
2629 #endif /* MBEDTLS_NIST_KW_ALT */
2630
2631 #if defined(MBEDTLS_MD5_ALT)
2632 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MD5_ALT);
2633 #endif /* MBEDTLS_MD5_ALT */
2634
2635 #if defined(MBEDTLS_POLY1305_ALT)
2636 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_POLY1305_ALT);
2637 #endif /* MBEDTLS_POLY1305_ALT */
2638
2639 #if defined(MBEDTLS_RIPEMD160_ALT)
2640 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_RIPEMD160_ALT);
2641 #endif /* MBEDTLS_RIPEMD160_ALT */
2642
2643 #if defined(MBEDTLS_RSA_ALT)
2644 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_RSA_ALT);
2645 #endif /* MBEDTLS_RSA_ALT */
2646
2647 #if defined(MBEDTLS_SHA1_ALT)
2648 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA1_ALT);
2649 #endif /* MBEDTLS_SHA1_ALT */
2650
2651 #if defined(MBEDTLS_SHA256_ALT)
2652 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA256_ALT);
2653 #endif /* MBEDTLS_SHA256_ALT */
2654
2655 #if defined(MBEDTLS_SHA512_ALT)
2656 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA512_ALT);
2657 #endif /* MBEDTLS_SHA512_ALT */
2658
2659 #if defined(MBEDTLS_ECP_ALT)
2660 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_ALT);
2661 #endif /* MBEDTLS_ECP_ALT */
2662
2663 #if defined(MBEDTLS_MD5_PROCESS_ALT)
2664 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MD5_PROCESS_ALT);
2665 #endif /* MBEDTLS_MD5_PROCESS_ALT */
2666
2667 #if defined(MBEDTLS_RIPEMD160_PROCESS_ALT)
2668 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_RIPEMD160_PROCESS_ALT);
2669 #endif /* MBEDTLS_RIPEMD160_PROCESS_ALT */
2670
2671 #if defined(MBEDTLS_SHA1_PROCESS_ALT)
2672 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA1_PROCESS_ALT);
2673 #endif /* MBEDTLS_SHA1_PROCESS_ALT */
2674
2675 #if defined(MBEDTLS_SHA256_PROCESS_ALT)
2676 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA256_PROCESS_ALT);
2677 #endif /* MBEDTLS_SHA256_PROCESS_ALT */
2678
2679 #if defined(MBEDTLS_SHA512_PROCESS_ALT)
2680 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA512_PROCESS_ALT);
2681 #endif /* MBEDTLS_SHA512_PROCESS_ALT */
2682
2683 #if defined(MBEDTLS_DES_SETKEY_ALT)
2684 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DES_SETKEY_ALT);
2685 #endif /* MBEDTLS_DES_SETKEY_ALT */
2686
2687 #if defined(MBEDTLS_DES_CRYPT_ECB_ALT)
2688 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DES_CRYPT_ECB_ALT);
2689 #endif /* MBEDTLS_DES_CRYPT_ECB_ALT */
2690
2691 #if defined(MBEDTLS_DES3_CRYPT_ECB_ALT)
2692 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DES3_CRYPT_ECB_ALT);
2693 #endif /* MBEDTLS_DES3_CRYPT_ECB_ALT */
2694
2695 #if defined(MBEDTLS_AES_SETKEY_ENC_ALT)
2696 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_SETKEY_ENC_ALT);
2697 #endif /* MBEDTLS_AES_SETKEY_ENC_ALT */
2698
2699 #if defined(MBEDTLS_AES_SETKEY_DEC_ALT)
2700 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_SETKEY_DEC_ALT);
2701 #endif /* MBEDTLS_AES_SETKEY_DEC_ALT */
2702
2703 #if defined(MBEDTLS_AES_ENCRYPT_ALT)
2704 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_ENCRYPT_ALT);
2705 #endif /* MBEDTLS_AES_ENCRYPT_ALT */
2706
2707 #if defined(MBEDTLS_AES_DECRYPT_ALT)
2708 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_DECRYPT_ALT);
2709 #endif /* MBEDTLS_AES_DECRYPT_ALT */
2710
2711 #if defined(MBEDTLS_ECDH_GEN_PUBLIC_ALT)
2712 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDH_GEN_PUBLIC_ALT);
2713 #endif /* MBEDTLS_ECDH_GEN_PUBLIC_ALT */
2714
2715 #if defined(MBEDTLS_ECDH_COMPUTE_SHARED_ALT)
2716 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDH_COMPUTE_SHARED_ALT);
2717 #endif /* MBEDTLS_ECDH_COMPUTE_SHARED_ALT */
2718
2719 #if defined(MBEDTLS_ECDSA_VERIFY_ALT)
2720 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDSA_VERIFY_ALT);
2721 #endif /* MBEDTLS_ECDSA_VERIFY_ALT */
2722
2723 #if defined(MBEDTLS_ECDSA_SIGN_ALT)
2724 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDSA_SIGN_ALT);
2725 #endif /* MBEDTLS_ECDSA_SIGN_ALT */
2726
2727 #if defined(MBEDTLS_ECDSA_GENKEY_ALT)
2728 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDSA_GENKEY_ALT);
2729 #endif /* MBEDTLS_ECDSA_GENKEY_ALT */
2730
2731 #if defined(MBEDTLS_ECP_INTERNAL_ALT)
2732 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_INTERNAL_ALT);
2733 #endif /* MBEDTLS_ECP_INTERNAL_ALT */
2734
2735 #if defined(MBEDTLS_ECP_NO_FALLBACK)
2736 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_NO_FALLBACK);
2737 #endif /* MBEDTLS_ECP_NO_FALLBACK */
2738
2739 #if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT)
2740 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_RANDOMIZE_JAC_ALT);
2741 #endif /* MBEDTLS_ECP_RANDOMIZE_JAC_ALT */
2742
2743 #if defined(MBEDTLS_ECP_ADD_MIXED_ALT)
2744 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_ADD_MIXED_ALT);
2745 #endif /* MBEDTLS_ECP_ADD_MIXED_ALT */
2746
2747 #if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT)
2748 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DOUBLE_JAC_ALT);
2749 #endif /* MBEDTLS_ECP_DOUBLE_JAC_ALT */
2750
2751 #if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT)
2752 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT);
2753 #endif /* MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT */
2754
2755 #if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT)
2756 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_NORMALIZE_JAC_ALT);
2757 #endif /* MBEDTLS_ECP_NORMALIZE_JAC_ALT */
2758
2759 #if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT)
2760 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT);
2761 #endif /* MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT */
2762
2763 #if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT)
2764 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT);
2765 #endif /* MBEDTLS_ECP_RANDOMIZE_MXZ_ALT */
2766
2767 #if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT)
2768 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_NORMALIZE_MXZ_ALT);
2769 #endif /* MBEDTLS_ECP_NORMALIZE_MXZ_ALT */
2770
2771 #if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
2772 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_HARDWARE_ALT);
2773 #endif /* MBEDTLS_ENTROPY_HARDWARE_ALT */
2774
2775 #if defined(MBEDTLS_AES_ROM_TABLES)
2776 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_ROM_TABLES);
2777 #endif /* MBEDTLS_AES_ROM_TABLES */
2778
2779 #if defined(MBEDTLS_AES_FEWER_TABLES)
2780 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_FEWER_TABLES);
2781 #endif /* MBEDTLS_AES_FEWER_TABLES */
2782
2783 #if defined(MBEDTLS_CAMELLIA_SMALL_MEMORY)
2784 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CAMELLIA_SMALL_MEMORY);
2785 #endif /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
2786
2787 #if defined(MBEDTLS_CHECK_RETURN_WARNING)
2788 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CHECK_RETURN_WARNING);
2789 #endif /* MBEDTLS_CHECK_RETURN_WARNING */
2790
2791 #if defined(MBEDTLS_CIPHER_MODE_CBC)
2792 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_MODE_CBC);
2793 #endif /* MBEDTLS_CIPHER_MODE_CBC */
2794
2795 #if defined(MBEDTLS_CIPHER_MODE_CFB)
2796 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_MODE_CFB);
2797 #endif /* MBEDTLS_CIPHER_MODE_CFB */
2798
2799 #if defined(MBEDTLS_CIPHER_MODE_CTR)
2800 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_MODE_CTR);
2801 #endif /* MBEDTLS_CIPHER_MODE_CTR */
2802
2803 #if defined(MBEDTLS_CIPHER_MODE_OFB)
2804 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_MODE_OFB);
2805 #endif /* MBEDTLS_CIPHER_MODE_OFB */
2806
2807 #if defined(MBEDTLS_CIPHER_MODE_XTS)
2808 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_MODE_XTS);
2809 #endif /* MBEDTLS_CIPHER_MODE_XTS */
2810
2811 #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2812 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_NULL_CIPHER);
2813 #endif /* MBEDTLS_CIPHER_NULL_CIPHER */
2814
2815 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
2816 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_PADDING_PKCS7);
2817 #endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
2818
2819 #if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
2820 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS);
2821 #endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
2822
2823 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
2824 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN);
2825 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
2826
2827 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
2828 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_PADDING_ZEROS);
2829 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
2830
2831 #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
2832 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY);
2833 #endif /* MBEDTLS_CTR_DRBG_USE_128_BIT_KEY */
2834
2835 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
2836 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP192R1_ENABLED);
2837 #endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
2838
2839 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
2840 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP224R1_ENABLED);
2841 #endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
2842
2843 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
2844 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP256R1_ENABLED);
2845 #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
2846
2847 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
2848 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP384R1_ENABLED);
2849 #endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
2850
2851 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
2852 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP521R1_ENABLED);
2853 #endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
2854
2855 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
2856 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP192K1_ENABLED);
2857 #endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
2858
2859 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
2860 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP224K1_ENABLED);
2861 #endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
2862
2863 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
2864 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_SECP256K1_ENABLED);
2865 #endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
2866
2867 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
2868 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_BP256R1_ENABLED);
2869 #endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
2870
2871 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
2872 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_BP384R1_ENABLED);
2873 #endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
2874
2875 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
2876 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_BP512R1_ENABLED);
2877 #endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
2878
2879 #if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
2880 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_CURVE25519_ENABLED);
2881 #endif /* MBEDTLS_ECP_DP_CURVE25519_ENABLED */
2882
2883 #if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
2884 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_DP_CURVE448_ENABLED);
2885 #endif /* MBEDTLS_ECP_DP_CURVE448_ENABLED */
2886
2887 #if defined(MBEDTLS_ECP_NIST_OPTIM)
2888 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_NIST_OPTIM);
2889 #endif /* MBEDTLS_ECP_NIST_OPTIM */
2890
2891 #if defined(MBEDTLS_ECP_RESTARTABLE)
2892 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_RESTARTABLE);
2893 #endif /* MBEDTLS_ECP_RESTARTABLE */
2894
2895 #if defined(MBEDTLS_ECDSA_DETERMINISTIC)
2896 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDSA_DETERMINISTIC);
2897 #endif /* MBEDTLS_ECDSA_DETERMINISTIC */
2898
2899 #if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
2900 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED);
2901 #endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
2902
2903 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
2904 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED);
2905 #endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
2906
2907 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
2908 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED);
2909 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
2910
2911 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
2912 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED);
2913 #endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
2914
2915 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
2916 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED);
2917 #endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
2918
2919 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
2920 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED);
2921 #endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
2922
2923 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
2924 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED);
2925 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
2926
2927 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
2928 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED);
2929 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
2930
2931 #if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
2932 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED);
2933 #endif /* MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
2934
2935 #if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED)
2936 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED);
2937 #endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED */
2938
2939 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
2940 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED);
2941 #endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
2942
2943 #if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
2944 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PK_PARSE_EC_EXTENDED);
2945 #endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
2946
2947 #if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
2948 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ERROR_STRERROR_DUMMY);
2949 #endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
2950
2951 #if defined(MBEDTLS_GENPRIME)
2952 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_GENPRIME);
2953 #endif /* MBEDTLS_GENPRIME */
2954
2955 #if defined(MBEDTLS_FS_IO)
2956 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_FS_IO);
2957 #endif /* MBEDTLS_FS_IO */
2958
2959 #if defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
2960 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES);
2961 #endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
2962
2963 #if defined(MBEDTLS_NO_PLATFORM_ENTROPY)
2964 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NO_PLATFORM_ENTROPY);
2965 #endif /* MBEDTLS_NO_PLATFORM_ENTROPY */
2966
2967 #if defined(MBEDTLS_ENTROPY_FORCE_SHA256)
2968 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_FORCE_SHA256);
2969 #endif /* MBEDTLS_ENTROPY_FORCE_SHA256 */
2970
2971 #if defined(MBEDTLS_ENTROPY_NV_SEED)
2972 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_NV_SEED);
2973 #endif /* MBEDTLS_ENTROPY_NV_SEED */
2974
2975 #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
2976 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER);
2977 #endif /* MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */
2978
2979 #if defined(MBEDTLS_MEMORY_DEBUG)
2980 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MEMORY_DEBUG);
2981 #endif /* MBEDTLS_MEMORY_DEBUG */
2982
2983 #if defined(MBEDTLS_MEMORY_BACKTRACE)
2984 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MEMORY_BACKTRACE);
2985 #endif /* MBEDTLS_MEMORY_BACKTRACE */
2986
2987 #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
2988 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PK_RSA_ALT_SUPPORT);
2989 #endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
2990
2991 #if defined(MBEDTLS_PKCS1_V15)
2992 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PKCS1_V15);
2993 #endif /* MBEDTLS_PKCS1_V15 */
2994
2995 #if defined(MBEDTLS_PKCS1_V21)
2996 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PKCS1_V21);
2997 #endif /* MBEDTLS_PKCS1_V21 */
2998
2999 #if defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
3000 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS);
3001 #endif /* MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
3002
3003 #if defined(MBEDTLS_PSA_CRYPTO_CLIENT)
3004 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_CLIENT);
3005 #endif /* MBEDTLS_PSA_CRYPTO_CLIENT */
3006
3007 #if defined(MBEDTLS_PSA_CRYPTO_DRIVERS)
3008 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_DRIVERS);
3009 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS */
3010
3011 #if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
3012 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG);
3013 #endif /* MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
3014
3015 #if defined(MBEDTLS_PSA_CRYPTO_SPM)
3016 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_SPM);
3017 #endif /* MBEDTLS_PSA_CRYPTO_SPM */
3018
3019 #if defined(MBEDTLS_PSA_INJECT_ENTROPY)
3020 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_INJECT_ENTROPY);
3021 #endif /* MBEDTLS_PSA_INJECT_ENTROPY */
3022
3023 #if defined(MBEDTLS_RSA_NO_CRT)
3024 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_RSA_NO_CRT);
3025 #endif /* MBEDTLS_RSA_NO_CRT */
3026
3027 #if defined(MBEDTLS_SELF_TEST)
3028 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SELF_TEST);
3029 #endif /* MBEDTLS_SELF_TEST */
3030
3031 #if defined(MBEDTLS_SHA256_SMALLER)
3032 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA256_SMALLER);
3033 #endif /* MBEDTLS_SHA256_SMALLER */
3034
3035 #if defined(MBEDTLS_SHA512_SMALLER)
3036 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA512_SMALLER);
3037 #endif /* MBEDTLS_SHA512_SMALLER */
3038
3039 #if defined(MBEDTLS_SSL_ALL_ALERT_MESSAGES)
3040 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_ALL_ALERT_MESSAGES);
3041 #endif /* MBEDTLS_SSL_ALL_ALERT_MESSAGES */
3042
3043 #if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
3044 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DTLS_CONNECTION_ID);
3045 #endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
3046
3047 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
3048 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_ASYNC_PRIVATE);
3049 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
3050
3051 #if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
3052 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CONTEXT_SERIALIZATION);
3053 #endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
3054
3055 #if defined(MBEDTLS_SSL_DEBUG_ALL)
3056 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DEBUG_ALL);
3057 #endif /* MBEDTLS_SSL_DEBUG_ALL */
3058
3059 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
3060 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_ENCRYPT_THEN_MAC);
3061 #endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
3062
3063 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
3064 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_EXTENDED_MASTER_SECRET);
3065 #endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
3066
3067 #if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
3068 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE);
3069 #endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
3070
3071 #if defined(MBEDTLS_SSL_RENEGOTIATION)
3072 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_RENEGOTIATION);
3073 #endif /* MBEDTLS_SSL_RENEGOTIATION */
3074
3075 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
3076 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH);
3077 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
3078
3079 #if defined(MBEDTLS_SSL_PROTO_TLS1_2)
3080 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_PROTO_TLS1_2);
3081 #endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
3082
3083 #if defined(MBEDTLS_SSL_PROTO_TLS1_3)
3084 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_PROTO_TLS1_3);
3085 #endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
3086
3087 #if defined(MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE)
3088 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE);
3089 #endif /* MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE */
3090
3091 #if defined(MBEDTLS_SSL_PROTO_DTLS)
3092 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_PROTO_DTLS);
3093 #endif /* MBEDTLS_SSL_PROTO_DTLS */
3094
3095 #if defined(MBEDTLS_SSL_ALPN)
3096 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_ALPN);
3097 #endif /* MBEDTLS_SSL_ALPN */
3098
3099 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
3100 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DTLS_ANTI_REPLAY);
3101 #endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
3102
3103 #if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
3104 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DTLS_HELLO_VERIFY);
3105 #endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
3106
3107 #if defined(MBEDTLS_SSL_DTLS_SRTP)
3108 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DTLS_SRTP);
3109 #endif /* MBEDTLS_SSL_DTLS_SRTP */
3110
3111 #if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE)
3112 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE);
3113 #endif /* MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE */
3114
3115 #if defined(MBEDTLS_SSL_SESSION_TICKETS)
3116 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_SESSION_TICKETS);
3117 #endif /* MBEDTLS_SSL_SESSION_TICKETS */
3118
3119 #if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
3120 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_SERVER_NAME_INDICATION);
3121 #endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
3122
3123 #if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
3124 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH);
3125 #endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
3126
3127 #if defined(MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN)
3128 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN);
3129 #endif /* MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN */
3130
3131 #if defined(MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND)
3132 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND);
3133 #endif /* MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND */
3134
3135 #if defined(MBEDTLS_TEST_HOOKS)
3136 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_TEST_HOOKS);
3137 #endif /* MBEDTLS_TEST_HOOKS */
3138
3139 #if defined(MBEDTLS_THREADING_ALT)
3140 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_THREADING_ALT);
3141 #endif /* MBEDTLS_THREADING_ALT */
3142
3143 #if defined(MBEDTLS_THREADING_PTHREAD)
3144 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_THREADING_PTHREAD);
3145 #endif /* MBEDTLS_THREADING_PTHREAD */
3146
3147 #if defined(MBEDTLS_USE_PSA_CRYPTO)
3148 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_USE_PSA_CRYPTO);
3149 #endif /* MBEDTLS_USE_PSA_CRYPTO */
3150
3151 #if defined(MBEDTLS_PSA_CRYPTO_CONFIG)
3152 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_CONFIG);
3153 #endif /* MBEDTLS_PSA_CRYPTO_CONFIG */
3154
3155 #if defined(MBEDTLS_VERSION_FEATURES)
3156 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_VERSION_FEATURES);
3157 #endif /* MBEDTLS_VERSION_FEATURES */
3158
3159 #if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
3160 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK);
3161 #endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
3162
3163 #if defined(MBEDTLS_X509_REMOVE_INFO)
3164 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_REMOVE_INFO);
3165 #endif /* MBEDTLS_X509_REMOVE_INFO */
3166
3167 #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
3168 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_RSASSA_PSS_SUPPORT);
3169 #endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
3170
3171 #if defined(MBEDTLS_AESNI_C)
3172 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AESNI_C);
3173 #endif /* MBEDTLS_AESNI_C */
3174
3175 #if defined(MBEDTLS_AES_C)
3176 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_AES_C);
3177 #endif /* MBEDTLS_AES_C */
3178
3179 #if defined(MBEDTLS_ASN1_PARSE_C)
3180 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ASN1_PARSE_C);
3181 #endif /* MBEDTLS_ASN1_PARSE_C */
3182
3183 #if defined(MBEDTLS_ASN1_WRITE_C)
3184 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ASN1_WRITE_C);
3185 #endif /* MBEDTLS_ASN1_WRITE_C */
3186
3187 #if defined(MBEDTLS_BASE64_C)
3188 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_BASE64_C);
3189 #endif /* MBEDTLS_BASE64_C */
3190
3191 #if defined(MBEDTLS_BIGNUM_C)
3192 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_BIGNUM_C);
3193 #endif /* MBEDTLS_BIGNUM_C */
3194
3195 #if defined(MBEDTLS_CAMELLIA_C)
3196 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CAMELLIA_C);
3197 #endif /* MBEDTLS_CAMELLIA_C */
3198
3199 #if defined(MBEDTLS_ARIA_C)
3200 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ARIA_C);
3201 #endif /* MBEDTLS_ARIA_C */
3202
3203 #if defined(MBEDTLS_CCM_C)
3204 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CCM_C);
3205 #endif /* MBEDTLS_CCM_C */
3206
3207 #if defined(MBEDTLS_CHACHA20_C)
3208 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CHACHA20_C);
3209 #endif /* MBEDTLS_CHACHA20_C */
3210
3211 #if defined(MBEDTLS_CHACHAPOLY_C)
3212 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CHACHAPOLY_C);
3213 #endif /* MBEDTLS_CHACHAPOLY_C */
3214
3215 #if defined(MBEDTLS_CIPHER_C)
3216 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CIPHER_C);
3217 #endif /* MBEDTLS_CIPHER_C */
3218
3219 #if defined(MBEDTLS_CMAC_C)
3220 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CMAC_C);
3221 #endif /* MBEDTLS_CMAC_C */
3222
3223 #if defined(MBEDTLS_CTR_DRBG_C)
3224 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_C);
3225 #endif /* MBEDTLS_CTR_DRBG_C */
3226
3227 #if defined(MBEDTLS_DEBUG_C)
3228 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DEBUG_C);
3229 #endif /* MBEDTLS_DEBUG_C */
3230
3231 #if defined(MBEDTLS_DES_C)
3232 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DES_C);
3233 #endif /* MBEDTLS_DES_C */
3234
3235 #if defined(MBEDTLS_DHM_C)
3236 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_DHM_C);
3237 #endif /* MBEDTLS_DHM_C */
3238
3239 #if defined(MBEDTLS_ECDH_C)
3240 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDH_C);
3241 #endif /* MBEDTLS_ECDH_C */
3242
3243 #if defined(MBEDTLS_ECDSA_C)
3244 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDSA_C);
3245 #endif /* MBEDTLS_ECDSA_C */
3246
3247 #if defined(MBEDTLS_ECJPAKE_C)
3248 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECJPAKE_C);
3249 #endif /* MBEDTLS_ECJPAKE_C */
3250
3251 #if defined(MBEDTLS_ECP_C)
3252 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_C);
3253 #endif /* MBEDTLS_ECP_C */
3254
3255 #if defined(MBEDTLS_ENTROPY_C)
3256 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_C);
3257 #endif /* MBEDTLS_ENTROPY_C */
3258
3259 #if defined(MBEDTLS_ERROR_C)
3260 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ERROR_C);
3261 #endif /* MBEDTLS_ERROR_C */
3262
3263 #if defined(MBEDTLS_GCM_C)
3264 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_GCM_C);
3265 #endif /* MBEDTLS_GCM_C */
3266
3267 #if defined(MBEDTLS_HKDF_C)
3268 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HKDF_C);
3269 #endif /* MBEDTLS_HKDF_C */
3270
3271 #if defined(MBEDTLS_HMAC_DRBG_C)
3272 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HMAC_DRBG_C);
3273 #endif /* MBEDTLS_HMAC_DRBG_C */
3274
3275 #if defined(MBEDTLS_NIST_KW_C)
3276 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NIST_KW_C);
3277 #endif /* MBEDTLS_NIST_KW_C */
3278
3279 #if defined(MBEDTLS_MD_C)
3280 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MD_C);
3281 #endif /* MBEDTLS_MD_C */
3282
3283 #if defined(MBEDTLS_MD5_C)
3284 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MD5_C);
3285 #endif /* MBEDTLS_MD5_C */
3286
3287 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
3288 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MEMORY_BUFFER_ALLOC_C);
3289 #endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
3290
3291 #if defined(MBEDTLS_NET_C)
3292 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_NET_C);
3293 #endif /* MBEDTLS_NET_C */
3294
3295 #if defined(MBEDTLS_OID_C)
3296 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_OID_C);
3297 #endif /* MBEDTLS_OID_C */
3298
3299 #if defined(MBEDTLS_PADLOCK_C)
3300 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PADLOCK_C);
3301 #endif /* MBEDTLS_PADLOCK_C */
3302
3303 #if defined(MBEDTLS_PEM_PARSE_C)
3304 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PEM_PARSE_C);
3305 #endif /* MBEDTLS_PEM_PARSE_C */
3306
3307 #if defined(MBEDTLS_PEM_WRITE_C)
3308 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PEM_WRITE_C);
3309 #endif /* MBEDTLS_PEM_WRITE_C */
3310
3311 #if defined(MBEDTLS_PK_C)
3312 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PK_C);
3313 #endif /* MBEDTLS_PK_C */
3314
3315 #if defined(MBEDTLS_PK_PARSE_C)
3316 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PK_PARSE_C);
3317 #endif /* MBEDTLS_PK_PARSE_C */
3318
3319 #if defined(MBEDTLS_PK_WRITE_C)
3320 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PK_WRITE_C);
3321 #endif /* MBEDTLS_PK_WRITE_C */
3322
3323 #if defined(MBEDTLS_PKCS5_C)
3324 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PKCS5_C);
3325 #endif /* MBEDTLS_PKCS5_C */
3326
3327 #if defined(MBEDTLS_PKCS12_C)
3328 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PKCS12_C);
3329 #endif /* MBEDTLS_PKCS12_C */
3330
3331 #if defined(MBEDTLS_PLATFORM_C)
3332 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_C);
3333 #endif /* MBEDTLS_PLATFORM_C */
3334
3335 #if defined(MBEDTLS_POLY1305_C)
3336 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_POLY1305_C);
3337 #endif /* MBEDTLS_POLY1305_C */
3338
3339 #if defined(MBEDTLS_PSA_CRYPTO_C)
3340 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_C);
3341 #endif /* MBEDTLS_PSA_CRYPTO_C */
3342
3343 #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
3344 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_SE_C);
3345 #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
3346
3347 #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
3348 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_CRYPTO_STORAGE_C);
3349 #endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
3350
3351 #if defined(MBEDTLS_PSA_ITS_FILE_C)
3352 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_ITS_FILE_C);
3353 #endif /* MBEDTLS_PSA_ITS_FILE_C */
3354
3355 #if defined(MBEDTLS_RIPEMD160_C)
3356 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_RIPEMD160_C);
3357 #endif /* MBEDTLS_RIPEMD160_C */
3358
3359 #if defined(MBEDTLS_RSA_C)
3360 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_RSA_C);
3361 #endif /* MBEDTLS_RSA_C */
3362
3363 #if defined(MBEDTLS_SHA1_C)
3364 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA1_C);
3365 #endif /* MBEDTLS_SHA1_C */
3366
3367 #if defined(MBEDTLS_SHA224_C)
3368 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA224_C);
3369 #endif /* MBEDTLS_SHA224_C */
3370
3371 #if defined(MBEDTLS_SHA256_C)
3372 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA256_C);
3373 #endif /* MBEDTLS_SHA256_C */
3374
3375 #if defined(MBEDTLS_SHA384_C)
3376 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA384_C);
3377 #endif /* MBEDTLS_SHA384_C */
3378
3379 #if defined(MBEDTLS_SHA512_C)
3380 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SHA512_C);
3381 #endif /* MBEDTLS_SHA512_C */
3382
3383 #if defined(MBEDTLS_SSL_CACHE_C)
3384 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CACHE_C);
3385 #endif /* MBEDTLS_SSL_CACHE_C */
3386
3387 #if defined(MBEDTLS_SSL_COOKIE_C)
3388 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_COOKIE_C);
3389 #endif /* MBEDTLS_SSL_COOKIE_C */
3390
3391 #if defined(MBEDTLS_SSL_TICKET_C)
3392 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_TICKET_C);
3393 #endif /* MBEDTLS_SSL_TICKET_C */
3394
3395 #if defined(MBEDTLS_SSL_CLI_C)
3396 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CLI_C);
3397 #endif /* MBEDTLS_SSL_CLI_C */
3398
3399 #if defined(MBEDTLS_SSL_SRV_C)
3400 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_SRV_C);
3401 #endif /* MBEDTLS_SSL_SRV_C */
3402
3403 #if defined(MBEDTLS_SSL_TLS_C)
3404 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_TLS_C);
3405 #endif /* MBEDTLS_SSL_TLS_C */
3406
3407 #if defined(MBEDTLS_THREADING_C)
3408 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_THREADING_C);
3409 #endif /* MBEDTLS_THREADING_C */
3410
3411 #if defined(MBEDTLS_TIMING_C)
3412 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_TIMING_C);
3413 #endif /* MBEDTLS_TIMING_C */
3414
3415 #if defined(MBEDTLS_VERSION_C)
3416 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_VERSION_C);
3417 #endif /* MBEDTLS_VERSION_C */
3418
3419 #if defined(MBEDTLS_X509_USE_C)
3420 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_USE_C);
3421 #endif /* MBEDTLS_X509_USE_C */
3422
3423 #if defined(MBEDTLS_X509_CRT_PARSE_C)
3424 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_CRT_PARSE_C);
3425 #endif /* MBEDTLS_X509_CRT_PARSE_C */
3426
3427 #if defined(MBEDTLS_X509_CRL_PARSE_C)
3428 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_CRL_PARSE_C);
3429 #endif /* MBEDTLS_X509_CRL_PARSE_C */
3430
3431 #if defined(MBEDTLS_X509_CSR_PARSE_C)
3432 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_CSR_PARSE_C);
3433 #endif /* MBEDTLS_X509_CSR_PARSE_C */
3434
3435 #if defined(MBEDTLS_X509_CREATE_C)
3436 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_CREATE_C);
3437 #endif /* MBEDTLS_X509_CREATE_C */
3438
3439 #if defined(MBEDTLS_X509_CRT_WRITE_C)
3440 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_CRT_WRITE_C);
3441 #endif /* MBEDTLS_X509_CRT_WRITE_C */
3442
3443 #if defined(MBEDTLS_X509_CSR_WRITE_C)
3444 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_CSR_WRITE_C);
3445 #endif /* MBEDTLS_X509_CSR_WRITE_C */
3446
3447 #if defined(MBEDTLS_MPI_WINDOW_SIZE)
3448 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MPI_WINDOW_SIZE);
3449 #endif /* MBEDTLS_MPI_WINDOW_SIZE */
3450
3451 #if defined(MBEDTLS_MPI_MAX_SIZE)
3452 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MPI_MAX_SIZE);
3453 #endif /* MBEDTLS_MPI_MAX_SIZE */
3454
3455 #if defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN)
3456 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_ENTROPY_LEN);
3457 #endif /* MBEDTLS_CTR_DRBG_ENTROPY_LEN */
3458
3459 #if defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL)
3460 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_RESEED_INTERVAL);
3461 #endif /* MBEDTLS_CTR_DRBG_RESEED_INTERVAL */
3462
3463 #if defined(MBEDTLS_CTR_DRBG_MAX_INPUT)
3464 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_MAX_INPUT);
3465 #endif /* MBEDTLS_CTR_DRBG_MAX_INPUT */
3466
3467 #if defined(MBEDTLS_CTR_DRBG_MAX_REQUEST)
3468 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_MAX_REQUEST);
3469 #endif /* MBEDTLS_CTR_DRBG_MAX_REQUEST */
3470
3471 #if defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT)
3472 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT);
3473 #endif /* MBEDTLS_CTR_DRBG_MAX_SEED_INPUT */
3474
3475 #if defined(MBEDTLS_HMAC_DRBG_RESEED_INTERVAL)
3476 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HMAC_DRBG_RESEED_INTERVAL);
3477 #endif /* MBEDTLS_HMAC_DRBG_RESEED_INTERVAL */
3478
3479 #if defined(MBEDTLS_HMAC_DRBG_MAX_INPUT)
3480 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HMAC_DRBG_MAX_INPUT);
3481 #endif /* MBEDTLS_HMAC_DRBG_MAX_INPUT */
3482
3483 #if defined(MBEDTLS_HMAC_DRBG_MAX_REQUEST)
3484 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HMAC_DRBG_MAX_REQUEST);
3485 #endif /* MBEDTLS_HMAC_DRBG_MAX_REQUEST */
3486
3487 #if defined(MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT)
3488 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT);
3489 #endif /* MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT */
3490
3491 #if defined(MBEDTLS_ECP_WINDOW_SIZE)
3492 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_WINDOW_SIZE);
3493 #endif /* MBEDTLS_ECP_WINDOW_SIZE */
3494
3495 #if defined(MBEDTLS_ECP_FIXED_POINT_OPTIM)
3496 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECP_FIXED_POINT_OPTIM);
3497 #endif /* MBEDTLS_ECP_FIXED_POINT_OPTIM */
3498
3499 #if defined(MBEDTLS_ENTROPY_MAX_SOURCES)
3500 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_MAX_SOURCES);
3501 #endif /* MBEDTLS_ENTROPY_MAX_SOURCES */
3502
3503 #if defined(MBEDTLS_ENTROPY_MAX_GATHER)
3504 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_MAX_GATHER);
3505 #endif /* MBEDTLS_ENTROPY_MAX_GATHER */
3506
3507 #if defined(MBEDTLS_ENTROPY_MIN_HARDWARE)
3508 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ENTROPY_MIN_HARDWARE);
3509 #endif /* MBEDTLS_ENTROPY_MIN_HARDWARE */
3510
3511 #if defined(MBEDTLS_MEMORY_ALIGN_MULTIPLE)
3512 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_MEMORY_ALIGN_MULTIPLE);
3513 #endif /* MBEDTLS_MEMORY_ALIGN_MULTIPLE */
3514
3515 #if defined(MBEDTLS_PLATFORM_STD_MEM_HDR)
3516 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_MEM_HDR);
3517 #endif /* MBEDTLS_PLATFORM_STD_MEM_HDR */
3518
3519 #if defined(MBEDTLS_PLATFORM_STD_CALLOC)
3520 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_CALLOC);
3521 #endif /* MBEDTLS_PLATFORM_STD_CALLOC */
3522
3523 #if defined(MBEDTLS_PLATFORM_STD_FREE)
3524 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_FREE);
3525 #endif /* MBEDTLS_PLATFORM_STD_FREE */
3526
3527 #if defined(MBEDTLS_PLATFORM_STD_EXIT)
3528 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_EXIT);
3529 #endif /* MBEDTLS_PLATFORM_STD_EXIT */
3530
3531 #if defined(MBEDTLS_PLATFORM_STD_TIME)
3532 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_TIME);
3533 #endif /* MBEDTLS_PLATFORM_STD_TIME */
3534
3535 #if defined(MBEDTLS_PLATFORM_STD_FPRINTF)
3536 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_FPRINTF);
3537 #endif /* MBEDTLS_PLATFORM_STD_FPRINTF */
3538
3539 #if defined(MBEDTLS_PLATFORM_STD_PRINTF)
3540 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_PRINTF);
3541 #endif /* MBEDTLS_PLATFORM_STD_PRINTF */
3542
3543 #if defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
3544 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_SNPRINTF);
3545 #endif /* MBEDTLS_PLATFORM_STD_SNPRINTF */
3546
3547 #if defined(MBEDTLS_PLATFORM_STD_EXIT_SUCCESS)
3548 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_EXIT_SUCCESS);
3549 #endif /* MBEDTLS_PLATFORM_STD_EXIT_SUCCESS */
3550
3551 #if defined(MBEDTLS_PLATFORM_STD_EXIT_FAILURE)
3552 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_EXIT_FAILURE);
3553 #endif /* MBEDTLS_PLATFORM_STD_EXIT_FAILURE */
3554
3555 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)
3556 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_NV_SEED_READ);
3557 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_READ */
3558
3559 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)
3560 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE);
3561 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_WRITE */
3562
3563 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_FILE)
3564 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_STD_NV_SEED_FILE);
3565 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_FILE */
3566
3567 #if defined(MBEDTLS_PLATFORM_CALLOC_MACRO)
3568 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_CALLOC_MACRO);
3569 #endif /* MBEDTLS_PLATFORM_CALLOC_MACRO */
3570
3571 #if defined(MBEDTLS_PLATFORM_FREE_MACRO)
3572 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_FREE_MACRO);
3573 #endif /* MBEDTLS_PLATFORM_FREE_MACRO */
3574
3575 #if defined(MBEDTLS_PLATFORM_EXIT_MACRO)
3576 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_EXIT_MACRO);
3577 #endif /* MBEDTLS_PLATFORM_EXIT_MACRO */
3578
3579 #if defined(MBEDTLS_PLATFORM_TIME_MACRO)
3580 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_TIME_MACRO);
3581 #endif /* MBEDTLS_PLATFORM_TIME_MACRO */
3582
3583 #if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO)
3584 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_TIME_TYPE_MACRO);
3585 #endif /* MBEDTLS_PLATFORM_TIME_TYPE_MACRO */
3586
3587 #if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO)
3588 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_FPRINTF_MACRO);
3589 #endif /* MBEDTLS_PLATFORM_FPRINTF_MACRO */
3590
3591 #if defined(MBEDTLS_PLATFORM_PRINTF_MACRO)
3592 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_PRINTF_MACRO);
3593 #endif /* MBEDTLS_PLATFORM_PRINTF_MACRO */
3594
3595 #if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO)
3596 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_SNPRINTF_MACRO);
3597 #endif /* MBEDTLS_PLATFORM_SNPRINTF_MACRO */
3598
3599 #if defined(MBEDTLS_PLATFORM_VSNPRINTF_MACRO)
3600 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_VSNPRINTF_MACRO);
3601 #endif /* MBEDTLS_PLATFORM_VSNPRINTF_MACRO */
3602
3603 #if defined(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO)
3604 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO);
3605 #endif /* MBEDTLS_PLATFORM_NV_SEED_READ_MACRO */
3606
3607 #if defined(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO)
3608 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO);
3609 #endif /* MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO */
3610
3611 #if defined(MBEDTLS_CHECK_RETURN)
3612 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_CHECK_RETURN);
3613 #endif /* MBEDTLS_CHECK_RETURN */
3614
3615 #if defined(MBEDTLS_IGNORE_RETURN)
3616 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_IGNORE_RETURN);
3617 #endif /* MBEDTLS_IGNORE_RETURN */
3618
3619 #if defined(MBEDTLS_PSA_HMAC_DRBG_MD_TYPE)
3620 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_HMAC_DRBG_MD_TYPE);
3621 #endif /* MBEDTLS_PSA_HMAC_DRBG_MD_TYPE */
3622
3623 #if defined(MBEDTLS_PSA_KEY_SLOT_COUNT)
3624 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSA_KEY_SLOT_COUNT);
3625 #endif /* MBEDTLS_PSA_KEY_SLOT_COUNT */
3626
3627 #if defined(MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT)
3628 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT);
3629 #endif /* MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT */
3630
3631 #if defined(MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES)
3632 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES);
3633 #endif /* MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES */
3634
3635 #if defined(MBEDTLS_SSL_IN_CONTENT_LEN)
3636 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_IN_CONTENT_LEN);
3637 #endif /* MBEDTLS_SSL_IN_CONTENT_LEN */
3638
3639 #if defined(MBEDTLS_SSL_CID_IN_LEN_MAX)
3640 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CID_IN_LEN_MAX);
3641 #endif /* MBEDTLS_SSL_CID_IN_LEN_MAX */
3642
3643 #if defined(MBEDTLS_SSL_CID_OUT_LEN_MAX)
3644 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CID_OUT_LEN_MAX);
3645 #endif /* MBEDTLS_SSL_CID_OUT_LEN_MAX */
3646
3647 #if defined(MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY)
3648 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY);
3649 #endif /* MBEDTLS_SSL_CID_TLS1_3_PADDING_GRANULARITY */
3650
3651 #if defined(MBEDTLS_SSL_OUT_CONTENT_LEN)
3652 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_OUT_CONTENT_LEN);
3653 #endif /* MBEDTLS_SSL_OUT_CONTENT_LEN */
3654
3655 #if defined(MBEDTLS_SSL_DTLS_MAX_BUFFERING)
3656 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_DTLS_MAX_BUFFERING);
3657 #endif /* MBEDTLS_SSL_DTLS_MAX_BUFFERING */
3658
3659 #if defined(MBEDTLS_PSK_MAX_LEN)
3660 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PSK_MAX_LEN);
3661 #endif /* MBEDTLS_PSK_MAX_LEN */
3662
3663 #if defined(MBEDTLS_SSL_COOKIE_TIMEOUT)
3664 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_SSL_COOKIE_TIMEOUT);
3665 #endif /* MBEDTLS_SSL_COOKIE_TIMEOUT */
3666
3667 #if defined(MBEDTLS_TLS_EXT_CID)
3668 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_TLS_EXT_CID);
3669 #endif /* MBEDTLS_TLS_EXT_CID */
3670
3671 #if defined(MBEDTLS_X509_MAX_INTERMEDIATE_CA)
3672 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_MAX_INTERMEDIATE_CA);
3673 #endif /* MBEDTLS_X509_MAX_INTERMEDIATE_CA */
3674
3675 #if defined(MBEDTLS_X509_MAX_FILE_PATH_LEN)
3676 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_X509_MAX_FILE_PATH_LEN);
3677 #endif /* MBEDTLS_X509_MAX_FILE_PATH_LEN */
3678
3679 #if defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
3680 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_ZEROIZE_ALT);
3681 #endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
3682
3683 #if defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
3684 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_PLATFORM_GMTIME_R_ALT);
3685 #endif /* MBEDTLS_PLATFORM_GMTIME_R_ALT */
3686
3687 #if defined(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED)
3688 OUTPUT_MACRO_NAME_VALUE(MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED);
3689 #endif /* MBEDTLS_ECDH_VARIANT_EVEREST_ENABLED */
3690
3691
3692 }
3693 #if defined(_MSC_VER)
3694 #pragma warning(pop)
3695 #endif /* _MSC_VER */
3696