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

components/util/Kconfig

@@ -1,5 +1,14 @@
 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
    bool "Enable Espressif SHA"
    default y

components/util/include/util_assert.h

@@ -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

components/util/src/aes.c

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 #include <sys/errno.h>
-#include <assert.h>
 #include <string.h>
 #include "esp_aes.h"
 #include "ibus_data.h"
+#include "util_assert.h"
 
 /*
  * 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;
     uint8_t *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     for (size_t i = 0; i < slen; i += 16)
         __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;
     uint8_t *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     for (size_t i = 0; i < slen; i += 16)
         __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 *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert(p_iv);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert(p_iv);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     for (int i = 0; i < slen; i += 16) {
         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 *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert(p_iv);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert(p_iv);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     for (int i = 0; i < slen; i += 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 *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert(p_iv);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert(p_iv);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     for (int i = 0; i < slen; i++) {
         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 *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert(p_iv);
-    assert(iv_off);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert(p_iv);
+    util_assert(iv_off);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     n = *iv_off;
     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 *output = (uint8_t *)p_dst;
 
-    assert(aes);
-    assert(p_src);
-    assert(p_dst);
-    assert(p_iv);
-    assert(iv_off);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert(p_iv);
+    util_assert(iv_off);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     n = *iv_off;
     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;
     const uint8_t *input = (const uint8_t *)p_src;
 
-    assert(aes);
-    assert(nc_off);
-    assert(p_nonce_counter);
-    assert(p_stream_block);
-    assert(p_src);
-    assert(p_dst);
-    assert((slen > 0) && ((slen % 16) == 0));
-    assert(dlen >= slen);
+    util_assert(aes);
+    util_assert(nc_off);
+    util_assert(p_nonce_counter);
+    util_assert(p_stream_block);
+    util_assert(p_src);
+    util_assert(p_dst);
+    util_assert((slen > 0) && ((slen % 16) == 0));
+    util_assert(dlen >= slen);
 
     n = *nc_off;
     for (int i = 0; i < slen; i++) {

components/util/src/base64.c

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

components/util/src/sha.c

@@ -14,7 +14,7 @@
 
 #include <stdio.h>
 #include <string.h>
-#include <assert.h>
+#include "util_assert.h"
 #include <sys/errno.h>
 #include "esp_sha.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)
 {
-    assert(ctx);
+    util_assert(ctx);
 
     ctx->total[0] = 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)
 {
-    assert(ctx);
+    util_assert(ctx);
 
     ctx->total[0] = 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;
     const uint8_t *input = (const uint8_t *)src;
 
-    assert(ctx);
-    assert(src);
+    util_assert(ctx);
+    util_assert(src);
 
     if (ilen == 0)
         return 0;
@@ -541,8 +541,8 @@ int __esp_sha_finish(esp_sha_t *ctx, void *dest)
     void *state;
     uint8_t msglen[16];
 
-    assert(ctx);
-    assert(dest);
+    util_assert(ctx);
+    util_assert(dest);
 
     if (SHA1 == ctx->type)
         bytes = 20;