1 /*
2 * Query Mbed TLS compile time configurations from config.h
3 *
4 * Copyright (C) 2018, Arm Limited, All Rights Reserved
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 * This file is part of Mbed TLS (https://tls.mbed.org)
20 */
21
22 #if !defined(MBEDTLS_CONFIG_FILE)
23 #include "mbedtls/config.h"
24 #else
25 #include MBEDTLS_CONFIG_FILE
26 #endif
27
28 #if defined(MBEDTLS_PLATFORM_C)
29 #include "mbedtls/platform.h"
30 #else
31 #include <stdio.h>
32 #define mbedtls_printf printf
33 #endif /* MBEDTLS_PLATFORM_C */
34
35 /*
36 * Include all the headers with public APIs in case they define a macro to its
37 * default value when that configuration is not set in the config.h.
38 */
39 #include "mbedtls/aes.h"
40 #include "mbedtls/aesni.h"
41 #include "mbedtls/arc4.h"
42 #include "mbedtls/aria.h"
43 #include "mbedtls/asn1.h"
44 #include "mbedtls/asn1write.h"
45 #include "mbedtls/base64.h"
46 #include "mbedtls/bignum.h"
47 #include "mbedtls/blowfish.h"
48 #include "mbedtls/camellia.h"
49 #include "mbedtls/ccm.h"
50 #include "mbedtls/certs.h"
51 #include "mbedtls/chacha20.h"
52 #include "mbedtls/chachapoly.h"
53 #include "mbedtls/cipher.h"
54 #include "mbedtls/cmac.h"
55 #include "mbedtls/ctr_drbg.h"
56 #include "mbedtls/debug.h"
57 #include "mbedtls/des.h"
58 #include "mbedtls/dhm.h"
59 #include "mbedtls/ecdh.h"
60 #include "mbedtls/ecdsa.h"
61 #include "mbedtls/ecjpake.h"
62 #include "mbedtls/ecp.h"
63 #include "mbedtls/entropy.h"
64 #include "mbedtls/entropy_poll.h"
65 #include "mbedtls/error.h"
66 #include "mbedtls/gcm.h"
67 #include "mbedtls/havege.h"
68 #include "mbedtls/hkdf.h"
69 #include "mbedtls/hmac_drbg.h"
70 #include "mbedtls/md.h"
71 #include "mbedtls/md2.h"
72 #include "mbedtls/md4.h"
73 #include "mbedtls/md5.h"
74 #include "mbedtls/memory_buffer_alloc.h"
75 #include "mbedtls/net_sockets.h"
76 #include "mbedtls/nist_kw.h"
77 #include "mbedtls/oid.h"
78 #include "mbedtls/padlock.h"
79 #include "mbedtls/pem.h"
80 #include "mbedtls/pk.h"
81 #include "mbedtls/pkcs11.h"
82 #include "mbedtls/pkcs12.h"
83 #include "mbedtls/pkcs5.h"
84 #include "mbedtls/platform_time.h"
85 #include "mbedtls/platform_util.h"
86 #include "mbedtls/poly1305.h"
87 #include "mbedtls/ripemd160.h"
88 #include "mbedtls/rsa.h"
89 #include "mbedtls/sha1.h"
90 #include "mbedtls/sha256.h"
91 #include "mbedtls/sha512.h"
92 #include "mbedtls/ssl.h"
93 #include "mbedtls/ssl_cache.h"
94 #include "mbedtls/ssl_ciphersuites.h"
95 #include "mbedtls/ssl_cookie.h"
96 #include "mbedtls/ssl_internal.h"
97 #include "mbedtls/ssl_ticket.h"
98 #include "mbedtls/threading.h"
99 #include "mbedtls/timing.h"
100 #include "mbedtls/version.h"
101 #include "mbedtls/x509.h"
102 #include "mbedtls/x509_crl.h"
103 #include "mbedtls/x509_crt.h"
104 #include "mbedtls/x509_csr.h"
105 #include "mbedtls/xtea.h"
106
107 #include <string.h>
108
109 /*
110 * Helper macros to convert a macro or its expansion into a string
111 * WARNING: This does not work for expanding function-like macros. However,
112 * Mbed TLS does not currently have configuration options used in this fashion.
113 */
114 #define MACRO_EXPANSION_TO_STR(macro) MACRO_NAME_TO_STR(macro)
115 #define MACRO_NAME_TO_STR(macro) \
116 mbedtls_printf( "%s", strlen( #macro "" ) > 0 ? #macro "\n" : "" )
117
118 #if defined(_MSC_VER)
119 /*
120 * Visual Studio throws the warning 4003 because many Mbed TLS feature macros
121 * are defined empty. This means that from the preprocessor's point of view
122 * the macro MBEDTLS_EXPANSION_TO_STR is being invoked without arguments as
123 * some macros expand to nothing. We suppress that specific warning to get a
124 * clean build and to ensure that tests treating warnings as errors do not
125 * fail.
126 */
127 #pragma warning(push)
128 #pragma warning(disable:4003)
129 #endif /* _MSC_VER */
130
query_config(const char * config)131 int query_config( const char *config )
132 {
133 #if defined(MBEDTLS_HAVE_ASM)
134 if( strcmp( "MBEDTLS_HAVE_ASM", config ) == 0 )
135 {
136 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_ASM );
137 return( 0 );
138 }
139 #endif /* MBEDTLS_HAVE_ASM */
140
141 #if defined(MBEDTLS_NO_UDBL_DIVISION)
142 if( strcmp( "MBEDTLS_NO_UDBL_DIVISION", config ) == 0 )
143 {
144 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_UDBL_DIVISION );
145 return( 0 );
146 }
147 #endif /* MBEDTLS_NO_UDBL_DIVISION */
148
149 #if defined(MBEDTLS_NO_64BIT_MULTIPLICATION)
150 if( strcmp( "MBEDTLS_NO_64BIT_MULTIPLICATION", config ) == 0 )
151 {
152 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_64BIT_MULTIPLICATION );
153 return( 0 );
154 }
155 #endif /* MBEDTLS_NO_64BIT_MULTIPLICATION */
156
157 #if defined(MBEDTLS_HAVE_SSE2)
158 if( strcmp( "MBEDTLS_HAVE_SSE2", config ) == 0 )
159 {
160 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_SSE2 );
161 return( 0 );
162 }
163 #endif /* MBEDTLS_HAVE_SSE2 */
164
165 #if defined(MBEDTLS_HAVE_TIME)
166 if( strcmp( "MBEDTLS_HAVE_TIME", config ) == 0 )
167 {
168 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_TIME );
169 return( 0 );
170 }
171 #endif /* MBEDTLS_HAVE_TIME */
172
173 #if defined(MBEDTLS_HAVE_TIME_DATE)
174 if( strcmp( "MBEDTLS_HAVE_TIME_DATE", config ) == 0 )
175 {
176 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVE_TIME_DATE );
177 return( 0 );
178 }
179 #endif /* MBEDTLS_HAVE_TIME_DATE */
180
181 #if defined(MBEDTLS_PLATFORM_MEMORY)
182 if( strcmp( "MBEDTLS_PLATFORM_MEMORY", config ) == 0 )
183 {
184 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_MEMORY );
185 return( 0 );
186 }
187 #endif /* MBEDTLS_PLATFORM_MEMORY */
188
189 #if defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
190 if( strcmp( "MBEDTLS_PLATFORM_NO_STD_FUNCTIONS", config ) == 0 )
191 {
192 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NO_STD_FUNCTIONS );
193 return( 0 );
194 }
195 #endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */
196
197 #if defined(MBEDTLS_PLATFORM_EXIT_ALT)
198 if( strcmp( "MBEDTLS_PLATFORM_EXIT_ALT", config ) == 0 )
199 {
200 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_EXIT_ALT );
201 return( 0 );
202 }
203 #endif /* MBEDTLS_PLATFORM_EXIT_ALT */
204
205 #if defined(MBEDTLS_PLATFORM_TIME_ALT)
206 if( strcmp( "MBEDTLS_PLATFORM_TIME_ALT", config ) == 0 )
207 {
208 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_TIME_ALT );
209 return( 0 );
210 }
211 #endif /* MBEDTLS_PLATFORM_TIME_ALT */
212
213 #if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
214 if( strcmp( "MBEDTLS_PLATFORM_FPRINTF_ALT", config ) == 0 )
215 {
216 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_FPRINTF_ALT );
217 return( 0 );
218 }
219 #endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */
220
221 #if defined(MBEDTLS_PLATFORM_PRINTF_ALT)
222 if( strcmp( "MBEDTLS_PLATFORM_PRINTF_ALT", config ) == 0 )
223 {
224 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_PRINTF_ALT );
225 return( 0 );
226 }
227 #endif /* MBEDTLS_PLATFORM_PRINTF_ALT */
228
229 #if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
230 if( strcmp( "MBEDTLS_PLATFORM_SNPRINTF_ALT", config ) == 0 )
231 {
232 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_SNPRINTF_ALT );
233 return( 0 );
234 }
235 #endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */
236
237 #if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
238 if( strcmp( "MBEDTLS_PLATFORM_NV_SEED_ALT", config ) == 0 )
239 {
240 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NV_SEED_ALT );
241 return( 0 );
242 }
243 #endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */
244
245 #if defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)
246 if( strcmp( "MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT", config ) == 0 )
247 {
248 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT );
249 return( 0 );
250 }
251 #endif /* MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */
252
253 #if defined(MBEDTLS_DEPRECATED_WARNING)
254 if( strcmp( "MBEDTLS_DEPRECATED_WARNING", config ) == 0 )
255 {
256 MACRO_EXPANSION_TO_STR( MBEDTLS_DEPRECATED_WARNING );
257 return( 0 );
258 }
259 #endif /* MBEDTLS_DEPRECATED_WARNING */
260
261 #if defined(MBEDTLS_DEPRECATED_REMOVED)
262 if( strcmp( "MBEDTLS_DEPRECATED_REMOVED", config ) == 0 )
263 {
264 MACRO_EXPANSION_TO_STR( MBEDTLS_DEPRECATED_REMOVED );
265 return( 0 );
266 }
267 #endif /* MBEDTLS_DEPRECATED_REMOVED */
268
269 #if defined(MBEDTLS_CHECK_PARAMS)
270 if( strcmp( "MBEDTLS_CHECK_PARAMS", config ) == 0 )
271 {
272 MACRO_EXPANSION_TO_STR( MBEDTLS_CHECK_PARAMS );
273 return( 0 );
274 }
275 #endif /* MBEDTLS_CHECK_PARAMS */
276
277 #if defined(MBEDTLS_TIMING_ALT)
278 if( strcmp( "MBEDTLS_TIMING_ALT", config ) == 0 )
279 {
280 MACRO_EXPANSION_TO_STR( MBEDTLS_TIMING_ALT );
281 return( 0 );
282 }
283 #endif /* MBEDTLS_TIMING_ALT */
284
285 #if defined(MBEDTLS_AES_ALT)
286 if( strcmp( "MBEDTLS_AES_ALT", config ) == 0 )
287 {
288 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_ALT );
289 return( 0 );
290 }
291 #endif /* MBEDTLS_AES_ALT */
292
293 #if defined(MBEDTLS_ARC4_ALT)
294 if( strcmp( "MBEDTLS_ARC4_ALT", config ) == 0 )
295 {
296 MACRO_EXPANSION_TO_STR( MBEDTLS_ARC4_ALT );
297 return( 0 );
298 }
299 #endif /* MBEDTLS_ARC4_ALT */
300
301 #if defined(MBEDTLS_ARIA_ALT)
302 if( strcmp( "MBEDTLS_ARIA_ALT", config ) == 0 )
303 {
304 MACRO_EXPANSION_TO_STR( MBEDTLS_ARIA_ALT );
305 return( 0 );
306 }
307 #endif /* MBEDTLS_ARIA_ALT */
308
309 #if defined(MBEDTLS_BLOWFISH_ALT)
310 if( strcmp( "MBEDTLS_BLOWFISH_ALT", config ) == 0 )
311 {
312 MACRO_EXPANSION_TO_STR( MBEDTLS_BLOWFISH_ALT );
313 return( 0 );
314 }
315 #endif /* MBEDTLS_BLOWFISH_ALT */
316
317 #if defined(MBEDTLS_CAMELLIA_ALT)
318 if( strcmp( "MBEDTLS_CAMELLIA_ALT", config ) == 0 )
319 {
320 MACRO_EXPANSION_TO_STR( MBEDTLS_CAMELLIA_ALT );
321 return( 0 );
322 }
323 #endif /* MBEDTLS_CAMELLIA_ALT */
324
325 #if defined(MBEDTLS_CCM_ALT)
326 if( strcmp( "MBEDTLS_CCM_ALT", config ) == 0 )
327 {
328 MACRO_EXPANSION_TO_STR( MBEDTLS_CCM_ALT );
329 return( 0 );
330 }
331 #endif /* MBEDTLS_CCM_ALT */
332
333 #if defined(MBEDTLS_CHACHA20_ALT)
334 if( strcmp( "MBEDTLS_CHACHA20_ALT", config ) == 0 )
335 {
336 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHA20_ALT );
337 return( 0 );
338 }
339 #endif /* MBEDTLS_CHACHA20_ALT */
340
341 #if defined(MBEDTLS_CHACHAPOLY_ALT)
342 if( strcmp( "MBEDTLS_CHACHAPOLY_ALT", config ) == 0 )
343 {
344 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHAPOLY_ALT );
345 return( 0 );
346 }
347 #endif /* MBEDTLS_CHACHAPOLY_ALT */
348
349 #if defined(MBEDTLS_CMAC_ALT)
350 if( strcmp( "MBEDTLS_CMAC_ALT", config ) == 0 )
351 {
352 MACRO_EXPANSION_TO_STR( MBEDTLS_CMAC_ALT );
353 return( 0 );
354 }
355 #endif /* MBEDTLS_CMAC_ALT */
356
357 #if defined(MBEDTLS_DES_ALT)
358 if( strcmp( "MBEDTLS_DES_ALT", config ) == 0 )
359 {
360 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_ALT );
361 return( 0 );
362 }
363 #endif /* MBEDTLS_DES_ALT */
364
365 #if defined(MBEDTLS_DHM_ALT)
366 if( strcmp( "MBEDTLS_DHM_ALT", config ) == 0 )
367 {
368 MACRO_EXPANSION_TO_STR( MBEDTLS_DHM_ALT );
369 return( 0 );
370 }
371 #endif /* MBEDTLS_DHM_ALT */
372
373 #if defined(MBEDTLS_ECJPAKE_ALT)
374 if( strcmp( "MBEDTLS_ECJPAKE_ALT", config ) == 0 )
375 {
376 MACRO_EXPANSION_TO_STR( MBEDTLS_ECJPAKE_ALT );
377 return( 0 );
378 }
379 #endif /* MBEDTLS_ECJPAKE_ALT */
380
381 #if defined(MBEDTLS_GCM_ALT)
382 if( strcmp( "MBEDTLS_GCM_ALT", config ) == 0 )
383 {
384 MACRO_EXPANSION_TO_STR( MBEDTLS_GCM_ALT );
385 return( 0 );
386 }
387 #endif /* MBEDTLS_GCM_ALT */
388
389 #if defined(MBEDTLS_NIST_KW_ALT)
390 if( strcmp( "MBEDTLS_NIST_KW_ALT", config ) == 0 )
391 {
392 MACRO_EXPANSION_TO_STR( MBEDTLS_NIST_KW_ALT );
393 return( 0 );
394 }
395 #endif /* MBEDTLS_NIST_KW_ALT */
396
397 #if defined(MBEDTLS_MD2_ALT)
398 if( strcmp( "MBEDTLS_MD2_ALT", config ) == 0 )
399 {
400 MACRO_EXPANSION_TO_STR( MBEDTLS_MD2_ALT );
401 return( 0 );
402 }
403 #endif /* MBEDTLS_MD2_ALT */
404
405 #if defined(MBEDTLS_MD4_ALT)
406 if( strcmp( "MBEDTLS_MD4_ALT", config ) == 0 )
407 {
408 MACRO_EXPANSION_TO_STR( MBEDTLS_MD4_ALT );
409 return( 0 );
410 }
411 #endif /* MBEDTLS_MD4_ALT */
412
413 #if defined(MBEDTLS_MD5_ALT)
414 if( strcmp( "MBEDTLS_MD5_ALT", config ) == 0 )
415 {
416 MACRO_EXPANSION_TO_STR( MBEDTLS_MD5_ALT );
417 return( 0 );
418 }
419 #endif /* MBEDTLS_MD5_ALT */
420
421 #if defined(MBEDTLS_POLY1305_ALT)
422 if( strcmp( "MBEDTLS_POLY1305_ALT", config ) == 0 )
423 {
424 MACRO_EXPANSION_TO_STR( MBEDTLS_POLY1305_ALT );
425 return( 0 );
426 }
427 #endif /* MBEDTLS_POLY1305_ALT */
428
429 #if defined(MBEDTLS_RIPEMD160_ALT)
430 if( strcmp( "MBEDTLS_RIPEMD160_ALT", config ) == 0 )
431 {
432 MACRO_EXPANSION_TO_STR( MBEDTLS_RIPEMD160_ALT );
433 return( 0 );
434 }
435 #endif /* MBEDTLS_RIPEMD160_ALT */
436
437 #if defined(MBEDTLS_RSA_ALT)
438 if( strcmp( "MBEDTLS_RSA_ALT", config ) == 0 )
439 {
440 MACRO_EXPANSION_TO_STR( MBEDTLS_RSA_ALT );
441 return( 0 );
442 }
443 #endif /* MBEDTLS_RSA_ALT */
444
445 #if defined(MBEDTLS_SHA1_ALT)
446 if( strcmp( "MBEDTLS_SHA1_ALT", config ) == 0 )
447 {
448 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA1_ALT );
449 return( 0 );
450 }
451 #endif /* MBEDTLS_SHA1_ALT */
452
453 #if defined(MBEDTLS_SHA256_ALT)
454 if( strcmp( "MBEDTLS_SHA256_ALT", config ) == 0 )
455 {
456 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_ALT );
457 return( 0 );
458 }
459 #endif /* MBEDTLS_SHA256_ALT */
460
461 #if defined(MBEDTLS_SHA512_ALT)
462 if( strcmp( "MBEDTLS_SHA512_ALT", config ) == 0 )
463 {
464 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_ALT );
465 return( 0 );
466 }
467 #endif /* MBEDTLS_SHA512_ALT */
468
469 #if defined(MBEDTLS_XTEA_ALT)
470 if( strcmp( "MBEDTLS_XTEA_ALT", config ) == 0 )
471 {
472 MACRO_EXPANSION_TO_STR( MBEDTLS_XTEA_ALT );
473 return( 0 );
474 }
475 #endif /* MBEDTLS_XTEA_ALT */
476
477 #if defined(MBEDTLS_ECP_ALT)
478 if( strcmp( "MBEDTLS_ECP_ALT", config ) == 0 )
479 {
480 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_ALT );
481 return( 0 );
482 }
483 #endif /* MBEDTLS_ECP_ALT */
484
485 #if defined(MBEDTLS_MD2_PROCESS_ALT)
486 if( strcmp( "MBEDTLS_MD2_PROCESS_ALT", config ) == 0 )
487 {
488 MACRO_EXPANSION_TO_STR( MBEDTLS_MD2_PROCESS_ALT );
489 return( 0 );
490 }
491 #endif /* MBEDTLS_MD2_PROCESS_ALT */
492
493 #if defined(MBEDTLS_MD4_PROCESS_ALT)
494 if( strcmp( "MBEDTLS_MD4_PROCESS_ALT", config ) == 0 )
495 {
496 MACRO_EXPANSION_TO_STR( MBEDTLS_MD4_PROCESS_ALT );
497 return( 0 );
498 }
499 #endif /* MBEDTLS_MD4_PROCESS_ALT */
500
501 #if defined(MBEDTLS_MD5_PROCESS_ALT)
502 if( strcmp( "MBEDTLS_MD5_PROCESS_ALT", config ) == 0 )
503 {
504 MACRO_EXPANSION_TO_STR( MBEDTLS_MD5_PROCESS_ALT );
505 return( 0 );
506 }
507 #endif /* MBEDTLS_MD5_PROCESS_ALT */
508
509 #if defined(MBEDTLS_RIPEMD160_PROCESS_ALT)
510 if( strcmp( "MBEDTLS_RIPEMD160_PROCESS_ALT", config ) == 0 )
511 {
512 MACRO_EXPANSION_TO_STR( MBEDTLS_RIPEMD160_PROCESS_ALT );
513 return( 0 );
514 }
515 #endif /* MBEDTLS_RIPEMD160_PROCESS_ALT */
516
517 #if defined(MBEDTLS_SHA1_PROCESS_ALT)
518 if( strcmp( "MBEDTLS_SHA1_PROCESS_ALT", config ) == 0 )
519 {
520 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA1_PROCESS_ALT );
521 return( 0 );
522 }
523 #endif /* MBEDTLS_SHA1_PROCESS_ALT */
524
525 #if defined(MBEDTLS_SHA256_PROCESS_ALT)
526 if( strcmp( "MBEDTLS_SHA256_PROCESS_ALT", config ) == 0 )
527 {
528 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_PROCESS_ALT );
529 return( 0 );
530 }
531 #endif /* MBEDTLS_SHA256_PROCESS_ALT */
532
533 #if defined(MBEDTLS_SHA512_PROCESS_ALT)
534 if( strcmp( "MBEDTLS_SHA512_PROCESS_ALT", config ) == 0 )
535 {
536 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_PROCESS_ALT );
537 return( 0 );
538 }
539 #endif /* MBEDTLS_SHA512_PROCESS_ALT */
540
541 #if defined(MBEDTLS_DES_SETKEY_ALT)
542 if( strcmp( "MBEDTLS_DES_SETKEY_ALT", config ) == 0 )
543 {
544 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_SETKEY_ALT );
545 return( 0 );
546 }
547 #endif /* MBEDTLS_DES_SETKEY_ALT */
548
549 #if defined(MBEDTLS_DES_CRYPT_ECB_ALT)
550 if( strcmp( "MBEDTLS_DES_CRYPT_ECB_ALT", config ) == 0 )
551 {
552 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_CRYPT_ECB_ALT );
553 return( 0 );
554 }
555 #endif /* MBEDTLS_DES_CRYPT_ECB_ALT */
556
557 #if defined(MBEDTLS_DES3_CRYPT_ECB_ALT)
558 if( strcmp( "MBEDTLS_DES3_CRYPT_ECB_ALT", config ) == 0 )
559 {
560 MACRO_EXPANSION_TO_STR( MBEDTLS_DES3_CRYPT_ECB_ALT );
561 return( 0 );
562 }
563 #endif /* MBEDTLS_DES3_CRYPT_ECB_ALT */
564
565 #if defined(MBEDTLS_AES_SETKEY_ENC_ALT)
566 if( strcmp( "MBEDTLS_AES_SETKEY_ENC_ALT", config ) == 0 )
567 {
568 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_SETKEY_ENC_ALT );
569 return( 0 );
570 }
571 #endif /* MBEDTLS_AES_SETKEY_ENC_ALT */
572
573 #if defined(MBEDTLS_AES_SETKEY_DEC_ALT)
574 if( strcmp( "MBEDTLS_AES_SETKEY_DEC_ALT", config ) == 0 )
575 {
576 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_SETKEY_DEC_ALT );
577 return( 0 );
578 }
579 #endif /* MBEDTLS_AES_SETKEY_DEC_ALT */
580
581 #if defined(MBEDTLS_AES_ENCRYPT_ALT)
582 if( strcmp( "MBEDTLS_AES_ENCRYPT_ALT", config ) == 0 )
583 {
584 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_ENCRYPT_ALT );
585 return( 0 );
586 }
587 #endif /* MBEDTLS_AES_ENCRYPT_ALT */
588
589 #if defined(MBEDTLS_AES_DECRYPT_ALT)
590 if( strcmp( "MBEDTLS_AES_DECRYPT_ALT", config ) == 0 )
591 {
592 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_DECRYPT_ALT );
593 return( 0 );
594 }
595 #endif /* MBEDTLS_AES_DECRYPT_ALT */
596
597 #if defined(MBEDTLS_ECDH_GEN_PUBLIC_ALT)
598 if( strcmp( "MBEDTLS_ECDH_GEN_PUBLIC_ALT", config ) == 0 )
599 {
600 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_GEN_PUBLIC_ALT );
601 return( 0 );
602 }
603 #endif /* MBEDTLS_ECDH_GEN_PUBLIC_ALT */
604
605 #if defined(MBEDTLS_ECDH_COMPUTE_SHARED_ALT)
606 if( strcmp( "MBEDTLS_ECDH_COMPUTE_SHARED_ALT", config ) == 0 )
607 {
608 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_COMPUTE_SHARED_ALT );
609 return( 0 );
610 }
611 #endif /* MBEDTLS_ECDH_COMPUTE_SHARED_ALT */
612
613 #if defined(MBEDTLS_ECDSA_VERIFY_ALT)
614 if( strcmp( "MBEDTLS_ECDSA_VERIFY_ALT", config ) == 0 )
615 {
616 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_VERIFY_ALT );
617 return( 0 );
618 }
619 #endif /* MBEDTLS_ECDSA_VERIFY_ALT */
620
621 #if defined(MBEDTLS_ECDSA_SIGN_ALT)
622 if( strcmp( "MBEDTLS_ECDSA_SIGN_ALT", config ) == 0 )
623 {
624 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_SIGN_ALT );
625 return( 0 );
626 }
627 #endif /* MBEDTLS_ECDSA_SIGN_ALT */
628
629 #if defined(MBEDTLS_ECDSA_GENKEY_ALT)
630 if( strcmp( "MBEDTLS_ECDSA_GENKEY_ALT", config ) == 0 )
631 {
632 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_GENKEY_ALT );
633 return( 0 );
634 }
635 #endif /* MBEDTLS_ECDSA_GENKEY_ALT */
636
637 #if defined(MBEDTLS_ECP_INTERNAL_ALT)
638 if( strcmp( "MBEDTLS_ECP_INTERNAL_ALT", config ) == 0 )
639 {
640 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_INTERNAL_ALT );
641 return( 0 );
642 }
643 #endif /* MBEDTLS_ECP_INTERNAL_ALT */
644
645 #if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT)
646 if( strcmp( "MBEDTLS_ECP_RANDOMIZE_JAC_ALT", config ) == 0 )
647 {
648 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_RANDOMIZE_JAC_ALT );
649 return( 0 );
650 }
651 #endif /* MBEDTLS_ECP_RANDOMIZE_JAC_ALT */
652
653 #if defined(MBEDTLS_ECP_ADD_MIXED_ALT)
654 if( strcmp( "MBEDTLS_ECP_ADD_MIXED_ALT", config ) == 0 )
655 {
656 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_ADD_MIXED_ALT );
657 return( 0 );
658 }
659 #endif /* MBEDTLS_ECP_ADD_MIXED_ALT */
660
661 #if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT)
662 if( strcmp( "MBEDTLS_ECP_DOUBLE_JAC_ALT", config ) == 0 )
663 {
664 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DOUBLE_JAC_ALT );
665 return( 0 );
666 }
667 #endif /* MBEDTLS_ECP_DOUBLE_JAC_ALT */
668
669 #if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT)
670 if( strcmp( "MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT", config ) == 0 )
671 {
672 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT );
673 return( 0 );
674 }
675 #endif /* MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT */
676
677 #if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT)
678 if( strcmp( "MBEDTLS_ECP_NORMALIZE_JAC_ALT", config ) == 0 )
679 {
680 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NORMALIZE_JAC_ALT );
681 return( 0 );
682 }
683 #endif /* MBEDTLS_ECP_NORMALIZE_JAC_ALT */
684
685 #if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT)
686 if( strcmp( "MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT", config ) == 0 )
687 {
688 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT );
689 return( 0 );
690 }
691 #endif /* MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT */
692
693 #if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT)
694 if( strcmp( "MBEDTLS_ECP_RANDOMIZE_MXZ_ALT", config ) == 0 )
695 {
696 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_RANDOMIZE_MXZ_ALT );
697 return( 0 );
698 }
699 #endif /* MBEDTLS_ECP_RANDOMIZE_MXZ_ALT */
700
701 #if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT)
702 if( strcmp( "MBEDTLS_ECP_NORMALIZE_MXZ_ALT", config ) == 0 )
703 {
704 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NORMALIZE_MXZ_ALT );
705 return( 0 );
706 }
707 #endif /* MBEDTLS_ECP_NORMALIZE_MXZ_ALT */
708
709 #if defined(MBEDTLS_TEST_NULL_ENTROPY)
710 if( strcmp( "MBEDTLS_TEST_NULL_ENTROPY", config ) == 0 )
711 {
712 MACRO_EXPANSION_TO_STR( MBEDTLS_TEST_NULL_ENTROPY );
713 return( 0 );
714 }
715 #endif /* MBEDTLS_TEST_NULL_ENTROPY */
716
717 #if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
718 if( strcmp( "MBEDTLS_ENTROPY_HARDWARE_ALT", config ) == 0 )
719 {
720 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_HARDWARE_ALT );
721 return( 0 );
722 }
723 #endif /* MBEDTLS_ENTROPY_HARDWARE_ALT */
724
725 #if defined(MBEDTLS_AES_ROM_TABLES)
726 if( strcmp( "MBEDTLS_AES_ROM_TABLES", config ) == 0 )
727 {
728 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_ROM_TABLES );
729 return( 0 );
730 }
731 #endif /* MBEDTLS_AES_ROM_TABLES */
732
733 #if defined(MBEDTLS_AES_FEWER_TABLES)
734 if( strcmp( "MBEDTLS_AES_FEWER_TABLES", config ) == 0 )
735 {
736 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_FEWER_TABLES );
737 return( 0 );
738 }
739 #endif /* MBEDTLS_AES_FEWER_TABLES */
740
741 #if defined(MBEDTLS_CAMELLIA_SMALL_MEMORY)
742 if( strcmp( "MBEDTLS_CAMELLIA_SMALL_MEMORY", config ) == 0 )
743 {
744 MACRO_EXPANSION_TO_STR( MBEDTLS_CAMELLIA_SMALL_MEMORY );
745 return( 0 );
746 }
747 #endif /* MBEDTLS_CAMELLIA_SMALL_MEMORY */
748
749 #if defined(MBEDTLS_CIPHER_MODE_CBC)
750 if( strcmp( "MBEDTLS_CIPHER_MODE_CBC", config ) == 0 )
751 {
752 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_CBC );
753 return( 0 );
754 }
755 #endif /* MBEDTLS_CIPHER_MODE_CBC */
756
757 #if defined(MBEDTLS_CIPHER_MODE_CFB)
758 if( strcmp( "MBEDTLS_CIPHER_MODE_CFB", config ) == 0 )
759 {
760 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_CFB );
761 return( 0 );
762 }
763 #endif /* MBEDTLS_CIPHER_MODE_CFB */
764
765 #if defined(MBEDTLS_CIPHER_MODE_CTR)
766 if( strcmp( "MBEDTLS_CIPHER_MODE_CTR", config ) == 0 )
767 {
768 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_CTR );
769 return( 0 );
770 }
771 #endif /* MBEDTLS_CIPHER_MODE_CTR */
772
773 #if defined(MBEDTLS_CIPHER_MODE_OFB)
774 if( strcmp( "MBEDTLS_CIPHER_MODE_OFB", config ) == 0 )
775 {
776 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_OFB );
777 return( 0 );
778 }
779 #endif /* MBEDTLS_CIPHER_MODE_OFB */
780
781 #if defined(MBEDTLS_CIPHER_MODE_XTS)
782 if( strcmp( "MBEDTLS_CIPHER_MODE_XTS", config ) == 0 )
783 {
784 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_MODE_XTS );
785 return( 0 );
786 }
787 #endif /* MBEDTLS_CIPHER_MODE_XTS */
788
789 #if defined(MBEDTLS_CIPHER_NULL_CIPHER)
790 if( strcmp( "MBEDTLS_CIPHER_NULL_CIPHER", config ) == 0 )
791 {
792 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_NULL_CIPHER );
793 return( 0 );
794 }
795 #endif /* MBEDTLS_CIPHER_NULL_CIPHER */
796
797 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
798 if( strcmp( "MBEDTLS_CIPHER_PADDING_PKCS7", config ) == 0 )
799 {
800 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_PKCS7 );
801 return( 0 );
802 }
803 #endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
804
805 #if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
806 if( strcmp( "MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS", config ) == 0 )
807 {
808 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS );
809 return( 0 );
810 }
811 #endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
812
813 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
814 if( strcmp( "MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN", config ) == 0 )
815 {
816 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN );
817 return( 0 );
818 }
819 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
820
821 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
822 if( strcmp( "MBEDTLS_CIPHER_PADDING_ZEROS", config ) == 0 )
823 {
824 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_PADDING_ZEROS );
825 return( 0 );
826 }
827 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
828
829 #if defined(MBEDTLS_ENABLE_WEAK_CIPHERSUITES)
830 if( strcmp( "MBEDTLS_ENABLE_WEAK_CIPHERSUITES", config ) == 0 )
831 {
832 MACRO_EXPANSION_TO_STR( MBEDTLS_ENABLE_WEAK_CIPHERSUITES );
833 return( 0 );
834 }
835 #endif /* MBEDTLS_ENABLE_WEAK_CIPHERSUITES */
836
837 #if defined(MBEDTLS_REMOVE_ARC4_CIPHERSUITES)
838 if( strcmp( "MBEDTLS_REMOVE_ARC4_CIPHERSUITES", config ) == 0 )
839 {
840 MACRO_EXPANSION_TO_STR( MBEDTLS_REMOVE_ARC4_CIPHERSUITES );
841 return( 0 );
842 }
843 #endif /* MBEDTLS_REMOVE_ARC4_CIPHERSUITES */
844
845 #if defined(MBEDTLS_REMOVE_3DES_CIPHERSUITES)
846 if( strcmp( "MBEDTLS_REMOVE_3DES_CIPHERSUITES", config ) == 0 )
847 {
848 MACRO_EXPANSION_TO_STR( MBEDTLS_REMOVE_3DES_CIPHERSUITES );
849 return( 0 );
850 }
851 #endif /* MBEDTLS_REMOVE_3DES_CIPHERSUITES */
852
853 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
854 if( strcmp( "MBEDTLS_ECP_DP_SECP192R1_ENABLED", config ) == 0 )
855 {
856 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP192R1_ENABLED );
857 return( 0 );
858 }
859 #endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
860
861 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
862 if( strcmp( "MBEDTLS_ECP_DP_SECP224R1_ENABLED", config ) == 0 )
863 {
864 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP224R1_ENABLED );
865 return( 0 );
866 }
867 #endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
868
869 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
870 if( strcmp( "MBEDTLS_ECP_DP_SECP256R1_ENABLED", config ) == 0 )
871 {
872 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP256R1_ENABLED );
873 return( 0 );
874 }
875 #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
876
877 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
878 if( strcmp( "MBEDTLS_ECP_DP_SECP384R1_ENABLED", config ) == 0 )
879 {
880 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP384R1_ENABLED );
881 return( 0 );
882 }
883 #endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
884
885 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
886 if( strcmp( "MBEDTLS_ECP_DP_SECP521R1_ENABLED", config ) == 0 )
887 {
888 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP521R1_ENABLED );
889 return( 0 );
890 }
891 #endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
892
893 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
894 if( strcmp( "MBEDTLS_ECP_DP_SECP192K1_ENABLED", config ) == 0 )
895 {
896 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP192K1_ENABLED );
897 return( 0 );
898 }
899 #endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
900
901 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
902 if( strcmp( "MBEDTLS_ECP_DP_SECP224K1_ENABLED", config ) == 0 )
903 {
904 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP224K1_ENABLED );
905 return( 0 );
906 }
907 #endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
908
909 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
910 if( strcmp( "MBEDTLS_ECP_DP_SECP256K1_ENABLED", config ) == 0 )
911 {
912 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_SECP256K1_ENABLED );
913 return( 0 );
914 }
915 #endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
916
917 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
918 if( strcmp( "MBEDTLS_ECP_DP_BP256R1_ENABLED", config ) == 0 )
919 {
920 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_BP256R1_ENABLED );
921 return( 0 );
922 }
923 #endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
924
925 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
926 if( strcmp( "MBEDTLS_ECP_DP_BP384R1_ENABLED", config ) == 0 )
927 {
928 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_BP384R1_ENABLED );
929 return( 0 );
930 }
931 #endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
932
933 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
934 if( strcmp( "MBEDTLS_ECP_DP_BP512R1_ENABLED", config ) == 0 )
935 {
936 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_BP512R1_ENABLED );
937 return( 0 );
938 }
939 #endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
940
941 #if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
942 if( strcmp( "MBEDTLS_ECP_DP_CURVE25519_ENABLED", config ) == 0 )
943 {
944 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_CURVE25519_ENABLED );
945 return( 0 );
946 }
947 #endif /* MBEDTLS_ECP_DP_CURVE25519_ENABLED */
948
949 #if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
950 if( strcmp( "MBEDTLS_ECP_DP_CURVE448_ENABLED", config ) == 0 )
951 {
952 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_DP_CURVE448_ENABLED );
953 return( 0 );
954 }
955 #endif /* MBEDTLS_ECP_DP_CURVE448_ENABLED */
956
957 #if defined(MBEDTLS_ECP_NIST_OPTIM)
958 if( strcmp( "MBEDTLS_ECP_NIST_OPTIM", config ) == 0 )
959 {
960 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_NIST_OPTIM );
961 return( 0 );
962 }
963 #endif /* MBEDTLS_ECP_NIST_OPTIM */
964
965 #if defined(MBEDTLS_ECP_RESTARTABLE)
966 if( strcmp( "MBEDTLS_ECP_RESTARTABLE", config ) == 0 )
967 {
968 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_RESTARTABLE );
969 return( 0 );
970 }
971 #endif /* MBEDTLS_ECP_RESTARTABLE */
972
973 #if defined(MBEDTLS_ECDSA_DETERMINISTIC)
974 if( strcmp( "MBEDTLS_ECDSA_DETERMINISTIC", config ) == 0 )
975 {
976 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_DETERMINISTIC );
977 return( 0 );
978 }
979 #endif /* MBEDTLS_ECDSA_DETERMINISTIC */
980
981 #if defined(MBEDTLS_KEY_EXCHANGE_PSK_ENABLED)
982 if( strcmp( "MBEDTLS_KEY_EXCHANGE_PSK_ENABLED", config ) == 0 )
983 {
984 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_PSK_ENABLED );
985 return( 0 );
986 }
987 #endif /* MBEDTLS_KEY_EXCHANGE_PSK_ENABLED */
988
989 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED)
990 if( strcmp( "MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED", config ) == 0 )
991 {
992 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED );
993 return( 0 );
994 }
995 #endif /* MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED */
996
997 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
998 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED", config ) == 0 )
999 {
1000 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED );
1001 return( 0 );
1002 }
1003 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
1004
1005 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED)
1006 if( strcmp( "MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED", config ) == 0 )
1007 {
1008 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED );
1009 return( 0 );
1010 }
1011 #endif /* MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED */
1012
1013 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED)
1014 if( strcmp( "MBEDTLS_KEY_EXCHANGE_RSA_ENABLED", config ) == 0 )
1015 {
1016 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_RSA_ENABLED );
1017 return( 0 );
1018 }
1019 #endif /* MBEDTLS_KEY_EXCHANGE_RSA_ENABLED */
1020
1021 #if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED)
1022 if( strcmp( "MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED", config ) == 0 )
1023 {
1024 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED );
1025 return( 0 );
1026 }
1027 #endif /* MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED */
1028
1029 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED)
1030 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED", config ) == 0 )
1031 {
1032 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED );
1033 return( 0 );
1034 }
1035 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
1036
1037 #if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
1038 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED", config ) == 0 )
1039 {
1040 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED );
1041 return( 0 );
1042 }
1043 #endif /* MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
1044
1045 #if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
1046 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED", config ) == 0 )
1047 {
1048 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED );
1049 return( 0 );
1050 }
1051 #endif /* MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
1052
1053 #if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED)
1054 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED", config ) == 0 )
1055 {
1056 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED );
1057 return( 0 );
1058 }
1059 #endif /* MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED */
1060
1061 #if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1062 if( strcmp( "MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED", config ) == 0 )
1063 {
1064 MACRO_EXPANSION_TO_STR( MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED );
1065 return( 0 );
1066 }
1067 #endif /* MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED */
1068
1069 #if defined(MBEDTLS_PK_PARSE_EC_EXTENDED)
1070 if( strcmp( "MBEDTLS_PK_PARSE_EC_EXTENDED", config ) == 0 )
1071 {
1072 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_PARSE_EC_EXTENDED );
1073 return( 0 );
1074 }
1075 #endif /* MBEDTLS_PK_PARSE_EC_EXTENDED */
1076
1077 #if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
1078 if( strcmp( "MBEDTLS_ERROR_STRERROR_DUMMY", config ) == 0 )
1079 {
1080 MACRO_EXPANSION_TO_STR( MBEDTLS_ERROR_STRERROR_DUMMY );
1081 return( 0 );
1082 }
1083 #endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
1084
1085 #if defined(MBEDTLS_GENPRIME)
1086 if( strcmp( "MBEDTLS_GENPRIME", config ) == 0 )
1087 {
1088 MACRO_EXPANSION_TO_STR( MBEDTLS_GENPRIME );
1089 return( 0 );
1090 }
1091 #endif /* MBEDTLS_GENPRIME */
1092
1093 #if defined(MBEDTLS_FS_IO)
1094 if( strcmp( "MBEDTLS_FS_IO", config ) == 0 )
1095 {
1096 MACRO_EXPANSION_TO_STR( MBEDTLS_FS_IO );
1097 return( 0 );
1098 }
1099 #endif /* MBEDTLS_FS_IO */
1100
1101 #if defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
1102 if( strcmp( "MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES", config ) == 0 )
1103 {
1104 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES );
1105 return( 0 );
1106 }
1107 #endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
1108
1109 #if defined(MBEDTLS_NO_PLATFORM_ENTROPY)
1110 if( strcmp( "MBEDTLS_NO_PLATFORM_ENTROPY", config ) == 0 )
1111 {
1112 MACRO_EXPANSION_TO_STR( MBEDTLS_NO_PLATFORM_ENTROPY );
1113 return( 0 );
1114 }
1115 #endif /* MBEDTLS_NO_PLATFORM_ENTROPY */
1116
1117 #if defined(MBEDTLS_ENTROPY_FORCE_SHA256)
1118 if( strcmp( "MBEDTLS_ENTROPY_FORCE_SHA256", config ) == 0 )
1119 {
1120 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_FORCE_SHA256 );
1121 return( 0 );
1122 }
1123 #endif /* MBEDTLS_ENTROPY_FORCE_SHA256 */
1124
1125 #if defined(MBEDTLS_ENTROPY_NV_SEED)
1126 if( strcmp( "MBEDTLS_ENTROPY_NV_SEED", config ) == 0 )
1127 {
1128 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_NV_SEED );
1129 return( 0 );
1130 }
1131 #endif /* MBEDTLS_ENTROPY_NV_SEED */
1132
1133 #if defined(MBEDTLS_MEMORY_DEBUG)
1134 if( strcmp( "MBEDTLS_MEMORY_DEBUG", config ) == 0 )
1135 {
1136 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_DEBUG );
1137 return( 0 );
1138 }
1139 #endif /* MBEDTLS_MEMORY_DEBUG */
1140
1141 #if defined(MBEDTLS_MEMORY_BACKTRACE)
1142 if( strcmp( "MBEDTLS_MEMORY_BACKTRACE", config ) == 0 )
1143 {
1144 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_BACKTRACE );
1145 return( 0 );
1146 }
1147 #endif /* MBEDTLS_MEMORY_BACKTRACE */
1148
1149 #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
1150 if( strcmp( "MBEDTLS_PK_RSA_ALT_SUPPORT", config ) == 0 )
1151 {
1152 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_RSA_ALT_SUPPORT );
1153 return( 0 );
1154 }
1155 #endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
1156
1157 #if defined(MBEDTLS_PKCS1_V15)
1158 if( strcmp( "MBEDTLS_PKCS1_V15", config ) == 0 )
1159 {
1160 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS1_V15 );
1161 return( 0 );
1162 }
1163 #endif /* MBEDTLS_PKCS1_V15 */
1164
1165 #if defined(MBEDTLS_PKCS1_V21)
1166 if( strcmp( "MBEDTLS_PKCS1_V21", config ) == 0 )
1167 {
1168 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS1_V21 );
1169 return( 0 );
1170 }
1171 #endif /* MBEDTLS_PKCS1_V21 */
1172
1173 #if defined(MBEDTLS_RSA_NO_CRT)
1174 if( strcmp( "MBEDTLS_RSA_NO_CRT", config ) == 0 )
1175 {
1176 MACRO_EXPANSION_TO_STR( MBEDTLS_RSA_NO_CRT );
1177 return( 0 );
1178 }
1179 #endif /* MBEDTLS_RSA_NO_CRT */
1180
1181 #if defined(MBEDTLS_SELF_TEST)
1182 if( strcmp( "MBEDTLS_SELF_TEST", config ) == 0 )
1183 {
1184 MACRO_EXPANSION_TO_STR( MBEDTLS_SELF_TEST );
1185 return( 0 );
1186 }
1187 #endif /* MBEDTLS_SELF_TEST */
1188
1189 #if defined(MBEDTLS_SHA256_SMALLER)
1190 if( strcmp( "MBEDTLS_SHA256_SMALLER", config ) == 0 )
1191 {
1192 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_SMALLER );
1193 return( 0 );
1194 }
1195 #endif /* MBEDTLS_SHA256_SMALLER */
1196
1197 #if defined(MBEDTLS_SSL_ALL_ALERT_MESSAGES)
1198 if( strcmp( "MBEDTLS_SSL_ALL_ALERT_MESSAGES", config ) == 0 )
1199 {
1200 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ALL_ALERT_MESSAGES );
1201 return( 0 );
1202 }
1203 #endif /* MBEDTLS_SSL_ALL_ALERT_MESSAGES */
1204
1205 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
1206 if( strcmp( "MBEDTLS_SSL_ASYNC_PRIVATE", config ) == 0 )
1207 {
1208 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ASYNC_PRIVATE );
1209 return( 0 );
1210 }
1211 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
1212
1213 #if defined(MBEDTLS_SSL_DEBUG_ALL)
1214 if( strcmp( "MBEDTLS_SSL_DEBUG_ALL", config ) == 0 )
1215 {
1216 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DEBUG_ALL );
1217 return( 0 );
1218 }
1219 #endif /* MBEDTLS_SSL_DEBUG_ALL */
1220
1221 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
1222 if( strcmp( "MBEDTLS_SSL_ENCRYPT_THEN_MAC", config ) == 0 )
1223 {
1224 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ENCRYPT_THEN_MAC );
1225 return( 0 );
1226 }
1227 #endif /* MBEDTLS_SSL_ENCRYPT_THEN_MAC */
1228
1229 #if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
1230 if( strcmp( "MBEDTLS_SSL_EXTENDED_MASTER_SECRET", config ) == 0 )
1231 {
1232 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_EXTENDED_MASTER_SECRET );
1233 return( 0 );
1234 }
1235 #endif /* MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
1236
1237 #if defined(MBEDTLS_SSL_FALLBACK_SCSV)
1238 if( strcmp( "MBEDTLS_SSL_FALLBACK_SCSV", config ) == 0 )
1239 {
1240 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_FALLBACK_SCSV );
1241 return( 0 );
1242 }
1243 #endif /* MBEDTLS_SSL_FALLBACK_SCSV */
1244
1245 #if defined(MBEDTLS_SSL_HW_RECORD_ACCEL)
1246 if( strcmp( "MBEDTLS_SSL_HW_RECORD_ACCEL", config ) == 0 )
1247 {
1248 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_HW_RECORD_ACCEL );
1249 return( 0 );
1250 }
1251 #endif /* MBEDTLS_SSL_HW_RECORD_ACCEL */
1252
1253 #if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
1254 if( strcmp( "MBEDTLS_SSL_CBC_RECORD_SPLITTING", config ) == 0 )
1255 {
1256 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CBC_RECORD_SPLITTING );
1257 return( 0 );
1258 }
1259 #endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */
1260
1261 #if defined(MBEDTLS_SSL_RENEGOTIATION)
1262 if( strcmp( "MBEDTLS_SSL_RENEGOTIATION", config ) == 0 )
1263 {
1264 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_RENEGOTIATION );
1265 return( 0 );
1266 }
1267 #endif /* MBEDTLS_SSL_RENEGOTIATION */
1268
1269 #if defined(MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO)
1270 if( strcmp( "MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO", config ) == 0 )
1271 {
1272 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO );
1273 return( 0 );
1274 }
1275 #endif /* MBEDTLS_SSL_SRV_SUPPORT_SSLV2_CLIENT_HELLO */
1276
1277 #if defined(MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE)
1278 if( strcmp( "MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE", config ) == 0 )
1279 {
1280 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE );
1281 return( 0 );
1282 }
1283 #endif /* MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE */
1284
1285 #if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
1286 if( strcmp( "MBEDTLS_SSL_MAX_FRAGMENT_LENGTH", config ) == 0 )
1287 {
1288 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_MAX_FRAGMENT_LENGTH );
1289 return( 0 );
1290 }
1291 #endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
1292
1293 #if defined(MBEDTLS_SSL_PROTO_SSL3)
1294 if( strcmp( "MBEDTLS_SSL_PROTO_SSL3", config ) == 0 )
1295 {
1296 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_SSL3 );
1297 return( 0 );
1298 }
1299 #endif /* MBEDTLS_SSL_PROTO_SSL3 */
1300
1301 #if defined(MBEDTLS_SSL_PROTO_TLS1)
1302 if( strcmp( "MBEDTLS_SSL_PROTO_TLS1", config ) == 0 )
1303 {
1304 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_TLS1 );
1305 return( 0 );
1306 }
1307 #endif /* MBEDTLS_SSL_PROTO_TLS1 */
1308
1309 #if defined(MBEDTLS_SSL_PROTO_TLS1_1)
1310 if( strcmp( "MBEDTLS_SSL_PROTO_TLS1_1", config ) == 0 )
1311 {
1312 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_TLS1_1 );
1313 return( 0 );
1314 }
1315 #endif /* MBEDTLS_SSL_PROTO_TLS1_1 */
1316
1317 #if defined(MBEDTLS_SSL_PROTO_TLS1_2)
1318 if( strcmp( "MBEDTLS_SSL_PROTO_TLS1_2", config ) == 0 )
1319 {
1320 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_TLS1_2 );
1321 return( 0 );
1322 }
1323 #endif /* MBEDTLS_SSL_PROTO_TLS1_2 */
1324
1325 #if defined(MBEDTLS_SSL_PROTO_DTLS)
1326 if( strcmp( "MBEDTLS_SSL_PROTO_DTLS", config ) == 0 )
1327 {
1328 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_PROTO_DTLS );
1329 return( 0 );
1330 }
1331 #endif /* MBEDTLS_SSL_PROTO_DTLS */
1332
1333 #if defined(MBEDTLS_SSL_ALPN)
1334 if( strcmp( "MBEDTLS_SSL_ALPN", config ) == 0 )
1335 {
1336 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_ALPN );
1337 return( 0 );
1338 }
1339 #endif /* MBEDTLS_SSL_ALPN */
1340
1341 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
1342 if( strcmp( "MBEDTLS_SSL_DTLS_ANTI_REPLAY", config ) == 0 )
1343 {
1344 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_ANTI_REPLAY );
1345 return( 0 );
1346 }
1347 #endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
1348
1349 #if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
1350 if( strcmp( "MBEDTLS_SSL_DTLS_HELLO_VERIFY", config ) == 0 )
1351 {
1352 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_HELLO_VERIFY );
1353 return( 0 );
1354 }
1355 #endif /* MBEDTLS_SSL_DTLS_HELLO_VERIFY */
1356
1357 #if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE)
1358 if( strcmp( "MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE", config ) == 0 )
1359 {
1360 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE );
1361 return( 0 );
1362 }
1363 #endif /* MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE */
1364
1365 #if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
1366 if( strcmp( "MBEDTLS_SSL_DTLS_BADMAC_LIMIT", config ) == 0 )
1367 {
1368 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_BADMAC_LIMIT );
1369 return( 0 );
1370 }
1371 #endif /* MBEDTLS_SSL_DTLS_BADMAC_LIMIT */
1372
1373 #if defined(MBEDTLS_SSL_SESSION_TICKETS)
1374 if( strcmp( "MBEDTLS_SSL_SESSION_TICKETS", config ) == 0 )
1375 {
1376 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SESSION_TICKETS );
1377 return( 0 );
1378 }
1379 #endif /* MBEDTLS_SSL_SESSION_TICKETS */
1380
1381 #if defined(MBEDTLS_SSL_EXPORT_KEYS)
1382 if( strcmp( "MBEDTLS_SSL_EXPORT_KEYS", config ) == 0 )
1383 {
1384 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_EXPORT_KEYS );
1385 return( 0 );
1386 }
1387 #endif /* MBEDTLS_SSL_EXPORT_KEYS */
1388
1389 #if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
1390 if( strcmp( "MBEDTLS_SSL_SERVER_NAME_INDICATION", config ) == 0 )
1391 {
1392 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SERVER_NAME_INDICATION );
1393 return( 0 );
1394 }
1395 #endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
1396
1397 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
1398 if( strcmp( "MBEDTLS_SSL_TRUNCATED_HMAC", config ) == 0 )
1399 {
1400 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TRUNCATED_HMAC );
1401 return( 0 );
1402 }
1403 #endif /* MBEDTLS_SSL_TRUNCATED_HMAC */
1404
1405 #if defined(MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT)
1406 if( strcmp( "MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT", config ) == 0 )
1407 {
1408 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT );
1409 return( 0 );
1410 }
1411 #endif /* MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT */
1412
1413 #if defined(MBEDTLS_THREADING_ALT)
1414 if( strcmp( "MBEDTLS_THREADING_ALT", config ) == 0 )
1415 {
1416 MACRO_EXPANSION_TO_STR( MBEDTLS_THREADING_ALT );
1417 return( 0 );
1418 }
1419 #endif /* MBEDTLS_THREADING_ALT */
1420
1421 #if defined(MBEDTLS_THREADING_PTHREAD)
1422 if( strcmp( "MBEDTLS_THREADING_PTHREAD", config ) == 0 )
1423 {
1424 MACRO_EXPANSION_TO_STR( MBEDTLS_THREADING_PTHREAD );
1425 return( 0 );
1426 }
1427 #endif /* MBEDTLS_THREADING_PTHREAD */
1428
1429 #if defined(MBEDTLS_VERSION_FEATURES)
1430 if( strcmp( "MBEDTLS_VERSION_FEATURES", config ) == 0 )
1431 {
1432 MACRO_EXPANSION_TO_STR( MBEDTLS_VERSION_FEATURES );
1433 return( 0 );
1434 }
1435 #endif /* MBEDTLS_VERSION_FEATURES */
1436
1437 #if defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
1438 if( strcmp( "MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3", config ) == 0 )
1439 {
1440 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3 );
1441 return( 0 );
1442 }
1443 #endif /* MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3 */
1444
1445 #if defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
1446 if( strcmp( "MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION", config ) == 0 )
1447 {
1448 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION );
1449 return( 0 );
1450 }
1451 #endif /* MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION */
1452
1453 #if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
1454 if( strcmp( "MBEDTLS_X509_CHECK_KEY_USAGE", config ) == 0 )
1455 {
1456 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CHECK_KEY_USAGE );
1457 return( 0 );
1458 }
1459 #endif /* MBEDTLS_X509_CHECK_KEY_USAGE */
1460
1461 #if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
1462 if( strcmp( "MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE", config ) == 0 )
1463 {
1464 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE );
1465 return( 0 );
1466 }
1467 #endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
1468
1469 #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1470 if( strcmp( "MBEDTLS_X509_RSASSA_PSS_SUPPORT", config ) == 0 )
1471 {
1472 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_RSASSA_PSS_SUPPORT );
1473 return( 0 );
1474 }
1475 #endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1476
1477 #if defined(MBEDTLS_ZLIB_SUPPORT)
1478 if( strcmp( "MBEDTLS_ZLIB_SUPPORT", config ) == 0 )
1479 {
1480 MACRO_EXPANSION_TO_STR( MBEDTLS_ZLIB_SUPPORT );
1481 return( 0 );
1482 }
1483 #endif /* MBEDTLS_ZLIB_SUPPORT */
1484
1485 #if defined(MBEDTLS_AESNI_C)
1486 if( strcmp( "MBEDTLS_AESNI_C", config ) == 0 )
1487 {
1488 MACRO_EXPANSION_TO_STR( MBEDTLS_AESNI_C );
1489 return( 0 );
1490 }
1491 #endif /* MBEDTLS_AESNI_C */
1492
1493 #if defined(MBEDTLS_AES_C)
1494 if( strcmp( "MBEDTLS_AES_C", config ) == 0 )
1495 {
1496 MACRO_EXPANSION_TO_STR( MBEDTLS_AES_C );
1497 return( 0 );
1498 }
1499 #endif /* MBEDTLS_AES_C */
1500
1501 #if defined(MBEDTLS_ARC4_C)
1502 if( strcmp( "MBEDTLS_ARC4_C", config ) == 0 )
1503 {
1504 MACRO_EXPANSION_TO_STR( MBEDTLS_ARC4_C );
1505 return( 0 );
1506 }
1507 #endif /* MBEDTLS_ARC4_C */
1508
1509 #if defined(MBEDTLS_ASN1_PARSE_C)
1510 if( strcmp( "MBEDTLS_ASN1_PARSE_C", config ) == 0 )
1511 {
1512 MACRO_EXPANSION_TO_STR( MBEDTLS_ASN1_PARSE_C );
1513 return( 0 );
1514 }
1515 #endif /* MBEDTLS_ASN1_PARSE_C */
1516
1517 #if defined(MBEDTLS_ASN1_WRITE_C)
1518 if( strcmp( "MBEDTLS_ASN1_WRITE_C", config ) == 0 )
1519 {
1520 MACRO_EXPANSION_TO_STR( MBEDTLS_ASN1_WRITE_C );
1521 return( 0 );
1522 }
1523 #endif /* MBEDTLS_ASN1_WRITE_C */
1524
1525 #if defined(MBEDTLS_BASE64_C)
1526 if( strcmp( "MBEDTLS_BASE64_C", config ) == 0 )
1527 {
1528 MACRO_EXPANSION_TO_STR( MBEDTLS_BASE64_C );
1529 return( 0 );
1530 }
1531 #endif /* MBEDTLS_BASE64_C */
1532
1533 #if defined(MBEDTLS_BIGNUM_C)
1534 if( strcmp( "MBEDTLS_BIGNUM_C", config ) == 0 )
1535 {
1536 MACRO_EXPANSION_TO_STR( MBEDTLS_BIGNUM_C );
1537 return( 0 );
1538 }
1539 #endif /* MBEDTLS_BIGNUM_C */
1540
1541 #if defined(MBEDTLS_BLOWFISH_C)
1542 if( strcmp( "MBEDTLS_BLOWFISH_C", config ) == 0 )
1543 {
1544 MACRO_EXPANSION_TO_STR( MBEDTLS_BLOWFISH_C );
1545 return( 0 );
1546 }
1547 #endif /* MBEDTLS_BLOWFISH_C */
1548
1549 #if defined(MBEDTLS_CAMELLIA_C)
1550 if( strcmp( "MBEDTLS_CAMELLIA_C", config ) == 0 )
1551 {
1552 MACRO_EXPANSION_TO_STR( MBEDTLS_CAMELLIA_C );
1553 return( 0 );
1554 }
1555 #endif /* MBEDTLS_CAMELLIA_C */
1556
1557 #if defined(MBEDTLS_ARIA_C)
1558 if( strcmp( "MBEDTLS_ARIA_C", config ) == 0 )
1559 {
1560 MACRO_EXPANSION_TO_STR( MBEDTLS_ARIA_C );
1561 return( 0 );
1562 }
1563 #endif /* MBEDTLS_ARIA_C */
1564
1565 #if defined(MBEDTLS_CCM_C)
1566 if( strcmp( "MBEDTLS_CCM_C", config ) == 0 )
1567 {
1568 MACRO_EXPANSION_TO_STR( MBEDTLS_CCM_C );
1569 return( 0 );
1570 }
1571 #endif /* MBEDTLS_CCM_C */
1572
1573 #if defined(MBEDTLS_CERTS_C)
1574 if( strcmp( "MBEDTLS_CERTS_C", config ) == 0 )
1575 {
1576 MACRO_EXPANSION_TO_STR( MBEDTLS_CERTS_C );
1577 return( 0 );
1578 }
1579 #endif /* MBEDTLS_CERTS_C */
1580
1581 #if defined(MBEDTLS_CHACHA20_C)
1582 if( strcmp( "MBEDTLS_CHACHA20_C", config ) == 0 )
1583 {
1584 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHA20_C );
1585 return( 0 );
1586 }
1587 #endif /* MBEDTLS_CHACHA20_C */
1588
1589 #if defined(MBEDTLS_CHACHAPOLY_C)
1590 if( strcmp( "MBEDTLS_CHACHAPOLY_C", config ) == 0 )
1591 {
1592 MACRO_EXPANSION_TO_STR( MBEDTLS_CHACHAPOLY_C );
1593 return( 0 );
1594 }
1595 #endif /* MBEDTLS_CHACHAPOLY_C */
1596
1597 #if defined(MBEDTLS_CIPHER_C)
1598 if( strcmp( "MBEDTLS_CIPHER_C", config ) == 0 )
1599 {
1600 MACRO_EXPANSION_TO_STR( MBEDTLS_CIPHER_C );
1601 return( 0 );
1602 }
1603 #endif /* MBEDTLS_CIPHER_C */
1604
1605 #if defined(MBEDTLS_CMAC_C)
1606 if( strcmp( "MBEDTLS_CMAC_C", config ) == 0 )
1607 {
1608 MACRO_EXPANSION_TO_STR( MBEDTLS_CMAC_C );
1609 return( 0 );
1610 }
1611 #endif /* MBEDTLS_CMAC_C */
1612
1613 #if defined(MBEDTLS_CTR_DRBG_C)
1614 if( strcmp( "MBEDTLS_CTR_DRBG_C", config ) == 0 )
1615 {
1616 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_C );
1617 return( 0 );
1618 }
1619 #endif /* MBEDTLS_CTR_DRBG_C */
1620
1621 #if defined(MBEDTLS_DEBUG_C)
1622 if( strcmp( "MBEDTLS_DEBUG_C", config ) == 0 )
1623 {
1624 MACRO_EXPANSION_TO_STR( MBEDTLS_DEBUG_C );
1625 return( 0 );
1626 }
1627 #endif /* MBEDTLS_DEBUG_C */
1628
1629 #if defined(MBEDTLS_DES_C)
1630 if( strcmp( "MBEDTLS_DES_C", config ) == 0 )
1631 {
1632 MACRO_EXPANSION_TO_STR( MBEDTLS_DES_C );
1633 return( 0 );
1634 }
1635 #endif /* MBEDTLS_DES_C */
1636
1637 #if defined(MBEDTLS_DHM_C)
1638 if( strcmp( "MBEDTLS_DHM_C", config ) == 0 )
1639 {
1640 MACRO_EXPANSION_TO_STR( MBEDTLS_DHM_C );
1641 return( 0 );
1642 }
1643 #endif /* MBEDTLS_DHM_C */
1644
1645 #if defined(MBEDTLS_ECDH_C)
1646 if( strcmp( "MBEDTLS_ECDH_C", config ) == 0 )
1647 {
1648 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDH_C );
1649 return( 0 );
1650 }
1651 #endif /* MBEDTLS_ECDH_C */
1652
1653 #if defined(MBEDTLS_ECDSA_C)
1654 if( strcmp( "MBEDTLS_ECDSA_C", config ) == 0 )
1655 {
1656 MACRO_EXPANSION_TO_STR( MBEDTLS_ECDSA_C );
1657 return( 0 );
1658 }
1659 #endif /* MBEDTLS_ECDSA_C */
1660
1661 #if defined(MBEDTLS_ECJPAKE_C)
1662 if( strcmp( "MBEDTLS_ECJPAKE_C", config ) == 0 )
1663 {
1664 MACRO_EXPANSION_TO_STR( MBEDTLS_ECJPAKE_C );
1665 return( 0 );
1666 }
1667 #endif /* MBEDTLS_ECJPAKE_C */
1668
1669 #if defined(MBEDTLS_ECP_C)
1670 if( strcmp( "MBEDTLS_ECP_C", config ) == 0 )
1671 {
1672 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_C );
1673 return( 0 );
1674 }
1675 #endif /* MBEDTLS_ECP_C */
1676
1677 #if defined(MBEDTLS_ENTROPY_C)
1678 if( strcmp( "MBEDTLS_ENTROPY_C", config ) == 0 )
1679 {
1680 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_C );
1681 return( 0 );
1682 }
1683 #endif /* MBEDTLS_ENTROPY_C */
1684
1685 #if defined(MBEDTLS_ERROR_C)
1686 if( strcmp( "MBEDTLS_ERROR_C", config ) == 0 )
1687 {
1688 MACRO_EXPANSION_TO_STR( MBEDTLS_ERROR_C );
1689 return( 0 );
1690 }
1691 #endif /* MBEDTLS_ERROR_C */
1692
1693 #if defined(MBEDTLS_GCM_C)
1694 if( strcmp( "MBEDTLS_GCM_C", config ) == 0 )
1695 {
1696 MACRO_EXPANSION_TO_STR( MBEDTLS_GCM_C );
1697 return( 0 );
1698 }
1699 #endif /* MBEDTLS_GCM_C */
1700
1701 #if defined(MBEDTLS_HAVEGE_C)
1702 if( strcmp( "MBEDTLS_HAVEGE_C", config ) == 0 )
1703 {
1704 MACRO_EXPANSION_TO_STR( MBEDTLS_HAVEGE_C );
1705 return( 0 );
1706 }
1707 #endif /* MBEDTLS_HAVEGE_C */
1708
1709 #if defined(MBEDTLS_HKDF_C)
1710 if( strcmp( "MBEDTLS_HKDF_C", config ) == 0 )
1711 {
1712 MACRO_EXPANSION_TO_STR( MBEDTLS_HKDF_C );
1713 return( 0 );
1714 }
1715 #endif /* MBEDTLS_HKDF_C */
1716
1717 #if defined(MBEDTLS_HMAC_DRBG_C)
1718 if( strcmp( "MBEDTLS_HMAC_DRBG_C", config ) == 0 )
1719 {
1720 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_C );
1721 return( 0 );
1722 }
1723 #endif /* MBEDTLS_HMAC_DRBG_C */
1724
1725 #if defined(MBEDTLS_NIST_KW_C)
1726 if( strcmp( "MBEDTLS_NIST_KW_C", config ) == 0 )
1727 {
1728 MACRO_EXPANSION_TO_STR( MBEDTLS_NIST_KW_C );
1729 return( 0 );
1730 }
1731 #endif /* MBEDTLS_NIST_KW_C */
1732
1733 #if defined(MBEDTLS_MD_C)
1734 if( strcmp( "MBEDTLS_MD_C", config ) == 0 )
1735 {
1736 MACRO_EXPANSION_TO_STR( MBEDTLS_MD_C );
1737 return( 0 );
1738 }
1739 #endif /* MBEDTLS_MD_C */
1740
1741 #if defined(MBEDTLS_MD2_C)
1742 if( strcmp( "MBEDTLS_MD2_C", config ) == 0 )
1743 {
1744 MACRO_EXPANSION_TO_STR( MBEDTLS_MD2_C );
1745 return( 0 );
1746 }
1747 #endif /* MBEDTLS_MD2_C */
1748
1749 #if defined(MBEDTLS_MD4_C)
1750 if( strcmp( "MBEDTLS_MD4_C", config ) == 0 )
1751 {
1752 MACRO_EXPANSION_TO_STR( MBEDTLS_MD4_C );
1753 return( 0 );
1754 }
1755 #endif /* MBEDTLS_MD4_C */
1756
1757 #if defined(MBEDTLS_MD5_C)
1758 if( strcmp( "MBEDTLS_MD5_C", config ) == 0 )
1759 {
1760 MACRO_EXPANSION_TO_STR( MBEDTLS_MD5_C );
1761 return( 0 );
1762 }
1763 #endif /* MBEDTLS_MD5_C */
1764
1765 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
1766 if( strcmp( "MBEDTLS_MEMORY_BUFFER_ALLOC_C", config ) == 0 )
1767 {
1768 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_BUFFER_ALLOC_C );
1769 return( 0 );
1770 }
1771 #endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
1772
1773 #if defined(MBEDTLS_NET_C)
1774 if( strcmp( "MBEDTLS_NET_C", config ) == 0 )
1775 {
1776 MACRO_EXPANSION_TO_STR( MBEDTLS_NET_C );
1777 return( 0 );
1778 }
1779 #endif /* MBEDTLS_NET_C */
1780
1781 #if defined(MBEDTLS_OID_C)
1782 if( strcmp( "MBEDTLS_OID_C", config ) == 0 )
1783 {
1784 MACRO_EXPANSION_TO_STR( MBEDTLS_OID_C );
1785 return( 0 );
1786 }
1787 #endif /* MBEDTLS_OID_C */
1788
1789 #if defined(MBEDTLS_PADLOCK_C)
1790 if( strcmp( "MBEDTLS_PADLOCK_C", config ) == 0 )
1791 {
1792 MACRO_EXPANSION_TO_STR( MBEDTLS_PADLOCK_C );
1793 return( 0 );
1794 }
1795 #endif /* MBEDTLS_PADLOCK_C */
1796
1797 #if defined(MBEDTLS_PEM_PARSE_C)
1798 if( strcmp( "MBEDTLS_PEM_PARSE_C", config ) == 0 )
1799 {
1800 MACRO_EXPANSION_TO_STR( MBEDTLS_PEM_PARSE_C );
1801 return( 0 );
1802 }
1803 #endif /* MBEDTLS_PEM_PARSE_C */
1804
1805 #if defined(MBEDTLS_PEM_WRITE_C)
1806 if( strcmp( "MBEDTLS_PEM_WRITE_C", config ) == 0 )
1807 {
1808 MACRO_EXPANSION_TO_STR( MBEDTLS_PEM_WRITE_C );
1809 return( 0 );
1810 }
1811 #endif /* MBEDTLS_PEM_WRITE_C */
1812
1813 #if defined(MBEDTLS_PK_C)
1814 if( strcmp( "MBEDTLS_PK_C", config ) == 0 )
1815 {
1816 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_C );
1817 return( 0 );
1818 }
1819 #endif /* MBEDTLS_PK_C */
1820
1821 #if defined(MBEDTLS_PK_PARSE_C)
1822 if( strcmp( "MBEDTLS_PK_PARSE_C", config ) == 0 )
1823 {
1824 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_PARSE_C );
1825 return( 0 );
1826 }
1827 #endif /* MBEDTLS_PK_PARSE_C */
1828
1829 #if defined(MBEDTLS_PK_WRITE_C)
1830 if( strcmp( "MBEDTLS_PK_WRITE_C", config ) == 0 )
1831 {
1832 MACRO_EXPANSION_TO_STR( MBEDTLS_PK_WRITE_C );
1833 return( 0 );
1834 }
1835 #endif /* MBEDTLS_PK_WRITE_C */
1836
1837 #if defined(MBEDTLS_PKCS5_C)
1838 if( strcmp( "MBEDTLS_PKCS5_C", config ) == 0 )
1839 {
1840 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS5_C );
1841 return( 0 );
1842 }
1843 #endif /* MBEDTLS_PKCS5_C */
1844
1845 #if defined(MBEDTLS_PKCS11_C)
1846 if( strcmp( "MBEDTLS_PKCS11_C", config ) == 0 )
1847 {
1848 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS11_C );
1849 return( 0 );
1850 }
1851 #endif /* MBEDTLS_PKCS11_C */
1852
1853 #if defined(MBEDTLS_PKCS12_C)
1854 if( strcmp( "MBEDTLS_PKCS12_C", config ) == 0 )
1855 {
1856 MACRO_EXPANSION_TO_STR( MBEDTLS_PKCS12_C );
1857 return( 0 );
1858 }
1859 #endif /* MBEDTLS_PKCS12_C */
1860
1861 #if defined(MBEDTLS_PLATFORM_C)
1862 if( strcmp( "MBEDTLS_PLATFORM_C", config ) == 0 )
1863 {
1864 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_C );
1865 return( 0 );
1866 }
1867 #endif /* MBEDTLS_PLATFORM_C */
1868
1869 #if defined(MBEDTLS_POLY1305_C)
1870 if( strcmp( "MBEDTLS_POLY1305_C", config ) == 0 )
1871 {
1872 MACRO_EXPANSION_TO_STR( MBEDTLS_POLY1305_C );
1873 return( 0 );
1874 }
1875 #endif /* MBEDTLS_POLY1305_C */
1876
1877 #if defined(MBEDTLS_RIPEMD160_C)
1878 if( strcmp( "MBEDTLS_RIPEMD160_C", config ) == 0 )
1879 {
1880 MACRO_EXPANSION_TO_STR( MBEDTLS_RIPEMD160_C );
1881 return( 0 );
1882 }
1883 #endif /* MBEDTLS_RIPEMD160_C */
1884
1885 #if defined(MBEDTLS_RSA_C)
1886 if( strcmp( "MBEDTLS_RSA_C", config ) == 0 )
1887 {
1888 MACRO_EXPANSION_TO_STR( MBEDTLS_RSA_C );
1889 return( 0 );
1890 }
1891 #endif /* MBEDTLS_RSA_C */
1892
1893 #if defined(MBEDTLS_SHA1_C)
1894 if( strcmp( "MBEDTLS_SHA1_C", config ) == 0 )
1895 {
1896 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA1_C );
1897 return( 0 );
1898 }
1899 #endif /* MBEDTLS_SHA1_C */
1900
1901 #if defined(MBEDTLS_SHA256_C)
1902 if( strcmp( "MBEDTLS_SHA256_C", config ) == 0 )
1903 {
1904 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA256_C );
1905 return( 0 );
1906 }
1907 #endif /* MBEDTLS_SHA256_C */
1908
1909 #if defined(MBEDTLS_SHA512_C)
1910 if( strcmp( "MBEDTLS_SHA512_C", config ) == 0 )
1911 {
1912 MACRO_EXPANSION_TO_STR( MBEDTLS_SHA512_C );
1913 return( 0 );
1914 }
1915 #endif /* MBEDTLS_SHA512_C */
1916
1917 #if defined(MBEDTLS_SSL_CACHE_C)
1918 if( strcmp( "MBEDTLS_SSL_CACHE_C", config ) == 0 )
1919 {
1920 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CACHE_C );
1921 return( 0 );
1922 }
1923 #endif /* MBEDTLS_SSL_CACHE_C */
1924
1925 #if defined(MBEDTLS_SSL_COOKIE_C)
1926 if( strcmp( "MBEDTLS_SSL_COOKIE_C", config ) == 0 )
1927 {
1928 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_COOKIE_C );
1929 return( 0 );
1930 }
1931 #endif /* MBEDTLS_SSL_COOKIE_C */
1932
1933 #if defined(MBEDTLS_SSL_TICKET_C)
1934 if( strcmp( "MBEDTLS_SSL_TICKET_C", config ) == 0 )
1935 {
1936 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TICKET_C );
1937 return( 0 );
1938 }
1939 #endif /* MBEDTLS_SSL_TICKET_C */
1940
1941 #if defined(MBEDTLS_SSL_CLI_C)
1942 if( strcmp( "MBEDTLS_SSL_CLI_C", config ) == 0 )
1943 {
1944 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CLI_C );
1945 return( 0 );
1946 }
1947 #endif /* MBEDTLS_SSL_CLI_C */
1948
1949 #if defined(MBEDTLS_SSL_SRV_C)
1950 if( strcmp( "MBEDTLS_SSL_SRV_C", config ) == 0 )
1951 {
1952 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_SRV_C );
1953 return( 0 );
1954 }
1955 #endif /* MBEDTLS_SSL_SRV_C */
1956
1957 #if defined(MBEDTLS_SSL_TLS_C)
1958 if( strcmp( "MBEDTLS_SSL_TLS_C", config ) == 0 )
1959 {
1960 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_TLS_C );
1961 return( 0 );
1962 }
1963 #endif /* MBEDTLS_SSL_TLS_C */
1964
1965 #if defined(MBEDTLS_THREADING_C)
1966 if( strcmp( "MBEDTLS_THREADING_C", config ) == 0 )
1967 {
1968 MACRO_EXPANSION_TO_STR( MBEDTLS_THREADING_C );
1969 return( 0 );
1970 }
1971 #endif /* MBEDTLS_THREADING_C */
1972
1973 #if defined(MBEDTLS_TIMING_C)
1974 if( strcmp( "MBEDTLS_TIMING_C", config ) == 0 )
1975 {
1976 MACRO_EXPANSION_TO_STR( MBEDTLS_TIMING_C );
1977 return( 0 );
1978 }
1979 #endif /* MBEDTLS_TIMING_C */
1980
1981 #if defined(MBEDTLS_VERSION_C)
1982 if( strcmp( "MBEDTLS_VERSION_C", config ) == 0 )
1983 {
1984 MACRO_EXPANSION_TO_STR( MBEDTLS_VERSION_C );
1985 return( 0 );
1986 }
1987 #endif /* MBEDTLS_VERSION_C */
1988
1989 #if defined(MBEDTLS_X509_USE_C)
1990 if( strcmp( "MBEDTLS_X509_USE_C", config ) == 0 )
1991 {
1992 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_USE_C );
1993 return( 0 );
1994 }
1995 #endif /* MBEDTLS_X509_USE_C */
1996
1997 #if defined(MBEDTLS_X509_CRT_PARSE_C)
1998 if( strcmp( "MBEDTLS_X509_CRT_PARSE_C", config ) == 0 )
1999 {
2000 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CRT_PARSE_C );
2001 return( 0 );
2002 }
2003 #endif /* MBEDTLS_X509_CRT_PARSE_C */
2004
2005 #if defined(MBEDTLS_X509_CRL_PARSE_C)
2006 if( strcmp( "MBEDTLS_X509_CRL_PARSE_C", config ) == 0 )
2007 {
2008 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CRL_PARSE_C );
2009 return( 0 );
2010 }
2011 #endif /* MBEDTLS_X509_CRL_PARSE_C */
2012
2013 #if defined(MBEDTLS_X509_CSR_PARSE_C)
2014 if( strcmp( "MBEDTLS_X509_CSR_PARSE_C", config ) == 0 )
2015 {
2016 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CSR_PARSE_C );
2017 return( 0 );
2018 }
2019 #endif /* MBEDTLS_X509_CSR_PARSE_C */
2020
2021 #if defined(MBEDTLS_X509_CREATE_C)
2022 if( strcmp( "MBEDTLS_X509_CREATE_C", config ) == 0 )
2023 {
2024 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CREATE_C );
2025 return( 0 );
2026 }
2027 #endif /* MBEDTLS_X509_CREATE_C */
2028
2029 #if defined(MBEDTLS_X509_CRT_WRITE_C)
2030 if( strcmp( "MBEDTLS_X509_CRT_WRITE_C", config ) == 0 )
2031 {
2032 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CRT_WRITE_C );
2033 return( 0 );
2034 }
2035 #endif /* MBEDTLS_X509_CRT_WRITE_C */
2036
2037 #if defined(MBEDTLS_X509_CSR_WRITE_C)
2038 if( strcmp( "MBEDTLS_X509_CSR_WRITE_C", config ) == 0 )
2039 {
2040 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_CSR_WRITE_C );
2041 return( 0 );
2042 }
2043 #endif /* MBEDTLS_X509_CSR_WRITE_C */
2044
2045 #if defined(MBEDTLS_XTEA_C)
2046 if( strcmp( "MBEDTLS_XTEA_C", config ) == 0 )
2047 {
2048 MACRO_EXPANSION_TO_STR( MBEDTLS_XTEA_C );
2049 return( 0 );
2050 }
2051 #endif /* MBEDTLS_XTEA_C */
2052
2053 #if defined(MBEDTLS_MPI_WINDOW_SIZE)
2054 if( strcmp( "MBEDTLS_MPI_WINDOW_SIZE", config ) == 0 )
2055 {
2056 MACRO_EXPANSION_TO_STR( MBEDTLS_MPI_WINDOW_SIZE );
2057 return( 0 );
2058 }
2059 #endif /* MBEDTLS_MPI_WINDOW_SIZE */
2060
2061 #if defined(MBEDTLS_MPI_MAX_SIZE)
2062 if( strcmp( "MBEDTLS_MPI_MAX_SIZE", config ) == 0 )
2063 {
2064 MACRO_EXPANSION_TO_STR( MBEDTLS_MPI_MAX_SIZE );
2065 return( 0 );
2066 }
2067 #endif /* MBEDTLS_MPI_MAX_SIZE */
2068
2069 #if defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN)
2070 if( strcmp( "MBEDTLS_CTR_DRBG_ENTROPY_LEN", config ) == 0 )
2071 {
2072 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_ENTROPY_LEN );
2073 return( 0 );
2074 }
2075 #endif /* MBEDTLS_CTR_DRBG_ENTROPY_LEN */
2076
2077 #if defined(MBEDTLS_CTR_DRBG_RESEED_INTERVAL)
2078 if( strcmp( "MBEDTLS_CTR_DRBG_RESEED_INTERVAL", config ) == 0 )
2079 {
2080 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_RESEED_INTERVAL );
2081 return( 0 );
2082 }
2083 #endif /* MBEDTLS_CTR_DRBG_RESEED_INTERVAL */
2084
2085 #if defined(MBEDTLS_CTR_DRBG_MAX_INPUT)
2086 if( strcmp( "MBEDTLS_CTR_DRBG_MAX_INPUT", config ) == 0 )
2087 {
2088 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_MAX_INPUT );
2089 return( 0 );
2090 }
2091 #endif /* MBEDTLS_CTR_DRBG_MAX_INPUT */
2092
2093 #if defined(MBEDTLS_CTR_DRBG_MAX_REQUEST)
2094 if( strcmp( "MBEDTLS_CTR_DRBG_MAX_REQUEST", config ) == 0 )
2095 {
2096 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_MAX_REQUEST );
2097 return( 0 );
2098 }
2099 #endif /* MBEDTLS_CTR_DRBG_MAX_REQUEST */
2100
2101 #if defined(MBEDTLS_CTR_DRBG_MAX_SEED_INPUT)
2102 if( strcmp( "MBEDTLS_CTR_DRBG_MAX_SEED_INPUT", config ) == 0 )
2103 {
2104 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_MAX_SEED_INPUT );
2105 return( 0 );
2106 }
2107 #endif /* MBEDTLS_CTR_DRBG_MAX_SEED_INPUT */
2108
2109 #if defined(MBEDTLS_CTR_DRBG_USE_128_BIT_KEY)
2110 if( strcmp( "MBEDTLS_CTR_DRBG_USE_128_BIT_KEY", config ) == 0 )
2111 {
2112 MACRO_EXPANSION_TO_STR( MBEDTLS_CTR_DRBG_USE_128_BIT_KEY );
2113 return( 0 );
2114 }
2115 #endif /* MBEDTLS_CTR_DRBG_USE_128_BIT_KEY */
2116
2117 #if defined(MBEDTLS_HMAC_DRBG_RESEED_INTERVAL)
2118 if( strcmp( "MBEDTLS_HMAC_DRBG_RESEED_INTERVAL", config ) == 0 )
2119 {
2120 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_RESEED_INTERVAL );
2121 return( 0 );
2122 }
2123 #endif /* MBEDTLS_HMAC_DRBG_RESEED_INTERVAL */
2124
2125 #if defined(MBEDTLS_HMAC_DRBG_MAX_INPUT)
2126 if( strcmp( "MBEDTLS_HMAC_DRBG_MAX_INPUT", config ) == 0 )
2127 {
2128 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_MAX_INPUT );
2129 return( 0 );
2130 }
2131 #endif /* MBEDTLS_HMAC_DRBG_MAX_INPUT */
2132
2133 #if defined(MBEDTLS_HMAC_DRBG_MAX_REQUEST)
2134 if( strcmp( "MBEDTLS_HMAC_DRBG_MAX_REQUEST", config ) == 0 )
2135 {
2136 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_MAX_REQUEST );
2137 return( 0 );
2138 }
2139 #endif /* MBEDTLS_HMAC_DRBG_MAX_REQUEST */
2140
2141 #if defined(MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT)
2142 if( strcmp( "MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT", config ) == 0 )
2143 {
2144 MACRO_EXPANSION_TO_STR( MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT );
2145 return( 0 );
2146 }
2147 #endif /* MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT */
2148
2149 #if defined(MBEDTLS_ECP_MAX_BITS)
2150 if( strcmp( "MBEDTLS_ECP_MAX_BITS", config ) == 0 )
2151 {
2152 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_MAX_BITS );
2153 return( 0 );
2154 }
2155 #endif /* MBEDTLS_ECP_MAX_BITS */
2156
2157 #if defined(MBEDTLS_ECP_WINDOW_SIZE)
2158 if( strcmp( "MBEDTLS_ECP_WINDOW_SIZE", config ) == 0 )
2159 {
2160 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_WINDOW_SIZE );
2161 return( 0 );
2162 }
2163 #endif /* MBEDTLS_ECP_WINDOW_SIZE */
2164
2165 #if defined(MBEDTLS_ECP_FIXED_POINT_OPTIM)
2166 if( strcmp( "MBEDTLS_ECP_FIXED_POINT_OPTIM", config ) == 0 )
2167 {
2168 MACRO_EXPANSION_TO_STR( MBEDTLS_ECP_FIXED_POINT_OPTIM );
2169 return( 0 );
2170 }
2171 #endif /* MBEDTLS_ECP_FIXED_POINT_OPTIM */
2172
2173 #if defined(MBEDTLS_ENTROPY_MAX_SOURCES)
2174 if( strcmp( "MBEDTLS_ENTROPY_MAX_SOURCES", config ) == 0 )
2175 {
2176 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_MAX_SOURCES );
2177 return( 0 );
2178 }
2179 #endif /* MBEDTLS_ENTROPY_MAX_SOURCES */
2180
2181 #if defined(MBEDTLS_ENTROPY_MAX_GATHER)
2182 if( strcmp( "MBEDTLS_ENTROPY_MAX_GATHER", config ) == 0 )
2183 {
2184 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_MAX_GATHER );
2185 return( 0 );
2186 }
2187 #endif /* MBEDTLS_ENTROPY_MAX_GATHER */
2188
2189 #if defined(MBEDTLS_ENTROPY_MIN_HARDWARE)
2190 if( strcmp( "MBEDTLS_ENTROPY_MIN_HARDWARE", config ) == 0 )
2191 {
2192 MACRO_EXPANSION_TO_STR( MBEDTLS_ENTROPY_MIN_HARDWARE );
2193 return( 0 );
2194 }
2195 #endif /* MBEDTLS_ENTROPY_MIN_HARDWARE */
2196
2197 #if defined(MBEDTLS_MEMORY_ALIGN_MULTIPLE)
2198 if( strcmp( "MBEDTLS_MEMORY_ALIGN_MULTIPLE", config ) == 0 )
2199 {
2200 MACRO_EXPANSION_TO_STR( MBEDTLS_MEMORY_ALIGN_MULTIPLE );
2201 return( 0 );
2202 }
2203 #endif /* MBEDTLS_MEMORY_ALIGN_MULTIPLE */
2204
2205 #if defined(MBEDTLS_PLATFORM_STD_MEM_HDR)
2206 if( strcmp( "MBEDTLS_PLATFORM_STD_MEM_HDR", config ) == 0 )
2207 {
2208 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_MEM_HDR );
2209 return( 0 );
2210 }
2211 #endif /* MBEDTLS_PLATFORM_STD_MEM_HDR */
2212
2213 #if defined(MBEDTLS_PLATFORM_STD_CALLOC)
2214 if( strcmp( "MBEDTLS_PLATFORM_STD_CALLOC", config ) == 0 )
2215 {
2216 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_CALLOC );
2217 return( 0 );
2218 }
2219 #endif /* MBEDTLS_PLATFORM_STD_CALLOC */
2220
2221 #if defined(MBEDTLS_PLATFORM_STD_FREE)
2222 if( strcmp( "MBEDTLS_PLATFORM_STD_FREE", config ) == 0 )
2223 {
2224 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_FREE );
2225 return( 0 );
2226 }
2227 #endif /* MBEDTLS_PLATFORM_STD_FREE */
2228
2229 #if defined(MBEDTLS_PLATFORM_STD_EXIT)
2230 if( strcmp( "MBEDTLS_PLATFORM_STD_EXIT", config ) == 0 )
2231 {
2232 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_EXIT );
2233 return( 0 );
2234 }
2235 #endif /* MBEDTLS_PLATFORM_STD_EXIT */
2236
2237 #if defined(MBEDTLS_PLATFORM_STD_TIME)
2238 if( strcmp( "MBEDTLS_PLATFORM_STD_TIME", config ) == 0 )
2239 {
2240 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_TIME );
2241 return( 0 );
2242 }
2243 #endif /* MBEDTLS_PLATFORM_STD_TIME */
2244
2245 #if defined(MBEDTLS_PLATFORM_STD_FPRINTF)
2246 if( strcmp( "MBEDTLS_PLATFORM_STD_FPRINTF", config ) == 0 )
2247 {
2248 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_FPRINTF );
2249 return( 0 );
2250 }
2251 #endif /* MBEDTLS_PLATFORM_STD_FPRINTF */
2252
2253 #if defined(MBEDTLS_PLATFORM_STD_PRINTF)
2254 if( strcmp( "MBEDTLS_PLATFORM_STD_PRINTF", config ) == 0 )
2255 {
2256 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_PRINTF );
2257 return( 0 );
2258 }
2259 #endif /* MBEDTLS_PLATFORM_STD_PRINTF */
2260
2261 #if defined(MBEDTLS_PLATFORM_STD_SNPRINTF)
2262 if( strcmp( "MBEDTLS_PLATFORM_STD_SNPRINTF", config ) == 0 )
2263 {
2264 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_SNPRINTF );
2265 return( 0 );
2266 }
2267 #endif /* MBEDTLS_PLATFORM_STD_SNPRINTF */
2268
2269 #if defined(MBEDTLS_PLATFORM_STD_EXIT_SUCCESS)
2270 if( strcmp( "MBEDTLS_PLATFORM_STD_EXIT_SUCCESS", config ) == 0 )
2271 {
2272 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_EXIT_SUCCESS );
2273 return( 0 );
2274 }
2275 #endif /* MBEDTLS_PLATFORM_STD_EXIT_SUCCESS */
2276
2277 #if defined(MBEDTLS_PLATFORM_STD_EXIT_FAILURE)
2278 if( strcmp( "MBEDTLS_PLATFORM_STD_EXIT_FAILURE", config ) == 0 )
2279 {
2280 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_EXIT_FAILURE );
2281 return( 0 );
2282 }
2283 #endif /* MBEDTLS_PLATFORM_STD_EXIT_FAILURE */
2284
2285 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)
2286 if( strcmp( "MBEDTLS_PLATFORM_STD_NV_SEED_READ", config ) == 0 )
2287 {
2288 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_NV_SEED_READ );
2289 return( 0 );
2290 }
2291 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_READ */
2292
2293 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)
2294 if( strcmp( "MBEDTLS_PLATFORM_STD_NV_SEED_WRITE", config ) == 0 )
2295 {
2296 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_NV_SEED_WRITE );
2297 return( 0 );
2298 }
2299 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_WRITE */
2300
2301 #if defined(MBEDTLS_PLATFORM_STD_NV_SEED_FILE)
2302 if( strcmp( "MBEDTLS_PLATFORM_STD_NV_SEED_FILE", config ) == 0 )
2303 {
2304 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_STD_NV_SEED_FILE );
2305 return( 0 );
2306 }
2307 #endif /* MBEDTLS_PLATFORM_STD_NV_SEED_FILE */
2308
2309 #if defined(MBEDTLS_PLATFORM_CALLOC_MACRO)
2310 if( strcmp( "MBEDTLS_PLATFORM_CALLOC_MACRO", config ) == 0 )
2311 {
2312 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_CALLOC_MACRO );
2313 return( 0 );
2314 }
2315 #endif /* MBEDTLS_PLATFORM_CALLOC_MACRO */
2316
2317 #if defined(MBEDTLS_PLATFORM_FREE_MACRO)
2318 if( strcmp( "MBEDTLS_PLATFORM_FREE_MACRO", config ) == 0 )
2319 {
2320 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_FREE_MACRO );
2321 return( 0 );
2322 }
2323 #endif /* MBEDTLS_PLATFORM_FREE_MACRO */
2324
2325 #if defined(MBEDTLS_PLATFORM_EXIT_MACRO)
2326 if( strcmp( "MBEDTLS_PLATFORM_EXIT_MACRO", config ) == 0 )
2327 {
2328 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_EXIT_MACRO );
2329 return( 0 );
2330 }
2331 #endif /* MBEDTLS_PLATFORM_EXIT_MACRO */
2332
2333 #if defined(MBEDTLS_PLATFORM_TIME_MACRO)
2334 if( strcmp( "MBEDTLS_PLATFORM_TIME_MACRO", config ) == 0 )
2335 {
2336 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_TIME_MACRO );
2337 return( 0 );
2338 }
2339 #endif /* MBEDTLS_PLATFORM_TIME_MACRO */
2340
2341 #if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO)
2342 if( strcmp( "MBEDTLS_PLATFORM_TIME_TYPE_MACRO", config ) == 0 )
2343 {
2344 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_TIME_TYPE_MACRO );
2345 return( 0 );
2346 }
2347 #endif /* MBEDTLS_PLATFORM_TIME_TYPE_MACRO */
2348
2349 #if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO)
2350 if( strcmp( "MBEDTLS_PLATFORM_FPRINTF_MACRO", config ) == 0 )
2351 {
2352 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_FPRINTF_MACRO );
2353 return( 0 );
2354 }
2355 #endif /* MBEDTLS_PLATFORM_FPRINTF_MACRO */
2356
2357 #if defined(MBEDTLS_PLATFORM_PRINTF_MACRO)
2358 if( strcmp( "MBEDTLS_PLATFORM_PRINTF_MACRO", config ) == 0 )
2359 {
2360 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_PRINTF_MACRO );
2361 return( 0 );
2362 }
2363 #endif /* MBEDTLS_PLATFORM_PRINTF_MACRO */
2364
2365 #if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO)
2366 if( strcmp( "MBEDTLS_PLATFORM_SNPRINTF_MACRO", config ) == 0 )
2367 {
2368 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_SNPRINTF_MACRO );
2369 return( 0 );
2370 }
2371 #endif /* MBEDTLS_PLATFORM_SNPRINTF_MACRO */
2372
2373 #if defined(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO)
2374 if( strcmp( "MBEDTLS_PLATFORM_NV_SEED_READ_MACRO", config ) == 0 )
2375 {
2376 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NV_SEED_READ_MACRO );
2377 return( 0 );
2378 }
2379 #endif /* MBEDTLS_PLATFORM_NV_SEED_READ_MACRO */
2380
2381 #if defined(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO)
2382 if( strcmp( "MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO", config ) == 0 )
2383 {
2384 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO );
2385 return( 0 );
2386 }
2387 #endif /* MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO */
2388
2389 #if defined(MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT)
2390 if( strcmp( "MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT", config ) == 0 )
2391 {
2392 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT );
2393 return( 0 );
2394 }
2395 #endif /* MBEDTLS_SSL_CACHE_DEFAULT_TIMEOUT */
2396
2397 #if defined(MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES)
2398 if( strcmp( "MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES", config ) == 0 )
2399 {
2400 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES );
2401 return( 0 );
2402 }
2403 #endif /* MBEDTLS_SSL_CACHE_DEFAULT_MAX_ENTRIES */
2404
2405 #if defined(MBEDTLS_SSL_MAX_CONTENT_LEN)
2406 if( strcmp( "MBEDTLS_SSL_MAX_CONTENT_LEN", config ) == 0 )
2407 {
2408 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_MAX_CONTENT_LEN );
2409 return( 0 );
2410 }
2411 #endif /* MBEDTLS_SSL_MAX_CONTENT_LEN */
2412
2413 #if defined(MBEDTLS_SSL_IN_CONTENT_LEN)
2414 if( strcmp( "MBEDTLS_SSL_IN_CONTENT_LEN", config ) == 0 )
2415 {
2416 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_IN_CONTENT_LEN );
2417 return( 0 );
2418 }
2419 #endif /* MBEDTLS_SSL_IN_CONTENT_LEN */
2420
2421 #if defined(MBEDTLS_SSL_OUT_CONTENT_LEN)
2422 if( strcmp( "MBEDTLS_SSL_OUT_CONTENT_LEN", config ) == 0 )
2423 {
2424 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_OUT_CONTENT_LEN );
2425 return( 0 );
2426 }
2427 #endif /* MBEDTLS_SSL_OUT_CONTENT_LEN */
2428
2429 #if defined(MBEDTLS_SSL_DTLS_MAX_BUFFERING)
2430 if( strcmp( "MBEDTLS_SSL_DTLS_MAX_BUFFERING", config ) == 0 )
2431 {
2432 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DTLS_MAX_BUFFERING );
2433 return( 0 );
2434 }
2435 #endif /* MBEDTLS_SSL_DTLS_MAX_BUFFERING */
2436
2437 #if defined(MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME)
2438 if( strcmp( "MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME", config ) == 0 )
2439 {
2440 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME );
2441 return( 0 );
2442 }
2443 #endif /* MBEDTLS_SSL_DEFAULT_TICKET_LIFETIME */
2444
2445 #if defined(MBEDTLS_PSK_MAX_LEN)
2446 if( strcmp( "MBEDTLS_PSK_MAX_LEN", config ) == 0 )
2447 {
2448 MACRO_EXPANSION_TO_STR( MBEDTLS_PSK_MAX_LEN );
2449 return( 0 );
2450 }
2451 #endif /* MBEDTLS_PSK_MAX_LEN */
2452
2453 #if defined(MBEDTLS_SSL_COOKIE_TIMEOUT)
2454 if( strcmp( "MBEDTLS_SSL_COOKIE_TIMEOUT", config ) == 0 )
2455 {
2456 MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_COOKIE_TIMEOUT );
2457 return( 0 );
2458 }
2459 #endif /* MBEDTLS_SSL_COOKIE_TIMEOUT */
2460
2461 #if defined(MBEDTLS_X509_MAX_INTERMEDIATE_CA)
2462 if( strcmp( "MBEDTLS_X509_MAX_INTERMEDIATE_CA", config ) == 0 )
2463 {
2464 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_MAX_INTERMEDIATE_CA );
2465 return( 0 );
2466 }
2467 #endif /* MBEDTLS_X509_MAX_INTERMEDIATE_CA */
2468
2469 #if defined(MBEDTLS_X509_MAX_FILE_PATH_LEN)
2470 if( strcmp( "MBEDTLS_X509_MAX_FILE_PATH_LEN", config ) == 0 )
2471 {
2472 MACRO_EXPANSION_TO_STR( MBEDTLS_X509_MAX_FILE_PATH_LEN );
2473 return( 0 );
2474 }
2475 #endif /* MBEDTLS_X509_MAX_FILE_PATH_LEN */
2476
2477 #if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES)
2478 if( strcmp( "MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES", config ) == 0 )
2479 {
2480 MACRO_EXPANSION_TO_STR( MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES );
2481 return( 0 );
2482 }
2483 #endif /* MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES */
2484
2485 #if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE)
2486 if( strcmp( "MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE", config ) == 0 )
2487 {
2488 MACRO_EXPANSION_TO_STR( MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE );
2489 return( 0 );
2490 }
2491 #endif /* MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_KEY_EXCHANGE */
2492
2493 #if defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
2494 if( strcmp( "MBEDTLS_PLATFORM_ZEROIZE_ALT", config ) == 0 )
2495 {
2496 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_ZEROIZE_ALT );
2497 return( 0 );
2498 }
2499 #endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
2500
2501 #if defined(MBEDTLS_PLATFORM_GMTIME_R_ALT)
2502 if( strcmp( "MBEDTLS_PLATFORM_GMTIME_R_ALT", config ) == 0 )
2503 {
2504 MACRO_EXPANSION_TO_STR( MBEDTLS_PLATFORM_GMTIME_R_ALT );
2505 return( 0 );
2506 }
2507 #endif /* MBEDTLS_PLATFORM_GMTIME_R_ALT */
2508
2509 /* If the symbol is not found, return an error */
2510 return( 1 );
2511 }
2512
2513 #if defined(_MSC_VER)
2514 #pragma warning(pop)
2515 #endif /* _MSC_VER */
2516