reactos/dll/3rdparty/mbedtls/error.c

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