This Trac instance is not used for development anymore!

We migrated our development workflow to git and Gitea.
To test the future redirection, replace trac by ariadne in the page URL.

source: ps/trunk/build/premake/premake5/contrib/mbedtls/library/error.c

Last change on this file was 20366, checked in by Itms, 7 years ago

Alpha 12 version of Premake 5, including prebuilt binary for Windows.
Directly taken from ​https://premake.github.io/.

Refs #3729.
File size: 35.6 KB
Line 
1/*
2 * Error message information
3 *
4 * Copyright (C) 2006-2015, 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_ERROR_C) || defined(MBEDTLS_ERROR_STRERROR_DUMMY)
29#include "mbedtls/error.h"
30#include <string.h>
31#endif
32
33#if defined(MBEDTLS_PLATFORM_C)
34#include "mbedtls/platform.h"
35#else
36#define mbedtls_snprintf snprintf
37#endif
38
39#if defined(MBEDTLS_ERROR_C)
40
41#include <stdio.h>
42
43#if defined(MBEDTLS_AES_C)
44#include "mbedtls/aes.h"
45#endif
46
47#if defined(MBEDTLS_BASE64_C)
48#include "mbedtls/base64.h"
49#endif
50
51#if defined(MBEDTLS_BIGNUM_C)
52#include "mbedtls/bignum.h"
53#endif
54
55#if defined(MBEDTLS_BLOWFISH_C)
56#include "mbedtls/blowfish.h"
57#endif
58
59#if defined(MBEDTLS_CAMELLIA_C)
60#include "mbedtls/camellia.h"
61#endif
62
63#if defined(MBEDTLS_CCM_C)
64#include "mbedtls/ccm.h"
65#endif
66
67#if defined(MBEDTLS_CIPHER_C)
68#include "mbedtls/cipher.h"
69#endif
70
71#if defined(MBEDTLS_CTR_DRBG_C)
72#include "mbedtls/ctr_drbg.h"
73#endif
74
75#if defined(MBEDTLS_DES_C)
76#include "mbedtls/des.h"
77#endif
78
79#if defined(MBEDTLS_DHM_C)
80#include "mbedtls/dhm.h"
81#endif
82
83#if defined(MBEDTLS_ECP_C)
84#include "mbedtls/ecp.h"
85#endif
86
87#if defined(MBEDTLS_ENTROPY_C)
88#include "mbedtls/entropy.h"
89#endif
90
91#if defined(MBEDTLS_GCM_C)
92#include "mbedtls/gcm.h"
93#endif
94
95#if defined(MBEDTLS_HMAC_DRBG_C)
96#include "mbedtls/hmac_drbg.h"
97#endif
98
99#if defined(MBEDTLS_MD_C)
100#include "mbedtls/md.h"
101#endif
102
103#if defined(MBEDTLS_NET_C)
104#include "mbedtls/net.h"
105#endif
106
107#if defined(MBEDTLS_OID_C)
108#include "mbedtls/oid.h"
109#endif
110
111#if defined(MBEDTLS_PADLOCK_C)
112#include "mbedtls/padlock.h"
113#endif
114
115#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
116#include "mbedtls/pem.h"
117#endif
118
119#if defined(MBEDTLS_PK_C)
120#include "mbedtls/pk.h"
121#endif
122
123#if defined(MBEDTLS_PKCS12_C)
124#include "mbedtls/pkcs12.h"
125#endif
126
127#if defined(MBEDTLS_PKCS5_C)
128#include "mbedtls/pkcs5.h"
129#endif
130
131#if defined(MBEDTLS_RSA_C)
132#include "mbedtls/rsa.h"
133#endif
134
135#if defined(MBEDTLS_SSL_TLS_C)
136#include "mbedtls/ssl.h"
137#endif
138
139#if defined(MBEDTLS_THREADING_C)
140#include "mbedtls/threading.h"
141#endif
142
143#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
144#include "mbedtls/x509.h"
145#endif
146
147#if defined(MBEDTLS_XTEA_C)
148#include "mbedtls/xtea.h"
149#endif
150
151
152void mbedtls_strerror( int ret, char *buf, size_t buflen )
153{
154 size_t len;
155 int use_ret;
156
157 if( buflen == 0 )
158 return;
159
160 memset( buf, 0x00, buflen );
161
162 if( ret < 0 )
163 ret = -ret;
164
165 if( ret & 0xFF80 )
166 {
167 use_ret = ret & 0xFF80;
168
169 // High level error codes
170 //
171 // BEGIN generated code
172#if defined(MBEDTLS_CIPHER_C)
173 if( use_ret == -(MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE) )
174 mbedtls_snprintf( buf, buflen, "CIPHER - The selected feature is not available" );
175 if( use_ret == -(MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA) )
176 mbedtls_snprintf( buf, buflen, "CIPHER - Bad input parameters to function" );
177 if( use_ret == -(MBEDTLS_ERR_CIPHER_ALLOC_FAILED) )
178 mbedtls_snprintf( buf, buflen, "CIPHER - Failed to allocate memory" );
179 if( use_ret == -(MBEDTLS_ERR_CIPHER_INVALID_PADDING) )
180 mbedtls_snprintf( buf, buflen, "CIPHER - Input data contains invalid padding and is rejected" );
181 if( use_ret == -(MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED) )
182 mbedtls_snprintf( buf, buflen, "CIPHER - Decryption of block requires a full block" );
183 if( use_ret == -(MBEDTLS_ERR_CIPHER_AUTH_FAILED) )
184 mbedtls_snprintf( buf, buflen, "CIPHER - Authentication failed (for AEAD modes)" );
185#endif /* MBEDTLS_CIPHER_C */
186
187#if defined(MBEDTLS_DHM_C)
188 if( use_ret == -(MBEDTLS_ERR_DHM_BAD_INPUT_DATA) )
189 mbedtls_snprintf( buf, buflen, "DHM - Bad input parameters to function" );
190 if( use_ret == -(MBEDTLS_ERR_DHM_READ_PARAMS_FAILED) )
191 mbedtls_snprintf( buf, buflen, "DHM - Reading of the DHM parameters failed" );
192 if( use_ret == -(MBEDTLS_ERR_DHM_MAKE_PARAMS_FAILED) )
193 mbedtls_snprintf( buf, buflen, "DHM - Making of the DHM parameters failed" );
194 if( use_ret == -(MBEDTLS_ERR_DHM_READ_PUBLIC_FAILED) )
195 mbedtls_snprintf( buf, buflen, "DHM - Reading of the public values failed" );
196 if( use_ret == -(MBEDTLS_ERR_DHM_MAKE_PUBLIC_FAILED) )
197 mbedtls_snprintf( buf, buflen, "DHM - Making of the public value failed" );
198 if( use_ret == -(MBEDTLS_ERR_DHM_CALC_SECRET_FAILED) )
199 mbedtls_snprintf( buf, buflen, "DHM - Calculation of the DHM secret failed" );
200 if( use_ret == -(MBEDTLS_ERR_DHM_INVALID_FORMAT) )
201 mbedtls_snprintf( buf, buflen, "DHM - The ASN.1 data is not formatted correctly" );
202 if( use_ret == -(MBEDTLS_ERR_DHM_ALLOC_FAILED) )
203 mbedtls_snprintf( buf, buflen, "DHM - Allocation of memory failed" );
204 if( use_ret == -(MBEDTLS_ERR_DHM_FILE_IO_ERROR) )
205 mbedtls_snprintf( buf, buflen, "DHM - Read/write of file failed" );
206#endif /* MBEDTLS_DHM_C */
207
208#if defined(MBEDTLS_ECP_C)
209 if( use_ret == -(MBEDTLS_ERR_ECP_BAD_INPUT_DATA) )
210 mbedtls_snprintf( buf, buflen, "ECP - Bad input parameters to function" );
211 if( use_ret == -(MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL) )
212 mbedtls_snprintf( buf, buflen, "ECP - The buffer is too small to write to" );
213 if( use_ret == -(MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE) )
214 mbedtls_snprintf( buf, buflen, "ECP - Requested curve not available" );
215 if( use_ret == -(MBEDTLS_ERR_ECP_VERIFY_FAILED) )
216 mbedtls_snprintf( buf, buflen, "ECP - The signature is not valid" );
217 if( use_ret == -(MBEDTLS_ERR_ECP_ALLOC_FAILED) )
218 mbedtls_snprintf( buf, buflen, "ECP - Memory allocation failed" );
219 if( use_ret == -(MBEDTLS_ERR_ECP_RANDOM_FAILED) )
220 mbedtls_snprintf( buf, buflen, "ECP - Generation of random value, such as (ephemeral) key, failed" );
221 if( use_ret == -(MBEDTLS_ERR_ECP_INVALID_KEY) )
222 mbedtls_snprintf( buf, buflen, "ECP - Invalid private or public key" );
223 if( use_ret == -(MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH) )
224 mbedtls_snprintf( buf, buflen, "ECP - Signature is valid but shorter than the user-supplied length" );
225#endif /* MBEDTLS_ECP_C */
226
227#if defined(MBEDTLS_MD_C)
228 if( use_ret == -(MBEDTLS_ERR_MD_FEATURE_UNAVAILABLE) )
229 mbedtls_snprintf( buf, buflen, "MD - The selected feature is not available" );
230 if( use_ret == -(MBEDTLS_ERR_MD_BAD_INPUT_DATA) )
231 mbedtls_snprintf( buf, buflen, "MD - Bad input parameters to function" );
232 if( use_ret == -(MBEDTLS_ERR_MD_ALLOC_FAILED) )
233 mbedtls_snprintf( buf, buflen, "MD - Failed to allocate memory" );
234 if( use_ret == -(MBEDTLS_ERR_MD_FILE_IO_ERROR) )
235 mbedtls_snprintf( buf, buflen, "MD - Opening or reading of file failed" );
236#endif /* MBEDTLS_MD_C */
237
238#if defined(MBEDTLS_PEM_PARSE_C) || defined(MBEDTLS_PEM_WRITE_C)
239 if( use_ret == -(MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT) )
240 mbedtls_snprintf( buf, buflen, "PEM - No PEM header or footer found" );
241 if( use_ret == -(MBEDTLS_ERR_PEM_INVALID_DATA) )
242 mbedtls_snprintf( buf, buflen, "PEM - PEM string is not as expected" );
243 if( use_ret == -(MBEDTLS_ERR_PEM_ALLOC_FAILED) )
244 mbedtls_snprintf( buf, buflen, "PEM - Failed to allocate memory" );
245 if( use_ret == -(MBEDTLS_ERR_PEM_INVALID_ENC_IV) )
246 mbedtls_snprintf( buf, buflen, "PEM - RSA IV is not in hex-format" );
247 if( use_ret == -(MBEDTLS_ERR_PEM_UNKNOWN_ENC_ALG) )
248 mbedtls_snprintf( buf, buflen, "PEM - Unsupported key encryption algorithm" );
249 if( use_ret == -(MBEDTLS_ERR_PEM_PASSWORD_REQUIRED) )
250 mbedtls_snprintf( buf, buflen, "PEM - Private key password can't be empty" );
251 if( use_ret == -(MBEDTLS_ERR_PEM_PASSWORD_MISMATCH) )
252 mbedtls_snprintf( buf, buflen, "PEM - Given private key password does not allow for correct decryption" );
253 if( use_ret == -(MBEDTLS_ERR_PEM_FEATURE_UNAVAILABLE) )
254 mbedtls_snprintf( buf, buflen, "PEM - Unavailable feature, e.g. hashing/encryption combination" );
255 if( use_ret == -(MBEDTLS_ERR_PEM_BAD_INPUT_DATA) )
256 mbedtls_snprintf( buf, buflen, "PEM - Bad input parameters to function" );
257#endif /* MBEDTLS_PEM_PARSE_C || MBEDTLS_PEM_WRITE_C */
258
259#if defined(MBEDTLS_PK_C)
260 if( use_ret == -(MBEDTLS_ERR_PK_ALLOC_FAILED) )
261 mbedtls_snprintf( buf, buflen, "PK - Memory allocation failed" );
262 if( use_ret == -(MBEDTLS_ERR_PK_TYPE_MISMATCH) )
263 mbedtls_snprintf( buf, buflen, "PK - Type mismatch, eg attempt to encrypt with an ECDSA key" );
264 if( use_ret == -(MBEDTLS_ERR_PK_BAD_INPUT_DATA) )
265 mbedtls_snprintf( buf, buflen, "PK - Bad input parameters to function" );
266 if( use_ret == -(MBEDTLS_ERR_PK_FILE_IO_ERROR) )
267 mbedtls_snprintf( buf, buflen, "PK - Read/write of file failed" );
268 if( use_ret == -(MBEDTLS_ERR_PK_KEY_INVALID_VERSION) )
269 mbedtls_snprintf( buf, buflen, "PK - Unsupported key version" );
270 if( use_ret == -(MBEDTLS_ERR_PK_KEY_INVALID_FORMAT) )
271 mbedtls_snprintf( buf, buflen, "PK - Invalid key tag or value" );
272 if( use_ret == -(MBEDTLS_ERR_PK_UNKNOWN_PK_ALG) )
273 mbedtls_snprintf( buf, buflen, "PK - Key algorithm is unsupported (only RSA and EC are supported)" );
274 if( use_ret == -(MBEDTLS_ERR_PK_PASSWORD_REQUIRED) )
275 mbedtls_snprintf( buf, buflen, "PK - Private key password can't be empty" );
276 if( use_ret == -(MBEDTLS_ERR_PK_PASSWORD_MISMATCH) )
277 mbedtls_snprintf( buf, buflen, "PK - Given private key password does not allow for correct decryption" );
278 if( use_ret == -(MBEDTLS_ERR_PK_INVALID_PUBKEY) )
279 mbedtls_snprintf( buf, buflen, "PK - The pubkey tag or value is invalid (only RSA and EC are supported)" );
280 if( use_ret == -(MBEDTLS_ERR_PK_INVALID_ALG) )
281 mbedtls_snprintf( buf, buflen, "PK - The algorithm tag or value is invalid" );
282 if( use_ret == -(MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE) )
283 mbedtls_snprintf( buf, buflen, "PK - Elliptic curve is unsupported (only NIST curves are supported)" );
284 if( use_ret == -(MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE) )
285 mbedtls_snprintf( buf, buflen, "PK - Unavailable feature, e.g. RSA disabled for RSA key" );
286 if( use_ret == -(MBEDTLS_ERR_PK_SIG_LEN_MISMATCH) )
287 mbedtls_snprintf( buf, buflen, "PK - The signature is valid but its length is less than expected" );
288#endif /* MBEDTLS_PK_C */
289
290#if defined(MBEDTLS_PKCS12_C)
291 if( use_ret == -(MBEDTLS_ERR_PKCS12_BAD_INPUT_DATA) )
292 mbedtls_snprintf( buf, buflen, "PKCS12 - Bad input parameters to function" );
293 if( use_ret == -(MBEDTLS_ERR_PKCS12_FEATURE_UNAVAILABLE) )
294 mbedtls_snprintf( buf, buflen, "PKCS12 - Feature not available, e.g. unsupported encryption scheme" );
295 if( use_ret == -(MBEDTLS_ERR_PKCS12_PBE_INVALID_FORMAT) )
296 mbedtls_snprintf( buf, buflen, "PKCS12 - PBE ASN.1 data not as expected" );
297 if( use_ret == -(MBEDTLS_ERR_PKCS12_PASSWORD_MISMATCH) )
298 mbedtls_snprintf( buf, buflen, "PKCS12 - Given private key password does not allow for correct decryption" );
299#endif /* MBEDTLS_PKCS12_C */
300
301#if defined(MBEDTLS_PKCS5_C)
302 if( use_ret == -(MBEDTLS_ERR_PKCS5_BAD_INPUT_DATA) )
303 mbedtls_snprintf( buf, buflen, "PKCS5 - Bad input parameters to function" );
304 if( use_ret == -(MBEDTLS_ERR_PKCS5_INVALID_FORMAT) )
305 mbedtls_snprintf( buf, buflen, "PKCS5 - Unexpected ASN.1 data" );
306 if( use_ret == -(MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE) )
307 mbedtls_snprintf( buf, buflen, "PKCS5 - Requested encryption or digest alg not available" );
308 if( use_ret == -(MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH) )
309 mbedtls_snprintf( buf, buflen, "PKCS5 - Given private key password does not allow for correct decryption" );
310#endif /* MBEDTLS_PKCS5_C */
311
312#if defined(MBEDTLS_RSA_C)
313 if( use_ret == -(MBEDTLS_ERR_RSA_BAD_INPUT_DATA) )
314 mbedtls_snprintf( buf, buflen, "RSA - Bad input parameters to function" );
315 if( use_ret == -(MBEDTLS_ERR_RSA_INVALID_PADDING) )
316 mbedtls_snprintf( buf, buflen, "RSA - Input data contains invalid padding and is rejected" );
317 if( use_ret == -(MBEDTLS_ERR_RSA_KEY_GEN_FAILED) )
318 mbedtls_snprintf( buf, buflen, "RSA - Something failed during generation of a key" );
319 if( use_ret == -(MBEDTLS_ERR_RSA_KEY_CHECK_FAILED) )
320 mbedtls_snprintf( buf, buflen, "RSA - Key failed to pass the library's validity check" );
321 if( use_ret == -(MBEDTLS_ERR_RSA_PUBLIC_FAILED) )
322 mbedtls_snprintf( buf, buflen, "RSA - The public key operation failed" );
323 if( use_ret == -(MBEDTLS_ERR_RSA_PRIVATE_FAILED) )
324 mbedtls_snprintf( buf, buflen, "RSA - The private key operation failed" );
325 if( use_ret == -(MBEDTLS_ERR_RSA_VERIFY_FAILED) )
326 mbedtls_snprintf( buf, buflen, "RSA - The PKCS#1 verification failed" );
327 if( use_ret == -(MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE) )
328 mbedtls_snprintf( buf, buflen, "RSA - The output buffer for decryption is not large enough" );
329 if( use_ret == -(MBEDTLS_ERR_RSA_RNG_FAILED) )
330 mbedtls_snprintf( buf, buflen, "RSA - The random generator failed to generate non-zeros" );
331#endif /* MBEDTLS_RSA_C */
332
333#if defined(MBEDTLS_SSL_TLS_C)
334 if( use_ret == -(MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) )
335 mbedtls_snprintf( buf, buflen, "SSL - The requested feature is not available" );
336 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_INPUT_DATA) )
337 mbedtls_snprintf( buf, buflen, "SSL - Bad input parameters to function" );
338 if( use_ret == -(MBEDTLS_ERR_SSL_INVALID_MAC) )
339 mbedtls_snprintf( buf, buflen, "SSL - Verification of the message MAC failed" );
340 if( use_ret == -(MBEDTLS_ERR_SSL_INVALID_RECORD) )
341 mbedtls_snprintf( buf, buflen, "SSL - An invalid SSL record was received" );
342 if( use_ret == -(MBEDTLS_ERR_SSL_CONN_EOF) )
343 mbedtls_snprintf( buf, buflen, "SSL - The connection indicated an EOF" );
344 if( use_ret == -(MBEDTLS_ERR_SSL_UNKNOWN_CIPHER) )
345 mbedtls_snprintf( buf, buflen, "SSL - An unknown cipher was received" );
346 if( use_ret == -(MBEDTLS_ERR_SSL_NO_CIPHER_CHOSEN) )
347 mbedtls_snprintf( buf, buflen, "SSL - The server has no ciphersuites in common with the client" );
348 if( use_ret == -(MBEDTLS_ERR_SSL_NO_RNG) )
349 mbedtls_snprintf( buf, buflen, "SSL - No RNG was provided to the SSL module" );
350 if( use_ret == -(MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE) )
351 mbedtls_snprintf( buf, buflen, "SSL - No client certification received from the client, but required by the authentication mode" );
352 if( use_ret == -(MBEDTLS_ERR_SSL_CERTIFICATE_TOO_LARGE) )
353 mbedtls_snprintf( buf, buflen, "SSL - Our own certificate(s) is/are too large to send in an SSL message" );
354 if( use_ret == -(MBEDTLS_ERR_SSL_CERTIFICATE_REQUIRED) )
355 mbedtls_snprintf( buf, buflen, "SSL - The own certificate is not set, but needed by the server" );
356 if( use_ret == -(MBEDTLS_ERR_SSL_PRIVATE_KEY_REQUIRED) )
357 mbedtls_snprintf( buf, buflen, "SSL - The own private key or pre-shared key is not set, but needed" );
358 if( use_ret == -(MBEDTLS_ERR_SSL_CA_CHAIN_REQUIRED) )
359 mbedtls_snprintf( buf, buflen, "SSL - No CA Chain is set, but required to operate" );
360 if( use_ret == -(MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE) )
361 mbedtls_snprintf( buf, buflen, "SSL - An unexpected message was received from our peer" );
362 if( use_ret == -(MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE) )
363 {
364 mbedtls_snprintf( buf, buflen, "SSL - A fatal alert message was received from our peer" );
365 return;
366 }
367 if( use_ret == -(MBEDTLS_ERR_SSL_PEER_VERIFY_FAILED) )
368 mbedtls_snprintf( buf, buflen, "SSL - Verification of our peer failed" );
369 if( use_ret == -(MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) )
370 mbedtls_snprintf( buf, buflen, "SSL - The peer notified us that the connection is going to be closed" );
371 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO) )
372 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientHello handshake message failed" );
373 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO) )
374 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ServerHello handshake message failed" );
375 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE) )
376 mbedtls_snprintf( buf, buflen, "SSL - Processing of the Certificate handshake message failed" );
377 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST) )
378 mbedtls_snprintf( buf, buflen, "SSL - Processing of the CertificateRequest handshake message failed" );
379 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE) )
380 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ServerKeyExchange handshake message failed" );
381 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO_DONE) )
382 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ServerHelloDone handshake message failed" );
383 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE) )
384 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed" );
385 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP) )
386 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public" );
387 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS) )
388 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret" );
389 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY) )
390 mbedtls_snprintf( buf, buflen, "SSL - Processing of the CertificateVerify handshake message failed" );
391 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC) )
392 mbedtls_snprintf( buf, buflen, "SSL - Processing of the ChangeCipherSpec handshake message failed" );
393 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_FINISHED) )
394 mbedtls_snprintf( buf, buflen, "SSL - Processing of the Finished handshake message failed" );
395 if( use_ret == -(MBEDTLS_ERR_SSL_ALLOC_FAILED) )
396 mbedtls_snprintf( buf, buflen, "SSL - Memory allocation failed" );
397 if( use_ret == -(MBEDTLS_ERR_SSL_HW_ACCEL_FAILED) )
398 mbedtls_snprintf( buf, buflen, "SSL - Hardware acceleration function returned with error" );
399 if( use_ret == -(MBEDTLS_ERR_SSL_HW_ACCEL_FALLTHROUGH) )
400 mbedtls_snprintf( buf, buflen, "SSL - Hardware acceleration function skipped / left alone data" );
401 if( use_ret == -(MBEDTLS_ERR_SSL_COMPRESSION_FAILED) )
402 mbedtls_snprintf( buf, buflen, "SSL - Processing of the compression / decompression failed" );
403 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION) )
404 mbedtls_snprintf( buf, buflen, "SSL - Handshake protocol not within min/max boundaries" );
405 if( use_ret == -(MBEDTLS_ERR_SSL_BAD_HS_NEW_SESSION_TICKET) )
406 mbedtls_snprintf( buf, buflen, "SSL - Processing of the NewSessionTicket handshake message failed" );
407 if( use_ret == -(MBEDTLS_ERR_SSL_SESSION_TICKET_EXPIRED) )
408 mbedtls_snprintf( buf, buflen, "SSL - Session ticket has expired" );
409 if( use_ret == -(MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH) )
410 mbedtls_snprintf( buf, buflen, "SSL - Public key type mismatch (eg, asked for RSA key exchange and presented EC key)" );
411 if( use_ret == -(MBEDTLS_ERR_SSL_UNKNOWN_IDENTITY) )
412 mbedtls_snprintf( buf, buflen, "SSL - Unknown identity received (eg, PSK identity)" );
413 if( use_ret == -(MBEDTLS_ERR_SSL_INTERNAL_ERROR) )
414 mbedtls_snprintf( buf, buflen, "SSL - Internal error (eg, unexpected failure in lower-level module)" );
415 if( use_ret == -(MBEDTLS_ERR_SSL_COUNTER_WRAPPING) )
416 mbedtls_snprintf( buf, buflen, "SSL - A counter would wrap (eg, too many messages exchanged)" );
417 if( use_ret == -(MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO) )
418 mbedtls_snprintf( buf, buflen, "SSL - Unexpected message at ServerHello in renegotiation" );
419 if( use_ret == -(MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED) )
420 mbedtls_snprintf( buf, buflen, "SSL - DTLS client must retry for hello verification" );
421 if( use_ret == -(MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL) )
422 mbedtls_snprintf( buf, buflen, "SSL - A buffer is too small to receive or write a message" );
423 if( use_ret == -(MBEDTLS_ERR_SSL_NO_USABLE_CIPHERSUITE) )
424 mbedtls_snprintf( buf, buflen, "SSL - None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages)" );
425 if( use_ret == -(MBEDTLS_ERR_SSL_WANT_READ) )
426 mbedtls_snprintf( buf, buflen, "SSL - Connection requires a read call" );
427 if( use_ret == -(MBEDTLS_ERR_SSL_WANT_WRITE) )
428 mbedtls_snprintf( buf, buflen, "SSL - Connection requires a write call" );
429 if( use_ret == -(MBEDTLS_ERR_SSL_TIMEOUT) )
430 mbedtls_snprintf( buf, buflen, "SSL - The operation timed out" );
431 if( use_ret == -(MBEDTLS_ERR_SSL_CLIENT_RECONNECT) )
432 mbedtls_snprintf( buf, buflen, "SSL - The client initiated a reconnect from the same port" );
433 if( use_ret == -(MBEDTLS_ERR_SSL_UNEXPECTED_RECORD) )
434 mbedtls_snprintf( buf, buflen, "SSL - Record header looks valid but is not expected" );
435#endif /* MBEDTLS_SSL_TLS_C */
436
437#if defined(MBEDTLS_X509_USE_C) || defined(MBEDTLS_X509_CREATE_C)
438 if( use_ret == -(MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE) )
439 mbedtls_snprintf( buf, buflen, "X509 - Unavailable feature, e.g. RSA hashing/encryption combination" );
440 if( use_ret == -(MBEDTLS_ERR_X509_UNKNOWN_OID) )
441 mbedtls_snprintf( buf, buflen, "X509 - Requested OID is unknown" );
442 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_FORMAT) )
443 mbedtls_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR format is invalid, e.g. different type expected" );
444 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_VERSION) )
445 mbedtls_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR version element is invalid" );
446 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_SERIAL) )
447 mbedtls_snprintf( buf, buflen, "X509 - The serial tag or value is invalid" );
448 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_ALG) )
449 mbedtls_snprintf( buf, buflen, "X509 - The algorithm tag or value is invalid" );
450 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_NAME) )
451 mbedtls_snprintf( buf, buflen, "X509 - The name tag or value is invalid" );
452 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_DATE) )
453 mbedtls_snprintf( buf, buflen, "X509 - The date tag or value is invalid" );
454 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_SIGNATURE) )
455 mbedtls_snprintf( buf, buflen, "X509 - The signature tag or value invalid" );
456 if( use_ret == -(MBEDTLS_ERR_X509_INVALID_EXTENSIONS) )
457 mbedtls_snprintf( buf, buflen, "X509 - The extension tag or value is invalid" );
458 if( use_ret == -(MBEDTLS_ERR_X509_UNKNOWN_VERSION) )
459 mbedtls_snprintf( buf, buflen, "X509 - CRT/CRL/CSR has an unsupported version number" );
460 if( use_ret == -(MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG) )
461 mbedtls_snprintf( buf, buflen, "X509 - Signature algorithm (oid) is unsupported" );
462 if( use_ret == -(MBEDTLS_ERR_X509_SIG_MISMATCH) )
463 mbedtls_snprintf( buf, buflen, "X509 - Signature algorithms do not match. (see \\c ::mbedtls_x509_crt sig_oid)" );
464 if( use_ret == -(MBEDTLS_ERR_X509_CERT_VERIFY_FAILED) )
465 mbedtls_snprintf( buf, buflen, "X509 - Certificate verification failed, e.g. CRL, CA or signature check failed" );
466 if( use_ret == -(MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT) )
467 mbedtls_snprintf( buf, buflen, "X509 - Format not recognized as DER or PEM" );
468 if( use_ret == -(MBEDTLS_ERR_X509_BAD_INPUT_DATA) )
469 mbedtls_snprintf( buf, buflen, "X509 - Input invalid" );
470 if( use_ret == -(MBEDTLS_ERR_X509_ALLOC_FAILED) )
471 mbedtls_snprintf( buf, buflen, "X509 - Allocation of memory failed" );
472 if( use_ret == -(MBEDTLS_ERR_X509_FILE_IO_ERROR) )
473 mbedtls_snprintf( buf, buflen, "X509 - Read/write of file failed" );
474 if( use_ret == -(MBEDTLS_ERR_X509_BUFFER_TOO_SMALL) )
475 mbedtls_snprintf( buf, buflen, "X509 - Destination buffer is too small" );
476#endif /* MBEDTLS_X509_USE_C || MBEDTLS_X509_CREATE_C */
477 // END generated code
478
479 if( strlen( buf ) == 0 )
480 mbedtls_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
481 }
482
483 use_ret = ret & ~0xFF80;
484
485 if( use_ret == 0 )
486 return;
487
488 // If high level code is present, make a concatenation between both
489 // error strings.
490 //
491 len = strlen( buf );
492
493 if( len > 0 )
494 {
495 if( buflen - len < 5 )
496 return;
497
498 mbedtls_snprintf( buf + len, buflen - len, " : " );
499
500 buf += len + 3;
501 buflen -= len + 3;
502 }
503
504 // Low level error codes
505 //
506 // BEGIN generated code
507#if defined(MBEDTLS_AES_C)
508 if( use_ret == -(MBEDTLS_ERR_AES_INVALID_KEY_LENGTH) )
509 mbedtls_snprintf( buf, buflen, "AES - Invalid key length" );
510 if( use_ret == -(MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH) )
511 mbedtls_snprintf( buf, buflen, "AES - Invalid data input length" );
512#endif /* MBEDTLS_AES_C */
513
514#if defined(MBEDTLS_ASN1_PARSE_C)
515 if( use_ret == -(MBEDTLS_ERR_ASN1_OUT_OF_DATA) )
516 mbedtls_snprintf( buf, buflen, "ASN1 - Out of data when parsing an ASN1 data structure" );
517 if( use_ret == -(MBEDTLS_ERR_ASN1_UNEXPECTED_TAG) )
518 mbedtls_snprintf( buf, buflen, "ASN1 - ASN1 tag was of an unexpected value" );
519 if( use_ret == -(MBEDTLS_ERR_ASN1_INVALID_LENGTH) )
520 mbedtls_snprintf( buf, buflen, "ASN1 - Error when trying to determine the length or invalid length" );
521 if( use_ret == -(MBEDTLS_ERR_ASN1_LENGTH_MISMATCH) )
522 mbedtls_snprintf( buf, buflen, "ASN1 - Actual length differs from expected length" );
523 if( use_ret == -(MBEDTLS_ERR_ASN1_INVALID_DATA) )
524 mbedtls_snprintf( buf, buflen, "ASN1 - Data is invalid. (not used)" );
525 if( use_ret == -(MBEDTLS_ERR_ASN1_ALLOC_FAILED) )
526 mbedtls_snprintf( buf, buflen, "ASN1 - Memory allocation failed" );
527 if( use_ret == -(MBEDTLS_ERR_ASN1_BUF_TOO_SMALL) )
528 mbedtls_snprintf( buf, buflen, "ASN1 - Buffer too small when writing ASN.1 data structure" );
529#endif /* MBEDTLS_ASN1_PARSE_C */
530
531#if defined(MBEDTLS_BASE64_C)
532 if( use_ret == -(MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL) )
533 mbedtls_snprintf( buf, buflen, "BASE64 - Output buffer too small" );
534 if( use_ret == -(MBEDTLS_ERR_BASE64_INVALID_CHARACTER) )
535 mbedtls_snprintf( buf, buflen, "BASE64 - Invalid character in input" );
536#endif /* MBEDTLS_BASE64_C */
537
538#if defined(MBEDTLS_BIGNUM_C)
539 if( use_ret == -(MBEDTLS_ERR_MPI_FILE_IO_ERROR) )
540 mbedtls_snprintf( buf, buflen, "BIGNUM - An error occurred while reading from or writing to a file" );
541 if( use_ret == -(MBEDTLS_ERR_MPI_BAD_INPUT_DATA) )
542 mbedtls_snprintf( buf, buflen, "BIGNUM - Bad input parameters to function" );
543 if( use_ret == -(MBEDTLS_ERR_MPI_INVALID_CHARACTER) )
544 mbedtls_snprintf( buf, buflen, "BIGNUM - There is an invalid character in the digit string" );
545 if( use_ret == -(MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL) )
546 mbedtls_snprintf( buf, buflen, "BIGNUM - The buffer is too small to write to" );
547 if( use_ret == -(MBEDTLS_ERR_MPI_NEGATIVE_VALUE) )
548 mbedtls_snprintf( buf, buflen, "BIGNUM - The input arguments are negative or result in illegal output" );
549 if( use_ret == -(MBEDTLS_ERR_MPI_DIVISION_BY_ZERO) )
550 mbedtls_snprintf( buf, buflen, "BIGNUM - The input argument for division is zero, which is not allowed" );
551 if( use_ret == -(MBEDTLS_ERR_MPI_NOT_ACCEPTABLE) )
552 mbedtls_snprintf( buf, buflen, "BIGNUM - The input arguments are not acceptable" );
553 if( use_ret == -(MBEDTLS_ERR_MPI_ALLOC_FAILED) )
554 mbedtls_snprintf( buf, buflen, "BIGNUM - Memory allocation failed" );
555#endif /* MBEDTLS_BIGNUM_C */
556
557#if defined(MBEDTLS_BLOWFISH_C)
558 if( use_ret == -(MBEDTLS_ERR_BLOWFISH_INVALID_KEY_LENGTH) )
559 mbedtls_snprintf( buf, buflen, "BLOWFISH - Invalid key length" );
560 if( use_ret == -(MBEDTLS_ERR_BLOWFISH_INVALID_INPUT_LENGTH) )
561 mbedtls_snprintf( buf, buflen, "BLOWFISH - Invalid data input length" );
562#endif /* MBEDTLS_BLOWFISH_C */
563
564#if defined(MBEDTLS_CAMELLIA_C)
565 if( use_ret == -(MBEDTLS_ERR_CAMELLIA_INVALID_KEY_LENGTH) )
566 mbedtls_snprintf( buf, buflen, "CAMELLIA - Invalid key length" );
567 if( use_ret == -(MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH) )
568 mbedtls_snprintf( buf, buflen, "CAMELLIA - Invalid data input length" );
569#endif /* MBEDTLS_CAMELLIA_C */
570
571#if defined(MBEDTLS_CCM_C)
572 if( use_ret == -(MBEDTLS_ERR_CCM_BAD_INPUT) )
573 mbedtls_snprintf( buf, buflen, "CCM - Bad input parameters to function" );
574 if( use_ret == -(MBEDTLS_ERR_CCM_AUTH_FAILED) )
575 mbedtls_snprintf( buf, buflen, "CCM - Authenticated decryption failed" );
576#endif /* MBEDTLS_CCM_C */
577
578#if defined(MBEDTLS_CTR_DRBG_C)
579 if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED) )
580 mbedtls_snprintf( buf, buflen, "CTR_DRBG - The entropy source failed" );
581 if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG) )
582 mbedtls_snprintf( buf, buflen, "CTR_DRBG - Too many random requested in single call" );
583 if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG) )
584 mbedtls_snprintf( buf, buflen, "CTR_DRBG - Input too large (Entropy + additional)" );
585 if( use_ret == -(MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR) )
586 mbedtls_snprintf( buf, buflen, "CTR_DRBG - Read/write error in file" );
587#endif /* MBEDTLS_CTR_DRBG_C */
588
589#if defined(MBEDTLS_DES_C)
590 if( use_ret == -(MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH) )
591 mbedtls_snprintf( buf, buflen, "DES - The data input has an invalid length" );
592#endif /* MBEDTLS_DES_C */
593
594#if defined(MBEDTLS_ENTROPY_C)
595 if( use_ret == -(MBEDTLS_ERR_ENTROPY_SOURCE_FAILED) )
596 mbedtls_snprintf( buf, buflen, "ENTROPY - Critical entropy source failure" );
597 if( use_ret == -(MBEDTLS_ERR_ENTROPY_MAX_SOURCES) )
598 mbedtls_snprintf( buf, buflen, "ENTROPY - No more sources can be added" );
599 if( use_ret == -(MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED) )
600 mbedtls_snprintf( buf, buflen, "ENTROPY - No sources have been added to poll" );
601 if( use_ret == -(MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE) )
602 mbedtls_snprintf( buf, buflen, "ENTROPY - No strong sources have been added to poll" );
603 if( use_ret == -(MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR) )
604 mbedtls_snprintf( buf, buflen, "ENTROPY - Read/write error in file" );
605#endif /* MBEDTLS_ENTROPY_C */
606
607#if defined(MBEDTLS_GCM_C)
608 if( use_ret == -(MBEDTLS_ERR_GCM_AUTH_FAILED) )
609 mbedtls_snprintf( buf, buflen, "GCM - Authenticated decryption failed" );
610 if( use_ret == -(MBEDTLS_ERR_GCM_BAD_INPUT) )
611 mbedtls_snprintf( buf, buflen, "GCM - Bad input parameters to function" );
612#endif /* MBEDTLS_GCM_C */
613
614#if defined(MBEDTLS_HMAC_DRBG_C)
615 if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_REQUEST_TOO_BIG) )
616 mbedtls_snprintf( buf, buflen, "HMAC_DRBG - Too many random requested in single call" );
617 if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG) )
618 mbedtls_snprintf( buf, buflen, "HMAC_DRBG - Input too large (Entropy + additional)" );
619 if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR) )
620 mbedtls_snprintf( buf, buflen, "HMAC_DRBG - Read/write error in file" );
621 if( use_ret == -(MBEDTLS_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED) )
622 mbedtls_snprintf( buf, buflen, "HMAC_DRBG - The entropy source failed" );
623#endif /* MBEDTLS_HMAC_DRBG_C */
624
625#if defined(MBEDTLS_NET_C)
626 if( use_ret == -(MBEDTLS_ERR_NET_SOCKET_FAILED) )
627 mbedtls_snprintf( buf, buflen, "NET - Failed to open a socket" );
628 if( use_ret == -(MBEDTLS_ERR_NET_CONNECT_FAILED) )
629 mbedtls_snprintf( buf, buflen, "NET - The connection to the given server / port failed" );
630 if( use_ret == -(MBEDTLS_ERR_NET_BIND_FAILED) )
631 mbedtls_snprintf( buf, buflen, "NET - Binding of the socket failed" );
632 if( use_ret == -(MBEDTLS_ERR_NET_LISTEN_FAILED) )
633 mbedtls_snprintf( buf, buflen, "NET - Could not listen on the socket" );
634 if( use_ret == -(MBEDTLS_ERR_NET_ACCEPT_FAILED) )
635 mbedtls_snprintf( buf, buflen, "NET - Could not accept the incoming connection" );
636 if( use_ret == -(MBEDTLS_ERR_NET_RECV_FAILED) )
637 mbedtls_snprintf( buf, buflen, "NET - Reading information from the socket failed" );
638 if( use_ret == -(MBEDTLS_ERR_NET_SEND_FAILED) )
639 mbedtls_snprintf( buf, buflen, "NET - Sending information through the socket failed" );
640 if( use_ret == -(MBEDTLS_ERR_NET_CONN_RESET) )
641 mbedtls_snprintf( buf, buflen, "NET - Connection was reset by peer" );
642 if( use_ret == -(MBEDTLS_ERR_NET_UNKNOWN_HOST) )
643 mbedtls_snprintf( buf, buflen, "NET - Failed to get an IP address for the given hostname" );
644 if( use_ret == -(MBEDTLS_ERR_NET_BUFFER_TOO_SMALL) )
645 mbedtls_snprintf( buf, buflen, "NET - Buffer is too small to hold the data" );
646 if( use_ret == -(MBEDTLS_ERR_NET_INVALID_CONTEXT) )
647 mbedtls_snprintf( buf, buflen, "NET - The context is invalid, eg because it was free()ed" );
648#endif /* MBEDTLS_NET_C */
649
650#if defined(MBEDTLS_OID_C)
651 if( use_ret == -(MBEDTLS_ERR_OID_NOT_FOUND) )
652 mbedtls_snprintf( buf, buflen, "OID - OID is not found" );
653 if( use_ret == -(MBEDTLS_ERR_OID_BUF_TOO_SMALL) )
654 mbedtls_snprintf( buf, buflen, "OID - output buffer is too small" );
655#endif /* MBEDTLS_OID_C */
656
657#if defined(MBEDTLS_PADLOCK_C)
658 if( use_ret == -(MBEDTLS_ERR_PADLOCK_DATA_MISALIGNED) )
659 mbedtls_snprintf( buf, buflen, "PADLOCK - Input data should be aligned" );
660#endif /* MBEDTLS_PADLOCK_C */
661
662#if defined(MBEDTLS_THREADING_C)
663 if( use_ret == -(MBEDTLS_ERR_THREADING_FEATURE_UNAVAILABLE) )
664 mbedtls_snprintf( buf, buflen, "THREADING - The selected feature is not available" );
665 if( use_ret == -(MBEDTLS_ERR_THREADING_BAD_INPUT_DATA) )
666 mbedtls_snprintf( buf, buflen, "THREADING - Bad input parameters to function" );
667 if( use_ret == -(MBEDTLS_ERR_THREADING_MUTEX_ERROR) )
668 mbedtls_snprintf( buf, buflen, "THREADING - Locking / unlocking / free failed with error code" );
669#endif /* MBEDTLS_THREADING_C */
670
671#if defined(MBEDTLS_XTEA_C)
672 if( use_ret == -(MBEDTLS_ERR_XTEA_INVALID_INPUT_LENGTH) )
673 mbedtls_snprintf( buf, buflen, "XTEA - The data input has an invalid length" );
674#endif /* MBEDTLS_XTEA_C */
675 // END generated code
676
677 if( strlen( buf ) != 0 )
678 return;
679
680 mbedtls_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
681}
682
683#else /* MBEDTLS_ERROR_C */
684
685#if defined(MBEDTLS_ERROR_STRERROR_DUMMY)
686
687/*
688 * Provide an non-function in case MBEDTLS_ERROR_C is not defined
689 */
690void mbedtls_strerror( int ret, char *buf, size_t buflen )
691{
692 ((void) ret);
693
694 if( buflen > 0 )
695 buf[0] = '\0';
696}
697
698#endif /* MBEDTLS_ERROR_STRERROR_DUMMY */
699
700#endif /* MBEDTLS_ERROR_C */
Note: See TracBrowser for help on using the repository browser.