espressif/ESP8266_RTOS_SDK
1
0
Fork 0
mirror of https://github.com/espressif/ESP8266_RTOS_SDK.git synced 2025-06-04 12:36:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(util): Use independent "util_assert" instead of "assert"

Browse Source
This commit is contained in:
dongheng
2019-04-24 14:57:02 +08:00
parent 402fdef09c
commit 0b571f4c58
5 changed files with 92 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
components/util/Kconfig
View File

@ -1,5 +1,14 @@
menu "Util" menu "Util"
config util_assert
bool "Enable assert for util components"
default n
help
Enable this option, util components will use assert to check if input
parameters are correct.
Disable this option will speed up the process of some calculation a lot.
config ESP_SHA config ESP_SHA
bool "Enable Espressif SHA" bool "Enable Espressif SHA"
default y default y

24
components/util/include/util_assert.h Normal file
View File

@ -0,0 +1,24 @@
// Copyright 2018-2019 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "sdkconfig.h"
#include "assert.h"
#ifdef CONFIG_UTIL_ASSERT
#define util_assert(_e) assert(_e)
#else
#define util_assert(_e)
#endif

102
components/util/src/aes.c
View File

@ -13,10 +13,10 @@
// limitations under the License. // limitations under the License.
#include <sys/errno.h> #include <sys/errno.h>
#include <assert.h>
#include <string.h> #include <string.h>
#include "esp_aes.h" #include "esp_aes.h"
#include "ibus_data.h" #include "ibus_data.h"
#include "util_assert.h"
/* /*
* 32-bit integer manipulation macros (little endian) * 32-bit integer manipulation macros (little endian)
@ -586,11 +586,11 @@ int esp_aes_encrypt(esp_aes_t *aes,
const uint8_t *input = (const uint8_t *)p_src; const uint8_t *input = (const uint8_t *)p_src;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
for (size_t i = 0; i < slen; i += 16) for (size_t i = 0; i < slen; i += 16)
__esp_aes_encrypt(aes, input + i, output + i); __esp_aes_encrypt(aes, input + i, output + i);
@ -607,11 +607,11 @@ int esp_aes_decrypt(esp_aes_t *aes,
const uint8_t *input = (const uint8_t *)p_src; const uint8_t *input = (const uint8_t *)p_src;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
for (size_t i = 0; i < slen; i += 16) for (size_t i = 0; i < slen; i += 16)
__esp_aes_decrypt(aes, input + i, output + i); __esp_aes_decrypt(aes, input + i, output + i);
@ -630,12 +630,12 @@ int esp_aes_encrypt_cbc(esp_aes_t *aes,
uint8_t *iv = (uint8_t *)p_iv; uint8_t *iv = (uint8_t *)p_iv;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert(p_iv); util_assert(p_iv);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
for (int i = 0; i < slen; i += 16) { for (int i = 0; i < slen; i += 16) {
for(int j = 0; j < 16; j++ ) for(int j = 0; j < 16; j++ )
@ -662,12 +662,12 @@ int esp_aes_decrypt_cbc(esp_aes_t *aes,
uint8_t *iv = (uint8_t *)p_iv; uint8_t *iv = (uint8_t *)p_iv;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert(p_iv); util_assert(p_iv);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
for (int i = 0; i < slen; i += 16) { for (int i = 0; i < slen; i += 16) {
uint8_t temp[16]; uint8_t temp[16];
@ -725,12 +725,12 @@ int esp_aes_decrypt_cfb8(esp_aes_t *aes,
uint8_t *iv = (uint8_t *)p_iv; uint8_t *iv = (uint8_t *)p_iv;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert(p_iv); util_assert(p_iv);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
for (int i = 0; i < slen; i++) { for (int i = 0; i < slen; i++) {
memcpy(ov, iv, 16); memcpy(ov, iv, 16);
@ -758,13 +758,13 @@ int esp_aes_encrypt_cfb128(esp_aes_t *aes,
uint8_t *iv = (uint8_t *)p_iv; uint8_t *iv = (uint8_t *)p_iv;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert(p_iv); util_assert(p_iv);
assert(iv_off); util_assert(iv_off);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
n = *iv_off; n = *iv_off;
for (int i = 0; i < slen; i++) { for (int i = 0; i < slen; i++) {
@ -795,13 +795,13 @@ int esp_aes_decrypt_cfb128(esp_aes_t *aes,
uint8_t *iv = (uint8_t *)p_iv; uint8_t *iv = (uint8_t *)p_iv;
uint8_t *output = (uint8_t *)p_dst; uint8_t *output = (uint8_t *)p_dst;
assert(aes); util_assert(aes);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert(p_iv); util_assert(p_iv);
assert(iv_off); util_assert(iv_off);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
n = *iv_off; n = *iv_off;
for (int i = 0; i < slen; i++) { for (int i = 0; i < slen; i++) {
@ -836,14 +836,14 @@ int esp_aes_encrypt_ctr(esp_aes_t *aes,
uint8_t *stream_block = (uint8_t *)p_stream_block; uint8_t *stream_block = (uint8_t *)p_stream_block;
const uint8_t *input = (const uint8_t *)p_src; const uint8_t *input = (const uint8_t *)p_src;
assert(aes); util_assert(aes);
assert(nc_off); util_assert(nc_off);
assert(p_nonce_counter); util_assert(p_nonce_counter);
assert(p_stream_block); util_assert(p_stream_block);
assert(p_src); util_assert(p_src);
assert(p_dst); util_assert(p_dst);
assert((slen > 0) && ((slen % 16) == 0)); util_assert((slen > 0) && ((slen % 16) == 0));
assert(dlen >= slen); util_assert(dlen >= slen);
n = *nc_off; n = *nc_off;
for (int i = 0; i < slen; i++) { for (int i = 0; i < slen; i++) {

2
components/util/src/base64.c
View File

@ -15,7 +15,7 @@
#include "sdkconfig.h" #include "sdkconfig.h"
#include "esp_base64.h" #include "esp_base64.h"
#include "ibus_data.h" #include "ibus_data.h"
#include <assert.h> #include "util_assert.h"
#include <sys/errno.h> #include <sys/errno.h>
typedef union _cache { typedef union _cache {

14
components/util/src/sha.c
View File

@ -14,7 +14,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <assert.h> #include "util_assert.h"
#include <sys/errno.h> #include <sys/errno.h>
#include "esp_sha.h" #include "esp_sha.h"
#include "esp_log.h" #include "esp_log.h"
@ -425,7 +425,7 @@ int __esp_sha512_process(void *in_ctx, const void *src)
*/ */
int __esp_sha_init(esp_sha_t *ctx, esp_sha_type_t type, const uint32_t *state_ctx, size_t size, sha_cal_t sha_cal) int __esp_sha_init(esp_sha_t *ctx, esp_sha_type_t type, const uint32_t *state_ctx, size_t size, sha_cal_t sha_cal)
{ {
assert(ctx); util_assert(ctx);
ctx->total[0] = 0; ctx->total[0] = 0;
ctx->total[1] = 0; ctx->total[1] = 0;
@ -444,7 +444,7 @@ int __esp_sha_init(esp_sha_t *ctx, esp_sha_type_t type, const uint32_t *state_ct
*/ */
int __esp_sha512_init(esp_sha512_t *ctx, esp_sha_type_t type, const uint64_t *state_ctx, size_t size) int __esp_sha512_init(esp_sha512_t *ctx, esp_sha_type_t type, const uint64_t *state_ctx, size_t size)
{ {
assert(ctx); util_assert(ctx);
ctx->total[0] = 0; ctx->total[0] = 0;
ctx->total[1] = 0; ctx->total[1] = 0;
@ -471,8 +471,8 @@ int __esp_sha_update(esp_sha_t *ctx, const void *src, size_t size)
size_t ilen = size; size_t ilen = size;
const uint8_t *input = (const uint8_t *)src; const uint8_t *input = (const uint8_t *)src;
assert(ctx); util_assert(ctx);
assert(src); util_assert(src);
if (ilen == 0) if (ilen == 0)
return 0; return 0;
@ -541,8 +541,8 @@ int __esp_sha_finish(esp_sha_t *ctx, void *dest)
void *state; void *state;
uint8_t msglen[16]; uint8_t msglen[16];
assert(ctx); util_assert(ctx);
assert(dest); util_assert(dest);
if (SHA1 == ctx->type) if (SHA1 == ctx->type)
bytes = 20; bytes = 20;