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