git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/platform.c

   1 /*\r
   2  *  Platform abstraction layer\r
   3  *\r
   4  *  Copyright (C) 2006-2016, ARM Limited, All Rights Reserved\r
   5  *  SPDX-License-Identifier: Apache-2.0\r
   6  *\r
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may\r
   8  *  not use this file except in compliance with the License.\r
   9  *  You may obtain a copy of the License at\r
  10  *\r
  11  *  http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  *  Unless required by applicable law or agreed to in writing, software\r
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  *  See the License for the specific language governing permissions and\r
  17  *  limitations under the License.\r
  18  *\r
  19  *  This file is part of mbed TLS (https://tls.mbed.org)\r
  20  */\r
  21 \r
  22 #if !defined(MBEDTLS_CONFIG_FILE)\r
  23 #include "mbedtls/config.h"\r
  24 #else\r
  25 #include MBEDTLS_CONFIG_FILE\r
  26 #endif\r
  27 \r
  28 #if defined(MBEDTLS_PLATFORM_C)\r
  29 \r
  30 #include "mbedtls/platform.h"\r
  31 #include "mbedtls/platform_util.h"\r
  32 \r
  33 /* The compile time configuration of memory allocation via the macros\r
  34  * MBEDTLS_PLATFORM_{FREE/CALLOC}_MACRO takes precedence over the runtime\r
  35  * configuration via mbedtls_platform_set_calloc_free(). So, omit everything\r
  36  * related to the latter if MBEDTLS_PLATFORM_{FREE/CALLOC}_MACRO are defined. */\r
  37 #if defined(MBEDTLS_PLATFORM_MEMORY) &&                 \\r
  38     !( defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&        \\r
  39        defined(MBEDTLS_PLATFORM_FREE_MACRO) )\r
  40 \r
  41 #if !defined(MBEDTLS_PLATFORM_STD_CALLOC)\r
  42 static void *platform_calloc_uninit( size_t n, size_t size )\r
  43 {\r
  44     ((void) n);\r
  45     ((void) size);\r
  46     return( NULL );\r
  47 }\r
  48 \r
  49 #define MBEDTLS_PLATFORM_STD_CALLOC   platform_calloc_uninit\r
  50 #endif /* !MBEDTLS_PLATFORM_STD_CALLOC */\r
  51 \r
  52 #if !defined(MBEDTLS_PLATFORM_STD_FREE)\r
  53 static void platform_free_uninit( void *ptr )\r
  54 {\r
  55     ((void) ptr);\r
  56 }\r
  57 \r
  58 #define MBEDTLS_PLATFORM_STD_FREE     platform_free_uninit\r
  59 #endif /* !MBEDTLS_PLATFORM_STD_FREE */\r
  60 \r
  61 static void * (*mbedtls_calloc_func)( size_t, size_t ) = MBEDTLS_PLATFORM_STD_CALLOC;\r
  62 static void (*mbedtls_free_func)( void * ) = MBEDTLS_PLATFORM_STD_FREE;\r
  63 \r
  64 void * mbedtls_calloc( size_t nmemb, size_t size )\r
  65 {\r
  66     return (*mbedtls_calloc_func)( nmemb, size );\r
  67 }\r
  68 \r
  69 void mbedtls_free( void * ptr )\r
  70 {\r
  71     (*mbedtls_free_func)( ptr );\r
  72 }\r
  73 \r
  74 int mbedtls_platform_set_calloc_free( void * (*calloc_func)( size_t, size_t ),\r
  75                               void (*free_func)( void * ) )\r
  76 {\r
  77     mbedtls_calloc_func = calloc_func;\r
  78     mbedtls_free_func = free_func;\r
  79     return( 0 );\r
  80 }\r
  81 #endif /* MBEDTLS_PLATFORM_MEMORY &&\r
  82           !( defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&\r
  83              defined(MBEDTLS_PLATFORM_FREE_MACRO) ) */\r
  84 \r
  85 #if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_SNPRINTF)\r
  86 #include <stdarg.h>\r
  87 int mbedtls_platform_win32_snprintf( char *s, size_t n, const char *fmt, ... )\r
  88 {\r
  89     int ret;\r
  90     va_list argp;\r
  91 \r
  92     va_start( argp, fmt );\r
  93     ret = mbedtls_vsnprintf( s, n, fmt, argp );\r
  94     va_end( argp );\r
  95 \r
  96     return( ret );\r
  97 }\r
  98 #endif\r
  99 \r
 100 #if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)\r
 101 #if !defined(MBEDTLS_PLATFORM_STD_SNPRINTF)\r
 102 /*\r
 103  * Make dummy function to prevent NULL pointer dereferences\r
 104  */\r
 105 static int platform_snprintf_uninit( char * s, size_t n,\r
 106                                      const char * format, ... )\r
 107 {\r
 108     ((void) s);\r
 109     ((void) n);\r
 110     ((void) format);\r
 111     return( 0 );\r
 112 }\r
 113 \r
 114 #define MBEDTLS_PLATFORM_STD_SNPRINTF    platform_snprintf_uninit\r
 115 #endif /* !MBEDTLS_PLATFORM_STD_SNPRINTF */\r
 116 \r
 117 int (*mbedtls_snprintf)( char * s, size_t n,\r
 118                           const char * format,\r
 119                           ... ) = MBEDTLS_PLATFORM_STD_SNPRINTF;\r
 120 \r
 121 int mbedtls_platform_set_snprintf( int (*snprintf_func)( char * s, size_t n,\r
 122                                                  const char * format,\r
 123                                                  ... ) )\r
 124 {\r
 125     mbedtls_snprintf = snprintf_func;\r
 126     return( 0 );\r
 127 }\r
 128 #endif /* MBEDTLS_PLATFORM_SNPRINTF_ALT */\r
 129 \r
 130 #if defined(MBEDTLS_PLATFORM_HAS_NON_CONFORMING_VSNPRINTF)\r
 131 #include <stdarg.h>\r
 132 int mbedtls_platform_win32_vsnprintf( char *s, size_t n, const char *fmt, va_list arg )\r
 133 {\r
 134     int ret;\r
 135 \r
 136     /* Avoid calling the invalid parameter handler by checking ourselves */\r
 137     if( s == NULL || n == 0 || fmt == NULL )\r
 138         return( -1 );\r
 139 \r
 140 #if defined(_TRUNCATE)\r
 141     ret = vsnprintf_s( s, n, _TRUNCATE, fmt, arg );\r
 142 #else\r
 143     ret = vsnprintf( s, n, fmt, arg );\r
 144     if( ret < 0 || (size_t) ret == n )\r
 145     {\r
 146         s[n-1] = '\0';\r
 147         ret = -1;\r
 148     }\r
 149 #endif\r
 150 \r
 151     return( ret );\r
 152 }\r
 153 #endif\r
 154 \r
 155 #if defined(MBEDTLS_PLATFORM_VSNPRINTF_ALT)\r
 156 #if !defined(MBEDTLS_PLATFORM_STD_VSNPRINTF)\r
 157 /*\r
 158  * Make dummy function to prevent NULL pointer dereferences\r
 159  */\r
 160 static int platform_vsnprintf_uninit( char * s, size_t n,\r
 161                                      const char * format, va_list arg )\r
 162 {\r
 163     ((void) s);\r
 164     ((void) n);\r
 165     ((void) format);\r
 166     ((void) arg);\r
 167     return( -1 );\r
 168 }\r
 169 \r
 170 #define MBEDTLS_PLATFORM_STD_VSNPRINTF    platform_vsnprintf_uninit\r
 171 #endif /* !MBEDTLS_PLATFORM_STD_VSNPRINTF */\r
 172 \r
 173 int (*mbedtls_vsnprintf)( char * s, size_t n,\r
 174                           const char * format,\r
 175                           va_list arg ) = MBEDTLS_PLATFORM_STD_VSNPRINTF;\r
 176 \r
 177 int mbedtls_platform_set_vsnprintf( int (*vsnprintf_func)( char * s, size_t n,\r
 178                                                  const char * format,\r
 179                                                  va_list arg ) )\r
 180 {\r
 181     mbedtls_vsnprintf = vsnprintf_func;\r
 182     return( 0 );\r
 183 }\r
 184 #endif /* MBEDTLS_PLATFORM_VSNPRINTF_ALT */\r
 185 \r
 186 #if defined(MBEDTLS_PLATFORM_PRINTF_ALT)\r
 187 #if !defined(MBEDTLS_PLATFORM_STD_PRINTF)\r
 188 /*\r
 189  * Make dummy function to prevent NULL pointer dereferences\r
 190  */\r
 191 static int platform_printf_uninit( const char *format, ... )\r
 192 {\r
 193     ((void) format);\r
 194     return( 0 );\r
 195 }\r
 196 \r
 197 #define MBEDTLS_PLATFORM_STD_PRINTF    platform_printf_uninit\r
 198 #endif /* !MBEDTLS_PLATFORM_STD_PRINTF */\r
 199 \r
 200 int (*mbedtls_printf)( const char *, ... ) = MBEDTLS_PLATFORM_STD_PRINTF;\r
 201 \r
 202 int mbedtls_platform_set_printf( int (*printf_func)( const char *, ... ) )\r
 203 {\r
 204     mbedtls_printf = printf_func;\r
 205     return( 0 );\r
 206 }\r
 207 #endif /* MBEDTLS_PLATFORM_PRINTF_ALT */\r
 208 \r
 209 #if defined(MBEDTLS_PLATFORM_FPRINTF_ALT)\r
 210 #if !defined(MBEDTLS_PLATFORM_STD_FPRINTF)\r
 211 /*\r
 212  * Make dummy function to prevent NULL pointer dereferences\r
 213  */\r
 214 static int platform_fprintf_uninit( FILE *stream, const char *format, ... )\r
 215 {\r
 216     ((void) stream);\r
 217     ((void) format);\r
 218     return( 0 );\r
 219 }\r
 220 \r
 221 #define MBEDTLS_PLATFORM_STD_FPRINTF   platform_fprintf_uninit\r
 222 #endif /* !MBEDTLS_PLATFORM_STD_FPRINTF */\r
 223 \r
 224 int (*mbedtls_fprintf)( FILE *, const char *, ... ) =\r
 225                                         MBEDTLS_PLATFORM_STD_FPRINTF;\r
 226 \r
 227 int mbedtls_platform_set_fprintf( int (*fprintf_func)( FILE *, const char *, ... ) )\r
 228 {\r
 229     mbedtls_fprintf = fprintf_func;\r
 230     return( 0 );\r
 231 }\r
 232 #endif /* MBEDTLS_PLATFORM_FPRINTF_ALT */\r
 233 \r
 234 #if defined(MBEDTLS_PLATFORM_EXIT_ALT)\r
 235 #if !defined(MBEDTLS_PLATFORM_STD_EXIT)\r
 236 /*\r
 237  * Make dummy function to prevent NULL pointer dereferences\r
 238  */\r
 239 static void platform_exit_uninit( int status )\r
 240 {\r
 241     ((void) status);\r
 242 }\r
 243 \r
 244 #define MBEDTLS_PLATFORM_STD_EXIT   platform_exit_uninit\r
 245 #endif /* !MBEDTLS_PLATFORM_STD_EXIT */\r
 246 \r
 247 void (*mbedtls_exit)( int status ) = MBEDTLS_PLATFORM_STD_EXIT;\r
 248 \r
 249 int mbedtls_platform_set_exit( void (*exit_func)( int status ) )\r
 250 {\r
 251     mbedtls_exit = exit_func;\r
 252     return( 0 );\r
 253 }\r
 254 #endif /* MBEDTLS_PLATFORM_EXIT_ALT */\r
 255 \r
 256 #if defined(MBEDTLS_HAVE_TIME)\r
 257 \r
 258 #if defined(MBEDTLS_PLATFORM_TIME_ALT)\r
 259 #if !defined(MBEDTLS_PLATFORM_STD_TIME)\r
 260 /*\r
 261  * Make dummy function to prevent NULL pointer dereferences\r
 262  */\r
 263 static mbedtls_time_t platform_time_uninit( mbedtls_time_t* timer )\r
 264 {\r
 265     ((void) timer);\r
 266     return( 0 );\r
 267 }\r
 268 \r
 269 #define MBEDTLS_PLATFORM_STD_TIME   platform_time_uninit\r
 270 #endif /* !MBEDTLS_PLATFORM_STD_TIME */\r
 271 \r
 272 mbedtls_time_t (*mbedtls_time)( mbedtls_time_t* timer ) = MBEDTLS_PLATFORM_STD_TIME;\r
 273 \r
 274 int mbedtls_platform_set_time( mbedtls_time_t (*time_func)( mbedtls_time_t* timer ) )\r
 275 {\r
 276     mbedtls_time = time_func;\r
 277     return( 0 );\r
 278 }\r
 279 #endif /* MBEDTLS_PLATFORM_TIME_ALT */\r
 280 \r
 281 #endif /* MBEDTLS_HAVE_TIME */\r
 282 \r
 283 #if defined(MBEDTLS_ENTROPY_NV_SEED)\r
 284 #if !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS) && defined(MBEDTLS_FS_IO)\r
 285 /* Default implementations for the platform independent seed functions use\r
 286  * standard libc file functions to read from and write to a pre-defined filename\r
 287  */\r
 288 int mbedtls_platform_std_nv_seed_read( unsigned char *buf, size_t buf_len )\r
 289 {\r
 290     FILE *file;\r
 291     size_t n;\r
 292 \r
 293     if( ( file = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb" ) ) == NULL )\r
 294         return( -1 );\r
 295 \r
 296     if( ( n = fread( buf, 1, buf_len, file ) ) != buf_len )\r
 297     {\r
 298         fclose( file );\r
 299         mbedtls_platform_zeroize( buf, buf_len );\r
 300         return( -1 );\r
 301     }\r
 302 \r
 303     fclose( file );\r
 304     return( (int)n );\r
 305 }\r
 306 \r
 307 int mbedtls_platform_std_nv_seed_write( unsigned char *buf, size_t buf_len )\r
 308 {\r
 309     FILE *file;\r
 310     size_t n;\r
 311 \r
 312     if( ( file = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w" ) ) == NULL )\r
 313         return -1;\r
 314 \r
 315     if( ( n = fwrite( buf, 1, buf_len, file ) ) != buf_len )\r
 316     {\r
 317         fclose( file );\r
 318         return -1;\r
 319     }\r
 320 \r
 321     fclose( file );\r
 322     return( (int)n );\r
 323 }\r
 324 #endif /* MBEDTLS_PLATFORM_NO_STD_FUNCTIONS */\r
 325 \r
 326 #if defined(MBEDTLS_PLATFORM_NV_SEED_ALT)\r
 327 #if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ)\r
 328 /*\r
 329  * Make dummy function to prevent NULL pointer dereferences\r
 330  */\r
 331 static int platform_nv_seed_read_uninit( unsigned char *buf, size_t buf_len )\r
 332 {\r
 333     ((void) buf);\r
 334     ((void) buf_len);\r
 335     return( -1 );\r
 336 }\r
 337 \r
 338 #define MBEDTLS_PLATFORM_STD_NV_SEED_READ   platform_nv_seed_read_uninit\r
 339 #endif /* !MBEDTLS_PLATFORM_STD_NV_SEED_READ */\r
 340 \r
 341 #if !defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE)\r
 342 /*\r
 343  * Make dummy function to prevent NULL pointer dereferences\r
 344  */\r
 345 static int platform_nv_seed_write_uninit( unsigned char *buf, size_t buf_len )\r
 346 {\r
 347     ((void) buf);\r
 348     ((void) buf_len);\r
 349     return( -1 );\r
 350 }\r
 351 \r
 352 #define MBEDTLS_PLATFORM_STD_NV_SEED_WRITE   platform_nv_seed_write_uninit\r
 353 #endif /* !MBEDTLS_PLATFORM_STD_NV_SEED_WRITE */\r
 354 \r
 355 int (*mbedtls_nv_seed_read)( unsigned char *buf, size_t buf_len ) =\r
 356             MBEDTLS_PLATFORM_STD_NV_SEED_READ;\r
 357 int (*mbedtls_nv_seed_write)( unsigned char *buf, size_t buf_len ) =\r
 358             MBEDTLS_PLATFORM_STD_NV_SEED_WRITE;\r
 359 \r
 360 int mbedtls_platform_set_nv_seed(\r
 361         int (*nv_seed_read_func)( unsigned char *buf, size_t buf_len ),\r
 362         int (*nv_seed_write_func)( unsigned char *buf, size_t buf_len ) )\r
 363 {\r
 364     mbedtls_nv_seed_read = nv_seed_read_func;\r
 365     mbedtls_nv_seed_write = nv_seed_write_func;\r
 366     return( 0 );\r
 367 }\r
 368 #endif /* MBEDTLS_PLATFORM_NV_SEED_ALT */\r
 369 #endif /* MBEDTLS_ENTROPY_NV_SEED */\r
 370 \r
 371 #if !defined(MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT)\r
 372 /*\r
 373  * Placeholder platform setup that does nothing by default\r
 374  */\r
 375 int mbedtls_platform_setup( mbedtls_platform_context *ctx )\r
 376 {\r
 377     (void)ctx;\r
 378 \r
 379     return( 0 );\r
 380 }\r
 381 \r
 382 /*\r
 383  * Placeholder platform teardown that does nothing by default\r
 384  */\r
 385 void mbedtls_platform_teardown( mbedtls_platform_context *ctx )\r
 386 {\r
 387     (void)ctx;\r
 388 }\r
 389 #endif /* MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT */\r
 390 \r
 391 #endif /* MBEDTLS_PLATFORM_C */\r