AES_LOCK();
AES_TAKE();
- ets_aes_enable();
- AES_UNLOCK();
+ ets_aes_enable();
+ AES_UNLOCK();
}
void esp_aes_free( AES_CTX *ctx )
{
- if( ctx == NULL )
+ if ( ctx == NULL ) {
return;
+ }
bzero( ctx, sizeof( AES_CTX ) );
AES_LOCK();
AES_GIVE();
- if (false == AES_IS_USED())
- ets_aes_disable();
- AES_UNLOCK();
+
+ if (false == AES_IS_USED()) {
+ ets_aes_disable();
+ }
+
+ AES_UNLOCK();
}
/*
* AES key schedule (encryption)
*/
int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key,
- unsigned int keybits )
+ unsigned int keybits )
{
- enum AES_BITS keybit;
- uint16_t keybyte = keybits / 8;
- switch (keybits){
- case 128:
- keybit = AES128;
- break;
- case 192:
- keybit = AES192;
- break;
- case 256:
- keybit = AES256;
- break;
- default : return( ERR_AES_INVALID_KEY_LENGTH );
- }
- if (ctx->enc.keyflag == false){
- ctx->enc.keyflag = true;
- ctx->enc.keybits = keybits;
- memset(ctx->enc.key, 0, sizeof(ctx->enc.key));
- memcpy(ctx->enc.key, key, keybyte);
- } else {
- ets_aes_setkey_enc(key, keybit);
- }
- return 0;
+ enum AES_BITS keybit;
+ uint16_t keybyte = keybits / 8;
+
+ switch (keybits) {
+ case 128:
+ keybit = AES128;
+ break;
+ case 192:
+ keybit = AES192;
+ break;
+ case 256:
+ keybit = AES256;
+ break;
+ default:
+ return ( ERR_AES_INVALID_KEY_LENGTH );
+ }
+
+ if (ctx->enc.keyflag == false) {
+ ctx->enc.keyflag = true;
+ ctx->enc.keybits = keybits;
+ memset(ctx->enc.key, 0, sizeof(ctx->enc.key));
+ memcpy(ctx->enc.key, key, keybyte);
+ } else {
+ ets_aes_setkey_enc(key, keybit);
+ }
+
+ return 0;
}
/*
* AES key schedule (decryption)
*/
int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key,
- unsigned int keybits )
+ unsigned int keybits )
{
- enum AES_BITS keybit;
- uint16_t keybyte = keybits / 8;
- switch (keybits){
- case 128:
- keybit = AES128;
- break;
- case 192:
- keybit = AES192;
- break;
- case 256:
- keybit = AES256;
- break;
- default : return( ERR_AES_INVALID_KEY_LENGTH );
- }
- if (ctx->dec.keyflag == false){
- ctx->dec.keyflag = true;
- ctx->dec.keybits = keybits;
- memset(ctx->dec.key, 0, sizeof(ctx->dec.key));
- memcpy(ctx->dec.key, key, keybyte);
- } else {
- ets_aes_setkey_dec(key, keybit);
- }
- return 0;
+ enum AES_BITS keybit;
+ uint16_t keybyte = keybits / 8;
+
+ switch (keybits) {
+ case 128:
+ keybit = AES128;
+ break;
+ case 192:
+ keybit = AES192;
+ break;
+ case 256:
+ keybit = AES256;
+ break;
+ default:
+ return ( ERR_AES_INVALID_KEY_LENGTH );
+ }
+
+ if (ctx->dec.keyflag == false) {
+ ctx->dec.keyflag = true;
+ ctx->dec.keybits = keybits;
+ memset(ctx->dec.key, 0, sizeof(ctx->dec.key));
+ memcpy(ctx->dec.key, key, keybyte);
+ } else {
+ ets_aes_setkey_dec(key, keybit);
+ }
+ return 0;
}
static void esp_aes_process_enable(AES_CTX *ctx, int mode)
{
- if( mode == AES_ENCRYPT ){
- esp_aes_setkey_enc(ctx, ctx->enc.key, ctx->enc.keybits);
- }else{
- esp_aes_setkey_dec(ctx, ctx->dec.key, ctx->dec.keybits);
- }
- return;
+ if ( mode == AES_ENCRYPT ) {
+ esp_aes_setkey_enc(ctx, ctx->enc.key, ctx->enc.keybits);
+ } else {
+ esp_aes_setkey_dec(ctx, ctx->dec.key, ctx->dec.keybits);
+ }
+
+ return;
}
static void esp_aes_process_disable(AES_CTX *ctx, int mode)
{
-
+
}
/*
*/
void esp_aes_encrypt( AES_CTX *ctx,
- const unsigned char input[16],
- unsigned char output[16] )
+ const unsigned char input[16],
+ unsigned char output[16] )
{
- ets_aes_crypt(input, output);
- return ;
+ ets_aes_crypt(input, output);
+
+ return ;
}
*/
void esp_aes_decrypt( AES_CTX *ctx,
- const unsigned char input[16],
- unsigned char output[16] )
+ const unsigned char input[16],
+ unsigned char output[16] )
{
- ets_aes_crypt(input, output);
- return ;
+ ets_aes_crypt(input, output);
+
+ return ;
}
* AES-ECB block encryption/decryption
*/
int esp_aes_crypt_ecb( AES_CTX *ctx,
- int mode,
- const unsigned char input[16],
- unsigned char output[16] )
+ int mode,
+ const unsigned char input[16],
+ unsigned char output[16] )
{
- AES_LOCK();
-
- esp_aes_process_enable(ctx, mode);
+ AES_LOCK();
+
+ esp_aes_process_enable(ctx, mode);
- if( mode == AES_ENCRYPT )
+ if ( mode == AES_ENCRYPT ) {
esp_aes_encrypt( ctx, input, output );
- else
+ } else {
esp_aes_decrypt( ctx, input, output );
+ }
+
+ esp_aes_process_disable(ctx, mode);
- esp_aes_process_disable(ctx, mode);
-
- AES_UNLOCK();
-
- return 0;
+ AES_UNLOCK();
+
+ return 0;
}
* AES-CBC buffer encryption/decryption
*/
int esp_aes_crypt_cbc( AES_CTX *ctx,
- int mode,
- size_t length,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output )
+ int mode,
+ size_t length,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output )
{
- int i;
+ int i;
unsigned char temp[16];
- if( length % 16 )
- return( ERR_AES_INVALID_INPUT_LENGTH );
+ if ( length % 16 ) {
+ return ( ERR_AES_INVALID_INPUT_LENGTH );
+ }
- if( mode == AES_DECRYPT )
- {
- while( length > 0 )
- {
+ if ( mode == AES_DECRYPT ) {
+ while ( length > 0 ) {
memcpy( temp, input, 16 );
esp_aes_crypt_ecb( ctx, mode, input, output );
- for( i = 0; i < 16; i++ )
+ for ( i = 0; i < 16; i++ ) {
output[i] = (unsigned char)( output[i] ^ iv[i] );
+ }
memcpy( iv, temp, 16 );
output += 16;
length -= 16;
}
- }
- else
- {
- while( length > 0 )
- {
- for( i = 0; i < 16; i++ )
+ } else {
+ while ( length > 0 ) {
+ for ( i = 0; i < 16; i++ ) {
output[i] = (unsigned char)( input[i] ^ iv[i] );
+ }
esp_aes_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
}
}
- return 0;
+ return 0;
}
/*
* AES-CFB128 buffer encryption/decryption
*/
int esp_aes_crypt_cfb128( AES_CTX *ctx,
- int mode,
- size_t length,
- size_t *iv_off,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output )
+ int mode,
+ size_t length,
+ size_t *iv_off,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output )
{
- int c;
- size_t n = *iv_off;
-
- if( mode == AES_DECRYPT )
- {
- while( length-- )
- {
- if( n == 0 )
- esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
-
- c = *input++;
- *output++ = (unsigned char)( c ^ iv[n] );
- iv[n] = (unsigned char) c;
-
- n = ( n + 1 ) & 0x0F;
- }
- }
- else
- {
- while( length-- )
- {
- if( n == 0 )
- esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
-
- iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
-
- n = ( n + 1 ) & 0x0F;
- }
- }
-
- *iv_off = n;
-
- return 0;
+ int c;
+ size_t n = *iv_off;
+
+ if ( mode == AES_DECRYPT ) {
+ while ( length-- ) {
+ if ( n == 0 ) {
+ esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+ }
+
+ c = *input++;
+ *output++ = (unsigned char)( c ^ iv[n] );
+ iv[n] = (unsigned char) c;
+
+ n = ( n + 1 ) & 0x0F;
+ }
+ } else {
+ while ( length-- ) {
+ if ( n == 0 ) {
+ esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+ }
+
+ iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
+
+ n = ( n + 1 ) & 0x0F;
+ }
+ }
+
+ *iv_off = n;
+
+ return 0;
}
/*
* AES-CFB8 buffer encryption/decryption
*/
int esp_aes_crypt_cfb8( AES_CTX *ctx,
- int mode,
- size_t length,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output )
+ int mode,
+ size_t length,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output )
{
- unsigned char c;
- unsigned char ov[17];
-
- while( length-- )
- {
- memcpy( ov, iv, 16 );
- esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
-
- if( mode == AES_DECRYPT )
- ov[16] = *input;
-
- c = *output++ = (unsigned char)( iv[0] ^ *input++ );
-
- if( mode == AES_ENCRYPT )
- ov[16] = c;
-
- memcpy( iv, ov + 1, 16 );
- }
-
- return 0;
+ unsigned char c;
+ unsigned char ov[17];
+
+ while ( length-- ) {
+ memcpy( ov, iv, 16 );
+ esp_aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+
+ if ( mode == AES_DECRYPT ) {
+ ov[16] = *input;
+ }
+
+ c = *output++ = (unsigned char)( iv[0] ^ *input++ );
+
+ if ( mode == AES_ENCRYPT ) {
+ ov[16] = c;
+ }
+
+ memcpy( iv, ov + 1, 16 );
+ }
+
+ return 0;
}
/*
unsigned char stream_block[16],
const unsigned char *input,
unsigned char *output )
-{
- int c, i;
+{
+ int c, i;
size_t n = *nc_off;
- while( length-- )
- {
- if( n == 0 ) {
+ while ( length-- ) {
+ if ( n == 0 ) {
esp_aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block );
- for( i = 16; i > 0; i-- )
- if( ++nonce_counter[i - 1] != 0 )
+ for ( i = 16; i > 0; i-- )
+ if ( ++nonce_counter[i - 1] != 0 ) {
break;
+ }
}
c = *input++;
*output++ = (unsigned char)( c ^ stream_block[n] );
*nc_off = n;
- return 0;
+ return 0;
}
static int esp_crypto_sig[MUTEX_MAX_NUM];
#if 0
- #define ESP_DEBUG ets_printf
+#define ESP_DEBUG ets_printf
#else
- #define ESP_DEBUG(...)
+#define ESP_DEBUG(...)
#endif
int esp_crypto_init(void)
{
- int i;
+ int i;
- for (i = 0; i < MUTEX_MAX_NUM; i++) {
- esp_crypto_mutex[i] = xSemaphoreCreateMutex();
- ESP_DEBUG("init num %d mutex %p\n", i, esp_crypto_mutex[i]);
- if (!esp_crypto_mutex[i]) {
- goto failed1;
- }
- esp_crypto_sig[i] = 0;
- }
+ for (i = 0; i < MUTEX_MAX_NUM; i++) {
+ esp_crypto_mutex[i] = xSemaphoreCreateMutex();
+ ESP_DEBUG("init num %d mutex %p\n", i, esp_crypto_mutex[i]);
+ if (!esp_crypto_mutex[i]) {
+ goto failed1;
+ }
+ esp_crypto_sig[i] = 0;
+ }
- return 0;
+ return 0;
failed1:
- ESP_DEBUG("esp_crypto_init failed\n");
- for (i--; i >= 0; i--)
- vQueueDelete(esp_crypto_mutex[i]);
+ ESP_DEBUG("esp_crypto_init failed\n");
+ for (i--; i >= 0; i--) {
+ vQueueDelete(esp_crypto_mutex[i]);
+ }
- return -1;
+ return -1;
}
void esp_crypto_lock(unsigned int num)
{
- ESP_DEBUG("1num %d, mutex %p\n", num, esp_crypto_mutex[num]);
- xSemaphoreTake(esp_crypto_mutex[num], portMAX_DELAY);
+ ESP_DEBUG("1num %d, mutex %p\n", num, esp_crypto_mutex[num]);
+ xSemaphoreTake(esp_crypto_mutex[num], portMAX_DELAY);
}
void esp_crypto_unlock(unsigned int num)
{
- ESP_DEBUG("2num %d, mutex %p\n", num, esp_crypto_mutex[num]);
- xSemaphoreGive(esp_crypto_mutex[num]);
+ ESP_DEBUG("2num %d, mutex %p\n", num, esp_crypto_mutex[num]);
+ xSemaphoreGive(esp_crypto_mutex[num]);
}
void esp_crypto_take(unsigned int num)
{
- esp_crypto_sig[num]++;
+ esp_crypto_sig[num]++;
}
void esp_crypto_give(unsigned int num)
{
- if (esp_crypto_sig[num])
- esp_crypto_sig[num]--;
+ if (esp_crypto_sig[num]) {
+ esp_crypto_sig[num]--;
+ }
}
bool esp_crypto_is_used(unsigned int num)
{
- return (esp_crypto_sig[num] != 0) ? true : false;
+ return (esp_crypto_sig[num] != 0) ? true : false;
}
* See the License for the specific language governing permissions and
* limitations under the License.
*
- *
+ *
*/
-
+
#ifndef ESP_AES_H
#define ESP_AES_H
#define ERR_AES_INVALID_KEY_LENGTH -0x0020 /**< Invalid key length. */
#define ERR_AES_INVALID_INPUT_LENGTH -0x0022 /**< Invalid data input length. */
-typedef struct{
- bool keyflag;
- uint16_t keybits;
+typedef struct {
+ bool keyflag;
+ uint16_t keybits;
uint8_t key[32];
-}key_context, KEY_CTX;
+} key_context, KEY_CTX;
/**
* \brief AES context structure
* - to simplify key expansion in the 256-bit case by
* generating an extra round key
*/
-typedef struct
-{
+typedef struct {
int nr; /*!< number of rounds */
uint32_t *rk; /*!< AES round keys */
- KEY_CTX enc;
- KEY_CTX dec;
-}aes_context, AES_CTX;
+ KEY_CTX enc;
+ KEY_CTX dec;
+} aes_context, AES_CTX;
/**
* \brief Initialize AES context
*
* \return 0 if successful, or ERR_AES_INVALID_KEY_LENGTH
*/
-int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key,unsigned int keybits );
+int esp_aes_setkey_enc( AES_CTX *ctx, const unsigned char *key, unsigned int keybits );
/**
* \brief AES key schedule (decryption)
*
* \return 0 if successful, or ERR_AES_INVALID_KEY_LENGTH
*/
-int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key,unsigned int keybits );
+int esp_aes_setkey_dec( AES_CTX *ctx, const unsigned char *key, unsigned int keybits );
/**
* \brief AES-ECB block encryption/decryption
*
* \return 0 if successful
*/
-int esp_aes_crypt_ecb( AES_CTX *ctx,int mode,const unsigned char input[16],unsigned char output[16] );
+int esp_aes_crypt_ecb( AES_CTX *ctx, int mode, const unsigned char input[16], unsigned char output[16] );
/**
* \brief AES-CBC buffer encryption/decryption
* \return 0 if successful, or ERR_AES_INVALID_INPUT_LENGTH
*/
int esp_aes_crypt_cbc( AES_CTX *ctx,
- int mode,
- size_t length,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output );
+ int mode,
+ size_t length,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output );
/**
* \return 0 if successful
*/
int esp_aes_crypt_cfb128( AES_CTX *ctx,
- int mode,
- size_t length,
- size_t *iv_off,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output );
+ int mode,
+ size_t length,
+ size_t *iv_off,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output );
/**
* \brief AES-CFB8 buffer encryption/decryption.
* \return 0 if successful
*/
int esp_aes_crypt_cfb8( AES_CTX *ctx,
- int mode,
- size_t length,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output );
+ int mode,
+ size_t length,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output );
/**
* \brief AES-CTR buffer encryption/decryption
* \param input Plaintext block
* \param output Output (ciphertext) block
*/
-void esp_aes_encrypt( AES_CTX *ctx, const unsigned char input[16],unsigned char output[16] );
+void esp_aes_encrypt( AES_CTX *ctx, const unsigned char input[16], unsigned char output[16] );
/**
* \brief Internal AES block decryption function
#endif
enum {
- AES_MUTEX = 0,
- BIGNUM_MUTEX,
- SHA_MUTEX,
+ AES_MUTEX = 0,
+ BIGNUM_MUTEX,
+ SHA_MUTEX,
- MUTEX_MAX_NUM,
+ MUTEX_MAX_NUM,
};
int esp_crypto_init(void);
void esp_crypto_give(unsigned int num);
bool esp_crypto_is_used(unsigned int num);
-#define MUTEX_LOCK(num) esp_crypto_lock(num)
-#define MUTEX_UNLOCK(num) esp_crypto_unlock(num)
-
-#define SIG_TAKE(num) esp_crypto_take(num)
-#define SIG_GIVE(num) esp_crypto_give(num)
-#define SIG_IS_USED(num) esp_crypto_is_used(num)
-
-#define AES_LOCK() MUTEX_LOCK(AES_MUTEX)
-#define AES_UNLOCK() MUTEX_UNLOCK(AES_MUTEX)
-#define BIGNUM_LOCK() MUTEX_LOCK(BIGNUM_MUTEX)
-#define BIGNUM_UNLOCK() MUTEX_UNLOCK(BIGNUM_MUTEX)
-#define SHA_LOCK() MUTEX_LOCK(SHA_MUTEX)
-#define SHA_UNLOCK() MUTEX_UNLOCK(SHA_MUTEX)
-
-#define AES_TAKE() SIG_TAKE(AES_MUTEX)
-#define AES_GIVE() SIG_GIVE(AES_MUTEX)
-#define AES_IS_USED() SIG_IS_USED(AES_MUTEX)
-#define BIGNUM_TAKE() SIG_TAKE(BIGNUM_MUTEX)
-#define BIGNUM_GIVE() SIG_GIVE(BIGNUM_MUTEX)
-#define BIGNUM_IS_USED() SIG_IS_USED(BIGNUM_MUTEX)
-#define SHA_TAKE() SIG_TAKE(SHA_MUTEX)
-#define SHA_GIVE() SIG_GIVE(SHA_MUTEX)
-#define SHA_IS_USED() SIG_IS_USED(SHA_MUTEX)
+#define MUTEX_LOCK(num) esp_crypto_lock(num)
+#define MUTEX_UNLOCK(num) esp_crypto_unlock(num)
+
+#define SIG_TAKE(num) esp_crypto_take(num)
+#define SIG_GIVE(num) esp_crypto_give(num)
+#define SIG_IS_USED(num) esp_crypto_is_used(num)
+
+#define AES_LOCK() MUTEX_LOCK(AES_MUTEX)
+#define AES_UNLOCK() MUTEX_UNLOCK(AES_MUTEX)
+#define BIGNUM_LOCK() MUTEX_LOCK(BIGNUM_MUTEX)
+#define BIGNUM_UNLOCK() MUTEX_UNLOCK(BIGNUM_MUTEX)
+#define SHA_LOCK() MUTEX_LOCK(SHA_MUTEX)
+#define SHA_UNLOCK() MUTEX_UNLOCK(SHA_MUTEX)
+
+#define AES_TAKE() SIG_TAKE(AES_MUTEX)
+#define AES_GIVE() SIG_GIVE(AES_MUTEX)
+#define AES_IS_USED() SIG_IS_USED(AES_MUTEX)
+#define BIGNUM_TAKE() SIG_TAKE(BIGNUM_MUTEX)
+#define BIGNUM_GIVE() SIG_GIVE(BIGNUM_MUTEX)
+#define BIGNUM_IS_USED() SIG_IS_USED(BIGNUM_MUTEX)
+#define SHA_TAKE() SIG_TAKE(SHA_MUTEX)
+#define SHA_GIVE() SIG_GIVE(SHA_MUTEX)
+#define SHA_IS_USED() SIG_IS_USED(SHA_MUTEX)
#ifdef __cplusplus
}
/**
* \brief SHA-1 context structure
*/
-typedef struct{
- SHA_CTX context;
- int context_type;
+typedef struct {
+ SHA_CTX context;
+ int context_type;
} sha_context;
typedef sha_context SHA1_CTX;
void esp_sha1_output( const unsigned char *input, size_t ilen, unsigned char output[20] );
///
-#define SHA256 SHA2_256
-#define SHA224 4
+#define SHA256 SHA2_256
+#define SHA224 4
/**
* \brief SHA-256 context structure
SHA_LOCK();
SHA_TAKE();
- ets_sha_enable();
- SHA_UNLOCK();
+ ets_sha_enable();
+ SHA_UNLOCK();
}
void esp_sha1_free( SHA1_CTX *ctx )
{
- if( ctx == NULL )
+ if ( ctx == NULL ) {
return;
+ }
bzero( ctx, sizeof( SHA1_CTX ) );
SHA_LOCK();
SHA_GIVE();
- if (false == SHA_IS_USED())
- ets_sha_disable();
- SHA_UNLOCK();
+
+ if (false == SHA_IS_USED()) {
+ ets_sha_disable();
+ }
+
+ SHA_UNLOCK();
}
void esp_sha1_clone( SHA1_CTX *dst, const SHA1_CTX *src )
*/
void esp_sha1_start( SHA1_CTX *ctx )
{
- SHA_LOCK();
- ets_sha_init(&ctx->context);
+ SHA_LOCK();
+ ets_sha_init(&ctx->context);
- ctx->context_type = SHA1;
+ ctx->context_type = SHA1;
}
/*
*/
void esp_sha1_update( SHA1_CTX *ctx, const unsigned char *input, size_t ilen )
{
- ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8);
+ ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8);
}
/*
*/
void esp_sha1_finish( SHA1_CTX *ctx, unsigned char output[20] )
{
- ets_sha_finish(&ctx->context, ctx->context_type, output);
- SHA_UNLOCK();
+ ets_sha_finish(&ctx->context, ctx->context_type, output);
+ SHA_UNLOCK();
}
/*
SHA_LOCK();
SHA_TAKE();
- ets_sha_enable();
- SHA_UNLOCK();
+ ets_sha_enable();
+ SHA_UNLOCK();
}
void esp_sha256_process(SHA256_CTX *ctx, const unsigned char data[64])
void esp_sha256_free( SHA256_CTX *ctx )
{
- if( ctx == NULL )
+ if ( ctx == NULL ) {
return;
+ }
bzero( ctx, sizeof( SHA256_CTX ) );
SHA_LOCK();
SHA_GIVE();
- if (false == SHA_IS_USED())
- ets_sha_disable();
- SHA_UNLOCK();
+
+ if (false == SHA_IS_USED()) {
+ ets_sha_disable();
+ }
+
+ SHA_UNLOCK();
}
void esp_sha256_clone( SHA256_CTX *dst, const SHA256_CTX *src )
*/
void esp_sha256_start( SHA256_CTX *ctx, int is224 )
{
- SHA_LOCK();
+ SHA_LOCK();
ets_sha_init(&ctx->context);
- if( is224 == 0 )
- {
+ if ( is224 == 0 ) {
/* SHA-256 */
- ctx->context_type = SHA256;
- }else{
- /* SHA-224 */
- ctx->context_type = SHA224;
- }
+ ctx->context_type = SHA256;
+ } else {
+ /* SHA-224 */
+ ctx->context_type = SHA224;
+ }
}
/*
*/
void esp_sha256_update( SHA256_CTX *ctx, const unsigned char *input, size_t ilen )
{
- ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8);
+ ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8);
}
/*
*/
void esp_sha256_finish( SHA256_CTX *ctx, unsigned char output[32] )
{
- ets_sha_finish(&ctx->context, ctx->context_type, output);
- SHA_UNLOCK();
+ ets_sha_finish(&ctx->context, ctx->context_type, output);
+ SHA_UNLOCK();
}
/*
SHA_LOCK();
SHA_TAKE();
- ets_sha_enable();
- SHA_UNLOCK();
+ ets_sha_enable();
+ SHA_UNLOCK();
}
void esp_sha512_process( SHA512_CTX *ctx, const unsigned char data[128] )
void esp_sha512_free( SHA512_CTX *ctx )
{
- if( ctx == NULL )
+ if ( ctx == NULL ) {
return;
+ }
bzero( ctx, sizeof( SHA512_CTX ) );
SHA_LOCK();
SHA_GIVE();
- if (false == SHA_IS_USED())
- ets_sha_disable();
- SHA_UNLOCK();
+
+ if (false == SHA_IS_USED()) {
+ ets_sha_disable();
+ }
+
+ SHA_UNLOCK();
}
void esp_sha512_clone( SHA512_CTX *dst, const SHA512_CTX *src )
*/
void esp_sha512_start( SHA512_CTX *ctx, int is384 )
{
- SHA_LOCK();
- ets_sha_init(&ctx->context);
+ SHA_LOCK();
+ ets_sha_init(&ctx->context);
- if( is384 == 0 )
- {
+ if ( is384 == 0 ) {
/* SHA-512 */
ctx->context_type = SHA2_512;
- }
- else
- {
+ } else {
/* SHA-384 */
ctx->context_type = SHA2_384;
}
/*
* SHA-512 process buffer
*/
-void esp_sha512_update( SHA512_CTX *ctx, const unsigned char *input,size_t ilen )
+void esp_sha512_update( SHA512_CTX *ctx, const unsigned char *input, size_t ilen )
{
ets_sha_update(&ctx->context, ctx->context_type, input, ilen * 8);
}
/*
* output = SHA-512( input buffer )
*/
-void esp_sha512_output( const unsigned char *input, size_t ilen,unsigned char output[64], int is384 )
+void esp_sha512_output( const unsigned char *input, size_t ilen, unsigned char output[64], int is384 )
{
SHA512_CTX ctx;
#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
+
#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
/**
* \brief Entropy poll callback for a hardware source
*/
static int os_get_random(unsigned char *buf, size_t len)
{
- int i, j;
- unsigned long tmp;
- for (i = 0; i < ((len + 3) & ~3) / 4; i ++){
- tmp = rand();
- for (j = 0; j < 4; j ++){
- if ((i * 4 + j) < len){
- buf[i * 4 + j] = (unsigned char)(tmp >> (j * 8));
- }else{
- break;
- }
- }
-
- }
- return 0;
+ int i, j;
+ unsigned long tmp;
+
+ for (i = 0; i < ((len + 3) & ~3) / 4; i ++) {
+ tmp = rand();
+ for (j = 0; j < 4; j ++) {
+ if ((i * 4 + j) < len) {
+ buf[i * 4 + j] = (unsigned char)(tmp >> (j * 8));
+ } else {
+ break;
+ }
+ }
+
+ }
+
+ return 0;
}
int mbedtls_hardware_poll( void *data,
unsigned char *output, size_t len, size_t *olen )
{
- os_get_random(output, len);
- *olen = len;
- return 0;
+ os_get_random(output, len);
+ *olen = len;
+
+ return 0;
}
#endif
* See the License for the specific language governing permissions and
* limitations under the License.
*
- *
+ *
*/
-
+
#ifndef AES_ALT_H
#define AES_ALT_H
typedef AES_CTX mbedtls_aes_context;
-#define mbedtls_aes_init esp_aes_init
-#define mbedtls_aes_free esp_aes_free
-#define mbedtls_aes_setkey_enc esp_aes_setkey_enc
-#define mbedtls_aes_setkey_dec esp_aes_setkey_dec
-#define mbedtls_aes_crypt_ecb esp_aes_crypt_ecb
+#define mbedtls_aes_init esp_aes_init
+#define mbedtls_aes_free esp_aes_free
+#define mbedtls_aes_setkey_enc esp_aes_setkey_enc
+#define mbedtls_aes_setkey_dec esp_aes_setkey_dec
+#define mbedtls_aes_crypt_ecb esp_aes_crypt_ecb
#if defined(MBEDTLS_CIPHER_MODE_CBC)
-#define mbedtls_aes_crypt_cbc esp_aes_crypt_cbc
+#define mbedtls_aes_crypt_cbc esp_aes_crypt_cbc
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
-#define mbedtls_aes_crypt_cfb128 esp_aes_crypt_cfb128
-#define mbedtls_aes_crypt_cfb8 esp_aes_crypt_cfb8
+#define mbedtls_aes_crypt_cfb128 esp_aes_crypt_cfb128
+#define mbedtls_aes_crypt_cfb8 esp_aes_crypt_cfb8
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
-#define mbedtls_aes_crypt_ctr esp_aes_crypt_ctr
+#define mbedtls_aes_crypt_ctr esp_aes_crypt_ctr
#endif
-#define mbedtls_aes_encrypt esp_aes_encrypt
-#define mbedtls_aes_decrypt esp_aes_decrypt
+#define mbedtls_aes_encrypt esp_aes_encrypt
+#define mbedtls_aes_decrypt esp_aes_decrypt
#endif /* MBEDTLS_AES_ALT */
#ifdef __cplusplus
* limitations under the License.
*
*/
-
+
#ifndef BIGNUM_ALT_H
#define BIGNUM_ALT_H
#if defined(MBEDTLS_BIGNUM_ALT)
-typedef MPI_CTX mbedtls_mpi;
-
-#define mbedtls_mpi_init esp_mpi_init
-#define mbedtls_mpi_free esp_mpi_free
-#define mbedtls_mpi_grow esp_mpi_grow
-#define mbedtls_mpi_shrink esp_mpi_shrink
-#define mbedtls_mpi_copy esp_mpi_copy
-#define mbedtls_mpi_swap esp_mpi_swap
-#define mbedtls_mpi_safe_cond_assign esp_mpi_safe_cond_assign
-#define mbedtls_mpi_safe_cond_swap esp_mpi_safe_cond_swap
-#define mbedtls_mpi_lset esp_mpi_lset
-#define mbedtls_mpi_get_bit esp_mpi_get_bit
-#define mbedtls_mpi_set_bit esp_mpi_set_bit
-#define mbedtls_mpi_lsb esp_mpi_lsb
-#define mbedtls_mpi_bitlen esp_mpi_bitlen
-#define mbedtls_mpi_size esp_mpi_size
-#define mbedtls_mpi_read_string esp_mpi_read_string
-#define mbedtls_mpi_write_string esp_mpi_write_string
-#define mbedtls_mpi_read_binary esp_mpi_read_binary
-#define mbedtls_mpi_write_binary esp_mpi_write_binary
-#define mbedtls_mpi_shift_l esp_mpi_shift_l
-#define mbedtls_mpi_shift_r esp_mpi_shift_r
-#define mbedtls_mpi_cmp_abs esp_mpi_cmp_abs
-#define mbedtls_mpi_cmp_mpi esp_mpi_cmp_mpi
-#define mbedtls_mpi_cmp_int esp_mpi_cmp_int
-#define mbedtls_mpi_add_abs esp_mpi_add_abs
-#define mbedtls_mpi_sub_abs esp_mpi_sub_abs
-#define mbedtls_mpi_add_mpi esp_mpi_add_mpi
-#define mbedtls_mpi_sub_mpi esp_mpi_sub_mpi
-#define mbedtls_mpi_add_int esp_mpi_add_int
-#define mbedtls_mpi_sub_int esp_mpi_sub_int
-#define mbedtls_mpi_mul_mpi esp_mpi_mul_mpi
-#define mbedtls_mpi_mul_int esp_mpi_mul_int
-#define mbedtls_mpi_div_mpi esp_mpi_div_mpi
-#define mbedtls_mpi_div_int esp_mpi_div_int
-#define mbedtls_mpi_mod_mpi esp_mpi_mod_mpi
-#define mbedtls_mpi_mod_int esp_mpi_mod_int
-#define mbedtls_mpi_exp_mod esp_mpi_exp_mod
-#define mbedtls_mpi_fill_random esp_mpi_fill_random
-#define mbedtls_mpi_gcd esp_mpi_gcd
-#define mbedtls_mpi_inv_mod esp_mpi_inv_mod
-#define mbedtls_mpi_is_prime esp_mpi_is_prime
-#define mbedtls_mpi_gen_prime esp_mpi_gen_prime
-
+typedef MPI_CTX mbedtls_mpi;
+
+#define mbedtls_mpi_init esp_mpi_init
+#define mbedtls_mpi_free esp_mpi_free
+#define mbedtls_mpi_grow esp_mpi_grow
+#define mbedtls_mpi_shrink esp_mpi_shrink
+#define mbedtls_mpi_copy esp_mpi_copy
+#define mbedtls_mpi_swap esp_mpi_swap
+#define mbedtls_mpi_safe_cond_assign esp_mpi_safe_cond_assign
+#define mbedtls_mpi_safe_cond_swap esp_mpi_safe_cond_swap
+#define mbedtls_mpi_lset esp_mpi_lset
+#define mbedtls_mpi_get_bit esp_mpi_get_bit
+#define mbedtls_mpi_set_bit esp_mpi_set_bit
+#define mbedtls_mpi_lsb esp_mpi_lsb
+#define mbedtls_mpi_bitlen esp_mpi_bitlen
+#define mbedtls_mpi_size esp_mpi_size
+#define mbedtls_mpi_read_string esp_mpi_read_string
+#define mbedtls_mpi_write_string esp_mpi_write_string
+#define mbedtls_mpi_read_binary esp_mpi_read_binary
+#define mbedtls_mpi_write_binary esp_mpi_write_binary
+#define mbedtls_mpi_shift_l esp_mpi_shift_l
+#define mbedtls_mpi_shift_r esp_mpi_shift_r
+#define mbedtls_mpi_cmp_abs esp_mpi_cmp_abs
+#define mbedtls_mpi_cmp_mpi esp_mpi_cmp_mpi
+#define mbedtls_mpi_cmp_int esp_mpi_cmp_int
+#define mbedtls_mpi_add_abs esp_mpi_add_abs
+#define mbedtls_mpi_sub_abs esp_mpi_sub_abs
+#define mbedtls_mpi_add_mpi esp_mpi_add_mpi
+#define mbedtls_mpi_sub_mpi esp_mpi_sub_mpi
+#define mbedtls_mpi_add_int esp_mpi_add_int
+#define mbedtls_mpi_sub_int esp_mpi_sub_int
+#define mbedtls_mpi_mul_mpi esp_mpi_mul_mpi
+#define mbedtls_mpi_mul_int esp_mpi_mul_int
+#define mbedtls_mpi_div_mpi esp_mpi_div_mpi
+#define mbedtls_mpi_div_int esp_mpi_div_int
+#define mbedtls_mpi_mod_mpi esp_mpi_mod_mpi
+#define mbedtls_mpi_mod_int esp_mpi_mod_int
+#define mbedtls_mpi_exp_mod esp_mpi_exp_mod
+#define mbedtls_mpi_fill_random esp_mpi_fill_random
+#define mbedtls_mpi_gcd esp_mpi_gcd
+#define mbedtls_mpi_inv_mod esp_mpi_inv_mod
+#define mbedtls_mpi_is_prime esp_mpi_is_prime
+#define mbedtls_mpi_gen_prime esp_mpi_gen_prime
+
#endif
#endif
-/*
- * copyright (c) 2010 - 2012 Espressif System
- *
+/*
+ * copyright (c) 2010 - 2012 Espressif System
+ *
* esf Link List Descriptor
*/
#ifndef _SHA1_ALT_H_
typedef SHA1_CTX mbedtls_sha1_context;
-#define mbedtls_sha1_init esp_sha1_init
-#define mbedtls_sha1_starts esp_sha1_start
-#define mbedtls_sha1_clone esp_sha1_clone
-#define mbedtls_sha1_update esp_sha1_update
-#define mbedtls_sha1_finish esp_sha1_finish
-#define mbedtls_sha1_free esp_sha1_free
-#define mbedtls_sha1_process esp_sha1_process
+#define mbedtls_sha1_init esp_sha1_init
+#define mbedtls_sha1_starts esp_sha1_start
+#define mbedtls_sha1_clone esp_sha1_clone
+#define mbedtls_sha1_update esp_sha1_update
+#define mbedtls_sha1_finish esp_sha1_finish
+#define mbedtls_sha1_free esp_sha1_free
+#define mbedtls_sha1_process esp_sha1_process
#endif
-/*
- * copyright (c) 2010 - 2012 Espressif System
- *
+/*
+ * copyright (c) 2010 - 2012 Espressif System
+ *
* esf Link List Descriptor
*/
typedef SHA256_CTX mbedtls_sha256_context;
-#define mbedtls_sha256_init esp_sha256_init
-#define mbedtls_sha256_clone esp_sha256_clone
-#define mbedtls_sha256_starts esp_sha256_start
-#define mbedtls_sha256_update esp_sha256_update
-#define mbedtls_sha256_finish esp_sha256_finish
-#define mbedtls_sha256_free esp_sha256_free
-#define mbedtls_sha256_process esp_sha256_process
+#define mbedtls_sha256_init esp_sha256_init
+#define mbedtls_sha256_clone esp_sha256_clone
+#define mbedtls_sha256_starts esp_sha256_start
+#define mbedtls_sha256_update esp_sha256_update
+#define mbedtls_sha256_finish esp_sha256_finish
+#define mbedtls_sha256_free esp_sha256_free
+#define mbedtls_sha256_process esp_sha256_process
#endif
-/*
- * copyright (c) 2010 - 2012 Espressif System
- *
+/*
+ * copyright (c) 2010 - 2012 Espressif System
+ *
* esf Link List Descriptor
*/
#if defined(MBEDTLS_SHA512_ALT)
#include "sha.h"
-typedef SHA512_CTX mbedtls_sha512_context;
+typedef SHA512_CTX mbedtls_sha512_context;
-#define mbedtls_sha512_init esp_sha512_init
-#define mbedtls_sha512_process esp_sha512_process
-#define mbedtls_sha512_clone esp_sha512_clone
-#define mbedtls_sha512_starts esp_sha512_start
-#define mbedtls_sha512_update esp_sha512_update
-#define mbedtls_sha512_finish esp_sha512_finish
-#define mbedtls_sha512_free esp_sha512_free
+#define mbedtls_sha512_init esp_sha512_init
+#define mbedtls_sha512_process esp_sha512_process
+#define mbedtls_sha512_clone esp_sha512_clone
+#define mbedtls_sha512_starts esp_sha512_start
+#define mbedtls_sha512_update esp_sha512_update
+#define mbedtls_sha512_finish esp_sha512_finish
+#define mbedtls_sha512_free esp_sha512_free
#endif
!defined(EFI32)
WSADATA wsaData;
- if( wsa_init_done == 0 )
- {
- if( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 )
- return( MBEDTLS_ERR_NET_SOCKET_FAILED );
+ if ( wsa_init_done == 0 ) {
+ if ( WSAStartup( MAKEWORD(2, 0), &wsaData ) != 0 ) {
+ return ( MBEDTLS_ERR_NET_SOCKET_FAILED );
+ }
wsa_init_done = 1;
}
#else
#endif
- return( 0 );
+ return ( 0 );
}
static int mbedtls_net_errno(int fd)
{
- int sock_errno = 0;
- u32_t optlen = sizeof(sock_errno);
- getsockopt(fd, SOL_SOCKET, SO_ERROR, &sock_errno, &optlen);
- return sock_errno;
+ int sock_errno = 0;
+ u32_t optlen = sizeof(sock_errno);
+
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &sock_errno, &optlen);
+
+ return sock_errno;
}
/*
int ret;
struct addrinfo hints, *addr_list, *cur;
- if( ( ret = net_prepare() ) != 0 )
- return( ret );
+ if ( ( ret = net_prepare() ) != 0 ) {
+ return ( ret );
+ }
/* Do name resolution with both IPv6 and IPv4 */
memset( &hints, 0, sizeof( hints ) );
hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
- if( getaddrinfo( host, port, &hints, &addr_list ) != 0 )
- return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
+ if ( getaddrinfo( host, port, &hints, &addr_list ) != 0 ) {
+ return ( MBEDTLS_ERR_NET_UNKNOWN_HOST );
+ }
/* Try the sockaddrs until a connection succeeds */
ret = MBEDTLS_ERR_NET_UNKNOWN_HOST;
- for( cur = addr_list; cur != NULL; cur = cur->ai_next )
- {
+ for ( cur = addr_list; cur != NULL; cur = cur->ai_next ) {
ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype,
- cur->ai_protocol );
- if( ctx->fd < 0 )
- {
+ cur->ai_protocol );
+ if ( ctx->fd < 0 ) {
ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
continue;
}
- if( connect( ctx->fd, cur->ai_addr, cur->ai_addrlen ) == 0 )
- {
+ if ( connect( ctx->fd, cur->ai_addr, cur->ai_addrlen ) == 0 ) {
ret = 0;
break;
}
freeaddrinfo( addr_list );
- return( ret );
+ return ( ret );
}
/*
int n, ret;
struct addrinfo hints, *addr_list, *cur;
- if( ( ret = net_prepare() ) != 0 )
- return( ret );
+ if ( ( ret = net_prepare() ) != 0 ) {
+ return ( ret );
+ }
/* Bind to IPv6 and/or IPv4, but only in the desired protocol */
memset( &hints, 0, sizeof( hints ) );
hints.ai_socktype = proto == MBEDTLS_NET_PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
hints.ai_protocol = proto == MBEDTLS_NET_PROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
- if( getaddrinfo( bind_ip, port, &hints, &addr_list ) != 0 )
- return( MBEDTLS_ERR_NET_UNKNOWN_HOST );
+ if ( getaddrinfo( bind_ip, port, &hints, &addr_list ) != 0 ) {
+ return ( MBEDTLS_ERR_NET_UNKNOWN_HOST );
+ }
/* Try the sockaddrs until a binding succeeds */
ret = MBEDTLS_ERR_NET_UNKNOWN_HOST;
- for( cur = addr_list; cur != NULL; cur = cur->ai_next )
- {
+ for ( cur = addr_list; cur != NULL; cur = cur->ai_next ) {
ctx->fd = (int) socket( cur->ai_family, cur->ai_socktype,
- cur->ai_protocol );
- if( ctx->fd < 0 )
- {
+ cur->ai_protocol );
+ if ( ctx->fd < 0 ) {
ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
continue;
}
- /*SO_REUSEADDR option dafault is disable in source code(lwip)*/
+ /*SO_REUSEADDR option dafault is disable in source code(lwip)*/
#if SO_REUSE
n = 1;
- if( setsockopt( ctx->fd, SOL_SOCKET, SO_REUSEADDR,
- (const char *) &n, sizeof( n ) ) != 0 )
- {
+ if ( setsockopt( ctx->fd, SOL_SOCKET, SO_REUSEADDR,
+ (const char *) &n, sizeof( n ) ) != 0 ) {
close( ctx->fd );
ret = MBEDTLS_ERR_NET_SOCKET_FAILED;
continue;
}
#endif
- /*bind interface dafault don't process the addr is 0xffffffff for TCP Protocol*/
- struct sockaddr_in *serv_addr = NULL;
- serv_addr = (struct sockaddr_in *)cur->ai_addr;
- serv_addr->sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */
- if( bind( ctx->fd, (struct sockaddr *)serv_addr, cur->ai_addrlen ) != 0 )
- {
+ /*bind interface dafault don't process the addr is 0xffffffff for TCP Protocol*/
+ struct sockaddr_in *serv_addr = NULL;
+ serv_addr = (struct sockaddr_in *)cur->ai_addr;
+ serv_addr->sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */
+ if ( bind( ctx->fd, (struct sockaddr *)serv_addr, cur->ai_addrlen ) != 0 ) {
close( ctx->fd );
ret = MBEDTLS_ERR_NET_BIND_FAILED;
continue;
}
/* Listen only makes sense for TCP */
- if( proto == MBEDTLS_NET_PROTO_TCP )
- {
- if( listen( ctx->fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 )
- {
+ if ( proto == MBEDTLS_NET_PROTO_TCP ) {
+ if ( listen( ctx->fd, MBEDTLS_NET_LISTEN_BACKLOG ) != 0 ) {
close( ctx->fd );
ret = MBEDTLS_ERR_NET_LISTEN_FAILED;
continue;
freeaddrinfo( addr_list );
- return( ret );
+ return ( ret );
}
static int net_would_block( const mbedtls_net_context *ctx )
{
((void) ctx);
- return( WSAGetLastError() == WSAEWOULDBLOCK );
+ return ( WSAGetLastError() == WSAEWOULDBLOCK );
}
#else
/*
/*
* Never return 'WOULD BLOCK' on a non-blocking socket
*/
- if( ( fcntl( ctx->fd, F_GETFL, 0) & O_NONBLOCK ) != O_NONBLOCK )
- return( 0 );
+ if ( ( fcntl( ctx->fd, F_GETFL, 0) & O_NONBLOCK ) != O_NONBLOCK ) {
+ return ( 0 );
+ }
- int error = mbedtls_net_errno(ctx->fd);
-
- switch( error )
- {
+ int error = mbedtls_net_errno(ctx->fd);
+
+ switch ( error ) {
#if defined EAGAIN
- case EAGAIN:
+ case EAGAIN:
#endif
#if defined EWOULDBLOCK && EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
+ case EWOULDBLOCK:
#endif
- return( 1 );
+ return ( 1 );
}
- return( 0 );
+ return ( 0 );
}
#endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
socklen_t type_len = (socklen_t) sizeof( type );
/* Is this a TCP or UDP socket? */
- if( getsockopt( bind_ctx->fd, SOL_SOCKET, SO_TYPE,
- (void *) &type, (socklen_t *) &type_len ) != 0 ||
- ( type != SOCK_STREAM && type != SOCK_DGRAM ) )
- {
- return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
+ if ( getsockopt( bind_ctx->fd, SOL_SOCKET, SO_TYPE,
+ (void *) &type, (socklen_t *) &type_len ) != 0 ||
+ ( type != SOCK_STREAM && type != SOCK_DGRAM ) ) {
+ return ( MBEDTLS_ERR_NET_ACCEPT_FAILED );
}
- if( type == SOCK_STREAM )
- {
+ if ( type == SOCK_STREAM ) {
/* TCP: actual accept() */
ret = client_ctx->fd = (int) accept( bind_ctx->fd,
(struct sockaddr *) &client_addr, &n );
- }
- else
- {
+ } else {
/* UDP: wait for a message, but keep it in the queue */
char buf[1] = { 0 };
(struct sockaddr *) &client_addr, &n );
#if defined(_WIN32)
- if( ret == SOCKET_ERROR &&
- WSAGetLastError() == WSAEMSGSIZE )
- {
+ if ( ret == SOCKET_ERROR &&
+ WSAGetLastError() == WSAEMSGSIZE ) {
/* We know buf is too small, thanks, just peeking here */
ret = 0;
}
#endif
}
- if( ret < 0 )
- {
- if( net_would_block( bind_ctx ) != 0 )
- return( MBEDTLS_ERR_SSL_WANT_READ );
+ if ( ret < 0 ) {
+ if ( net_would_block( bind_ctx ) != 0 ) {
+ return ( MBEDTLS_ERR_SSL_WANT_READ );
+ }
- return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
+ return ( MBEDTLS_ERR_NET_ACCEPT_FAILED );
}
/* UDP: hijack the listening socket to communicate with the client,
* then bind a new socket to accept new connections */
- if( type != SOCK_STREAM )
- {
+ if ( type != SOCK_STREAM ) {
struct sockaddr_in local_addr;
int one = 1;
- if( connect( bind_ctx->fd, (struct sockaddr *) &client_addr, n ) != 0 )
- return( MBEDTLS_ERR_NET_ACCEPT_FAILED );
+ if ( connect( bind_ctx->fd, (struct sockaddr *) &client_addr, n ) != 0 ) {
+ return ( MBEDTLS_ERR_NET_ACCEPT_FAILED );
+ }
client_ctx->fd = bind_ctx->fd;
bind_ctx->fd = -1; /* In case we exit early */
n = sizeof( struct sockaddr_in );
- if( getsockname( client_ctx->fd,
- (struct sockaddr *) &local_addr, &n ) != 0 ||
- ( bind_ctx->fd = (int) socket( AF_INET,
- SOCK_DGRAM, IPPROTO_UDP ) ) < 0 ||
- setsockopt( bind_ctx->fd, SOL_SOCKET, SO_REUSEADDR,
- (const char *) &one, sizeof( one ) ) != 0 )
- {
- return( MBEDTLS_ERR_NET_SOCKET_FAILED );
+ if ( getsockname( client_ctx->fd,
+ (struct sockaddr *) &local_addr, &n ) != 0 ||
+ ( bind_ctx->fd = (int) socket( AF_INET,
+ SOCK_DGRAM, IPPROTO_UDP ) ) < 0 ||
+ setsockopt( bind_ctx->fd, SOL_SOCKET, SO_REUSEADDR,
+ (const char *) &one, sizeof( one ) ) != 0 ) {
+ return ( MBEDTLS_ERR_NET_SOCKET_FAILED );
}
- if( bind( bind_ctx->fd, (struct sockaddr *) &local_addr, n ) != 0 )
- {
- return( MBEDTLS_ERR_NET_BIND_FAILED );
+ if ( bind( bind_ctx->fd, (struct sockaddr *) &local_addr, n ) != 0 ) {
+ return ( MBEDTLS_ERR_NET_BIND_FAILED );
}
}
- if( client_ip != NULL )
- {
- struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr;
- *ip_len = sizeof( addr4->sin_addr.s_addr );
+ if ( client_ip != NULL ) {
+ struct sockaddr_in *addr4 = (struct sockaddr_in *) &client_addr;
+ *ip_len = sizeof( addr4->sin_addr.s_addr );
- if( buf_size < *ip_len )
- return( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL );
+ if ( buf_size < *ip_len ) {
+ return ( MBEDTLS_ERR_NET_BUFFER_TOO_SMALL );
+ }
- memcpy( client_ip, &addr4->sin_addr.s_addr, *ip_len );
+ memcpy( client_ip, &addr4->sin_addr.s_addr, *ip_len );
}
- return( 0 );
+ return ( 0 );
}
/*
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
u_long n = 0;
- return( ioctlsocket( ctx->fd, FIONBIO, &n ) );
+ return ( ioctlsocket( ctx->fd, FIONBIO, &n ) );
#else
- return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) & ~O_NONBLOCK ) );
+ return ( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) & ~O_NONBLOCK ) );
#endif
}
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
u_long n = 1;
- return( ioctlsocket( ctx->fd, FIONBIO, &n ) );
+ return ( ioctlsocket( ctx->fd, FIONBIO, &n ) );
#else
- return( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) | O_NONBLOCK ) );
+ return ( fcntl( ctx->fd, F_SETFL, fcntl( ctx->fd, F_GETFL, 0 ) | O_NONBLOCK ) );
#endif
}
int ret;
int fd = ((mbedtls_net_context *) ctx)->fd;
int error = 0;
-
- if( fd < 0 )
- return( MBEDTLS_ERR_NET_INVALID_CONTEXT );
+
+ if ( fd < 0 ) {
+ return ( MBEDTLS_ERR_NET_INVALID_CONTEXT );
+ }
ret = (int) read( fd, buf, len );
- if( ret < 0 )
- {
- if( net_would_block( ctx ) != 0 )
- return( MBEDTLS_ERR_SSL_WANT_READ );
+ if ( ret < 0 ) {
+ if ( net_would_block( ctx ) != 0 ) {
+ return ( MBEDTLS_ERR_SSL_WANT_READ );
+ }
- error = mbedtls_net_errno(fd);
+ error = mbedtls_net_errno(fd);
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
- if( WSAGetLastError() == WSAECONNRESET )
- return( MBEDTLS_ERR_NET_CONN_RESET );
+ if ( WSAGetLastError() == WSAECONNRESET ) {
+ return ( MBEDTLS_ERR_NET_CONN_RESET );
+ }
#else
- if( error == EPIPE || error == ECONNRESET )
- return( MBEDTLS_ERR_NET_CONN_RESET );
+ if ( error == EPIPE || error == ECONNRESET ) {
+ return ( MBEDTLS_ERR_NET_CONN_RESET );
+ }
- if( error == EINTR )
- return( MBEDTLS_ERR_SSL_WANT_READ );
+ if ( error == EINTR ) {
+ return ( MBEDTLS_ERR_SSL_WANT_READ );
+ }
#endif
- return( MBEDTLS_ERR_NET_RECV_FAILED );
+ return ( MBEDTLS_ERR_NET_RECV_FAILED );
}
- return( ret );
+ return ( ret );
}
/*
* Read at most 'len' characters, blocking for at most 'timeout' ms
*/
int mbedtls_net_recv_timeout( void *ctx, unsigned char *buf, size_t len,
- uint32_t timeout )
+ uint32_t timeout )
{
int ret;
struct timeval tv;
fd_set read_fds;
int fd = ((mbedtls_net_context *) ctx)->fd;
- if( fd < 0 )
- return( MBEDTLS_ERR_NET_INVALID_CONTEXT );
+ if ( fd < 0 ) {
+ return ( MBEDTLS_ERR_NET_INVALID_CONTEXT );
+ }
FD_ZERO( &read_fds );
FD_SET( fd, &read_fds );
ret = select( fd + 1, &read_fds, NULL, NULL, timeout == 0 ? NULL : &tv );
/* Zero fds ready means we timed out */
- if( ret == 0 )
- return( MBEDTLS_ERR_SSL_TIMEOUT );
+ if ( ret == 0 ) {
+ return ( MBEDTLS_ERR_SSL_TIMEOUT );
+ }
- if( ret < 0 )
- {
+ if ( ret < 0 ) {
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
- if( WSAGetLastError() == WSAEINTR )
- return( MBEDTLS_ERR_SSL_WANT_READ );
+ if ( WSAGetLastError() == WSAEINTR ) {
+ return ( MBEDTLS_ERR_SSL_WANT_READ );
+ }
#else
- if( errno == EINTR )
- return( MBEDTLS_ERR_SSL_WANT_READ );
+ if ( errno == EINTR ) {
+ return ( MBEDTLS_ERR_SSL_WANT_READ );
+ }
#endif
- return( MBEDTLS_ERR_NET_RECV_FAILED );
+ return ( MBEDTLS_ERR_NET_RECV_FAILED );
}
/* This call will not block */
- return( mbedtls_net_recv( ctx, buf, len ) );
+ return ( mbedtls_net_recv( ctx, buf, len ) );
}
/*
int ret;
int fd = ((mbedtls_net_context *) ctx)->fd;
- int error = 0;
+ int error = 0;
- if( fd < 0 )
- return( MBEDTLS_ERR_NET_INVALID_CONTEXT );
+ if ( fd < 0 ) {
+ return ( MBEDTLS_ERR_NET_INVALID_CONTEXT );
+ }
ret = (int) write( fd, buf, len );
- if( ret < 0 )
- {
- if( net_would_block( ctx ) != 0 )
- return( MBEDTLS_ERR_SSL_WANT_WRITE );
+ if ( ret < 0 ) {
+ if ( net_would_block( ctx ) != 0 ) {
+ return ( MBEDTLS_ERR_SSL_WANT_WRITE );
+ }
- error = mbedtls_net_errno(fd);
+ error = mbedtls_net_errno(fd);
#if ( defined(_WIN32) || defined(_WIN32_WCE) ) && !defined(EFIX64) && \
!defined(EFI32)
- if( WSAGetLastError() == WSAECONNRESET )
- return( MBEDTLS_ERR_NET_CONN_RESET );
+ if ( WSAGetLastError() == WSAECONNRESET ) {
+ return ( MBEDTLS_ERR_NET_CONN_RESET );
+ }
#else
- if( error == EPIPE || error == ECONNRESET )
- return( MBEDTLS_ERR_NET_CONN_RESET );
+ if ( error == EPIPE || error == ECONNRESET ) {
+ return ( MBEDTLS_ERR_NET_CONN_RESET );
+ }
- if( error == EINTR )
- return( MBEDTLS_ERR_SSL_WANT_WRITE );
+ if ( error == EINTR ) {
+ return ( MBEDTLS_ERR_SSL_WANT_WRITE );
+ }
#endif
- return( MBEDTLS_ERR_NET_SEND_FAILED );
+ return ( MBEDTLS_ERR_NET_SEND_FAILED );
}
- return( ret );
+ return ( ret );
}
/*
*/
void mbedtls_net_free( mbedtls_net_context *ctx )
{
- if( ctx->fd == -1 )
+ if ( ctx->fd == -1 ) {
return;
+ }
shutdown( ctx->fd, 2 );
close( ctx->fd );
projects / esp-idf / commitdiff