From 944cfe8899062ce6a810c0b891da78a2737e414a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Manuel=20P=C3=A9gouri=C3=A9-Gonnard?= Date: Wed, 27 May 2015 20:07:18 +0200 Subject: [PATCH] Allow use of global mutexes with threading_alt --- include/mbedtls/threading.h | 20 ++++++++++++++++---- include/mbedtls/x509_crt.h | 5 ----- library/threading.c | 31 ++++++++++++++++++++++++++++--- library/x509_crt.c | 11 ++--------- 4 files changed, 46 insertions(+), 21 deletions(-) diff --git a/include/mbedtls/threading.h b/include/mbedtls/threading.h index d400abe262..309727f18b 100644 --- a/include/mbedtls/threading.h +++ b/include/mbedtls/threading.h @@ -55,7 +55,11 @@ typedef struct /** * \brief Set your alternate threading implementation function - * pointers + * pointers and initialize global mutexes. If used, this + * function must be called once in the main thread before any + * other mbed TLS function is called, and + * mbedtls_threading_free_alt() must be called once in the main + * thread after all other mbed TLS functions. * * \note mutex_init() and mutex_free() don't return a status code. * If mutex_init() fails, it should leave its argument (the @@ -66,13 +70,16 @@ typedef struct * \param mutex_free the free function implementation * \param mutex_lock the lock function implementation * \param mutex_unlock the unlock function implementation - * - * \return 0 if successful */ -int mbedtls_threading_set_alt( void (*mutex_init)( mbedtls_threading_mutex_t * ), +void mbedtls_threading_set_alt( void (*mutex_init)( mbedtls_threading_mutex_t * ), void (*mutex_free)( mbedtls_threading_mutex_t * ), int (*mutex_lock)( mbedtls_threading_mutex_t * ), int (*mutex_unlock)( mbedtls_threading_mutex_t * ) ); + +/** + * \brief Free global mutexes. + */ +void mbedtls_threading_free_alt( void ); #endif /* MBEDTLS_THREADING_ALT */ /* @@ -85,6 +92,11 @@ extern void (*mbedtls_mutex_free)( mbedtls_threading_mutex_t *mutex ); extern int (*mbedtls_mutex_lock)( mbedtls_threading_mutex_t *mutex ); extern int (*mbedtls_mutex_unlock)( mbedtls_threading_mutex_t *mutex ); +/* + * Global mutexes + */ +extern mbedtls_threading_mutex_t mbedtls_threading_readdir_mutex; + #ifdef __cplusplus } #endif diff --git a/include/mbedtls/x509_crt.h b/include/mbedtls/x509_crt.h index aced7eb0f0..dbc39e516f 100644 --- a/include/mbedtls/x509_crt.h +++ b/include/mbedtls/x509_crt.h @@ -173,11 +173,6 @@ int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path ); * of failed certificates it encountered. If none complete * correctly, the first error is returned. * - * \warning This function is NOT thread-safe unless - * MBEDTLS_THREADING_PTHREAD is defined. If you're using an - * alternative threading implementation, you should either use - * this function only in the main thread, or mutex it. - * * \param chain points to the start of the chain * \param path directory / folder to read the certificate files from * diff --git a/library/threading.c b/library/threading.c index 35388ca80b..e904b195cc 100644 --- a/library/threading.c +++ b/library/threading.c @@ -73,6 +73,12 @@ void (*mbedtls_mutex_init)( mbedtls_threading_mutex_t * ) = threading_mutex_init void (*mbedtls_mutex_free)( mbedtls_threading_mutex_t * ) = threading_mutex_free_pthread; int (*mbedtls_mutex_lock)( mbedtls_threading_mutex_t * ) = threading_mutex_lock_pthread; int (*mbedtls_mutex_unlock)( mbedtls_threading_mutex_t * ) = threading_mutex_unlock_pthread; + +/* + * With phtreads we can statically initialize mutexes + */ +#define MUTEX_INIT = { PTHREAD_MUTEX_INITIALIZER, 1 } + #endif /* MBEDTLS_THREADING_PTHREAD */ #if defined(MBEDTLS_THREADING_ALT) @@ -92,8 +98,11 @@ void (*mbedtls_mutex_free)( mbedtls_threading_mutex_t * ) = threading_mutex_dumm int (*mbedtls_mutex_lock)( mbedtls_threading_mutex_t * ) = threading_mutex_fail; int (*mbedtls_mutex_unlock)( mbedtls_threading_mutex_t * ) = threading_mutex_fail; -int mbedtls_threading_set_alt( int (*mutex_init)( mbedtls_threading_mutex_t * ), - int (*mutex_free)( mbedtls_threading_mutex_t * ), +/* + * Set functions pointers and initialize global mutexes + */ +void mbedtls_threading_set_alt( void (*mutex_init)( mbedtls_threading_mutex_t * ), + void (*mutex_free)( mbedtls_threading_mutex_t * ), int (*mutex_lock)( mbedtls_threading_mutex_t * ), int (*mutex_unlock)( mbedtls_threading_mutex_t * ) ) { @@ -102,8 +111,24 @@ int mbedtls_threading_set_alt( int (*mutex_init)( mbedtls_threading_mutex_t * ), mbedtls_mutex_lock = mutex_lock; mbedtls_mutex_unlock = mutex_unlock; - return( 0 ); + mbedtls_mutex_init( &mbedtls_threading_readdir_mutex ); +} + +/* + * Free global mutexes + */ +void mbedtls_threading_free_alt( void ) +{ + mbedtls_mutex_free( &mbedtls_threading_readdir_mutex ); } #endif /* MBEDTLS_THREADING_ALT */ +/* + * Define global mutexes + */ +#ifndef MUTEX_INIT +#define MUTEX_INIT +#endif +mbedtls_threading_mutex_t mbedtls_threading_readdir_mutex MUTEX_INIT; + #endif /* MBEDTLS_THREADING_C */ diff --git a/library/x509_crt.c b/library/x509_crt.c index d1749b9e13..e46c9343c7 100644 --- a/library/x509_crt.c +++ b/library/x509_crt.c @@ -963,13 +963,6 @@ int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path ) return( ret ); } -#if defined(MBEDTLS_THREADING_PTHREAD) -static mbedtls_threading_mutex_t readdir_mutex = { - PTHREAD_MUTEX_INITIALIZER, - 1 -}; -#endif - int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path ) { int ret = 0; @@ -1040,7 +1033,7 @@ int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path ) return( MBEDTLS_ERR_X509_FILE_IO_ERROR ); #if defined(MBEDTLS_THREADING_PTHREAD) - if( ( ret = mbedtls_mutex_lock( &readdir_mutex ) ) != 0 ) + if( ( ret = mbedtls_mutex_lock( &mbedtls_threading_readdir_mutex ) ) != 0 ) return( ret ); #endif @@ -1070,7 +1063,7 @@ int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path ) cleanup: #if defined(MBEDTLS_THREADING_PTHREAD) - if( mbedtls_mutex_unlock( &readdir_mutex ) != 0 ) + if( mbedtls_mutex_unlock( &mbedtls_threading_readdir_mutex ) != 0 ) ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR; #endif