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