!1046 Fix : pthread_cond_timedwait 信号丢失问题修复挑单到3.0-LTS 分支

Merge pull request !1046 from yinjiaming/cherry-pick-1680507888

.gitee/PULL_REQUEST_TEMPLATE.zh-CN.md

@@ -1,6 +1,6 @@
 ### 相关的Issue
-    
-    
+
+  
 ### 原因（目的、解决的问题等）
 
 

BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -27,37 +27,67 @@
 # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-declare_args() {
-  enable_ohos_kernel_liteos_m_cppsupport = true
-  enable_ohos_kernel_liteos_m_cpup = true
-  enable_ohos_kernel_liteos_m_exchook = true
-  enable_ohos_kernel_liteos_m_kal = true
-  enable_ohos_kernel_liteos_m_fs = true
-  enable_ohos_kernel_liteos_m_backtrace = true
+import("config.gni")
+
+LITEOS_LOS_CONFIG_H = rebase_path("$LITEOSTOPDIR/kernel/include/los_config.h")
+
+config("los_config") {
+  cflags = [ "-Werror" ]
+
+  asmflags = [
+    "-DCLZ=CLZ",
+    "-imacros",
+    "$LITEOS_LOS_CONFIG_H",
+  ]
+
+  include_dirs = [
+    "//kernel/liteos_m/kernel/include",
+    "//kernel/liteos_m/kernel/arch/include",
+    "//kernel/liteos_m/utils",
+    "//third_party/bounds_checking_function/include",
+  ]
 }
 
 group("kernel") {
   deps = [
-    "components/bounds_checking_function:sec",
     "kernel:kernel",
     "utils:utils",
+    "//third_party/bounds_checking_function:libsec_static",
   ]
-  if (enable_ohos_kernel_liteos_m_cppsupport == true) {
+  if (enable_ohos_kernel_liteos_m_cppsupport) {
     deps += [ "components/cppsupport:cppsupport" ]
   }
-  if (enable_ohos_kernel_liteos_m_cpup == true) {
+  if (enable_ohos_kernel_liteos_m_cpup) {
     deps += [ "components/cpup:cpup" ]
   }
-  if (enable_ohos_kernel_liteos_m_exchook == true) {
+  if (enable_ohos_kernel_liteos_m_exchook) {
     deps += [ "components/exchook:exchook" ]
   }
-  if (enable_ohos_kernel_liteos_m_backtrace == true) {
+  if (enable_ohos_kernel_liteos_m_backtrace) {
     deps += [ "components/backtrace:backtrace" ]
   }
-  if (enable_ohos_kernel_liteos_m_fs == true) {
+  if (enable_ohos_kernel_liteos_m_fs) {
     deps += [ "components/fs:fs" ]
   }
-  if (enable_ohos_kernel_liteos_m_kal == true) {
+  if (enable_ohos_kernel_liteos_m_pm) {
+    deps += [ "components/power:pm" ]
+  }
+  if (enable_ohos_kernel_liteos_m_trace) {
+    deps += [ "components/trace:trace" ]
+  }
+  if (enable_ohos_kernel_liteos_m_kal) {
     deps += [ "kal:kal" ]
   }
+  if (enable_ohos_kernel_liteos_m_shell) {
+    deps += [ "components/shell:shell" ]
+  }
+  if (enable_ohos_kernel_liteos_m_test) {
+    deps += [ "testsuits:test" ]
+  }
+  if (enable_ohos_kernel_liteos_m_lwip) {
+    deps += [ ohos_kernel_liteos_m_lwip_path ]
+  }
+  if (enable_ohos_kernel_liteos_m_dynlink) {
+    deps += [ "components/dynlink:dynlink" ]
+  }
 }

OAT.xml

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (c) 2021 Huawei Device Co., 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.
+
+    This is the configuration file template for OpenHarmony OSS Audit Tool, please copy it to your project root dir and modify it refer to OpenHarmony/tools_oat/README.
+
+-->
+
+<configuration>
+    <oatconfig>
+        <licensefile></licensefile>
+        <policylist>
+            <policy name="projectPolicy" desc="">
+                <policyitem type="copyright" name="Huawei Technologies Co., Ltd. All rights reserved." path=".*" desc="original liteos copyright"/>
+                <policyitem type="license" name="BSD-3-Clause" path=".*" desc="Liteos kernel use bsd3 license"/>
+                <policyitem type="license" name="BSD-3-Clause" path=".*" desc="Liteos kernel use bsd3 license"/>
+            </policy>
+        </policylist>
+        <filefilterlist>
+            <filefilter name="defaultFilter" desc="文件属于FreeBSD仓库软连接，本仓库屏蔽告警，在FreeBSD仓库进行处理">
+                <filteritem type="filepath" name="kernel/arch/risc-v/nuclei/gcc/nmsis/Library/.*" desc="文件属于三方芯片的二进制代码，属于社区贡献，不用提供额外的说明"/>
+                <filteritem type="filepath" name="targets/riscv_nuclei_demo_soc_gcc/.*" desc="文件属于nuclei三方芯片的源代码，文件头说明跟随liteos_m/LICENSE，不用额外说明"/>
+                <filteritem type="filepath" name="targets/riscv_nuclei_gd32vf103_soc_gcc/.*" desc="文件属于nuclei三方芯片的源代码，文件头说明跟随liteos_m/LICENSE，不用额外说明"/>
+                <filteritem type="filepath" name="NOTICE" desc="NOTICE文件"/>
+                <filteritem type="filepath" name="kernel/arch/risc-v/nuclei" desc="该文件的license为apache 2.0符合"/>
+            </filefilter>
+            <filefilter name="defaultFilter" desc="Files not to check">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+            <filefilter name="defaultPolicyFilter" desc="Filters for compatibility，license header policies">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+            <filefilter name="copyrightPolicyFilter" desc="Filters for copyright header policies">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+            <filefilter name="licenseFileNamePolicyFilter" desc="Filters for LICENSE file policies">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+            <filefilter name="readmeFileNamePolicyFilter" desc="Filters for README file policies">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+            <filefilter name="readmeOpenSourcefileNamePolicyFilter" desc="Filters for README.OpenSource file policies">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+            <filefilter name="binaryFileTypePolicyFilter" desc="Filters for binary file policies">
+                <!--filteritem type="filename" name="*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="abcdefg/.*.uvwxyz" desc="Describe the reason for filtering scan results"/-->
+                <!--filteritem type="filepath" name="projectroot/[a-zA-Z0-9]{20,}.sh" desc="Temp files"/-->
+            </filefilter>
+
+        </filefilterlist>
+        <licensematcherlist>
+            <!--licensematcher name="uvwxyz License" desc="If the scanning result is InvalidLicense, you can define matching rules here. Note that quotation marks must be escaped.">
+                <licensetext name="
+                    uvwxyz license textA xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+                " desc=""/>
+                <licensetext name="
+                    uvwxyz license textB xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+                " desc=""/>
+            </licensematcher-->
+        </licensematcherlist>
+    </oatconfig>
+</configuration>

README.md

@@ -15,11 +15,18 @@ The OpenHarmony LiteOS Cortex-M is the kernel designed for the lightweight opera
 
 ## Directory Structure<a name="section161941989596"></a>
 
+The directory structure is listed as below, for the detailed directories, please refer to [arch_spec.md](arch_spec.md).
+
 ```
 /kernel/liteos_m
 ├── components           # Optional components
+│   ├── backtrace        # Backtrace support
 │   ├── cppsupport       # C++ support
-│   └── cpup             # CPU possession (CPUP)
+│   ├── cpup             # CPU possession (CPUP)
+│   ├── dynlink          # Dynamic loader & linker
+│   ├── exchook          # Exception hook
+│   ├── fs               # File system
+│   └── net              # Network support
 ├── kal                  # Kernel abstraction layer
 │   ├── cmsis            # CMSIS-compliant API support
 │   └── posix            # POSIX API support
@@ -62,18 +69,9 @@ make clean; make
 
 After the compilation is successful, the executable file  **NUCLEO-F767.hex**  is generated in the  **cortex-m7\_nucleo\_f767zi\_gcc/build**  directory. Burn the file to the corresponding board using STM32 ST-LINK Utility.
 
-## Change Log
-
-v1.0.1
-1. removed these KAL apis: `KalThreadGetInfo`,`KalDelayUs`,`KalTimerCreate`,`KalTimerStart`,`KalTimerChange`,`KalTimerStop`,`KalTimerDelete`,`KalTimerIsRunning`,`KalTickToMs`,`KalMsToTick`,`KalGetMemInfo`
-2. add some POSIX apis
-
-v1.0
-1. first release
-
 ## Repositories Involved<a name="section1371113476307"></a>
 
-[Kernel subsystem](https://gitee.com/openharmony/docs/blob/master/en/readme/kernel.md)
+[Kernel subsystem](https://gitee.com/openharmony/docs/blob/HEAD/en/readme/kernel.md)
 
 **kernel\_liteos\_m**
 

README_zh.md

@@ -15,11 +15,18 @@ OpenHarmony LiteOS-M内核是面向IoT领域构建的轻量级物联网操作系
 
 ## 目录<a name="section161941989596"></a>
 
+目录结构如下，详细目录请参考[arch_spec_zh.md](arch_spec_zh.md)。
+
 ```
 /kernel/liteos_m
 ├── components           # 可选组件
+│   ├── backtrace        # 回溯栈支持
 │   ├── cppsupport       # C++支持
-│   └── cpup             # CPUP功能
+│   ├── cpup             # CPUP功能
+│   ├── dynlink          # 动态加载与链接
+│   ├── exchook          # 异常钩子
+│   ├── fs               # 文件系统
+│   └── net              # Network功能
 ├── kal                  # 内核抽象层
 │   ├── cmsis            # cmsis标准接口支持
 │   └── posix            # posix标准接口支持
@@ -41,39 +48,80 @@ OpenHarmony LiteOS-M内核是面向IoT领域构建的轻量级物联网操作系
 
 ## 使用说明<a name="section3732185231214"></a>
 
-LiteOS-M内核提供了三种芯片架构的工程位于targets目录。三种架构的工程编译及使用方式如下：
+OpenHarmony LiteOS-M内核的编译构建系统是一个基于gn和ninja的组件化构建系统，支持按组件配置、裁剪和拼装，按需构建出定制化的产品。本文主要介绍如何基于gn和ninja编译LiteOS-M工程，GCC+Makefile、IAR、Keil MDK等编译方式可以参考社区爱好者贡献的站点。
+
+### 搭建系统基础环境
+
+在搭建各个开发板环境前，需要完成OpenHarmony系统基础环境搭建。系统基础环境主要是指OpenHarmony的编译环境和开发环境，详细介绍请参考官方站点[Ubuntu编译环境准备](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/device-dev/quick-start/quickstart-lite-env-setup-linux.md)。开发者需要根据环境搭建文档，完成下述软件的安装：Python3.7+、gn、ninja、hb。对于LiteOS-M内核，还需要安装Make构建工具和[ARM GCC编译工具链](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads)。
+
+### 获取OpenHarmony源码
+
+开发者需要在Linux服务器上通过Git克隆获取OpenHarmony最新源码，详细的源码获取方式，请见[源码获取](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/device-dev/get-code/sourcecode-acquire.md)。获取OpenHarmony完整仓代码后，假设克隆目录为`~/openHarmony`。
+
+### 获取示例工程源码
+
+以开发板Nucleo-F767Zi为例，演示如何编译运行`OpenHarmony LiteOS-M`内核工程。在本地目录，执行下述命令克隆示例代码。
+
+```
+git clone https://gitee.com/harylee/nucleo_f767zi.git
+```
+
+假设克隆到的代码目录为`~/nucleo_f767zi`。 执行如下命令把代码目录的`device`、`vendor`目录复制到`openHarmony`工程的相应目录。
+
+```
+mkdir ~/openHarmony/device/st
+
+cp -r ~/nucleo_f767zi/device/st/nucleo_f767zi ~/openHarmony/device/st/nucleo_f767zi
+
+chmod +x ~/openHarmony/device/st/nucleo_f767zi/build.sh
+
+cp -r ~/nucleo_f767zi/vendor/st ~/openHarmony/vendor/st
+```
+
+关于示例代码目录的说明，可以参考资料站点[板级目录规范](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/device-dev/porting/transplant-chip-board-overview.md)。如果需要自行移植开发板，请参考[板级系统移植](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/device-dev/porting/transplant-chip-board.md)。
+
+### 编译运行
+
+编译运行前，交叉编译工具链`bin`目录配置到`PATH`环境变量中或者配置`device/st/nucleo_f767zi/liteos_m/config.gni`文件中`board_toolchain_path`配置项为交叉编译工具链`bin`目录。
+在`OpenHarmony`根目录，执行`hb set`设置产品路径，选择`nucleo_f767zi`产品，然后执行`hb build`开启编译。如下：
+
+```
+user@dev:~/OpenHarmony$ hb set
+
+[OHOS INFO] Input code path: # 直接按回车，然后选择nucleo_f767zi产品即可
+
+OHOS Which product do you need? nucleo_f767zi@st
+
+user@dev:~/OpenHarmony$ hb build
+```
+
+最终的镜像生成在`~/openHarmony/out/nucleo_f767zi/`目录中，通过`STM32 ST-LINK Utility`软件将镜像文件下载至单板查看运行效果。
+
+### 社区移植工程链接
+
+LiteOS-M内核移植的具体开发板的工程由社区开发者提供，可以访问社区开发者代码仓获取。如果您移植支持了更多开发板，可以提供链接给我们进行社区分享。
 
 -   cortex-m3：
 
-kernel/liteos\_m/targets/cortex-m3\_stm32f103\_simulator\_keil目录是基于STM32F103芯片架构构建的keil工程目录，keil开发工具可通过网络下载并安装。进入cortex-m3\_stm32f103\_simulator\_keil/project目录，双击los\_demo.uvproj文件即可打开相应工程，编译成功后即可通过JLINK或者STM32 ST-LINK Utility烧录至对应单板。
+    - STM32F103   https://gitee.com/rtos_lover/stm32f103_simulator_keil
+
+        该仓包含OpenHarmony LiteOS-M内核基于STM32F103芯片架构构建的Keil工程，支持Keil MDK方式进行编译。
 
 -   cortex-m4：
 
-kernel/liteos\_m/targets/cortex-m4\_stm32f429ig\_fire-challenger\_iar目录是基于STM32F429IG芯片架构构建的IAR工程目录，IAR开发工具可通过网络下载并安装。进入cortex-m4\_stm32f429ig\_fire-challenger\_iar/project目录，双击los\_demo.eww文件即可打开相应工程，编译成功后即可通过JLINK或者STM32 ST-LINK Utility烧录至对应单板。
+    - 野火挑战者STM32F429IGTb   https://gitee.com/harylee/stm32f429ig_firechallenger
+
+        该仓包含OpenHarmony LiteOS-M内核移植支持`野火挑战者STM32F429IGTb`开发板的工程代码，支持Ninja、GCC、IAR等方式进行编译。
 
 -   cortex-m7：
 
-kernel/liteos\_m/targets/cortex-m7\_nucleo\_f767zi\_gcc目录是基于STM32F767ZI芯片架构构建的Makefile工程目录。编译方式如下：
+    - Nucleo-F767ZI   https://gitee.com/harylee/nucleo_f767zi
 
-```
-cd kernel/liteos_m/targets/cortex-m7_nucleo_f767zi_gcc
-make clean; make
-```
-
-编译成功后在cortex-m7\_nucleo\_f767zi\_gcc/build目录下生成NUCLEO-F767.hex可执行文件，通过烧录工具STM32 ST-LINK Utility烧录到对应的单板。
-
-## 修改日志
-
-v1.0.1
-1. 删除以下KAL接口: `KalThreadGetInfo`,`KalDelayUs`,`KalTimerCreate`,`KalTimerStart`,`KalTimerChange`,`KalTimerStop`,`KalTimerDelete`,`KalTimerIsRunning`,`KalTickToMs`,`KalMsToTick`,`KalGetMemInfo`
-2. 添加部分POSIX接口
-
-v1.0
-1. 首次发布
+        该仓包含OpenHarmony LiteOS-M内核移植支持`Nucleo-F767ZI`开发板的工程代码，支持Ninja、GCC、IAR等方式进行编译。
 
 ## 相关仓<a name="section1371113476307"></a>
 
-[内核子系统](https://gitee.com/openharmony/docs/blob/master/zh-cn/readme/%E5%86%85%E6%A0%B8%E5%AD%90%E7%B3%BB%E7%BB%9F.md)
+[内核子系统](https://gitee.com/openharmony/docs/blob/HEAD/zh-cn/readme/%E5%86%85%E6%A0%B8%E5%AD%90%E7%B3%BB%E7%BB%9F.md)
 
 **kernel\_liteos\_m**
 

arch_spec.md

@@ -1,52 +1,77 @@
 ```
 .
-├── components                                                  --- 可选组件，可裁剪，依赖kernel
-│   ├── cppsupport                                              --- C++支持
-│   └── cpup                                                    --- CPUP功能
-├── kal                                                         --- 内核抽象层
-│   ├── cmsis                                                   --- cmsis标准支持
-│   └── posix                                                   --- posix标准支持
-├── kernel                                                      --- 内核最小功能集支持
-│   ├── arch                                                    --- 硬件架构相关
-│   │   ├── arm                                                 --- arm32架构
-│   │   │   └── cortex-m4                                       --- cortex-m4架构
-│   │   │       └── iar                                         ---
-│   │   │           ├── los_atomic.h
-│   │   │           ├── los_context.h
-│   │   │           ├── los_interrupt.h
-│   │   │           └── los_mpu.h
+├── components                                                  --- Components available for porting and header files exposed externally
+│   ├── backtrace                                               --- Backtrace
+│   ├── cppsupport                                              --- C++
+│   ├── cpup                                                    --- CPUP
+│   ├── dynlink                                                 --- Dynamic loader & linker
+│   ├── exchook                                                 --- Exception hook
+│   ├── fs                                                      --- File System
+│   └── net                                                     --- Network
+├── kal                                                         --- Kernel Abstraction Layer, APIs exposed externally, including CMSIS APIs and part of POSIX APIs
+│   ├── cmsis                                                   --- CMSIS
+│   └── posix                                                   --- POSIX
+├── kernel                                                      --- Code for defining the minimum kernel function set
+│   ├── arch                                                    --- Code of the kernel instruction architecture layer
+│   │   ├── arm                                                 --- ARM32 architecture
+│   │   │   ├── cortex-m3                                       --- Cortex-m3 architecture
+│   │   │   │   └── keil                                        --- Implementation of the Keil toolchain
+│   │   │   ├── cortex-m33                                      --- Cortex-m33 architecture
+│   │   │   │   │── gcc                                         --- Implementation of the GCC toolchain
+│   │   │   │   └── iar                                         --- Implementation of the IAR toolchain
+│   │   │   └── cortex-m4                                       --- Cortex-m4 architecture
+│   │   │   │   │── gcc                                         --- Implementation of the GCC toolchain
+│   │   │   │   └── iar                                         --- Implementation of the IAR toolchain
+│   │   │   └── cortex-m7                                       --- Cortex-m7 architecture
+│   │   │   │   │── gcc                                         --- Implementation of the GCC toolchain
+│   │   │   │   └── iar                                         --- Implementation of the IAR toolchain
+│   │   ├── risc-v                                              --- Risc-v architecture
+│   │   │   ├── nuclei                                          --- Nuclei architecture
+│   │   │   │   └── gcc                                         --- Implementation of the GCC toolchain
+│   │   │   └── riscv32                                         --- Riscv32 architecture
+│   │   │   │   └── gcc                                         --- Implementation of the GCC toolchain
 │   │   └── include
-│   │       ├── los_arch_atomic.h                               --- 定义通用arch的原子操作
-│   │       ├── los_arch_context.h                              --- 定义通用arch的上下文切换
-│   │       ├── los_arch.h                                      --- 定义通用arch初始化
-│   │       └── los_arch_interrupt.h                            --- 定义通用arch中断
+│   │       ├── los_arch.h                                      --- Arch initialization
+│   │       ├── los_atomic.h                                    --- Atomic operations
+│   │       ├── los_context.h                                   --- Context switch
+│   │       ├── los_interrupt.h                                 --- Interrupts
+│   │       ├── los_mpu.h                                       --- Memory protection unit operations
+│   │       └── los_timer.h                                     --- Timer operations
 │   ├── include
-│   │   ├── los_config.h                                        --- 功能开关和配置参数
-│   │   ├── los_event.h                                         --- 事件
-│   │   ├── los_liteos.h                                        --- liteos最小功能集对外提供的头文件
-│   │   ├── los_memory.h                                        --- 堆内存管理
-│   │   ├── los_mutex.h                                         --- 互斥锁
-│   │   ├── los_queue.h                                         --- 队列
-│   │   ├── los_scheduler.h                                     --- 调度算法
-│   │   ├── los_sem.h                                           --- 信号量
-│   │   ├── los_task.h                                          --- 任务
-│   │   └── los_timer.h                                         --- 定时器
+│   │   ├── los_config.h                                        --- Configuration parameters
+│   │   ├── los_event.h                                         --- Events management
+│   │   ├── los_membox.h                                        --- Membox management
+│   │   ├── los_memory.h                                        --- Heap memory management
+│   │   ├── los_mux.h                                           --- Mutex
+│   │   ├── los_queue.h                                         --- Queue
+│   │   ├── los_sched.h                                         --- Scheduler
+│   │   ├── los_sem.h                                           --- Semaphores
+│   │   ├── los_sortlink.h                                      --- Sort link
+│   │   ├── los_swtmr.h                                         --- Timer
+│   │   ├── los_task.h                                          --- Tasks
+│   │   └── los_tick.h                                          --- Tick
 │   └── src
 ├── targets
 │   └── targets
-│       └── cortex-m4_stm32f429ig_fire-challenger_iar
-│           ├── board
-│           ├── dprintf.c
-│           ├── Libraries
-│           ├── main.c
-│           ├── project
-│           ├── target_config.h                                 --- 板级配置功能开关和配置参数
-│           └── Utilities
+│       └── riscv_nuclei_demo_soc_gcc
+│       │   ├── GCC                                            --- Compilation config
+│       │   ├── OS_CONFIG                                      --- Board config
+│       │   ├── SoC                                            --- SOC codes
+│       │   └── Src                                            --- Application codes
+│       └── riscv_nuclei_gd32vf103_soc_gcc
+│       └── riscv_sifive_fe310_gcc
 └── utils
-    ├── include
-    │   ├── los_compiler.h                                      --- 编译工具配置，类型定义
-    │   ├── los_debug.h                                         --- debug，printf相关
-    │   ├── los_error.h                                         --- 错误定义
-    │   └── los_list.h
+    ├── internal
+    ├── BUILD.gn                                               --- Gn build config file
+    ├── los_compiler.h                                         --- Compiler configuration
+    ├── los_debug.c                                            --- Debugging facilities
+    ├── los_debug.h
+    ├── los_error.c                                            --- Errors codes and definitions
+    ├── los_error.h
+    ├── los_hook.c                                             --- Hook function facilities
+    ├── los_hook.h
+    ├── los_list.h                                             --- Doubly linked list
+    └── los_reg.h                                              --- Register macros
     └── src
 ```
+

arch_spec_zh.md

@@ -0,0 +1,77 @@
+```
+.
+├── components                                                  --- 移植可选组件，依赖内核，单独对外提供头文件
+│   ├── backtrace                                               --- 回溯栈支持
+│   ├── cppsupport                                              --- C++支持
+│   ├── cpup                                                    --- CPUP功能
+│   ├── dynlink                                                 --- 动态加载与链接
+│   ├── exchook                                                 --- 异常钩子
+│   ├── fs                                                      --- 文件系统
+│   └── net                                                     --- 网络功能
+├── kal                                                         --- 内核抽象层，提供内核对外接口，当前支持CMSIS接口和部分POSIX接口
+│   ├── cmsis                                                   --- CMSIS标准支持
+│   └── posix                                                   --- POSIX标准支持
+├── kernel                                                      --- 内核最小功能集代码
+│   ├── arch                                                    --- 内核指令架构层代码
+│   │   ├── arm                                                 --- ARM32架构
+│   │   │   ├── cortex-m3                                       --- Cortex-m3架构
+│   │   │   │   └── keil                                        --- Keil编译工具链实现
+│   │   │   ├── cortex-m33                                      --- Cortex-m33架构
+│   │   │   │   │── gcc                                         --- GCC编译工具链实现
+│   │   │   │   └── iar                                         --- IAR编译工具链实现
+│   │   │   └── cortex-m4                                       --- Cortex-m4架构
+│   │   │   │   │── gcc                                         --- GCC编译工具链实现
+│   │   │   │   └── iar                                         --- IAR编译工具链实现
+│   │   │   └── cortex-m7                                       --- Cortex-m7架构
+│   │   │   │   │── gcc                                         --- GCC编译工具链实现
+│   │   │   │   └── iar                                         --- IAR编译工具链实现
+│   │   ├── risc-v                                              --- Risc-v架构
+│   │   │   ├── nuclei                                          --- Nuclei架构
+│   │   │   │   └── gcc                                         --- GCC编译工具链实现
+│   │   │   └── riscv32                                         --- Riscv32架构
+│   │   │   │   └── gcc                                         --- GCC编译工具链实现
+│   │   └── include
+│   │       ├── los_arch.h                                      --- 定义arch初始化
+│   │       ├── los_atomic.h                                    --- 定义通用arch原子操作
+│   │       ├── los_context.h                                   --- 定义通用arch上下文切换
+│   │       ├── los_interrupt.h                                 --- 定义通用arch中断
+│   │       ├── los_mpu.h                                       --- 定义通用arch内存保护
+│   │       └── los_timer.h                                     --- 定义通用arch定时器
+│   ├── include
+│   │   ├── los_config.h                                        --- 功能开关和配置参数
+│   │   ├── los_event.h                                         --- 事件
+│   │   ├── los_membox.h                                        --- 静态内存管理
+│   │   ├── los_memory.h                                        --- 动态内存管理
+│   │   ├── los_mux.h                                           --- 互斥锁
+│   │   ├── los_queue.h                                         --- 队列
+│   │   ├── los_sched.h                                         --- 调度算法
+│   │   ├── los_sem.h                                           --- 信号量
+│   │   ├── los_sortlink.h                                      --- 排序链表
+│   │   ├── los_swtmr.h                                         --- 定时器
+│   │   ├── los_task.h                                          --- 任务
+│   │   └── los_tick.h                                          --- Tick时钟
+   └── src
+├── targets
+│   └── targets
+│       └── riscv_nuclei_demo_soc_gcc
+│       │   ├── GCC                                             --- 编译相关
+│       │   ├── OS_CONFIG                                       --- 开发板配置功能开关和配置参数
+│       │   ├── SoC                                             --- SOC相关代码
+│       │   └── Src                                             --- Application相关代码
+│       └── riscv_nuclei_gd32vf103_soc_gcc
+│       └── riscv_sifive_fe310_gcc
+└── utils
+    ├── internal
+    ├── BUILD.gn                                                --- Gn构建文件
+    ├── los_compiler.h                                          --- 编译工具配置，类型定义
+    ├── los_debug.c                                             --- Debug，printf相关
+    ├── los_debug.h
+    ├── los_error.c                                             --- 错误处理
+    ├── los_error.h
+    ├── los_hook.c                                              --- 钩子函数注册和调用
+    ├── los_hook.h
+    ├── los_list.h                                              --- 双向链表
+    └── los_reg.h                                               --- 寄存器读写宏定义
+    └── src
+```
+

bundle.json

@@ -0,0 +1,59 @@
+{
+    "name": "@ohos/kernel_liteos_m",
+    "version": "",
+    "description": "liteos-m内核",
+    "homePage": "https://gitee.com/openharmony",
+    "license": "BSD 3-clause",
+    "repository": "https://gitee.com/openharmony/kernel_liteos_m",
+    "domain": "os",
+    "language": "",
+    "publishAs": "code-segment",
+    "private": false,
+    "scripts": {},
+    "tags": [
+        "kernel"
+    ],
+    "keywords": [
+        "kernel",
+        "liteos-m"
+    ],
+    "envs": [],
+    "dirs": [],
+    "author": {
+        "name": "",
+        "email": "",
+        "url": ""
+    },
+    "contributors": [
+        {
+            "name": "",
+            "email": "",
+            "url": ""
+        }
+    ],
+    "segment": {
+        "destPath": "kernel/liteos_m"
+    },
+    "component": {
+        "name": "liteos-m",
+        "subsystem": "liteos_m",
+        "syscap": [
+            "SystemCapability.Kernel.liteos-m"
+        ],
+        "features": [],
+        "adapted_system_type": [
+            "mini"
+        ],
+        "rom": "",
+        "ram": "",
+        "deps": {
+            "components": [],
+            "third_party": []
+        },
+        "build": {
+            "sub_component": [],
+            "inner_kits": [],
+            "test": []
+        }
+    }
+}

components/backtrace/BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -27,14 +27,10 @@
 # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import("//kernel/liteos_m/config.gni")
+
 static_library("backtrace") {
   sources = [ "los_backtrace.c" ]
 
-  include_dirs = [
-    "../../kernel/include",
-    "../../kernel/arch/include",
-    "../../utils",
-    "./",
-    "//third_party/bounds_checking_function/include",
-  ]
+  configs += [ "$LITEOSTOPDIR:los_config" ]
 }

components/backtrace/los_backtrace.c

@@ -33,13 +33,19 @@
 #include "los_task.h"
 #include "los_debug.h"
 
-#ifdef __cplusplus
-#if __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-#endif /* __cplusplus */
-
 #if (LOSCFG_BACKTRACE_TYPE != 0)
+/* This function is used to judge whether the data in the stack is a code section address.
+   The default code section is only one, but there may be more than one. Modify the
+   judgment condition to support multiple code sections. */
+WEAK BOOL OsStackDataIsCodeAddr(UINTPTR value)
+{
+    if ((value >= CODE_START_ADDR) && (value < CODE_END_ADDR)) {
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
 #if (LOSCFG_BACKTRACE_TYPE == 1)
 #define OS_BACKTRACE_START     2
 /* Thumb instruction, so the pc must be an odd number */
@@ -117,7 +123,7 @@ STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINT
 {
     if (SP != 0) {
         *stackStart = SP;
-        if ((SP >= CODE_START_ADDR) && (SP < CSTACK_END_ADDR)) {
+        if ((SP >= CSTACK_START_ADDR) && (SP < CSTACK_END_ADDR)) {
             *stackEnd = CSTACK_END_ADDR;
         } else {
             UINT32 taskID = LOS_CurTaskIDGet();
@@ -125,7 +131,7 @@ STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINT
             *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize;
             if ((SP < (UINTPTR)taskCB->topOfStack) || (SP >= *stackEnd)) {
                 PRINT_ERR("msp statck [0x%x, 0x%x], cur task stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n",
-                          CODE_START_ADDR, CSTACK_END_ADDR, (UINTPTR)taskCB->topOfStack, *stackEnd, SP);
+                          CSTACK_START_ADDR, CSTACK_END_ADDR, (UINTPTR)taskCB->topOfStack, *stackEnd, SP);
                 return LOS_NOK;
             }
         }
@@ -133,9 +139,9 @@ STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINT
         if (HalSpGet() != HalPspGet()) {
             *stackStart = HalMspGet();
             *stackEnd = CSTACK_END_ADDR;
-            if ((*stackStart < CODE_START_ADDR) || (*stackStart >= CSTACK_END_ADDR)) {
+            if ((*stackStart < CSTACK_START_ADDR) || (*stackStart >= CSTACK_END_ADDR)) {
                 PRINT_ERR("msp stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n",
-                          CODE_START_ADDR, CSTACK_END_ADDR, *stackStart);
+                          CSTACK_START_ADDR, CSTACK_END_ADDR, *stackStart);
                 return LOS_NOK;
             }
             PRINTK("msp, start = %x, end = %x\n", *stackStart, *stackEnd);
@@ -145,7 +151,7 @@ STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINT
             LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
             *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize;
             if ((*stackStart < (UINTPTR)taskCB->topOfStack) || (*stackStart >= *stackEnd)) {
-                PRINT_ERR("psp stack [0x%x, 0x%x], cur sp(0x%x) is overflow, cur task id is %d!\n",
+                PRINT_ERR("psp stack [0x%x, 0x%x], cur sp(0x%x) is overflow, cur task id is %u!\n",
                           taskCB->topOfStack, *stackEnd, *stackStart, taskID);
                 return LOS_NOK;
             }
@@ -184,7 +190,172 @@ STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp)
 
     return pc;
 }
+#elif (LOSCFG_BACKTRACE_TYPE == 2)
+STATIC INLINE BOOL OsBackTraceFpCheck(UINT32 value);
+#define OS_BACKTRACE_START     1
+#define OS_RA_OFFSET           4
+#define OS_FP_OFFSET           8
+#define OS_FP_ALIGN(value)     (((UINT32)(value) & (UINT32)(LOSCFG_STACK_POINT_ALIGN_SIZE - 1)) == 0)
+#define OS_FP_CHECK(value)     (((UINT32)(value) != FP_INIT_VALUE) && OS_FP_ALIGN(value))
 
+STATIC INLINE UINTPTR OsFpGet(VOID)
+{
+    UINTPTR fp = 0;
+    __asm volatile("mv %0, s0" : "=r"(fp));
+    dsb();
+    return fp;
+}
+
+VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
+{
+    UNUSED(SP);
+    UINT32 backFp = OsFpGet();
+    UINT32 tmpFp;
+    UINT32 backRa;
+    UINT32 count = 0;
+    UINT32 index = 0;
+
+    if (LR == NULL) {
+        return;
+    }
+
+    while (OS_FP_CHECK(backFp)) {
+        tmpFp = backFp;
+        backRa = *((UINT32 *)(UINTPTR)(tmpFp - OS_RA_OFFSET));
+        backFp = *((UINT32 *)(UINTPTR)(tmpFp - OS_FP_OFFSET));
+        if (index++ < jumpCount) {
+            continue;
+        }
+
+        LR[count] = backRa;
+        count++;
+        if ((count == LRSize) || (backFp == tmpFp) ||
+            (!OsStackDataIsCodeAddr(backRa))) {
+            break;
+        }
+    }
+
+    if (count < LRSize) {
+        LR[count] = 0;
+    }
+}
+#elif (LOSCFG_BACKTRACE_TYPE == 3)
+#define OS_BACKTRACE_START  1
+#define OS_JALX_INS_MASK    0x7F
+#define OS_JAL_INS_LOW      0x6F
+#define OS_JAL_16_INS_MASK  0x2001
+#define OS_JALR_INS_LOW     0x67
+#define OS_JALR_16_INS_MASK 0x9002
+#define OS_JR_16_INS_MASK   0x8002
+#define OS_J_16_INS_MASK    0xA001
+
+STATIC INLINE BOOL OsInsIsJump(UINTPTR addr)
+{
+    UINT16 ins1 = *((UINT16 *)addr);
+    UINT16 ins2 = *((UINT16 *)(addr + 2)); // 2, for the mask
+
+    /* Jal ins */
+    if (((ins1 & OS_JALX_INS_MASK) == OS_JAL_INS_LOW) ||
+        ((ins1 & OS_JAL_16_INS_MASK) == OS_JAL_16_INS_MASK) ||
+        ((ins2 & OS_JAL_16_INS_MASK) == OS_JAL_16_INS_MASK)) {
+        return TRUE;
+    }
+
+    /* Jalr ins */
+    if (((ins1 & OS_JALX_INS_MASK) == OS_JALR_INS_LOW) ||
+        ((ins1 & OS_JALR_16_INS_MASK) == OS_JALR_16_INS_MASK) ||
+        ((ins2 & OS_JALR_16_INS_MASK) == OS_JALR_16_INS_MASK)) {
+        return TRUE;
+    }
+
+    /* Jr ins */
+    if (((ins1 & OS_JR_16_INS_MASK) == OS_JR_16_INS_MASK) ||
+        ((ins2 & OS_JR_16_INS_MASK) == OS_JR_16_INS_MASK)) {
+        return TRUE;
+    }
+
+    /* J ins */
+    if (((ins1 & OS_J_16_INS_MASK) == OS_J_16_INS_MASK) ||
+        ((ins2 & OS_J_16_INS_MASK) == OS_J_16_INS_MASK)) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+STATIC INLINE UINTPTR OsSpGet(VOID)
+{
+    UINTPTR sp = 0;
+    __asm volatile("mv %0, sp" : "=r"(sp));
+    dsb();
+    return sp;
+}
+
+STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINTPTR SP)
+{
+    if (SP != 0) {
+        *stackStart = SP;
+        if ((SP >= CSTACK_START_ADDR) && (SP < CSTACK_END_ADDR)) {
+            *stackEnd = CSTACK_END_ADDR;
+        } else {
+            UINT32 taskID = LOS_CurTaskIDGet();
+            LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+            *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize;
+            if ((SP < (UINTPTR)taskCB->topOfStack) || (SP >= *stackEnd)) {
+                PRINT_ERR("msp statck [0x%x, 0x%x], cur task stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n",
+                          CSTACK_START_ADDR, CSTACK_END_ADDR, (UINTPTR)taskCB->topOfStack, *stackEnd, SP);
+                return LOS_NOK;
+            }
+        }
+    } else {
+        if (!LOS_TaskIsRunning()) {
+            *stackStart = OsSpGet();
+            *stackEnd = CSTACK_END_ADDR;
+            if ((*stackStart < CSTACK_START_ADDR) || (*stackStart >= CSTACK_END_ADDR)) {
+                PRINT_ERR("msp stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n",
+                          CSTACK_START_ADDR, CSTACK_END_ADDR, *stackStart);
+                return LOS_NOK;
+            }
+        } else {
+            *stackStart = OsSpGet();
+            UINT32 taskID = LOS_CurTaskIDGet();
+            LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
+            *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize;
+            if ((*stackStart < (UINTPTR)taskCB->topOfStack) || (*stackStart >= *stackEnd)) {
+                PRINT_ERR("psp stack [0x%x, 0x%x], cur sp(0x%x) is overflow, cur task id is %d!\n",
+                          taskCB->topOfStack, *stackEnd, *stackStart, taskID);
+                return LOS_NOK;
+            }
+        }
+    }
+
+    return LOS_OK;
+}
+
+STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp)
+{
+    UINTPTR pc;
+    BOOL ret;
+
+    pc = *((UINTPTR *)sp);
+
+    ret = OsStackDataIsCodeAddr(pc);
+    if (ret == FALSE) {
+        return 0;
+    }
+
+    ret = OsInsIsJump(pc - sizeof(UINTPTR));
+    if (ret == FALSE) {
+        return 0;
+    }
+
+    return pc;
+}
+#else
+#error Unknown backtrace type.
+#endif
+
+#if (LOSCFG_BACKTRACE_TYPE == 1) || (LOSCFG_BACKTRACE_TYPE == 3)
 VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
 {
     if (LR == NULL) {
@@ -223,57 +394,6 @@ VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
         LR[count] = 0;
     }
 }
-#elif (LOSCFG_BACKTRACE_TYPE == 2)
-STATIC INLINE BOOL OsBackTraceFpCheck(UINT32 value);
-#define OS_BACKTRACE_START     1
-#define OS_RA_OFFSET           4
-#define OS_FP_OFFSET           8
-#define OS_FP_ALIGN(value)     (((UINT32)(value) & (UINT32)(LOSCFG_STACK_POINT_ALIGN_SIZE - 1)) == 0)
-#define OS_FP_CHECK(value)     (((UINT32)(value) != FP_INIT_VALUE) && OS_FP_ALIGN(value))
-
-STATIC INLINE UINTPTR OsFpGet(VOID)
-{
-    UINTPTR fp = 0;
-    __asm volatile("mv %0, s0" : "=r"(fp));
-    dsb();
-    return fp;
-}
-
-VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
-{
-    UNUSED(SP);
-    UINT32 backFp = OsFpGet();
-    UINT32 tmpFp;
-    UINT32 backRa;
-    UINT32 count = 0;
-    UINT32 index = 0;
-
-    if (LR == NULL) {
-        return;
-    }
-
-    while (OS_FP_CHECK(backFp)) {
-        tmpFp = backFp;
-        backRa = *((UINT32 *)(UINTPTR)(tmpFp - OS_RA_OFFSET));
-        backFp = *((UINT32 *)(UINTPTR)(tmpFp - OS_FP_OFFSET));
-        if (index++ < jumpCount) {
-            continue;
-        }
-
-        LR[count] = backRa;
-        count++;
-        if ((count == LRSize) || (backFp == tmpFp) ||
-            (!OsStackDataIsCodeAddr(backRa))) {
-            break;
-        }
-    }
-
-    if (count < LRSize) {
-        LR[count] = 0;
-    }
-}
-#else
-#error Unknown backtrace type.
 #endif
 
 VOID LOS_BackTrace(VOID)
@@ -293,20 +413,15 @@ VOID LOS_BackTrace(VOID)
         if (LR[index] == 0) {
             break;
         }
-        PRINTK("traceback %d -- lr = 0x%x\r\n", index, LR[index]);
+        PRINTK("traceback %u -- lr = 0x%x\r\n", index, LR[index]);
     }
     PRINTK("----- traceback end -----\r\n");
 }
 
-VOID LOS_BackTraceInit(VOID)
+VOID OSBackTraceInit(VOID)
 {
     OsBackTraceHookSet(LOS_RecordLR);
 }
 #endif
 
-#ifdef __cplusplus
-#if __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* __cplusplus */
 

components/backtrace/los_backtrace.h

@@ -46,7 +46,7 @@ extern "C" {
 #if (LOSCFG_BACKTRACE_TYPE != 0)
 #if (LOSCFG_BACKTRACE_TYPE == 1)
 /* The default name of the code section and CSTACK section are given below,
-   and the user can be adjust it according to the linker script file. */
+   and the user can adjust it according to the linker script file. */
 #if defined(__ICCARM__)
 /* The default code section name is .text */
 #define CODE_SECTION_NAME    ".text"
@@ -56,7 +56,7 @@ extern "C" {
 #pragma section=CSTACK_SECTION_NAME
 
 /* Default only one code section. In fact, there may be more than one.
-   You can define more than one and modify the OsStackDataIsCodeAddr function
+   You can define more than one and redefine the OsStackDataIsCodeAddr function
    to support searching in multiple code sections */
 #define CODE_START_ADDR     ((UINTPTR)__section_begin(CODE_SECTION_NAME))
 #define CODE_END_ADDR       ((UINTPTR)__section_end(CODE_SECTION_NAME))
@@ -84,16 +84,16 @@ extern CHAR *CODE_SECTION_START(CODE_SECTION_NAME);
 extern CHAR *CODE_SECTION_END(CODE_SECTION_NAME);
 
 /* Default only one code section. In fact, there may be more than one.
-   You can define more than one and modify the OsStackDataIsCodeAddr function
+   You can define more than one and redefine the OsStackDataIsCodeAddr function
    to support searching in multiple code sections */
 #define CODE_START_ADDR     ((UINTPTR)&CODE_SECTION_START(CODE_SECTION_NAME))
 #define CODE_END_ADDR       ((UINTPTR)&CODE_SECTION_END(CODE_SECTION_NAME))
 #define CSTACK_START_ADDR   ((UINTPTR)&CSTACK_SECTION_START(CSTACK_SECTION_NAME))
 #define CSTACK_END_ADDR     ((UINTPTR)&CSTACK_SECTION_END(CSTACK_SECTION_NAME))
 #elif defined(__GNUC__)
-/* The defalut code section start address */
+/* The default code section start address */
 #define CODE_SECTION_START      _stext
-/* The defalut code section end address */
+/* The default code section end address */
 #define CODE_SECTION_END        _etext
 /* The default C stack section start address */
 #define CSTACK_SECTION_START    _sstack
@@ -106,7 +106,7 @@ extern CHAR *CSTACK_SECTION_START;
 extern CHAR *CSTACK_SECTION_END;
 
 /* Default only one code section. In fact, there may be more than one.
-   You can define more than one and modify the OsStackDataIsCodeAddr function
+   You can define more than one and redefine the OsStackDataIsCodeAddr function
    to support searching in multiple code sections */
 #define CODE_START_ADDR     ((UINTPTR)&CODE_SECTION_START)
 #define CODE_END_ADDR       ((UINTPTR)&CODE_SECTION_END)
@@ -115,37 +115,34 @@ extern CHAR *CSTACK_SECTION_END;
 #else
 #error Unknown compiler.
 #endif
-#elif (LOSCFG_BACKTRACE_TYPE == 2)
+#elif (LOSCFG_BACKTRACE_TYPE == 2) || (LOSCFG_BACKTRACE_TYPE == 3)
 #if defined(__GNUC__)
-/* The defalut code section start address */
+/* The default code section start address */
 #define CODE_SECTION_START      __text_start
-/* The defalut code section end address */
+/* The default code section end address */
 #define CODE_SECTION_END        __text_end
+/* The default C stack section start address */
+#define CSTACK_SECTION_START    __except_stack_top
+/* The default C stack section end address */
+#define CSTACK_SECTION_END      __start_and_irq_stack_top
 
 extern CHAR *CODE_SECTION_START;
 extern CHAR *CODE_SECTION_END;
+extern CHAR *CSTACK_SECTION_START;
+extern CHAR *CSTACK_SECTION_END;
 
-#define CODE_START_ADDR         ((UINTPTR)&CODE_SECTION_START)
-#define CODE_END_ADDR           ((UINTPTR)&CODE_SECTION_END)
+#define CODE_START_ADDR     ((UINTPTR)&CODE_SECTION_START)
+#define CODE_END_ADDR       ((UINTPTR)&CODE_SECTION_END)
+#define CSTACK_START_ADDR   ((UINTPTR)&CSTACK_SECTION_START)
+#define CSTACK_END_ADDR     ((UINTPTR)&CSTACK_SECTION_END)
 #else
 #error Unknown compiler.
 #endif
 #endif
 
-/* This function is used to judge whether the data in the stack is a code section address.
-   The default code section is only one, but there may be more than one. Modify the
-   judgment condition to support multiple code sections. */
-STATIC INLINE BOOL OsStackDataIsCodeAddr(UINTPTR value)
-{
-    if ((value >= CODE_START_ADDR) && (value < CODE_END_ADDR)) {
-        return TRUE;
-    }
-    return FALSE;
-}
-
 /* This function is currently used to register the memory leak check hook,
    other uses do not need to be called temporarily. */
-VOID LOS_BackTraceInit(VOID);
+VOID OSBackTraceInit(VOID);
 
 /* This function is used to print the function call stack. */
 VOID LOS_BackTrace(VOID);

components/bounds_checking_function/BUILD.gn

@@ -1,74 +0,0 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-#
-# 1. Redistributions of source code must retain the above copyright notice, this list of
-#    conditions and the following disclaimer.
-#
-# 2. Redistributions in binary form must reproduce the above copyright notice, this list
-#    of conditions and the following disclaimer in the documentation and/or other materials
-#    provided with the distribution.
-#
-# 3. Neither the name of the copyright holder nor the names of its contributors may be used
-#    to endorse or promote products derived from this software without specific prior written
-#    permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-static_library("sec") {
-  include_dirs = [ "//third_party/bounds_checking_function/include" ]
-
-  sources = [
-    "//third_party/bounds_checking_function/src/fscanf_s.c",
-    "//third_party/bounds_checking_function/src/fwscanf_s.c",
-    "//third_party/bounds_checking_function/src/gets_s.c",
-    "//third_party/bounds_checking_function/src/memcpy_s.c",
-    "//third_party/bounds_checking_function/src/memmove_s.c",
-    "//third_party/bounds_checking_function/src/memset_s.c",
-    "//third_party/bounds_checking_function/src/scanf_s.c",
-    "//third_party/bounds_checking_function/src/securecutil.c",
-    "//third_party/bounds_checking_function/src/secureinput_a.c",
-    "//third_party/bounds_checking_function/src/secureinput_w.c",
-    "//third_party/bounds_checking_function/src/secureprintoutput_a.c",
-    "//third_party/bounds_checking_function/src/secureprintoutput_w.c",
-    "//third_party/bounds_checking_function/src/snprintf_s.c",
-    "//third_party/bounds_checking_function/src/sprintf_s.c",
-    "//third_party/bounds_checking_function/src/sscanf_s.c",
-    "//third_party/bounds_checking_function/src/strcat_s.c",
-    "//third_party/bounds_checking_function/src/strcpy_s.c",
-    "//third_party/bounds_checking_function/src/strncat_s.c",
-    "//third_party/bounds_checking_function/src/strncpy_s.c",
-    "//third_party/bounds_checking_function/src/strtok_s.c",
-    "//third_party/bounds_checking_function/src/swprintf_s.c",
-    "//third_party/bounds_checking_function/src/swscanf_s.c",
-    "//third_party/bounds_checking_function/src/vfscanf_s.c",
-    "//third_party/bounds_checking_function/src/vfwscanf_s.c",
-    "//third_party/bounds_checking_function/src/vscanf_s.c",
-    "//third_party/bounds_checking_function/src/vsnprintf_s.c",
-    "//third_party/bounds_checking_function/src/vsprintf_s.c",
-    "//third_party/bounds_checking_function/src/vsscanf_s.c",
-    "//third_party/bounds_checking_function/src/vswprintf_s.c",
-    "//third_party/bounds_checking_function/src/vswscanf_s.c",
-    "//third_party/bounds_checking_function/src/vwscanf_s.c",
-    "//third_party/bounds_checking_function/src/wcscat_s.c",
-    "//third_party/bounds_checking_function/src/wcscpy_s.c",
-    "//third_party/bounds_checking_function/src/wcsncat_s.c",
-    "//third_party/bounds_checking_function/src/wcsncpy_s.c",
-    "//third_party/bounds_checking_function/src/wcstok_s.c",
-    "//third_party/bounds_checking_function/src/wmemcpy_s.c",
-    "//third_party/bounds_checking_function/src/wmemmove_s.c",
-    "//third_party/bounds_checking_function/src/wscanf_s.c",
-  ]
-}

components/bounds_checking_function/COPYRIGHT.OpenSource

@@ -1 +0,0 @@
-Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.

components/bounds_checking_function/LICENSE

@@ -1,124 +0,0 @@
-木兰宽松许可证， 第2版
-
-2020年1月 http://license.coscl.org.cn/MulanPSL2
-
-您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
-
-0.   定义
-
-“软件” 是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
-
-“贡献” 是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
-
-“贡献者” 是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
-
-“法人实体” 是指提交贡献的机构及其“关联实体”。
-
-“关联实体” 是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
-
-1.   授予版权许可
-
-每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
-
-2.   授予专利许可
-
-每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
-
-3.   无商标许可
-
-“本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
-
-4.   分发限制
-
-您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
-
-5.   免责声明与责任限制
-
-“软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。
-
-6.   语言
-
-“本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
-
-条款结束
-
-如何将木兰宽松许可证，第2版，应用到您的软件
-
-如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
-
-1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
-
-2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
-
-3， 请将如下声明文本放入每个源文件的头部注释中。
-
-Copyright (c) [Year] [name of copyright holder]
-[Software Name] is licensed under Mulan PSL v2.
-You can use this software according to the terms and conditions of the Mulan PSL v2.
-You may obtain a copy of Mulan PSL v2 at:
-         http://license.coscl.org.cn/MulanPSL2
-THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
-EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
-MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
-See the Mulan PSL v2 for more details.
-Mulan Permissive Software License,Version 2
-Mulan Permissive Software License,Version 2 (Mulan PSL v2)
-
-January 2020 http://license.coscl.org.cn/MulanPSL2
-
-Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions:
-
-0. Definition
-
-Software means the program and related documents which are licensed under this License and comprise all Contribution(s).
-
-Contribution means the copyrightable work licensed by a particular Contributor under this License.
-
-Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
-
-Legal Entity means the entity making a Contribution and all its Affiliates.
-
-Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, 'control' means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
-
-1. Grant of Copyright License
-
-Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
-
-2. Grant of Patent License
-
-Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
-
-3. No Trademark License
-
-No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in section 4.
-
-4. Distribution Restriction
-
-You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
-
-5. Disclaimer of Warranty and Limitation of Liability
-
-THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT'S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-6. Language
-
-THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
-
-END OF THE TERMS AND CONDITIONS
-
-How to Apply the Mulan Permissive Software License,Version 2 (Mulan PSL v2) to Your Software
-
-To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
-
-Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;
-Create a file named "LICENSE" which contains the whole context of this License in the first directory of your software package;
-Attach the statement to the appropriate annotated syntax at the beginning of each source file.
-Copyright (c) [Year] [name of copyright holder]
-[Software Name] is licensed under Mulan PSL v2.
-You can use this software according to the terms and conditions of the Mulan PSL v2.
-You may obtain a copy of Mulan PSL v2 at:
-         http://license.coscl.org.cn/MulanPSL2
-THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
-EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
-MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
-See the Mulan PSL v2 for more details.

components/bounds_checking_function/README.OpenSource

@@ -1,13 +0,0 @@
-[
-    {
-        "Name"                  : "bounds_checking_function",
-        "License"               : "Mulan Permissive Software License，Version 2",
-        "License File"          : "LICENSE",
-        "Version Number"        : "v1.1.10",
-        "Owner"                 : "jianghan2@huawei.com",
-        "PDM Number"            : "05835DMT",
-        "Upstream URL"          : "https://gitee.com/openeuler/bounds_checking_function",
-        "Use Application URL"   : "http://pdm.huawei.com/Windchill/hwdispatcher/iris/?status=view&pboid=OR:ext.huawei.huaweipbo.HuaweiPBO:70160914898&virtualid=basicinfo&lang=en",
-        "Description"           : "following the standard of C11 Annex K (bound-checking interfaces), functions of the common memory/string operation classes, such as memcpy_s, strcpy_s, are selected and implemented."
-    }
-]

components/bounds_checking_function/README.en.md

@@ -1,9 +0,0 @@
-# bounds_checking_function
-
-#### Description
-
-- following the standard of C11 Annex K (bound-checking interfaces), functions of the common memory/string operation classes, such as memcpy_s, strcpy_s, are selected and implemented.
-
-- other standard functions in C11 Annex K will be analyzed in the future and implemented in this organization if necessary.
-
-- handles the release, update, and maintenance of bounds_checking_function.

components/bounds_checking_function/README.md

@@ -1,6 +0,0 @@
-# bounds_checking_function
-
-#### 介绍
-- 遵循C11 Annex K (Bounds-checking interfaces)的标准，选取并实现了常见的内存/字符串操作类的函数，如memcpy_s、strcpy_s等函数。
-- 未来将分析C11 Annex K中的其他标准函数，如果有必要，将在该组织中实现。
-- 处理边界检查函数的版本发布、更新以及维护。

components/bounds_checking_function/include/securec.h

@@ -1,623 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: The user of this secure c library should include this header file in you source code.
- *              This header file declare all supported API prototype of the library,
- *              such as memcpy_s, strcpy_s, wcscpy_s,strcat_s, strncat_s, sprintf_s, scanf_s, and so on.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECUREC_H_5D13A042_DC3F_4ED9_A8D1_882811274C27
-#define SECUREC_H_5D13A042_DC3F_4ED9_A8D1_882811274C27
-
-#include "securectype.h"
-#ifndef SECUREC_HAVE_STDARG_H
-#define SECUREC_HAVE_STDARG_H 1
-#endif
-
-#if SECUREC_HAVE_STDARG_H
-#include <stdarg.h>
-#endif
-
-#ifndef SECUREC_HAVE_ERRNO_H
-#define SECUREC_HAVE_ERRNO_H 1
-#endif
-
-/* EINVAL ERANGE may defined in errno.h */
-#if SECUREC_HAVE_ERRNO_H
-#if SECUREC_IN_KERNEL
-#include <linux/errno.h>
-#else
-#include <errno.h>
-#endif
-#endif
-
-/* Define error code */
-#if defined(SECUREC_NEED_ERRNO_TYPE) || !defined(__STDC_WANT_LIB_EXT1__) || \
-    (defined(__STDC_WANT_LIB_EXT1__) && (!__STDC_WANT_LIB_EXT1__))
-#ifndef SECUREC_DEFINED_ERRNO_TYPE
-#define SECUREC_DEFINED_ERRNO_TYPE
-/* Just check whether macrodefinition exists. */
-#ifndef errno_t
-typedef int errno_t;
-#endif
-#endif
-#endif
-
-/* Success */
-#ifndef EOK
-#define EOK 0
-#endif
-
-#ifndef EINVAL
-/* The src buffer is not correct and destination buffer cant not be reset */
-#define EINVAL 22
-#endif
-
-#ifndef EINVAL_AND_RESET
-/* Once the error is detected, the dest buffer must be reseted! Value is 22 or 128 */
-#define EINVAL_AND_RESET 150
-#endif
-
-#ifndef ERANGE
-/* The destination buffer is not long enough and destination buffer can not be reset */
-#define ERANGE 34
-#endif
-
-#ifndef ERANGE_AND_RESET
-/* Once the error is detected, the dest buffer must be reseted! Value is 34 or 128 */
-#define ERANGE_AND_RESET  162
-#endif
-
-#ifndef EOVERLAP_AND_RESET
-/* Once the buffer overlap is detected, the dest buffer must be reseted! Value is 54 or 128 */
-#define EOVERLAP_AND_RESET 182
-#endif
-
-/* If you need export the function of this library in Win32 dll, use __declspec(dllexport) */
-#ifndef SECUREC_API
-#if defined(SECUREC_DLL_EXPORT)
-#define SECUREC_API __declspec(dllexport)
-#elif defined(SECUREC_DLL_IMPORT)
-#define SECUREC_API __declspec(dllimport)
-#else
-/*
- * Standardized function declaration. If a security function is declared in the your code,
- * it may cause a compilation alarm,Please delete the security function you declared.
- * Adding extern under windows will cause the system to have inline functions to expand,
- * so do not add the extern in default
- */
-#if defined(_MSC_VER)
-#define SECUREC_API
-#else
-#define SECUREC_API extern
-#endif
-#endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#if SECUREC_ENABLE_MEMSET
-    /*
-     * Description: The memset_s function copies the value of c (converted to an unsigned char) into each of
-     * the first count characters of the object pointed to by dest.
-     * Parameter: dest - destination address
-     * Parameter: destMax - The maximum length of destination buffer
-     * Parameter: c - the value to be copied
-     * Parameter: count - copies count bytes of value to dest
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t memset_s(void *dest, size_t destMax, int c, size_t count);
-#endif
-
-#ifndef SECUREC_ONLY_DECLARE_MEMSET
-#define SECUREC_ONLY_DECLARE_MEMSET     0
-#endif
-
-#if !SECUREC_ONLY_DECLARE_MEMSET
-
-#if SECUREC_ENABLE_MEMMOVE
-    /*
-     * Description: The memmove_s function copies n characters from the object pointed to by src
-     * into the object pointed to by dest.
-     * Parameter: dest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer
-     * Parameter: src - source address
-     * Parameter: count - copies count bytes from the src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t memmove_s(void *dest, size_t destMax, const void *src, size_t count);
-#endif
-
-#if SECUREC_ENABLE_MEMCPY
-    /*
-     * Description: The memcpy_s function copies n characters from the object pointed to
-     * by src into the object pointed to by dest.
-     * Parameter: dest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer
-     * Parameter: src - source address
-     * Parameter: count - copies count bytes from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t memcpy_s(void *dest, size_t destMax, const void *src, size_t count);
-#endif
-
-#if SECUREC_ENABLE_STRCPY
-    /*
-     * Description: The strcpy_s function copies the string pointed to by strSrc (including
-     * the terminating null character) into the array pointed to by strDest
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null character)
-     * Parameter: strSrc - source address
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t strcpy_s(char *strDest, size_t destMax, const char *strSrc);
-#endif
-
-#if SECUREC_ENABLE_STRNCPY
-    /*
-     * Description: The strncpy_s function copies not more than n successive characters (not including
-     * the terminating null character) from the array pointed to by strSrc to the array pointed to by strDest.
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null character)
-     * Parameter: strSrc - source  address
-     * Parameter: count - copies count  characters from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t strncpy_s(char *strDest, size_t destMax, const char *strSrc, size_t count);
-#endif
-
-#if SECUREC_ENABLE_STRCAT
-    /*
-     * Description: The strcat_s function appends a copy of the string pointed to by strSrc (including
-     * the terminating null character) to the end of the string pointed to by strDest.
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null wide character)
-     * Parameter: strSrc - source  address
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t strcat_s(char *strDest, size_t destMax, const char *strSrc);
-#endif
-
-#if SECUREC_ENABLE_STRNCAT
-    /*
-     * Description: The strncat_s function appends not more than n successive  characters (not including
-     * the terminating null  character)
-     * from the array pointed to by strSrc to the end of the  string pointed to by strDest.
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null character)
-     * Parameter: strSrc - source  address
-     * Parameter: count - copies count  characters from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t strncat_s(char *strDest, size_t destMax, const char *strSrc, size_t count);
-#endif
-
-#if SECUREC_ENABLE_VSPRINTF
-    /*
-     * Description:  The vsprintf_s function is equivalent to the vsprintf function except for the parameter destMax
-     * and the explicit runtime-constraints violation
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest.
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null wide characte)
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of characters printed(not including the terminating null byte '\0'),
-     * If an error occurred Return: -1.
-     */
-    SECUREC_API int vsprintf_s(char *strDest, size_t destMax, const char *format,
-                               va_list argList) SECUREC_ATTRIBUTE(3, 0);
-#endif
-
-#if SECUREC_ENABLE_SPRINTF
-    /*
-     * Description:  The sprintf_s function is equivalent to the sprintf function except for the parameter destMax
-     * and the explicit runtime-constraints violation
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest.
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null byte '\0')
-     * Parameter: format - fromat string
-     * Return:    the number of characters printed(not including the terminating null byte '\0'),
-     * If an error occurred Return: -1.
-     */
-    SECUREC_API int sprintf_s(char *strDest, size_t destMax, const char *format, ...) SECUREC_ATTRIBUTE(3, 4);
-#endif
-
-#if SECUREC_ENABLE_VSNPRINTF
-    /*
-     * Description:  The vsnprintf_s function is equivalent to the vsnprintf function except for
-     * the parameter destMax/count and the explicit runtime-constraints violation
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest.
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null  byte '\0')
-     * Parameter: count - do not write more than count bytes to strDest(not including the terminating null  byte '\0')
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of characters printed(not including the terminating null byte '\0'),
-     * If an error occurred Return: -1.Pay special attention to returning -1 when truncation occurs
-     */
-    SECUREC_API int vsnprintf_s(char *strDest, size_t destMax, size_t count, const char *format,
-                                va_list argList) SECUREC_ATTRIBUTE(4, 0);
-#endif
-
-#if SECUREC_ENABLE_SNPRINTF
-    /*
-     * Description:  The snprintf_s function is equivalent to the snprintf function except for
-     * the parameter destMax/count and the explicit runtime-constraints violation
-     * Parameter: strDest - produce output according to a format ,write to the character string strDest.
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null  byte '\0')
-     * Parameter: count - do not write more than count bytes to strDest(not including the terminating null  byte '\0')
-     * Parameter: format - fromat string
-     * Return:    the number of characters printed(not including the terminating null byte '\0'),
-     * If an error occurred Return: -1.Pay special attention to returning -1 when truncation occurs
-     */
-    SECUREC_API int snprintf_s(char *strDest, size_t destMax, size_t count, const char *format,
-                               ...) SECUREC_ATTRIBUTE(4, 5);
-#endif
-
-#if SECUREC_SNPRINTF_TRUNCATED
-    /*
-     * Description:  The vsnprintf_truncated_s function is equivalent to the vsnprintf_s function except
-     * no count parameter and return value
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null  byte '\0')
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of characters printed(not including the terminating null byte '\0'),
-     * If an error occurred Return: -1.Pay special attention to returning destMax - 1 when truncation occurs
-     */
-    SECUREC_API int vsnprintf_truncated_s(char *strDest, size_t destMax, const char *format,
-                                          va_list argList) SECUREC_ATTRIBUTE(3, 0);
-
-    /*
-     * Description:  The snprintf_truncated_s function is equivalent to the snprintf_2 function except
-     * no count parameter and return value
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest.
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null  byte '\0')
-     * Parameter: format - fromat string
-     * Return:    the number of characters printed(not including the terminating null byte '\0'),
-     * If an error occurred Return: -1.Pay special attention to returning destMax - 1 when truncation occurs
-     */
-    SECUREC_API int snprintf_truncated_s(char *strDest, size_t destMax,
-                                         const char *format, ...) SECUREC_ATTRIBUTE(3, 4);
-#endif
-
-#if SECUREC_ENABLE_SCANF
-    /*
-     * Description:  The scanf_s function is equivalent to fscanf_s with the argument stdin
-     * interposed before the arguments to scanf_s
-     * Parameter: format - fromat string
-     * Return:   the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int scanf_s(const char *format, ...);
-#endif
-
-#if SECUREC_ENABLE_VSCANF
-    /*
-     * Description: The vscanf_s function is equivalent to scanf_s, with the variable argument list replaced by argList
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int vscanf_s(const char *format, va_list argList);
-#endif
-
-#if SECUREC_ENABLE_SSCANF
-    /*
-     * Description:  The sscanf_s function is equivalent to fscanf_s, except that input is obtained from a
-     * string (specified by the argument buffer) rather than from a stream
-     * Parameter: buffer -  read character from  buffer
-     * Parameter: format - fromat string
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int sscanf_s(const char *buffer, const char *format, ...);
-#endif
-
-#if SECUREC_ENABLE_VSSCANF
-    /*
-     * Description:  The vsscanf_s function is equivalent to sscanf_s, with the variable argument list
-     * replaced by argList
-     * Parameter: buffer -  read character from  buffer
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int vsscanf_s(const char *buffer, const char *format, va_list argList);
-#endif
-
-#if SECUREC_ENABLE_FSCANF
-    /*
-     * Description:  The fscanf_s function is equivalent to fscanf except that the c, s, and [ conversion specifiers
-     * apply to a pair of arguments (unless assignment suppression is indicated by a*)
-     * Parameter: stream - stdio file stream
-     * Parameter: format - fromat string
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int fscanf_s(FILE *stream, const char *format, ...);
-#endif
-
-#if SECUREC_ENABLE_VFSCANF
-    /*
-     * Description:  The vfscanf_s function is equivalent to fscanf_s, with the variable argument list
-     * replaced by argList
-     * Parameter: stream - stdio file stream
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int vfscanf_s(FILE *stream, const char *format, va_list argList);
-#endif
-
-#if SECUREC_ENABLE_STRTOK
-    /*
-     * Description:  The strtok_s function parses a string into a sequence of strToken,
-     * replace all characters in strToken string that match to strDelimit set with 0.
-     * On the first call to strtok_s the string to be parsed should be specified in strToken.
-     * In each subsequent call that should parse the same string, strToken should be NULL
-     * Parameter: strToken - the string to be delimited
-     * Parameter: strDelimit - specifies a set of characters that delimit the tokens in the parsed string
-     * Parameter: context - is a pointer to a char * variable that is used internally by strtok_s function
-     * Return:  On the first call returns the address of the first non \0 character, otherwise NULL is returned.
-     * In subsequent calls, the strtoken is set to NULL, and the context set is the same as the previous call,
-     * return NULL if the *context string length is equal 0, otherwise return *context.
-     */
-    SECUREC_API char *strtok_s(char *strToken, const char *strDelimit, char **context);
-#endif
-
-#if SECUREC_ENABLE_GETS && !SECUREC_IN_KERNEL
-    /*
-     * Description: The gets_s function reads at most one less than the number of characters specified
-     * by destMax from the stream pointed to by stdin, into the array pointed to by buffer
-     * Parameter: buffer - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null character)
-     * Return:    buffer if there was no runtime-constraint violation,If an error occurred Return: NULL.
-     */
-    SECUREC_API char *gets_s(char *buffer, size_t destMax);
-#endif
-
-#if SECUREC_ENABLE_WCHAR_FUNC
-#if SECUREC_ENABLE_MEMCPY
-    /*
-     * Description: The wmemcpy_s function copies n successive wide characters from the object pointed to
-     * by src into the object pointed to by dest.
-     * Parameter: dest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer
-     * Parameter: src - source  address
-     * Parameter: count - copies count wide characters from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t wmemcpy_s(wchar_t *dest, size_t destMax, const wchar_t *src, size_t count);
-#endif
-
-#if SECUREC_ENABLE_MEMMOVE
-    /*
-     * Description: The wmemmove_s function copies n successive wide characters from the object
-     * pointed to by src into the object pointed to by dest.
-     * Parameter: dest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer
-     * Parameter: src - source  address
-     * Parameter: count - copies count wide characters from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t wmemmove_s(wchar_t *dest, size_t destMax, const wchar_t *src, size_t count);
-#endif
-
-#if SECUREC_ENABLE_STRCPY
-    /*
-     * Description: The wcscpy_s function copies the wide string pointed to by strSrc (including theterminating
-     * null wide character) into the array pointed to by strDest
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer
-     * Parameter: strSrc - source  address
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t wcscpy_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc);
-#endif
-
-#if SECUREC_ENABLE_STRNCPY
-    /*
-     * Description: The wcsncpy_s function copies not more than n successive wide characters (not including the
-     * terminating null wide character) from the array pointed to by strSrc to the array pointed to by strDest
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating wide character)
-     * Parameter: strSrc - source  address
-     * Parameter: count - copies count wide characters from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t wcsncpy_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count);
-#endif
-
-#if SECUREC_ENABLE_STRCAT
-    /*
-     * Description: The wcscat_s function appends a copy of the wide string pointed to by strSrc (including the
-     * terminating null wide character) to the end of the wide string pointed to by strDest
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating wide character)
-     * Parameter: strSrc - source  address
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t wcscat_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc);
-#endif
-
-#if SECUREC_ENABLE_STRNCAT
-    /*
-     * Description: The wcsncat_s function appends not more than n successive wide characters (not including the
-     * terminating null wide character) from the array pointed to by strSrc to the end of the wide string pointed to
-     * by strDest.
-     * Parameter: strDest - destination  address
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating wide character)
-     * Parameter: strSrc - source  address
-     * Parameter: count - copies count wide characters from the  src
-     * Return:    EOK if there was no runtime-constraint violation
-     */
-    SECUREC_API errno_t wcsncat_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count);
-#endif
-
-#if SECUREC_ENABLE_STRTOK
-    /*
-     * Description:  The  wcstok_s  function  is  the  wide-character  equivalent  of the strtok_s function
-     * Parameter: strToken - the string to be delimited
-     * Parameter: strDelimit - specifies a set of characters that delimit the tokens in the parsed string
-     * Parameter: context - is a pointer to a char * variable that is used internally by strtok_s function
-     * Return:    a pointer to the first character of a token, or a null pointer if there is no token
-     * or there is a runtime-constraint violation.
-     */
-    SECUREC_API wchar_t *wcstok_s(wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context);
-#endif
-
-#if SECUREC_ENABLE_VSPRINTF
-    /*
-     * Description:  The  vswprintf_s  function  is  the  wide-character  equivalent  of the vsprintf_s function
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null )
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of characters printed(not including the terminating null wide characte),
-     * If an error occurred Return: -1.
-     */
-    SECUREC_API int vswprintf_s(wchar_t *strDest, size_t destMax, const wchar_t *format, va_list argList);
-#endif
-
-#if SECUREC_ENABLE_SPRINTF
-
-    /*
-     * Description:  The  swprintf_s  function  is  the  wide-character  equivalent  of the sprintf_s function
-     * Parameter: strDest -  produce output according to a format ,write to the character string strDest
-     * Parameter: destMax - The maximum length of destination buffer(including the terminating null )
-     * Parameter: format - fromat string
-     * Return:    the number of characters printed(not including the terminating null wide characte),
-     * If an error occurred Return: -1.
-     */
-    SECUREC_API int swprintf_s(wchar_t *strDest, size_t destMax, const wchar_t *format, ...);
-#endif
-
-#if SECUREC_ENABLE_FSCANF
-    /*
-     * Description:  The  fwscanf_s  function  is  the  wide-character  equivalent  of the fscanf_s function
-     * Parameter: stream - stdio file stream
-     * Parameter: format - fromat string
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int fwscanf_s(FILE *stream, const wchar_t *format, ...);
-#endif
-
-#if SECUREC_ENABLE_VFSCANF
-    /*
-     * Description:  The  vfwscanf_s  function  is  the  wide-character  equivalent  of the vfscanf_s function
-     * Parameter: stream - stdio file stream
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int vfwscanf_s(FILE *stream, const wchar_t *format, va_list argList);
-#endif
-
-#if SECUREC_ENABLE_SCANF
-    /*
-     * Description:  The  wscanf_s  function  is  the  wide-character  equivalent  of the scanf_s function
-     * Parameter: format - fromat string
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int wscanf_s(const wchar_t *format, ...);
-#endif
-
-#if SECUREC_ENABLE_VSCANF
-    /*
-     * Description:  The  vwscanf_s  function  is  the  wide-character  equivalent  of the vscanf_s function
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int vwscanf_s(const wchar_t *format, va_list argList);
-#endif
-
-#if SECUREC_ENABLE_SSCANF
-    /*
-     * Description:  The  swscanf_s  function  is  the  wide-character  equivalent  of the sscanf_s function
-     * Parameter: buffer -  read character from  buffer
-     * Parameter: format - fromat string
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int swscanf_s(const wchar_t *buffer, const wchar_t *format, ...);
-#endif
-
-#if SECUREC_ENABLE_VSSCANF
-    /*
-     * Description:  The  vswscanf_s  function  is  the  wide-character  equivalent  of the vsscanf_s function
-     * Parameter: buffer -  read character from  buffer
-     * Parameter: format - fromat string
-     * Parameter: argList - instead of  a variable  number of arguments
-     * Return:    the number of input items assigned, If an error occurred Return: -1.
-     */
-    SECUREC_API int vswscanf_s(const wchar_t *buffer, const wchar_t *format, va_list argList);
-#endif
-#endif /* SECUREC_ENABLE_WCHAR_FUNC */
-#endif
-
-    /* Those functions are used by macro ,must declare hare , also for  without function declaration warning */
-    extern errno_t strncpy_error(char *strDest, size_t destMax, const char *strSrc, size_t count);
-    extern errno_t strcpy_error(char *strDest, size_t destMax, const char *strSrc);
-
-#if SECUREC_WITH_PERFORMANCE_ADDONS
-    /* Those functions are used by macro */
-    extern errno_t memset_sOptAsm(void *dest, size_t destMax, int c, size_t count);
-    extern errno_t memset_sOptTc(void *dest, size_t destMax, int c, size_t count);
-    extern errno_t memcpy_sOptAsm(void *dest, size_t destMax, const void *src, size_t count);
-    extern errno_t memcpy_sOptTc(void *dest, size_t destMax, const void *src, size_t count);
-
-/* The strcpy_sp is a macro, not a function in performance optimization mode. */
-#define strcpy_sp(dest, destMax, src)  ((__builtin_constant_p((destMax)) && \
-    __builtin_constant_p((src))) ?  \
-    SECUREC_STRCPY_SM((dest), (destMax), (src)) : \
-    strcpy_s((dest), (destMax), (src)))
-
-/* The strncpy_sp is a macro, not a function in performance optimization mode. */
-#define strncpy_sp(dest, destMax, src, count)  ((__builtin_constant_p((count)) && \
-    __builtin_constant_p((destMax)) && \
-    __builtin_constant_p((src))) ?  \
-    SECUREC_STRNCPY_SM((dest), (destMax), (src), (count)) : \
-    strncpy_s((dest), (destMax), (src), (count)))
-
-/* The strcat_sp is a macro, not a function in performance optimization mode. */
-#define strcat_sp(dest, destMax, src) ((__builtin_constant_p((destMax)) && \
-    __builtin_constant_p((src))) ?  \
-    SECUREC_STRCAT_SM((dest), (destMax), (src)) : \
-    strcat_s((dest), (destMax), (src)))
-
-/* The strncat_sp is a macro, not a function in performance optimization mode. */
-#define strncat_sp(dest, destMax, src, count) ((__builtin_constant_p((count)) &&  \
-    __builtin_constant_p((destMax)) && \
-    __builtin_constant_p((src))) ?  \
-    SECUREC_STRNCAT_SM((dest), (destMax), (src), (count)) : \
-    strncat_s((dest), (destMax), (src), (count)))
-
-/* The memcpy_sp is a macro, not a function in performance optimization mode. */
-#define memcpy_sp(dest, destMax, src, count)  (__builtin_constant_p((count)) ? \
-    (SECUREC_MEMCPY_SM((dest), (destMax), (src), (count))) : \
-    (__builtin_constant_p((destMax)) ? \
-    (((size_t)(destMax) > 0 && \
-    (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_MEM_MAX_LEN)) ? \
-    memcpy_sOptTc((dest), (destMax), (src), (count)) : ERANGE) : \
-    memcpy_sOptAsm((dest), (destMax), (src), (count))))
-
-/* The memset_sp is a macro, not a function in performance optimization mode. */
-#define memset_sp(dest, destMax, c, count)  (__builtin_constant_p((count)) ? \
-    (SECUREC_MEMSET_SM((dest), (destMax), (c), (count))) : \
-    (__builtin_constant_p((destMax)) ? \
-    (((((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_MEM_MAX_LEN)) ? \
-    memset_sOptTc((dest), (destMax), (c), (count)) : ERANGE) : \
-    memset_sOptAsm((dest), (destMax), (c), (count))))
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-

components/bounds_checking_function/include/securectype.h

@@ -1,570 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: Define internal used macro and data type. The marco of SECUREC_ON_64BITS
- *              will be determined in this header file, which is a switch for part
- *              of code. Some macro are used to supress warning by MS compiler.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECURECTYPE_H_A7BBB686_AADA_451B_B9F9_44DACDAE18A7
-#define SECURECTYPE_H_A7BBB686_AADA_451B_B9F9_44DACDAE18A7
-
-#ifndef SECUREC_USING_STD_SECURE_LIB
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#if defined(__STDC_WANT_SECURE_LIB__) && (!__STDC_WANT_SECURE_LIB__)
-/* Security functions have been provided since vs2005, default use of system library functions */
-#define SECUREC_USING_STD_SECURE_LIB    0
-#else
-#define SECUREC_USING_STD_SECURE_LIB    1
-#endif
-#else
-#define SECUREC_USING_STD_SECURE_LIB    0
-#endif
-#endif
-
-/* Compatibility with older Secure C versions, shielding VC symbol redefinition warning */
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && (!SECUREC_USING_STD_SECURE_LIB)
-#ifndef SECUREC_DISABLE_CRT_FUNC
-#define SECUREC_DISABLE_CRT_FUNC        1
-#endif
-#ifndef SECUREC_DISABLE_CRT_IMP
-#define SECUREC_DISABLE_CRT_IMP         1
-#endif
-#else /*  MSC VER */
-#ifndef SECUREC_DISABLE_CRT_FUNC
-#define SECUREC_DISABLE_CRT_FUNC        0
-#endif
-#ifndef SECUREC_DISABLE_CRT_IMP
-#define SECUREC_DISABLE_CRT_IMP         0
-#endif
-#endif
-
-#if SECUREC_DISABLE_CRT_FUNC
-#ifdef __STDC_WANT_SECURE_LIB__
-#undef __STDC_WANT_SECURE_LIB__
-#endif
-#define __STDC_WANT_SECURE_LIB__        0
-#endif
-
-#if SECUREC_DISABLE_CRT_IMP
-#ifdef _CRTIMP_ALTERNATIVE
-#undef _CRTIMP_ALTERNATIVE
-#endif
-#define _CRTIMP_ALTERNATIVE     /* Comment microsoft *_s function */
-#endif
-
-/* Compile in kernel under macro control */
-#ifndef SECUREC_IN_KERNEL
-#ifdef __KERNEL__
-#define SECUREC_IN_KERNEL               1
-#else
-#define SECUREC_IN_KERNEL               0
-#endif
-#endif
-
-#if SECUREC_IN_KERNEL
-#ifndef SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_SCANF_FILE       0
-#endif
-#ifndef SECUREC_ENABLE_WCHAR_FUNC
-#define SECUREC_ENABLE_WCHAR_FUNC       0
-#endif
-#else /* SECUREC_IN_KERNEL */
-#ifndef SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_SCANF_FILE       1
-#endif
-#ifndef SECUREC_ENABLE_WCHAR_FUNC
-#define SECUREC_ENABLE_WCHAR_FUNC       1
-#endif
-#endif
-
-/* Default secure function declaration, default declarations for non-standard functions */
-#ifndef SECUREC_SNPRINTF_TRUNCATED
-#define SECUREC_SNPRINTF_TRUNCATED      1
-#endif
-
-#if SECUREC_USING_STD_SECURE_LIB
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-/* Declare secure functions that are not available in the VS compiler */
-#ifndef SECUREC_ENABLE_MEMSET
-#define SECUREC_ENABLE_MEMSET           1
-#endif
-/* VS 2005 have vsnprintf_s function */
-#ifndef SECUREC_ENABLE_VSNPRINTF
-#define SECUREC_ENABLE_VSNPRINTF        0
-#endif
-#ifndef SECUREC_ENABLE_SNPRINTF
-/* VS 2005 have vsnprintf_s function Adapt the snprintf_s of the security function */
-#define snprintf_s _snprintf_s
-#define SECUREC_ENABLE_SNPRINTF         0
-#endif
-/* Before VS 2010 do not have v functions */
-#if _MSC_VER <= 1600 || defined(SECUREC_FOR_V_SCANFS)
-#ifndef SECUREC_ENABLE_VFSCANF
-#define SECUREC_ENABLE_VFSCANF          1
-#endif
-#ifndef SECUREC_ENABLE_VSCANF
-#define SECUREC_ENABLE_VSCANF           1
-#endif
-#ifndef SECUREC_ENABLE_VSSCANF
-#define SECUREC_ENABLE_VSSCANF          1
-#endif
-#endif
-
-#else /* MSC VER */
-#ifndef SECUREC_ENABLE_MEMSET
-#define SECUREC_ENABLE_MEMSET           0
-#endif
-#ifndef SECUREC_ENABLE_SNPRINTF
-#define SECUREC_ENABLE_SNPRINTF         0
-#endif
-#ifndef SECUREC_ENABLE_VSNPRINTF
-#define SECUREC_ENABLE_VSNPRINTF        0
-#endif
-#endif
-
-#ifndef SECUREC_ENABLE_MEMMOVE
-#define SECUREC_ENABLE_MEMMOVE          0
-#endif
-#ifndef SECUREC_ENABLE_MEMCPY
-#define SECUREC_ENABLE_MEMCPY           0
-#endif
-#ifndef SECUREC_ENABLE_STRCPY
-#define SECUREC_ENABLE_STRCPY           0
-#endif
-#ifndef SECUREC_ENABLE_STRNCPY
-#define SECUREC_ENABLE_STRNCPY          0
-#endif
-#ifndef SECUREC_ENABLE_STRCAT
-#define SECUREC_ENABLE_STRCAT           0
-#endif
-#ifndef SECUREC_ENABLE_STRNCAT
-#define SECUREC_ENABLE_STRNCAT          0
-#endif
-#ifndef SECUREC_ENABLE_SPRINTF
-#define SECUREC_ENABLE_SPRINTF          0
-#endif
-#ifndef SECUREC_ENABLE_VSPRINTF
-#define SECUREC_ENABLE_VSPRINTF          0
-#endif
-#ifndef SECUREC_ENABLE_SSCANF
-#define SECUREC_ENABLE_SSCANF           0
-#endif
-#ifndef SECUREC_ENABLE_VSSCANF
-#define SECUREC_ENABLE_VSSCANF          0
-#endif
-#ifndef SECUREC_ENABLE_SCANF
-#define SECUREC_ENABLE_SCANF            0
-#endif
-#ifndef SECUREC_ENABLE_VSCANF
-#define SECUREC_ENABLE_VSCANF           0
-#endif
-
-#ifndef SECUREC_ENABLE_FSCANF
-#define SECUREC_ENABLE_FSCANF           0
-#endif
-#ifndef SECUREC_ENABLE_VFSCANF
-#define SECUREC_ENABLE_VFSCANF          0
-#endif
-#ifndef SECUREC_ENABLE_STRTOK
-#define SECUREC_ENABLE_STRTOK           0
-#endif
-#ifndef SECUREC_ENABLE_GETS
-#define SECUREC_ENABLE_GETS             0
-#endif
-
-#else /* SECUREC USE STD SECURE LIB */
-
-#ifndef SECUREC_ENABLE_MEMSET
-#define SECUREC_ENABLE_MEMSET           1
-#endif
-#ifndef SECUREC_ENABLE_MEMMOVE
-#define SECUREC_ENABLE_MEMMOVE          1
-#endif
-#ifndef SECUREC_ENABLE_MEMCPY
-#define SECUREC_ENABLE_MEMCPY           1
-#endif
-#ifndef SECUREC_ENABLE_STRCPY
-#define SECUREC_ENABLE_STRCPY           1
-#endif
-#ifndef SECUREC_ENABLE_STRNCPY
-#define SECUREC_ENABLE_STRNCPY          1
-#endif
-#ifndef SECUREC_ENABLE_STRCAT
-#define SECUREC_ENABLE_STRCAT           1
-#endif
-#ifndef SECUREC_ENABLE_STRNCAT
-#define SECUREC_ENABLE_STRNCAT          1
-#endif
-#ifndef SECUREC_ENABLE_SPRINTF
-#define SECUREC_ENABLE_SPRINTF          1
-#endif
-#ifndef SECUREC_ENABLE_VSPRINTF
-#define SECUREC_ENABLE_VSPRINTF          1
-#endif
-#ifndef SECUREC_ENABLE_SNPRINTF
-#define SECUREC_ENABLE_SNPRINTF         1
-#endif
-#ifndef SECUREC_ENABLE_VSNPRINTF
-#define SECUREC_ENABLE_VSNPRINTF        1
-#endif
-#ifndef SECUREC_ENABLE_SSCANF
-#define SECUREC_ENABLE_SSCANF           1
-#endif
-#ifndef SECUREC_ENABLE_VSSCANF
-#define SECUREC_ENABLE_VSSCANF          1
-#endif
-#ifndef SECUREC_ENABLE_SCANF
-#if SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_SCANF            1
-#else
-#define SECUREC_ENABLE_SCANF            0
-#endif
-#endif
-#ifndef SECUREC_ENABLE_VSCANF
-#if SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_VSCANF           1
-#else
-#define SECUREC_ENABLE_VSCANF           0
-#endif
-#endif
-
-#ifndef SECUREC_ENABLE_FSCANF
-#if SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_FSCANF           1
-#else
-#define SECUREC_ENABLE_FSCANF           0
-#endif
-#endif
-#ifndef SECUREC_ENABLE_VFSCANF
-#if SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_VFSCANF          1
-#else
-#define SECUREC_ENABLE_VFSCANF          0
-#endif
-#endif
-
-#ifndef SECUREC_ENABLE_STRTOK
-#define SECUREC_ENABLE_STRTOK           1
-#endif
-#ifndef SECUREC_ENABLE_GETS
-#define SECUREC_ENABLE_GETS             1
-#endif
-#endif /* SECUREC_USE_STD_SECURE_LIB */
-
-#if !SECUREC_ENABLE_SCANF_FILE
-#if SECUREC_ENABLE_FSCANF
-#undef SECUREC_ENABLE_FSCANF
-#define SECUREC_ENABLE_FSCANF           0
-#endif
-#if SECUREC_ENABLE_VFSCANF
-#undef SECUREC_ENABLE_VFSCANF
-#define SECUREC_ENABLE_VFSCANF          0
-#endif
-#if SECUREC_ENABLE_SCANF
-#undef SECUREC_ENABLE_SCANF
-#define SECUREC_ENABLE_SCANF            0
-#endif
-#if SECUREC_ENABLE_FSCANF
-#undef SECUREC_ENABLE_FSCANF
-#define SECUREC_ENABLE_FSCANF           0
-#endif
-
-#endif
-
-#if SECUREC_IN_KERNEL
-#include <linux/kernel.h>
-#include <linux/module.h>
-#else
-#ifndef SECUREC_HAVE_STDIO_H
-#define SECUREC_HAVE_STDIO_H 1
-#endif
-#ifndef SECUREC_HAVE_STRING_H
-#define SECUREC_HAVE_STRING_H 1
-#endif
-#ifndef SECUREC_HAVE_STDLIB_H
-#define SECUREC_HAVE_STDLIB_H 1
-#endif
-#if SECUREC_HAVE_STDIO_H
-#include <stdio.h>
-#endif
-#if SECUREC_HAVE_STRING_H
-#include <string.h>
-#endif
-#if SECUREC_HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#endif
-
-/*
- * If you need high performance, enable the SECUREC_WITH_PERFORMANCE_ADDONS macro, default is enable.
- * The macro is automatically closed on the windows platform and linux kernel
- */
-#ifndef SECUREC_WITH_PERFORMANCE_ADDONS
-#if SECUREC_IN_KERNEL
-#define SECUREC_WITH_PERFORMANCE_ADDONS 0
-#else
-#define SECUREC_WITH_PERFORMANCE_ADDONS 1
-#endif
-#endif
-
-/* If enable SECUREC_COMPATIBLE_WIN_FORMAT, the output format will be compatible to Windows. */
-#if (defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)) && !defined(SECUREC_COMPATIBLE_LINUX_FORMAT)
-#ifndef SECUREC_COMPATIBLE_WIN_FORMAT
-#define SECUREC_COMPATIBLE_WIN_FORMAT
-#endif
-#endif
-
-#if defined(SECUREC_COMPATIBLE_WIN_FORMAT)
-/* On windows platform, can't use optimized function for there is no __builtin_constant_p like function */
-/* If need optimized macro, can define this: define __builtin_constant_p(x) 0 */
-#ifdef SECUREC_WITH_PERFORMANCE_ADDONS
-#undef SECUREC_WITH_PERFORMANCE_ADDONS
-#define SECUREC_WITH_PERFORMANCE_ADDONS 0
-#endif
-#endif
-
-#if defined(__VXWORKS__) || defined(__vxworks) || defined(__VXWORKS) || defined(_VXWORKS_PLATFORM_)  || \
-    defined(SECUREC_VXWORKS_VERSION_5_4)
-#ifndef SECUREC_VXWORKS_PLATFORM
-#define SECUREC_VXWORKS_PLATFORM
-#endif
-#endif
-
-/* If enable SECUREC_COMPATIBLE_LINUX_FORMAT, the output format will be compatible to Linux. */
-#if !defined(SECUREC_COMPATIBLE_WIN_FORMAT) && !defined(SECUREC_VXWORKS_PLATFORM)
-#ifndef SECUREC_COMPATIBLE_LINUX_FORMAT
-#define SECUREC_COMPATIBLE_LINUX_FORMAT
-#endif
-#endif
-
-#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT
-#ifndef SECUREC_HAVE_STDDEF_H
-#define SECUREC_HAVE_STDDEF_H 1
-#endif
-/* Some system may no stddef.h */
-#if SECUREC_HAVE_STDDEF_H
-#if !SECUREC_IN_KERNEL
-#include <stddef.h>
-#endif
-#endif
-#endif
-
-/*
- * Add  the -DSECUREC_SUPPORT_FORMAT_WARNING=1  compiler option to supoort  -Wformat=2.
- * Default does not check the format is that the same data type in the actual code.
- * In the product is different in the original data type definition of VxWorks and Linux.
- */
-#ifndef SECUREC_SUPPORT_FORMAT_WARNING
-#define SECUREC_SUPPORT_FORMAT_WARNING 0
-#endif
-
-#if SECUREC_SUPPORT_FORMAT_WARNING
-#define SECUREC_ATTRIBUTE(x, y)  __attribute__((format(printf, (x), (y))))
-#else
-#define SECUREC_ATTRIBUTE(x, y)
-#endif
-
-/*
- * Add the -DSECUREC_SUPPORT_BUILTIN_EXPECT=0 compiler option, if complier can not support __builtin_expect.
- */
-#ifndef SECUREC_SUPPORT_BUILTIN_EXPECT
-#define SECUREC_SUPPORT_BUILTIN_EXPECT 1
-#endif
-
-#if SECUREC_SUPPORT_BUILTIN_EXPECT && defined(__GNUC__) && ((__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)))
-/*
- * This is a built-in function that can be used without a declaration, if warning for declaration not found occurred,
- * you can add -DSECUREC_NEED_BUILTIN_EXPECT_DECLARE to complier options
- */
-#ifdef SECUREC_NEED_BUILTIN_EXPECT_DECLARE
-long __builtin_expect(long exp, long c);
-#endif
-
-#define SECUREC_LIKELY(x) __builtin_expect(!!(x), 1)
-#define SECUREC_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define SECUREC_LIKELY(x) (x)
-#define SECUREC_UNLIKELY(x) (x)
-#endif
-
-/* Define the max length of the string */
-#ifndef SECUREC_STRING_MAX_LEN
-#define SECUREC_STRING_MAX_LEN 0x7fffffffUL
-#endif
-#define SECUREC_WCHAR_STRING_MAX_LEN (SECUREC_STRING_MAX_LEN / sizeof(wchar_t))
-
-/* Add SECUREC_MEM_MAX_LEN for memcpy and memmove */
-#ifndef SECUREC_MEM_MAX_LEN
-#define SECUREC_MEM_MAX_LEN 0x7fffffffUL
-#endif
-#define SECUREC_WCHAR_MEM_MAX_LEN (SECUREC_MEM_MAX_LEN / sizeof(wchar_t))
-
-#if SECUREC_STRING_MAX_LEN > 0x7fffffffUL
-#error "max string is 2G"
-#endif
-
-#if (defined(__GNUC__) && defined(__SIZEOF_POINTER__))
-#if (__SIZEOF_POINTER__ != 4) && (__SIZEOF_POINTER__ != 8)
-#error "unsupported system"
-#endif
-#endif
-
-#if defined(_WIN64) || defined(WIN64) || defined(__LP64__) || defined(_LP64)
-#define SECUREC_ON_64BITS
-#endif
-
-#if (!defined(SECUREC_ON_64BITS) && defined(__GNUC__) && defined(__SIZEOF_POINTER__))
-#if __SIZEOF_POINTER__ == 8
-#define SECUREC_ON_64BITS
-#endif
-#endif
-
-#if defined(__SVR4) || defined(__svr4__)
-#define SECUREC_ON_SOLARIS
-#endif
-
-#if (defined(__hpux) || defined(_AIX) || defined(SECUREC_ON_SOLARIS))
-#define SECUREC_ON_UNIX
-#endif
-
-/*
- * Codes should run under the macro SECUREC_COMPATIBLE_LINUX_FORMAT in unknow system on default,
- * and strtold.
- * The function strtold is referenced first at ISO9899:1999(C99), and some old compilers can
- * not support these functions. Here provides a macro to open these functions:
- * SECUREC_SUPPORT_STRTOLD  -- If defined, strtold will be used
- */
-#ifndef SECUREC_SUPPORT_STRTOLD
-#define SECUREC_SUPPORT_STRTOLD 0
-#if (defined(SECUREC_COMPATIBLE_LINUX_FORMAT))
-#if defined(__USE_ISOC99)  || \
-    (defined(_AIX) && defined(_ISOC99_SOURCE)) || \
-    (defined(__hpux) && defined(__ia64)) || \
-    (defined(SECUREC_ON_SOLARIS) && (!defined(_STRICT_STDC) && !defined(__XOPEN_OR_POSIX)) || \
-    defined(_STDC_C99) || defined(__EXTENSIONS__))
-#undef  SECUREC_SUPPORT_STRTOLD
-#define SECUREC_SUPPORT_STRTOLD 1
-#endif
-#endif
-#if ((defined(SECUREC_WRLINUX_BELOW4) || defined(_WRLINUX_BELOW4_)))
-#undef  SECUREC_SUPPORT_STRTOLD
-#define SECUREC_SUPPORT_STRTOLD 0
-#endif
-#endif
-
-#if SECUREC_WITH_PERFORMANCE_ADDONS
-
-#ifndef SECUREC_TWO_MIN
-#define SECUREC_TWO_MIN(a, b) ((a) < (b) ? (a) : (b))
-#endif
-
-/* For strncpy_s performance optimization */
-#define SECUREC_STRNCPY_SM(dest, destMax, src, count) \
-    (((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \
-    (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN) && \
-    (SECUREC_TWO_MIN((size_t)(count), strlen(src)) + 1) <= (size_t)(destMax)) ? \
-    (((size_t)(count) < strlen(src)) ? (memcpy((dest), (src), (count)), *((char *)(dest) + (count)) = '\0', EOK) : \
-    (memcpy((dest), (src), strlen(src) + 1), EOK)) : (strncpy_error((dest), (destMax), (src), (count))))
-
-#define SECUREC_STRCPY_SM(dest, destMax, src) \
-    (((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \
-    (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN) && \
-    (strlen(src) + 1) <= (size_t)(destMax)) ? (memcpy((dest), (src), strlen(src) + 1), EOK) : \
-    (strcpy_error((dest), (destMax), (src))))
-
-/* For strcat_s performance optimization */
-#if defined(__GNUC__)
-#define SECUREC_STRCAT_SM(dest, destMax, src) ({ \
-    int catRet_ = EOK; \
-    if ((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \
-        (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN)) { \
-        char *catTmpDst_ = (char *)(dest); \
-        size_t catRestSize_ = (destMax); \
-        while (catRestSize_ > 0 && *catTmpDst_ != '\0') { \
-            ++catTmpDst_; \
-            --catRestSize_; \
-        } \
-        if (catRestSize_ == 0) { \
-            catRet_ = EINVAL; \
-        } else if ((strlen(src) + 1) <= catRestSize_) { \
-            memcpy(catTmpDst_, (src), strlen(src) + 1); \
-            catRet_ = EOK; \
-        } else { \
-            catRet_ = ERANGE; \
-        } \
-        if (catRet_ != EOK) { \
-            catRet_ = strcat_s((dest), (destMax), (src)); \
-        } \
-    } else { \
-        catRet_ = strcat_s((dest), (destMax), (src)); \
-    } \
-    catRet_; \
-})
-#else
-#define SECUREC_STRCAT_SM(dest, destMax, src) strcat_s((dest), (destMax), (src))
-#endif
-
-/* For strncat_s performance optimization */
-#if defined(__GNUC__)
-#define SECUREC_STRNCAT_SM(dest, destMax, src, count) ({ \
-    int ncatRet_ = EOK; \
-    if ((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \
-        (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN)  && \
-        (((unsigned long long)(count) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN)) { \
-        char *ncatTmpDest_ = (char *)(dest); \
-        size_t ncatRestSize_ = (size_t)(destMax); \
-        while (ncatRestSize_ > 0 && *ncatTmpDest_ != '\0') { \
-            ++ncatTmpDest_; \
-            --ncatRestSize_; \
-        } \
-        if (ncatRestSize_ == 0) { \
-            ncatRet_ = EINVAL; \
-        } else if ((SECUREC_TWO_MIN((count), strlen(src)) + 1) <= ncatRestSize_) { \
-            if ((size_t)(count) < strlen(src)) { \
-                memcpy(ncatTmpDest_, (src), (count)); \
-                *(ncatTmpDest_ + (count)) = '\0'; \
-            } else { \
-                memcpy(ncatTmpDest_, (src), strlen(src) + 1); \
-            } \
-        } else { \
-            ncatRet_ = ERANGE; \
-        } \
-        if (ncatRet_ != EOK) { \
-            ncatRet_ = strncat_s((dest), (destMax), (src), (count)); \
-        } \
-    } else { \
-        ncatRet_ = strncat_s((dest), (destMax), (src), (count)); \
-    } \
-    ncatRet_; \
-})
-#else
-#define SECUREC_STRNCAT_SM(dest, destMax, src, count) strncat_s((dest), (destMax), (src), (count))
-#endif
-
-/* This macro do not check buffer overlap by default */
-#define  SECUREC_MEMCPY_SM(dest, destMax, src, count) \
-    (!(((size_t)(destMax) == 0) || \
-        (((unsigned long long)(destMax) & (unsigned long long)(-2)) > SECUREC_MEM_MAX_LEN) || \
-        ((size_t)(count) > (size_t)(destMax)) || ((void *)(dest)) == NULL || ((void *)(src) == NULL)) ? \
-        (memcpy((dest), (src), (count)), EOK) : \
-        (memcpy_s((dest), (destMax), (src), (count))))
-
-#define  SECUREC_MEMSET_SM(dest, destMax, c, count) \
-    (!((((unsigned long long)(destMax) & (unsigned long long)(-2)) > SECUREC_MEM_MAX_LEN) || \
-        ((void *)(dest) == NULL) || ((size_t)(count) > (size_t)(destMax))) ? \
-        (memset((dest), (c), (count)), EOK) : \
-        (memset_s((dest), (destMax), (c), (count))))
-
-#endif
-#endif
-

components/bounds_checking_function/src/fscanf_s.c

@@ -1,54 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: fscanf_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The fscanf_s function is equivalent to fscanf except that the c, s,
- *    and [ conversion specifiers apply to a pair of arguments (unless assignment suppression is indicated by a*)
- *    The fscanf function reads data from the current position of stream into
- *    the locations given by argument (if any). Each argument must be a pointer
- *    to a variable of a type that corresponds to a type specifier in format.
- *    format controls the interpretation of the input fields and has the same
- *    form and function as the format argument for scanf.
- *
- * <INPUT PARAMETERS>
- *    stream              Pointer to FILE structure.
- *    format              Format control string, see Format Specifications.
- *    ...                 Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    ...                 The convered value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned. A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int fscanf_s(FILE *stream, const char *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vfscanf_s(stream, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-

components/bounds_checking_function/src/fwscanf_s.c

@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: fwscanf_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The fwscanf_s function  is  the  wide-character  equivalent  of the fscanf_s function
- *    The fwscanf_s function reads data from the current position of stream into
- *    the locations given by argument (if any). Each argument must be a pointer
- *    to a variable of a type that corresponds to a type specifier in format.
- *    format controls the interpretation of the input fields and has the same
- *    form and function as the format argument for scanf.
- *
- * <INPUT PARAMETERS>
- *    stream                   Pointer to FILE structure.
- *    format                   Format control string, see Format Specifications.
- *    ...                      Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    ...                      The converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned. A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int fwscanf_s(FILE *stream, const wchar_t *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vfwscanf_s(stream, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-

components/bounds_checking_function/src/gets_s.c

@@ -1,72 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: gets_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * The parameter size is buffer size in byte
- */
-SECUREC_INLINE void SecTrimCRLF(char *buffer, size_t size)
-{
-    size_t len = strlen(buffer);
-    --len; /* Unsigned integer wrapping is accepted and is checked afterwards */
-    while (len < size && (buffer[len] == '\r' || buffer[len] == '\n')) {
-        buffer[len] = '\0';
-        --len; /* Unsigned integer wrapping is accepted and is checked next loop */
-    }
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The gets_s function reads at most one less than the number of characters
- *    specified by destMax from the std input stream, into the array pointed to by buffer
- *    The line consists of all characters up to and including
- *    the first newline character ('\n'). gets_s then replaces the newline
- *    character with a null character ('\0') before returning the line.
- *    If the first character read is the end-of-file character, a null character
- *    is stored at the beginning of buffer and NULL is returned.
- *
- * <INPUT PARAMETERS>
- *    buffer                         Storage location for input string.
- *    destMax                        The size of the buffer.
- *
- * <OUTPUT PARAMETERS>
- *    buffer                         is updated
- *
- * <RETURN VALUE>
- *    buffer                         Successful operation
- *    NULL                           Improper parameter or read fail
- */
-char *gets_s(char *buffer, size_t destMax)
-{
-#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
-    size_t bufferSize = ((destMax == (size_t)(-1)) ? SECUREC_STRING_MAX_LEN : destMax);
-#else
-    size_t bufferSize = destMax;
-#endif
-
-    if (buffer == NULL || bufferSize == 0 || bufferSize > SECUREC_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_PARAMTER("gets_s");
-        return NULL;
-    }
-
-    if (fgets(buffer, (int)bufferSize, SECUREC_STREAM_STDIN) != NULL) {
-        SecTrimCRLF(buffer, bufferSize);
-        return buffer;
-    }
-
-    return NULL;
-}
-

components/bounds_checking_function/src/memcpy_s.c

@@ -1,564 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: memcpy_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-/*
- * [Standardize-exceptions] Use unsafe function: Portability
- * [reason] Use unsafe function to implement security function to maintain platform compatibility.
- *          And sufficient input validation is performed before calling
- */
-
-#include "securecutil.h"
-
-#ifndef SECUREC_MEMCOPY_WITH_PERFORMANCE
-#define SECUREC_MEMCOPY_WITH_PERFORMANCE 0
-#endif
-
-#if SECUREC_WITH_PERFORMANCE_ADDONS || SECUREC_MEMCOPY_WITH_PERFORMANCE
-#ifndef SECUREC_MEMCOPY_THRESHOLD_SIZE
-#define SECUREC_MEMCOPY_THRESHOLD_SIZE 64UL
-#endif
-
-#define SECUREC_SMALL_MEM_COPY(dest, src, count) do { \
-    if (SECUREC_ADDR_ALIGNED_8(dest) && SECUREC_ADDR_ALIGNED_8(src)) { \
-        /* Use struct assignment */ \
-        switch (count) { \
-            case 1: \
-                *(unsigned char *)(dest) = *(const unsigned char *)(src); \
-                break; \
-            case 2: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 2); \
-                break; \
-            case 3: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 3); \
-                break; \
-            case 4: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 4); \
-                break; \
-            case 5: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 5); \
-                break; \
-            case 6: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 6); \
-                break; \
-            case 7: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 7); \
-                break; \
-            case 8: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 8); \
-                break; \
-            case 9: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 9); \
-                break; \
-            case 10: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 10); \
-                break; \
-            case 11: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 11); \
-                break; \
-            case 12: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 12); \
-                break; \
-            case 13: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 13); \
-                break; \
-            case 14: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 14); \
-                break; \
-            case 15: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 15); \
-                break; \
-            case 16: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 16); \
-                break; \
-            case 17: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 17); \
-                break; \
-            case 18: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 18); \
-                break; \
-            case 19: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 19); \
-                break; \
-            case 20: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 20); \
-                break; \
-            case 21: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 21); \
-                break; \
-            case 22: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 22); \
-                break; \
-            case 23: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 23); \
-                break; \
-            case 24: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 24); \
-                break; \
-            case 25: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 25); \
-                break; \
-            case 26: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 26); \
-                break; \
-            case 27: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 27); \
-                break; \
-            case 28: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 28); \
-                break; \
-            case 29: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 29); \
-                break; \
-            case 30: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 30); \
-                break; \
-            case 31: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 31); \
-                break; \
-            case 32: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 32); \
-                break; \
-            case 33: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 33); \
-                break; \
-            case 34: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 34); \
-                break; \
-            case 35: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 35); \
-                break; \
-            case 36: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 36); \
-                break; \
-            case 37: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 37); \
-                break; \
-            case 38: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 38); \
-                break; \
-            case 39: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 39); \
-                break; \
-            case 40: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 40); \
-                break; \
-            case 41: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 41); \
-                break; \
-            case 42: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 42); \
-                break; \
-            case 43: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 43); \
-                break; \
-            case 44: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 44); \
-                break; \
-            case 45: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 45); \
-                break; \
-            case 46: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 46); \
-                break; \
-            case 47: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 47); \
-                break; \
-            case 48: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 48); \
-                break; \
-            case 49: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 49); \
-                break; \
-            case 50: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 50); \
-                break; \
-            case 51: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 51); \
-                break; \
-            case 52: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 52); \
-                break; \
-            case 53: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 53); \
-                break; \
-            case 54: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 54); \
-                break; \
-            case 55: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 55); \
-                break; \
-            case 56: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 56); \
-                break; \
-            case 57: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 57); \
-                break; \
-            case 58: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 58); \
-                break; \
-            case 59: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 59); \
-                break; \
-            case 60: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 60); \
-                break; \
-            case 61: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 61); \
-                break; \
-            case 62: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 62); \
-                break; \
-            case 63: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 63); \
-                break; \
-            case 64: \
-                SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 64); \
-                break; \
-            default: \
-                /* Do nothing */ \
-                break; \
-        } /* END switch */ \
-    } else { \
-        unsigned char *tmpDest_ = (unsigned char *)(dest); \
-        const unsigned char *tmpSrc_ = (const unsigned char *)(src); \
-        switch (count) { \
-            case 64: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 63: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 62: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 61: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 60: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 59: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 58: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 57: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 56: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 55: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 54: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 53: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 52: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 51: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 50: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 49: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 48: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 47: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 46: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 45: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 44: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 43: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 42: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 41: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 40: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 39: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 38: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 37: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 36: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 35: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 34: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 33: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 32: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 31: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 30: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 29: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 28: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 27: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 26: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 25: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 24: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 23: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 22: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 21: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 20: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 19: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 18: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 17: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 16: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 15: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 14: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 13: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 12: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 11: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 10: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 9: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 8: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 7: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 6: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 5: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 4: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 3: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 2: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 1: \
-                *(tmpDest_++) = *(tmpSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            default: \
-                /* Do nothing */ \
-                break; \
-        } \
-    } \
-} SECUREC_WHILE_ZERO
-
-/*
- * Performance optimization
- */
-#define SECUREC_MEMCPY_OPT(dest, src, count) do { \
-    if ((count) > SECUREC_MEMCOPY_THRESHOLD_SIZE) { \
-        SECUREC_MEMCPY_WARP_OPT((dest), (src), (count)); \
-    } else { \
-        SECUREC_SMALL_MEM_COPY((dest), (src), (count)); \
-    } \
-} SECUREC_WHILE_ZERO
-#endif
-
-/*
- * Handling errors
- */
-SECUREC_INLINE errno_t SecMemcpyError(void *dest, size_t destMax, const void *src, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("memcpy_s");
-        return ERANGE;
-    }
-    if (dest == NULL || src == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("memcpy_s");
-        if (dest != NULL) {
-            (void)memset(dest, 0, destMax);
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    if (count > destMax) {
-        (void)memset(dest, 0, destMax);
-        SECUREC_ERROR_INVALID_RANGE("memcpy_s");
-        return ERANGE_AND_RESET;
-    }
-    if (SECUREC_MEMORY_IS_OVERLAP(dest, src, count)) {
-        (void)memset(dest, 0, destMax);
-        SECUREC_ERROR_BUFFER_OVERLAP("memcpy_s");
-        return EOVERLAP_AND_RESET;
-    }
-    /* Count is 0 or dest equal src also ret EOK */
-    return EOK;
-}
-
-#if defined(SECUREC_COMPATIBLE_WIN_FORMAT)
-    /*
-     * The fread API in windows will call memcpy_s and pass 0xffffffff to destMax.
-     * To avoid the failure of fread, we don't check desMax limit.
-     */
-#define SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count) (SECUREC_LIKELY((count) <= (destMax) && \
-    (dest) != NULL && (src) != NULL && \
-    (count) > 0 && SECUREC_MEMORY_NO_OVERLAP((dest), (src), (count))))
-#else
-#define SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count) (SECUREC_LIKELY((count) <= (destMax) && \
-    (dest) != NULL && (src) != NULL && (destMax) <= SECUREC_MEM_MAX_LEN && \
-    (count) > 0 && SECUREC_MEMORY_NO_OVERLAP((dest), (src), (count))))
-#endif
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The memcpy_s function copies n characters from the object pointed to by src into the object pointed to by dest
- *
- * <INPUT PARAMETERS>
- *    dest                      Destination buffer.
- *    destMax                   Size of the destination buffer.
- *    src                       Buffer to copy from.
- *    count                     Number of characters to copy
- *
- * <OUTPUT PARAMETERS>
- *    dest buffer               is updated.
- *
- * <RETURN VALUE>
- *    EOK                      Success
- *    EINVAL                   dest is  NULL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
- *    EINVAL_AND_RESET         dest != NULL and src is NULLL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
- *    ERANGE                   destMax > SECUREC_MEM_MAX_LEN or destMax is 0
- *    ERANGE_AND_RESET         count > destMax and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
- *                             and dest  !=  NULL  and src != NULL
- *    EOVERLAP_AND_RESET       dest buffer and source buffer are overlapped and
- *                             count <= destMax destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN and dest  !=  NULL
- *                             and src != NULL  and dest != src
- *
- *    if an error occured, dest will be filled with 0.
- *    If the source and destination overlap, the behavior of memcpy_s is undefined.
- *    Use memmove_s to handle overlapping regions.
- */
-errno_t memcpy_s(void *dest, size_t destMax, const void *src, size_t count)
-{
-    if (SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count)) {
-#if SECUREC_MEMCOPY_WITH_PERFORMANCE
-        SECUREC_MEMCPY_OPT(dest, src, count);
-#else
-        SECUREC_MEMCPY_WARP_OPT(dest, src, count);
-#endif
-        return EOK;
-    }
-    /* Meet some runtime violation, return error code */
-    return SecMemcpyError(dest, destMax, src, count);
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(memcpy_s);
-#endif
-
-#if SECUREC_WITH_PERFORMANCE_ADDONS
-/*
- * Performance optimization
- */
-errno_t memcpy_sOptAsm(void *dest, size_t destMax, const void *src, size_t count)
-{
-    if (SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count)) {
-        SECUREC_MEMCPY_OPT(dest, src, count);
-        return EOK;
-    }
-    /* Meet some runtime violation, return error code */
-    return SecMemcpyError(dest, destMax, src, count);
-}
-
-/* Trim judgement on "destMax <= SECUREC_MEM_MAX_LEN" */
-errno_t memcpy_sOptTc(void *dest, size_t destMax, const void *src, size_t count)
-{
-    if (SECUREC_LIKELY(count <= destMax && dest != NULL && src != NULL && \
-                       count > 0 && SECUREC_MEMORY_NO_OVERLAP((dest), (src), (count)))) {
-        SECUREC_MEMCPY_OPT(dest, src, count);
-        return EOK;
-    }
-    /* Meet some runtime violation, return error code */
-    return SecMemcpyError(dest, destMax, src, count);
-}
-#endif
-

components/bounds_checking_function/src/memmove_s.c

@@ -1,119 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: memmove_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-#ifdef SECUREC_NOT_CALL_LIBC_CORE_API
-/*
- * Implementing memory data movement
- */
-SECUREC_INLINE void SecUtilMemmove(void *dst, const void *src, size_t count)
-{
-    unsigned char *pDest = (unsigned char *)dst;
-    const unsigned char *pSrc = (const unsigned char *)src;
-    size_t maxCount = count;
-
-    if (dst <= src || pDest >= (pSrc + maxCount)) {
-        /*
-         * Non-Overlapping Buffers
-         * Copy from lower addresses to higher addresses
-         */
-        while (maxCount > 0) {
-            --maxCount;
-            *pDest = *pSrc;
-            ++pDest;
-            ++pSrc;
-        }
-    } else {
-        /*
-         * Overlapping Buffers
-         * Copy from higher addresses to lower addresses
-         */
-        pDest = pDest + maxCount - 1;
-        pSrc = pSrc + maxCount - 1;
-        while (maxCount > 0) {
-            --maxCount;
-            *pDest = *pSrc;
-            --pDest;
-            --pSrc;
-        }
-    }
-}
-#endif
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The memmove_s function copies count bytes of characters from src to dest.
- *    This function can be assigned correctly when memory overlaps.
- * <INPUT PARAMETERS>
- *    dest                    Destination object.
- *    destMax                 Size of the destination buffer.
- *    src                     Source object.
- *    count                   Number of characters to copy.
- *
- * <OUTPUT PARAMETERS>
- *    dest buffer             is uptdated.
- *
- * <RETURN VALUE>
- *    EOK                     Success
- *    EINVAL                  dest is  NULL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
- *    EINVAL_AND_RESET        dest != NULL and src is NULLL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
- *    ERANGE                  destMax > SECUREC_MEM_MAX_LEN or destMax is 0
- *    ERANGE_AND_RESET        count > destMax and dest  !=  NULL and src != NULL and destMax != 0
- *                            and destMax <= SECUREC_MEM_MAX_LEN
- *
- *    If an error occured, dest will  be filled with 0 when dest and destMax valid.
- *    If some regions of the source area and the destination overlap, memmove_s
- *    ensures that the original source bytes in the overlapping region are copied
- *    before being overwritten.
- */
-errno_t memmove_s(void *dest, size_t destMax, const void *src, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("memmove_s");
-        return ERANGE;
-    }
-    if (dest == NULL || src == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("memmove_s");
-        if (dest != NULL) {
-            (void)memset(dest, 0, destMax);
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    if (count > destMax) {
-        (void)memset(dest, 0, destMax);
-        SECUREC_ERROR_INVALID_RANGE("memmove_s");
-        return ERANGE_AND_RESET;
-    }
-    if (dest == src) {
-        return EOK;
-    }
-
-    if (count > 0) {
-#ifdef SECUREC_NOT_CALL_LIBC_CORE_API
-        SecUtilMemmove(dest, src, count);
-#else
-        /* Use underlying memmove for performance consideration */
-        (void)memmove(dest, src, count);
-#endif
-    }
-    return EOK;
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(memmove_s);
-#endif
-

components/bounds_checking_function/src/memset_s.c

@@ -1,509 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: memset_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-#define SECUREC_MEMSET_PARAM_OK(dest, destMax, count) (SECUREC_LIKELY((destMax) <= SECUREC_MEM_MAX_LEN && \
-    (dest) != NULL && (count) <= (destMax)))
-
-#if SECUREC_WITH_PERFORMANCE_ADDONS
-
-/* Use union to clear strict-aliasing warning */
-typedef union {
-    SecStrBuf32 buf32;
-    SecStrBuf31 buf31;
-    SecStrBuf30 buf30;
-    SecStrBuf29 buf29;
-    SecStrBuf28 buf28;
-    SecStrBuf27 buf27;
-    SecStrBuf26 buf26;
-    SecStrBuf25 buf25;
-    SecStrBuf24 buf24;
-    SecStrBuf23 buf23;
-    SecStrBuf22 buf22;
-    SecStrBuf21 buf21;
-    SecStrBuf20 buf20;
-    SecStrBuf19 buf19;
-    SecStrBuf18 buf18;
-    SecStrBuf17 buf17;
-    SecStrBuf16 buf16;
-    SecStrBuf15 buf15;
-    SecStrBuf14 buf14;
-    SecStrBuf13 buf13;
-    SecStrBuf12 buf12;
-    SecStrBuf11 buf11;
-    SecStrBuf10 buf10;
-    SecStrBuf9 buf9;
-    SecStrBuf8 buf8;
-    SecStrBuf7 buf7;
-    SecStrBuf6 buf6;
-    SecStrBuf5 buf5;
-    SecStrBuf4 buf4;
-    SecStrBuf3 buf3;
-    SecStrBuf2 buf2;
-} SecStrBuf32Union;
-/* C standard initializes the first member of the consortium. */
-static const SecStrBuf32 g_allZero = {{
-    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
-    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
-    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
-    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
-}};
-static const SecStrBuf32 g_allFF = {{
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-}};
-
-/* Clear coversion warning strict aliasing" */
-SECUREC_INLINE const SecStrBuf32Union *SecStrictAliasingCast(const SecStrBuf32 *buf)
-{
-    return (const SecStrBuf32Union *)buf;
-}
-
-#ifndef SECUREC_MEMSET_THRESHOLD_SIZE
-#define SECUREC_MEMSET_THRESHOLD_SIZE 32UL
-#endif
-
-#define SECUREC_UNALIGNED_SET(dest, c, count) do { \
-    unsigned char *pDest_ = (unsigned char *)(dest); \
-    switch (count) { \
-        case 32: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 31: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 30: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 29: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 28: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 27: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 26: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 25: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 24: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 23: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 22: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 21: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 20: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 19: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 18: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 17: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 16: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 15: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 14: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 13: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 12: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 11: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 10: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 9: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 8: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 7: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 6: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 5: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 4: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 3: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 2: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        case 1: \
-            *(pDest_++) = (unsigned char)(c); \
-            /* fall-through */ /* FALLTHRU */ \
-        default: \
-            /* Do nothing */ \
-            break; \
-    } \
-} SECUREC_WHILE_ZERO
-
-#define SECUREC_SET_VALUE_BY_STRUCT(dest, dataName, n) do { \
-    *(SecStrBuf##n *)(dest) = *(const SecStrBuf##n *)(&((SecStrictAliasingCast(&(dataName)))->buf##n)); \
-} SECUREC_WHILE_ZERO
-
-#define SECUREC_ALIGNED_SET_OPT_ZERO_FF(dest, c, count) do { \
-    switch (c) { \
-        case 0: \
-            switch (count) { \
-                case 1: \
-                    *(unsigned char *)(dest) = (unsigned char)0; \
-                    break; \
-                case 2: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 2); \
-                    break; \
-                case 3: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 3); \
-                    break; \
-                case 4: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 4); \
-                    break; \
-                case 5: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 5); \
-                    break; \
-                case 6: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 6); \
-                    break; \
-                case 7: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 7); \
-                    break; \
-                case 8: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 8); \
-                    break; \
-                case 9: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 9); \
-                    break; \
-                case 10: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 10); \
-                    break; \
-                case 11: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 11); \
-                    break; \
-                case 12: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 12); \
-                    break; \
-                case 13: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 13); \
-                    break; \
-                case 14: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 14); \
-                    break; \
-                case 15: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 15); \
-                    break; \
-                case 16: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 16); \
-                    break; \
-                case 17: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 17); \
-                    break; \
-                case 18: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 18); \
-                    break; \
-                case 19: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 19); \
-                    break; \
-                case 20: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 20); \
-                    break; \
-                case 21: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 21); \
-                    break; \
-                case 22: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 22); \
-                    break; \
-                case 23: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 23); \
-                    break; \
-                case 24: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 24); \
-                    break; \
-                case 25: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 25); \
-                    break; \
-                case 26: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 26); \
-                    break; \
-                case 27: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 27); \
-                    break; \
-                case 28: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 28); \
-                    break; \
-                case 29: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 29); \
-                    break; \
-                case 30: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 30); \
-                    break; \
-                case 31: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 31); \
-                    break; \
-                case 32: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 32); \
-                    break; \
-                default: \
-                    /* Do nothing */ \
-                    break; \
-            } \
-            break; \
-        case 0xFF: \
-            switch (count) { \
-                case 1: \
-                    *(unsigned char *)(dest) = (unsigned char)0xffU; \
-                    break; \
-                case 2: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 2); \
-                    break; \
-                case 3: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 3); \
-                    break; \
-                case 4: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 4); \
-                    break; \
-                case 5: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 5); \
-                    break; \
-                case 6: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 6); \
-                    break; \
-                case 7: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 7); \
-                    break; \
-                case 8: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 8); \
-                    break; \
-                case 9: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 9); \
-                    break; \
-                case 10: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 10); \
-                    break; \
-                case 11: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 11); \
-                    break; \
-                case 12: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 12); \
-                    break; \
-                case 13: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 13); \
-                    break; \
-                case 14: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 14); \
-                    break; \
-                case 15: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 15); \
-                    break; \
-                case 16: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 16); \
-                    break; \
-                case 17: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 17); \
-                    break; \
-                case 18: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 18); \
-                    break; \
-                case 19: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 19); \
-                    break; \
-                case 20: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 20); \
-                    break; \
-                case 21: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 21); \
-                    break; \
-                case 22: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 22); \
-                    break; \
-                case 23: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 23); \
-                    break; \
-                case 24: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 24); \
-                    break; \
-                case 25: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 25); \
-                    break; \
-                case 26: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 26); \
-                    break; \
-                case 27: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 27); \
-                    break; \
-                case 28: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 28); \
-                    break; \
-                case 29: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 29); \
-                    break; \
-                case 30: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 30); \
-                    break; \
-                case 31: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 31); \
-                    break; \
-                case 32: \
-                    SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 32); \
-                    break; \
-                default: \
-                    /* Do nothing */ \
-                    break; \
-            } \
-            break; \
-        default: \
-            SECUREC_UNALIGNED_SET((dest), (c), (count)); \
-            break; \
-    } /* END switch */ \
-} SECUREC_WHILE_ZERO
-
-#define SECUREC_SMALL_MEM_SET(dest, c, count) do { \
-    if (SECUREC_ADDR_ALIGNED_8((dest))) { \
-        SECUREC_ALIGNED_SET_OPT_ZERO_FF((dest), (c), (count)); \
-    } else { \
-        SECUREC_UNALIGNED_SET((dest), (c), (count)); \
-    } \
-} SECUREC_WHILE_ZERO
-
-/*
- * Performance optimization
- */
-#define SECUREC_MEMSET_OPT(dest, c, count) do { \
-    if ((count) > SECUREC_MEMSET_THRESHOLD_SIZE) { \
-        SECUREC_MEMSET_WARP_OPT((dest), (c), (count)); \
-    } else { \
-        SECUREC_SMALL_MEM_SET((dest), (c), (count)); \
-    } \
-} SECUREC_WHILE_ZERO
-#endif
-
-/*
- * Handling errors
- */
-SECUREC_INLINE errno_t SecMemsetError(void *dest, size_t destMax, int c, size_t count)
-{
-    /* Check destMax is 0 compatible with _sp macro */
-    if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("memset_s");
-        return ERANGE;
-    }
-    if (dest == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("memset_s");
-        return EINVAL;
-    }
-    if (count > destMax) {
-        (void)memset(dest, c, destMax); /* Set entire buffer to value c */
-        SECUREC_ERROR_INVALID_RANGE("memset_s");
-        return ERANGE_AND_RESET;
-    }
-    return EOK;
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The memset_s function copies the value of c (converted to an unsigned char)
- *     into each of the first count characters of the object pointed to by dest.
- *
- * <INPUT PARAMETERS>
- *    dest                Pointer to destination.
- *    destMax             The size of the buffer.
- *    c                   Character to set.
- *    count               Number of characters.
- *
- * <OUTPUT PARAMETERS>
- *    dest buffer         is uptdated.
- *
- * <RETURN VALUE>
- *    EOK                 Success
- *    EINVAL              dest == NULL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
- *    ERANGE              destMax > SECUREC_MEM_MAX_LEN or (destMax is 0 and count > destMax)
- *    ERANGE_AND_RESET    count > destMax and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN and dest != NULL
- *
- *    if return ERANGE_AND_RESET then fill dest to c ,fill length is destMax
- */
-errno_t memset_s(void *dest, size_t destMax, int c, size_t count)
-{
-    if (SECUREC_MEMSET_PARAM_OK(dest, destMax, count)) {
-        SECUREC_MEMSET_WARP_OPT(dest, c, count);
-        return EOK;
-    }
-    /* Meet some runtime violation, return error code */
-    return SecMemsetError(dest, destMax, c, count);
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(memset_s);
-#endif
-
-#if SECUREC_WITH_PERFORMANCE_ADDONS
-/*
- * Performance optimization
- */
-errno_t memset_sOptAsm(void *dest, size_t destMax, int c, size_t count)
-{
-    if (SECUREC_MEMSET_PARAM_OK(dest, destMax, count)) {
-        SECUREC_MEMSET_OPT(dest, c, count);
-        return EOK;
-    }
-    /* Meet some runtime violation, return error code */
-    return SecMemsetError(dest, destMax, c, count);
-}
-
-/*
- * Performance optimization, trim judgement on "destMax <= SECUREC_MEM_MAX_LEN"
- */
-errno_t memset_sOptTc(void *dest, size_t destMax, int c, size_t count)
-{
-    if (SECUREC_LIKELY(count <= destMax && dest != NULL)) {
-        SECUREC_MEMSET_OPT(dest, c, count);
-        return EOK;
-    }
-    /* Meet some runtime violation, return error code */
-    return SecMemsetError(dest, destMax, c, count);
-}
-#endif
-

components/bounds_checking_function/src/scanf_s.c

@@ -1,52 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: scanf_s function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The scanf_s function is equivalent to fscanf_s with the argument stdin interposed before the arguments to scanf_s
- *     The scanf_s function reads data from the standard input stream stdin and
- *    writes the data into the location that's given by argument. Each argument
- *    must be a pointer to a variable of a type that corresponds to a type specifier
- *    in format. If copying occurs between strings that overlap, the behavior is
- *    undefined.
- *
- * <INPUT PARAMETERS>
- *    format                  Format control string.
- *    ...                       Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    ...                       The converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Returns the number of fields successfully converted and assigned;
- *    the return value does not include fields that were read but not assigned.
- *    A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int scanf_s(const char *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vscanf_s(format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-

components/bounds_checking_function/src/secinput.h

@@ -1,194 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: Define macro, data struct, and declare function prototype,
- *              which is used by input.inl, secureinput_a.c and secureinput_w.c.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SEC_INPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
-#define SEC_INPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
-#include "securecutil.h"
-
-#define SECUREC_SCANF_EINVAL             (-1)
-#define SECUREC_SCANF_ERROR_PARA         (-2)
-
-/* For internal stream flag */
-#define SECUREC_MEM_STR_FLAG             0x01U
-#define SECUREC_FILE_STREAM_FLAG         0x02U
-#define SECUREC_PIPE_STREAM_FLAG         0x04U
-#define SECUREC_LOAD_FILE_TO_MEM_FLAG    0x08U
-
-#define SECUREC_UCS_BOM_HEADER_SIZE      2U
-#define SECUREC_UCS_BOM_HEADER_BE_1ST    0xfeU
-#define SECUREC_UCS_BOM_HEADER_BE_2ST    0xffU
-#define SECUREC_UCS_BOM_HEADER_LE_1ST    0xffU
-#define SECUREC_UCS_BOM_HEADER_LE_2ST    0xfeU
-#define SECUREC_UTF8_BOM_HEADER_SIZE     3U
-#define SECUREC_UTF8_BOM_HEADER_1ST      0xefU
-#define SECUREC_UTF8_BOM_HEADER_2ND      0xbbU
-#define SECUREC_UTF8_BOM_HEADER_3RD      0xbfU
-#define SECUREC_UTF8_LEAD_1ST            0xe0U
-#define SECUREC_UTF8_LEAD_2ND            0x80U
-
-#define SECUREC_BEGIN_WITH_UCS_BOM(s, len) ((len) >= SECUREC_UCS_BOM_HEADER_SIZE && \
-    (((unsigned char)((s)[0]) == SECUREC_UCS_BOM_HEADER_LE_1ST && \
-    (unsigned char)((s)[1]) == SECUREC_UCS_BOM_HEADER_LE_2ST) || \
-    ((unsigned char)((s)[0]) == SECUREC_UCS_BOM_HEADER_BE_1ST && \
-    (unsigned char)((s)[1]) == SECUREC_UCS_BOM_HEADER_BE_2ST)))
-
-#define SECUREC_BEGIN_WITH_UTF8_BOM(s, len) ((len) >= SECUREC_UTF8_BOM_HEADER_SIZE && \
-    (unsigned char)((s)[0]) == SECUREC_UTF8_BOM_HEADER_1ST && \
-    (unsigned char)((s)[1]) == SECUREC_UTF8_BOM_HEADER_2ND && \
-    (unsigned char)((s)[2]) == SECUREC_UTF8_BOM_HEADER_3RD)
-
-#ifdef SECUREC_FOR_WCHAR
-#define SECUREC_BOM_HEADER_SIZE SECUREC_UCS_BOM_HEADER_SIZE
-#define SECUREC_BEGIN_WITH_BOM(s, len) SECUREC_BEGIN_WITH_UCS_BOM((s), (len))
-#else
-#define SECUREC_BOM_HEADER_SIZE SECUREC_UTF8_BOM_HEADER_SIZE
-#define SECUREC_BEGIN_WITH_BOM(s, len) SECUREC_BEGIN_WITH_UTF8_BOM((s), (len))
-#endif
-
-typedef struct {
-    unsigned int flag;          /* Mark the properties of input stream */
-    char *base;                 /* The pointer to the header of buffered string */
-    const char *cur;            /* The pointer to next read position */
-    size_t count;               /* The size of buffered string in bytes */
-#if SECUREC_ENABLE_SCANF_FILE
-    FILE *pf;                   /* The file pointer */
-    size_t fileRealRead;
-    long oriFilePos;            /* The original position of file offset when fscanf is called */
-#if !SECUREC_USE_STD_UNGETC
-    unsigned int lastChar;      /* The char code of last input */
-    int fUnGet;                 /* The boolean flag of pushing a char back to read stream */
-#endif
-#endif
-} SecFileStream;
-
-#if SECUREC_ENABLE_SCANF_FILE && !SECUREC_USE_STD_UNGETC
-#define SECUREC_FILE_STREAM_INIT_FILE(stream, fp) do { \
-    (stream)->pf = (fp); \
-    (stream)->fileRealRead = 0; \
-    (stream)->oriFilePos = 0; \
-    (stream)->lastChar = 0; \
-    (stream)->fUnGet = 0; \
-} SECUREC_WHILE_ZERO
-#elif SECUREC_ENABLE_SCANF_FILE && SECUREC_USE_STD_UNGETC
-#define SECUREC_FILE_STREAM_INIT_FILE(stream, fp) do { \
-    (stream)->pf = (fp); \
-    (stream)->fileRealRead = 0; \
-    (stream)->oriFilePos = 0; \
-} SECUREC_WHILE_ZERO
-#else
-/* Disable file */
-#define SECUREC_FILE_STREAM_INIT_FILE(stream, fp)
-#endif
-
-/* This initialization for eliminating redundant initialization. */
-#define SECUREC_FILE_STREAM_FROM_STRING(stream, buf, cnt) do { \
-    (stream)->flag = SECUREC_MEM_STR_FLAG; \
-    (stream)->base = NULL; \
-    (stream)->cur = (buf); \
-    (stream)->count = (cnt); \
-    SECUREC_FILE_STREAM_INIT_FILE((stream), NULL); \
-} SECUREC_WHILE_ZERO
-
-/* This initialization for eliminating redundant initialization. */
-#define SECUREC_FILE_STREAM_FROM_FILE(stream, fp) do { \
-    (stream)->flag = SECUREC_FILE_STREAM_FLAG; \
-    (stream)->base = NULL; \
-    (stream)->cur = NULL; \
-    (stream)->count = 0; \
-    SECUREC_FILE_STREAM_INIT_FILE((stream), (fp)); \
-} SECUREC_WHILE_ZERO
-
-/* This initialization for eliminating redundant initialization. */
-#define SECUREC_FILE_STREAM_FROM_STDIN(stream) do { \
-    (stream)->flag = SECUREC_PIPE_STREAM_FLAG; \
-    (stream)->base = NULL; \
-    (stream)->cur = NULL; \
-    (stream)->count = 0; \
-    SECUREC_FILE_STREAM_INIT_FILE((stream), SECUREC_STREAM_STDIN); \
-} SECUREC_WHILE_ZERO
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-    int SecInputS(SecFileStream *stream, const char *cFormat, va_list argList);
-    void SecClearDestBuf(const char *buffer, const char *format, va_list argList);
-#ifdef SECUREC_FOR_WCHAR
-    int SecInputSW(SecFileStream *stream, const wchar_t *cFormat, va_list argList);
-    void SecClearDestBufW(const wchar_t *buffer, const wchar_t *format, va_list argList);
-#endif
-
-/* 20150105 For software and hardware decoupling,such as UMG */
-#ifdef SECUREC_SYSAPI4VXWORKS
-#ifdef feof
-#undef feof
-#endif
-    extern int feof(FILE *stream);
-#endif
-
-#if defined(SECUREC_SYSAPI4VXWORKS) || defined(SECUREC_CTYPE_MACRO_ADAPT)
-#ifndef isspace
-#define isspace(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\r') || ((c) == '\n'))
-#endif
-#ifndef iswspace
-#define iswspace(c) (((c) == L' ') || ((c) == L'\t') || ((c) == L'\r') || ((c) == L'\n'))
-#endif
-#ifndef isascii
-#define isascii(c) (((unsigned char)(c)) <= 0x7f)
-#endif
-#ifndef isupper
-#define isupper(c) ((c) >= 'A' && (c) <= 'Z')
-#endif
-#ifndef islower
-#define islower(c) ((c) >= 'a' && (c) <= 'z')
-#endif
-#ifndef isalpha
-#define isalpha(c) (isupper(c) || (islower(c)))
-#endif
-#ifndef isdigit
-#define isdigit(c) ((c) >= '0' && (c) <= '9')
-#endif
-#ifndef isxupper
-#define isxupper(c) ((c) >= 'A' && (c) <= 'F')
-#endif
-#ifndef isxlower
-#define isxlower(c) ((c) >= 'a' && (c) <= 'f')
-#endif
-#ifndef isxdigit
-#define isxdigit(c) (isdigit(c) || isxupper(c) || isxlower(c))
-#endif
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-/* Reserved file operation macro interface, s is FILE *, i is fileno zero. */
-#ifndef SECUREC_LOCK_FILE
-#define SECUREC_LOCK_FILE(s)
-#endif
-
-#ifndef SECUREC_UNLOCK_FILE
-#define SECUREC_UNLOCK_FILE(s)
-#endif
-
-#ifndef SECUREC_LOCK_STDIN
-#define SECUREC_LOCK_STDIN(i, s)
-#endif
-
-#ifndef SECUREC_UNLOCK_STDIN
-#define SECUREC_UNLOCK_STDIN(i, s)
-#endif
-#endif
-

components/bounds_checking_function/src/securecutil.c

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: Provides internal functions used by this library, such as memory
- *              copy and memory move. Besides, include some helper function for
- *              printf family API, such as SecVsnprintfImpl
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-/* Avoid duplicate header files,not include securecutil.h */
-#include "securecutil.h"
-
-#if defined(ANDROID) && (SECUREC_HAVE_WCTOMB || SECUREC_HAVE_MBTOWC)
-#include <wchar.h>
-#if SECUREC_HAVE_WCTOMB
-/*
- * Convert wide characters to narrow multi-bytes
- */
-int wctomb(char *s, wchar_t wc)
-{
-    return wcrtomb(s, wc, NULL);
-}
-#endif
-
-#if SECUREC_HAVE_MBTOWC
-/*
- * Converting narrow multi-byte characters to wide characters
- */
-int mbtowc(wchar_t *pwc, const char *s, size_t n)
-{
-    return mbrtowc(pwc, s, n, NULL);
-}
-#endif
-#endif
-

components/bounds_checking_function/src/securecutil.h

@@ -1,559 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: Define macro, data struct, and declare internal used function prototype,
- *              which is used by secure functions.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECURECUTIL_H_46C86578_F8FF_4E49_8E64_9B175241761F
-#define SECURECUTIL_H_46C86578_F8FF_4E49_8E64_9B175241761F
-#include "securec.h"
-
-#if (defined(_MSC_VER)) && (_MSC_VER >= 1400)
-/* Shield compilation alerts using discarded functions and Constant  expression to maximize code compatibility */
-#define SECUREC_MASK_MSVC_CRT_WARNING __pragma(warning(push)) \
-    __pragma(warning(disable : 4996 4127))
-#define SECUREC_END_MASK_MSVC_CRT_WARNING  __pragma(warning(pop))
-#else
-#define SECUREC_MASK_MSVC_CRT_WARNING
-#define SECUREC_END_MASK_MSVC_CRT_WARNING
-#endif
-#define SECUREC_WHILE_ZERO SECUREC_MASK_MSVC_CRT_WARNING while (0) SECUREC_END_MASK_MSVC_CRT_WARNING
-
-/* Automatically identify the platform that supports strnlen function, and use this function to improve performance */
-#ifndef SECUREC_HAVE_STRNLEN
-#if (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700) || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L)
-#if SECUREC_IN_KERNEL
-#define SECUREC_HAVE_STRNLEN 0
-#else
-#if defined(__GLIBC__) && __GLIBC__ >= 2 && defined(__GLIBC_MINOR__) && __GLIBC_MINOR__ >= 10
-#define SECUREC_HAVE_STRNLEN 1
-#else
-#define SECUREC_HAVE_STRNLEN 0
-#endif
-#endif
-#else
-#define SECUREC_HAVE_STRNLEN 0
-#endif
-#endif
-
-#if SECUREC_IN_KERNEL
-/* In kernel disbale functions */
-#ifndef SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_SCANF_FILE 0
-#endif
-#ifndef SECUREC_ENABLE_SCANF_FLOAT
-#define SECUREC_ENABLE_SCANF_FLOAT 0
-#endif
-#ifndef SECUREC_ENABLE_SPRINTF_FLOAT
-#define SECUREC_ENABLE_SPRINTF_FLOAT 0
-#endif
-#ifndef SECUREC_HAVE_MBTOWC
-#define SECUREC_HAVE_MBTOWC 0
-#endif
-#ifndef SECUREC_HAVE_WCTOMB
-#define SECUREC_HAVE_WCTOMB 0
-#endif
-#ifndef SECUREC_HAVE_WCHART
-#define SECUREC_HAVE_WCHART 0
-#endif
-#else /* Not in kernel */
-/* Systems that do not support file, can define this macro to 0. */
-#ifndef SECUREC_ENABLE_SCANF_FILE
-#define SECUREC_ENABLE_SCANF_FILE 1
-#endif
-#ifndef SECUREC_ENABLE_SCANF_FLOAT
-#define SECUREC_ENABLE_SCANF_FLOAT 1
-#endif
-/* Systems that do not support float, can define this macro to 0. */
-#ifndef SECUREC_ENABLE_SPRINTF_FLOAT
-#define SECUREC_ENABLE_SPRINTF_FLOAT 1
-#endif
-#ifndef SECUREC_HAVE_MBTOWC
-#define SECUREC_HAVE_MBTOWC 1
-#endif
-#ifndef SECUREC_HAVE_WCTOMB
-#define SECUREC_HAVE_WCTOMB 1
-#endif
-#ifndef SECUREC_HAVE_WCHART
-#define SECUREC_HAVE_WCHART 1
-#endif
-#endif
-
-#ifndef SECUREC_USE_STD_UNGETC
-#define SECUREC_USE_STD_UNGETC 1
-#endif
-
-#ifndef SECUREC_ENABLE_INLINE
-#define SECUREC_ENABLE_INLINE 0
-#endif
-
-#ifndef SECUREC_INLINE
-#if SECUREC_ENABLE_INLINE
-#define SECUREC_INLINE static inline
-#else
-#define SECUREC_INLINE static
-#endif
-#endif
-
-#ifndef SECUREC_WARP_OUTPUT
-#if SECUREC_IN_KERNEL
-#define SECUREC_WARP_OUTPUT 1
-#else
-#define SECUREC_WARP_OUTPUT 0
-#endif
-#endif
-
-#ifndef SECUREC_STREAM_STDIN
-#define SECUREC_STREAM_STDIN stdin
-#endif
-
-#define SECUREC_MUL_SIXTEEN(x)              ((x) << 4U)
-#define SECUREC_MUL_EIGHT(x)                ((x) << 3U)
-#define SECUREC_MUL_TEN(x)                  ((((x) << 2U) + (x)) << 1U)
-/* Limited format input and output width, use signed integer */
-#define SECUREC_MAX_WIDTH_LEN_DIV_TEN       21474836
-#define SECUREC_MAX_WIDTH_LEN               (SECUREC_MAX_WIDTH_LEN_DIV_TEN * 10)
-/* Is the x multiplied by 10 greater than */
-#define SECUREC_MUL_TEN_ADD_BEYOND_MAX(x)   (((x) > SECUREC_MAX_WIDTH_LEN_DIV_TEN))
-
-#define SECUREC_FLOAT_BUFSIZE               (309 + 40)  /* Max length of double value */
-#define SECUREC_FLOAT_BUFSIZE_LB            (4932 + 40) /* Max length of long double value */
-#define SECUREC_FLOAT_DEFAULT_PRECISION     6
-
-/* This macro does not handle pointer equality or integer overflow */
-#define SECUREC_MEMORY_NO_OVERLAP(dest, src, count) \
-    (((src) < (dest) && ((const char *)(src) + (count)) <= (char *)(dest)) || \
-    ((dest) < (src) && ((char *)(dest) + (count)) <= (const char *)(src)))
-
-#define SECUREC_MEMORY_IS_OVERLAP(dest, src, count) \
-    (((src) < (dest) && ((const char *)(src) + (count)) > (char *)(dest)) || \
-    ((dest) < (src) && ((char *)(dest) + (count)) > (const char *)(src)))
-
-/*
- * Check whether the strings overlap, len is the length of the string not include terminator
- * Length is related to data type char or wchar , do not force conversion of types
- */
-#define SECUREC_STRING_NO_OVERLAP(dest, src, len) \
-    (((src) < (dest) && ((src) + (len)) < (dest)) || \
-    ((dest) < (src) && ((dest) + (len)) < (src)))
-
-/*
- * Check whether the strings overlap for strcpy wcscpy function, dest len and src Len are not include terminator
- * Length is related to data type char or wchar , do not force conversion of types
- */
-#define SECUREC_STRING_IS_OVERLAP(dest, src, len) \
-    (((src) < (dest) && ((src) + (len)) >= (dest)) || \
-    ((dest) < (src) && ((dest) + (len)) >= (src)))
-
-/*
- * Check whether the strings overlap for strcat wcscat function, dest len and src Len are not include terminator
- * Length is related to data type char or wchar , do not force conversion of types
- */
-#define SECUREC_CAT_STRING_IS_OVERLAP(dest, destLen, src, srcLen) \
-    (((dest) < (src) && ((dest) + (destLen) + (srcLen)) >= (src)) || \
-    ((src) < (dest) && ((src) + (srcLen)) >= (dest)))
-
-#if SECUREC_HAVE_STRNLEN
-#define SECUREC_CALC_STR_LEN(str, maxLen, outLen) do { \
-    *(outLen) = strnlen((str), (maxLen)); \
-} SECUREC_WHILE_ZERO
-#define SECUREC_CALC_STR_LEN_OPT(str, maxLen, outLen) do { \
-    if ((maxLen) > 8) { \
-        /* Optimization or len less then 8 */ \
-        if (*((str) + 0) == '\0') { \
-            *(outLen) = 0; \
-        } else if (*((str) + 1) == '\0') { \
-            *(outLen) = 1; \
-        } else if (*((str) + 2) == '\0') { \
-            *(outLen) = 2; \
-        } else if (*((str) + 3) == '\0') { \
-            *(outLen) = 3; \
-        } else if (*((str) + 4) == '\0') { \
-            *(outLen) = 4; \
-        } else if (*((str) + 5) == '\0') { \
-            *(outLen) = 5; \
-        } else if (*((str) + 6) == '\0') { \
-            *(outLen) = 6; \
-        } else if (*((str) + 7) == '\0') { \
-            *(outLen) = 7; \
-        } else if (*((str) + 8) == '\0') { \
-            /* Optimization with a length of 8 */ \
-            *(outLen) = 8; \
-        } else { \
-            /* The offset is 8 because the performance of 8 byte alignment is high */ \
-            *(outLen) = 8 + strnlen((str) + 8, (maxLen) - 8); \
-        } \
-    } else { \
-        SECUREC_CALC_STR_LEN((str), (maxLen), (outLen)); \
-    } \
-} SECUREC_WHILE_ZERO
-#else
-#define SECUREC_CALC_STR_LEN(str, maxLen, outLen) do { \
-    const char *strEnd_ = (const char *)(str); \
-    size_t availableSize_ = (size_t)(maxLen); \
-    while (availableSize_ > 0 && *strEnd_ != '\0') { \
-        --availableSize_; \
-        ++strEnd_; \
-    } \
-    *(outLen) = (size_t)(strEnd_ - (str)); \
-} SECUREC_WHILE_ZERO
-#define SECUREC_CALC_STR_LEN_OPT SECUREC_CALC_STR_LEN
-#endif
-
-#define SECUREC_CALC_WSTR_LEN(str, maxLen, outLen) do { \
-    const wchar_t *strEnd_ = (const wchar_t *)(str); \
-    size_t len_ = 0; \
-    while (len_ < (maxLen) && *strEnd_ != L'\0') { \
-        ++len_; \
-        ++strEnd_; \
-    } \
-    *(outLen) = len_; \
-} SECUREC_WHILE_ZERO
-
-/*
- * Performance optimization, product may disable inline function.
- * Using function pointer for MEMSET to prevent compiler optimization when cleaning up memory.
- */
-#ifdef SECUREC_USE_ASM
-#define SECUREC_MEMSET_FUNC_OPT  memset_opt
-#define SECUREC_MEMCPY_FUNC_OPT  memcpy_opt
-#else
-#define SECUREC_MEMSET_FUNC_OPT  memset
-#define SECUREC_MEMCPY_FUNC_OPT  memcpy
-#endif
-
-#define SECUREC_MEMCPY_WARP_OPT(dest, src, count)    (void)SECUREC_MEMCPY_FUNC_OPT((dest), (src), (count))
-
-#ifndef SECUREC_MEMSET_INDIRECT_USE
-/* Can be turned off for scenarios that do not allow pointer calls */
-#define SECUREC_MEMSET_INDIRECT_USE 1
-#endif
-
-#if SECUREC_MEMSET_INDIRECT_USE
-#define SECUREC_MEMSET_WARP_OPT(dest, value, count)  do { \
-    void *(* const volatile fn_)(void *s_, int c_, size_t n_) = SECUREC_MEMSET_FUNC_OPT; \
-    (void)(*fn_)((dest), (value), (count)); \
-} SECUREC_WHILE_ZERO
-#else
-#define SECUREC_MEMSET_WARP_OPT(dest, value, count)  (void)SECUREC_MEMSET_FUNC_OPT((dest), (value), (count))
-#endif
-
-#ifdef SECUREC_FORMAT_OUTPUT_INPUT
-#if defined(SECUREC_COMPATIBLE_WIN_FORMAT) || defined(__ARMCC_VERSION)
-typedef __int64 SecInt64;
-typedef unsigned __int64 SecUnsignedInt64;
-#if defined(__ARMCC_VERSION)
-typedef unsigned int SecUnsignedInt32;
-#else
-typedef unsigned __int32 SecUnsignedInt32;
-#endif
-#else
-typedef unsigned int SecUnsignedInt32;
-typedef long long SecInt64;
-typedef unsigned long long SecUnsignedInt64;
-#endif
-
-#ifdef SECUREC_FOR_WCHAR
-#if defined(SECUREC_VXWORKS_PLATFORM) && !defined(__WINT_TYPE__)
-typedef wchar_t wint_t;
-#endif
-#ifndef WEOF
-#define WEOF ((wchar_t)(-1))
-#endif
-#define SECUREC_CHAR(x) L ## x
-typedef wchar_t SecChar;
-typedef wchar_t SecUnsignedChar;
-typedef wint_t SecInt;
-typedef wint_t SecUnsignedInt;
-#else /*  no SECUREC_FOR_WCHAR */
-#define SECUREC_CHAR(x) (x)
-typedef char SecChar;
-typedef unsigned char SecUnsignedChar;
-typedef int SecInt;
-typedef unsigned int SecUnsignedInt;
-#endif
-#endif
-
-/*
- * Determine whether the address is 8-byte aligned
- * Some systems do not have uintptr_t type, so  use NULL to clear tool alarm 507
- */
-#define SECUREC_ADDR_ALIGNED_8(addr) ((((size_t)(addr)) & 7U) == 0) /* Use 7 to check aligned 8 */
-
-/*
- * If you define the memory allocation function, you need to define the function prototype.
- * You can define this macro as a header file.
- */
-#if defined(SECUREC_MALLOC_PROTOTYPE)
-SECUREC_MALLOC_PROTOTYPE
-#endif
-
-#ifndef SECUREC_MALLOC
-#define SECUREC_MALLOC(x) malloc((size_t)(x))
-#endif
-
-#ifndef SECUREC_FREE
-#define SECUREC_FREE(x)   free((void *)(x))
-#endif
-
-/* Improve performance with struct assignment, buf1 is not defined to avoid tool false positive */
-#define SECUREC_COPY_VALUE_BY_STRUCT(dest, src, n) do { \
-    *(SecStrBuf##n *)(void *)(dest) = *(const SecStrBuf##n *)(const void *)(src); \
-} SECUREC_WHILE_ZERO
-
-typedef struct {
-    unsigned char buf[2]; /* Performance optimization code structure assignment length 2 bytes */
-} SecStrBuf2;
-typedef struct {
-    unsigned char buf[3]; /* Performance optimization code structure assignment length 3 bytes */
-} SecStrBuf3;
-typedef struct {
-    unsigned char buf[4]; /* Performance optimization code structure assignment length 4 bytes */
-} SecStrBuf4;
-typedef struct {
-    unsigned char buf[5]; /* Performance optimization code structure assignment length 5 bytes */
-} SecStrBuf5;
-typedef struct {
-    unsigned char buf[6]; /* Performance optimization code structure assignment length 6 bytes */
-} SecStrBuf6;
-typedef struct {
-    unsigned char buf[7]; /* Performance optimization code structure assignment length 7 bytes */
-} SecStrBuf7;
-typedef struct {
-    unsigned char buf[8]; /* Performance optimization code structure assignment length 8 bytes */
-} SecStrBuf8;
-typedef struct {
-    unsigned char buf[9]; /* Performance optimization code structure assignment length 9 bytes */
-} SecStrBuf9;
-typedef struct {
-    unsigned char buf[10]; /* Performance optimization code structure assignment length 10 bytes */
-} SecStrBuf10;
-typedef struct {
-    unsigned char buf[11]; /* Performance optimization code structure assignment length 11 bytes */
-} SecStrBuf11;
-typedef struct {
-    unsigned char buf[12]; /* Performance optimization code structure assignment length 12 bytes */
-} SecStrBuf12;
-typedef struct {
-    unsigned char buf[13]; /* Performance optimization code structure assignment length 13 bytes */
-} SecStrBuf13;
-typedef struct {
-    unsigned char buf[14]; /* Performance optimization code structure assignment length 14 bytes */
-} SecStrBuf14;
-typedef struct {
-    unsigned char buf[15]; /* Performance optimization code structure assignment length 15 bytes */
-} SecStrBuf15;
-typedef struct {
-    unsigned char buf[16]; /* Performance optimization code structure assignment length 16 bytes */
-} SecStrBuf16;
-typedef struct {
-    unsigned char buf[17]; /* Performance optimization code structure assignment length 17 bytes */
-} SecStrBuf17;
-typedef struct {
-    unsigned char buf[18]; /* Performance optimization code structure assignment length 18 bytes */
-} SecStrBuf18;
-typedef struct {
-    unsigned char buf[19]; /* Performance optimization code structure assignment length 19 bytes */
-} SecStrBuf19;
-typedef struct {
-    unsigned char buf[20]; /* Performance optimization code structure assignment length 20 bytes */
-} SecStrBuf20;
-typedef struct {
-    unsigned char buf[21]; /* Performance optimization code structure assignment length 21 bytes */
-} SecStrBuf21;
-typedef struct {
-    unsigned char buf[22]; /* Performance optimization code structure assignment length 22 bytes */
-} SecStrBuf22;
-typedef struct {
-    unsigned char buf[23]; /* Performance optimization code structure assignment length 23 bytes */
-} SecStrBuf23;
-typedef struct {
-    unsigned char buf[24]; /* Performance optimization code structure assignment length 24 bytes */
-} SecStrBuf24;
-typedef struct {
-    unsigned char buf[25]; /* Performance optimization code structure assignment length 25 bytes */
-} SecStrBuf25;
-typedef struct {
-    unsigned char buf[26]; /* Performance optimization code structure assignment length 26 bytes */
-} SecStrBuf26;
-typedef struct {
-    unsigned char buf[27]; /* Performance optimization code structure assignment length 27 bytes */
-} SecStrBuf27;
-typedef struct {
-    unsigned char buf[28]; /* Performance optimization code structure assignment length 28 bytes */
-} SecStrBuf28;
-typedef struct {
-    unsigned char buf[29]; /* Performance optimization code structure assignment length 29 bytes */
-} SecStrBuf29;
-typedef struct {
-    unsigned char buf[30]; /* Performance optimization code structure assignment length 30 bytes */
-} SecStrBuf30;
-typedef struct {
-    unsigned char buf[31]; /* Performance optimization code structure assignment length 31 bytes */
-} SecStrBuf31;
-typedef struct {
-    unsigned char buf[32]; /* Performance optimization code structure assignment length 32 bytes */
-} SecStrBuf32;
-typedef struct {
-    unsigned char buf[33]; /* Performance optimization code structure assignment length 33 bytes */
-} SecStrBuf33;
-typedef struct {
-    unsigned char buf[34]; /* Performance optimization code structure assignment length 34 bytes */
-} SecStrBuf34;
-typedef struct {
-    unsigned char buf[35]; /* Performance optimization code structure assignment length 35 bytes */
-} SecStrBuf35;
-typedef struct {
-    unsigned char buf[36]; /* Performance optimization code structure assignment length 36 bytes */
-} SecStrBuf36;
-typedef struct {
-    unsigned char buf[37]; /* Performance optimization code structure assignment length 37 bytes */
-} SecStrBuf37;
-typedef struct {
-    unsigned char buf[38]; /* Performance optimization code structure assignment length 38 bytes */
-} SecStrBuf38;
-typedef struct {
-    unsigned char buf[39]; /* Performance optimization code structure assignment length 39 bytes */
-} SecStrBuf39;
-typedef struct {
-    unsigned char buf[40]; /* Performance optimization code structure assignment length 40 bytes */
-} SecStrBuf40;
-typedef struct {
-    unsigned char buf[41]; /* Performance optimization code structure assignment length 41 bytes */
-} SecStrBuf41;
-typedef struct {
-    unsigned char buf[42]; /* Performance optimization code structure assignment length 42 bytes */
-} SecStrBuf42;
-typedef struct {
-    unsigned char buf[43]; /* Performance optimization code structure assignment length 43 bytes */
-} SecStrBuf43;
-typedef struct {
-    unsigned char buf[44]; /* Performance optimization code structure assignment length 44 bytes */
-} SecStrBuf44;
-typedef struct {
-    unsigned char buf[45]; /* Performance optimization code structure assignment length 45 bytes */
-} SecStrBuf45;
-typedef struct {
-    unsigned char buf[46]; /* Performance optimization code structure assignment length 46 bytes */
-} SecStrBuf46;
-typedef struct {
-    unsigned char buf[47]; /* Performance optimization code structure assignment length 47 bytes */
-} SecStrBuf47;
-typedef struct {
-    unsigned char buf[48]; /* Performance optimization code structure assignment length 48 bytes */
-} SecStrBuf48;
-typedef struct {
-    unsigned char buf[49]; /* Performance optimization code structure assignment length 49 bytes */
-} SecStrBuf49;
-typedef struct {
-    unsigned char buf[50]; /* Performance optimization code structure assignment length 50 bytes */
-} SecStrBuf50;
-typedef struct {
-    unsigned char buf[51]; /* Performance optimization code structure assignment length 51 bytes */
-} SecStrBuf51;
-typedef struct {
-    unsigned char buf[52]; /* Performance optimization code structure assignment length 52 bytes */
-} SecStrBuf52;
-typedef struct {
-    unsigned char buf[53]; /* Performance optimization code structure assignment length 53 bytes */
-} SecStrBuf53;
-typedef struct {
-    unsigned char buf[54]; /* Performance optimization code structure assignment length 54 bytes */
-} SecStrBuf54;
-typedef struct {
-    unsigned char buf[55]; /* Performance optimization code structure assignment length 55 bytes */
-} SecStrBuf55;
-typedef struct {
-    unsigned char buf[56]; /* Performance optimization code structure assignment length 56 bytes */
-} SecStrBuf56;
-typedef struct {
-    unsigned char buf[57]; /* Performance optimization code structure assignment length 57 bytes */
-} SecStrBuf57;
-typedef struct {
-    unsigned char buf[58]; /* Performance optimization code structure assignment length 58 bytes */
-} SecStrBuf58;
-typedef struct {
-    unsigned char buf[59]; /* Performance optimization code structure assignment length 59 bytes */
-} SecStrBuf59;
-typedef struct {
-    unsigned char buf[60]; /* Performance optimization code structure assignment length 60 bytes */
-} SecStrBuf60;
-typedef struct {
-    unsigned char buf[61]; /* Performance optimization code structure assignment length 61 bytes */
-} SecStrBuf61;
-typedef struct {
-    unsigned char buf[62]; /* Performance optimization code structure assignment length 62 bytes */
-} SecStrBuf62;
-typedef struct {
-    unsigned char buf[63]; /* Performance optimization code structure assignment length 63 bytes */
-} SecStrBuf63;
-typedef struct {
-    unsigned char buf[64]; /* Performance optimization code structure assignment length 64 bytes */
-} SecStrBuf64;
-
-/*
- * User can change the error handler by modify the following definition,
- * such as logging the detail error in file.
- */
-#if defined(_DEBUG) || defined(DEBUG)
-#if defined(SECUREC_ERROR_HANDLER_BY_ASSERT)
-#define SECUREC_ERROR_INVALID_PARAMTER(msg) assert(msg "invalid argument" == NULL)
-#define SECUREC_ERROR_INVALID_RANGE(msg)    assert(msg "invalid dest buffer size" == NULL)
-#define SECUREC_ERROR_BUFFER_OVERLAP(msg)   assert(msg "buffer overlap" == NULL)
-#elif defined(SECUREC_ERROR_HANDLER_BY_PRINTF)
-#if SECUREC_IN_KERNEL
-#define SECUREC_ERROR_INVALID_PARAMTER(msg) printk("%s invalid argument\n", msg)
-#define SECUREC_ERROR_INVALID_RANGE(msg)    printk("%s invalid dest buffer size\n", msg)
-#define SECUREC_ERROR_BUFFER_OVERLAP(msg)   printk("%s buffer overlap\n", msg)
-#else
-#define SECUREC_ERROR_INVALID_PARAMTER(msg) printf("%s invalid argument\n", msg)
-#define SECUREC_ERROR_INVALID_RANGE(msg)    printf("%s invalid dest buffer size\n", msg)
-#define SECUREC_ERROR_BUFFER_OVERLAP(msg)   printf("%s buffer overlap\n", msg)
-#endif
-#elif defined(SECUREC_ERROR_HANDLER_BY_FILE_LOG)
-#define SECUREC_ERROR_INVALID_PARAMTER(msg) LogSecureCRuntimeError(msg " EINVAL\n")
-#define SECUREC_ERROR_INVALID_RANGE(msg)    LogSecureCRuntimeError(msg " ERANGE\n")
-#define SECUREC_ERROR_BUFFER_OVERLAP(msg)   LogSecureCRuntimeError(msg " EOVERLAP\n")
-#endif
-#endif
-
-/* Default handler is none */
-#ifndef SECUREC_ERROR_INVALID_PARAMTER
-#define SECUREC_ERROR_INVALID_PARAMTER(msg)
-#endif
-#ifndef SECUREC_ERROR_INVALID_RANGE
-#define SECUREC_ERROR_INVALID_RANGE(msg)
-#endif
-#ifndef SECUREC_ERROR_BUFFER_OVERLAP
-#define SECUREC_ERROR_BUFFER_OVERLAP(msg)
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Assembly language memory copy and memory set for X86 or MIPS ... */
-#ifdef SECUREC_USE_ASM
-    void *memcpy_opt(void *dest, const void *src, size_t n);
-    void *memset_opt(void *s, int c, size_t n);
-#endif
-
-#if defined(SECUREC_ERROR_HANDLER_BY_FILE_LOG)
-    void LogSecureCRuntimeError(const char *errDetail);
-#endif
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif
-

components/bounds_checking_function/src/secureinput_a.c

@@ -1,39 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: By defining data type for ANSI string and including "input.inl",
- *              this file generates real underlying function used by scanf family API.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#define SECUREC_FORMAT_OUTPUT_INPUT 1
-#ifdef SECUREC_FOR_WCHAR
-#undef SECUREC_FOR_WCHAR
-#endif
-
-#include "secinput.h"
-
-#include "input.inl"
-
-SECUREC_INLINE int SecIsDigit(SecInt ch)
-{
-    /* SecInt to unsigned char clear  571, use bit mask to clear negative return of ch */
-    return isdigit((int)((unsigned int)(unsigned char)(ch) & 0xffU));
-}
-SECUREC_INLINE int SecIsXdigit(SecInt ch)
-{
-    return isxdigit((int)((unsigned int)(unsigned char)(ch) & 0xffU));
-}
-SECUREC_INLINE int SecIsSpace(SecInt ch)
-{
-    return isspace((int)((unsigned int)(unsigned char)(ch) & 0xffU));
-}
-

components/bounds_checking_function/src/secureinput_w.c

@@ -1,78 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: By defining data type for UNICODE string and including "input.inl",
- *             this file generates real underlying function used by scanf family API.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-/* If some platforms don't have wchar.h, dont't include it */
-#if !(defined(SECUREC_VXWORKS_PLATFORM))
-/* If there is no macro below, it will cause vs2010 compiling alarm */
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-#ifndef __STDC_WANT_SECURE_LIB__
-/* The order of adjustment is to eliminate alarm of Duplicate Block */
-#define __STDC_WANT_SECURE_LIB__ 0
-#endif
-#ifndef _CRTIMP_ALTERNATIVE
-#define _CRTIMP_ALTERNATIVE     /* Comment microsoft *_s function */
-#endif
-#endif
-#include <wchar.h>
-#endif
-
-/* fix redefined */
-#undef SECUREC_ENABLE_WCHAR_FUNC
-/* Disable wchar func to clear vs warning */
-#define SECUREC_ENABLE_WCHAR_FUNC       0
-#define SECUREC_FORMAT_OUTPUT_INPUT     1
-
-#ifndef SECUREC_FOR_WCHAR
-#define SECUREC_FOR_WCHAR
-#endif
-
-#include "secinput.h"
-
-#include "input.inl"
-
-SECUREC_INLINE unsigned int SecWcharHighBits(SecInt ch)
-{
-    /* Convert int to unsigned int clear 571 */
-    return ((unsigned int)(int)ch & (~0xffU));
-}
-
-SECUREC_INLINE unsigned char SecWcharLowByte(SecInt ch)
-{
-    /* Convert int to unsigned int clear 571 */
-    return (unsigned char)((unsigned int)(int)ch & 0xffU);
-}
-
-SECUREC_INLINE int SecIsDigit(SecInt ch)
-{
-    if (SecWcharHighBits(ch) != 0) {
-        return 0; /* Same as isdigit */
-    }
-    return isdigit((int)SecWcharLowByte(ch));
-}
-
-SECUREC_INLINE int SecIsXdigit(SecInt ch)
-{
-    if (SecWcharHighBits(ch) != 0) {
-        return 0; /* Same as isxdigit */
-    }
-    return isxdigit((int)SecWcharLowByte(ch));
-}
-
-SECUREC_INLINE int SecIsSpace(SecInt ch)
-{
-    return iswspace((wint_t)(int)(ch));
-}
-

components/bounds_checking_function/src/secureprintoutput.h

@@ -1,124 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: Define macro, enum, data struct, and declare internal used function
- *              prototype, which is used by output.inl, secureprintoutput_w.c and
- *              secureprintoutput_a.c.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECUREPRINTOUTPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
-#define SECUREPRINTOUTPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
-#include "securecutil.h"
-
-/*
- * Flag definitions.
- * Using macros instead of enumerations is because some of the enumerated types under the compiler are 16bit.
- */
-#define SECUREC_FLAG_SIGN           0x00001U
-#define SECUREC_FLAG_SIGN_SPACE     0x00002U
-#define SECUREC_FLAG_LEFT           0x00004U
-#define SECUREC_FLAG_LEADZERO       0x00008U
-#define SECUREC_FLAG_LONG           0x00010U
-#define SECUREC_FLAG_SHORT          0x00020U
-#define SECUREC_FLAG_SIGNED         0x00040U
-#define SECUREC_FLAG_ALTERNATE      0x00080U
-#define SECUREC_FLAG_NEGATIVE       0x00100U
-#define SECUREC_FLAG_FORCE_OCTAL    0x00200U
-#define SECUREC_FLAG_LONG_DOUBLE    0x00400U
-#define SECUREC_FLAG_WIDECHAR       0x00800U
-#define SECUREC_FLAG_LONGLONG       0x01000U
-#define SECUREC_FLAG_CHAR           0x02000U
-#define SECUREC_FLAG_POINTER        0x04000U
-#define SECUREC_FLAG_I64            0x08000U
-#define SECUREC_FLAG_PTRDIFF        0x10000U
-#define SECUREC_FLAG_SIZE           0x20000U
-#ifdef  SECUREC_COMPATIBLE_LINUX_FORMAT
-#define SECUREC_FLAG_INTMAX         0x40000U
-#endif
-
-/* State definitions. Identify the status of the current format */
-typedef enum {
-    STAT_NORMAL,
-    STAT_PERCENT,
-    STAT_FLAG,
-    STAT_WIDTH,
-    STAT_DOT,
-    STAT_PRECIS,
-    STAT_SIZE,
-    STAT_TYPE,
-    STAT_INVALID
-} SecFmtState;
-
-/* Format output buffer pointer and available size */
-typedef struct {
-    int count;
-    char *cur;
-} SecPrintfStream;
-
-#ifndef SECUREC_BUFFER_SIZE
-#if SECUREC_IN_KERNEL
-#define SECUREC_BUFFER_SIZE    32
-#elif defined(SECUREC_STACK_SIZE_LESS_THAN_1K)
-/*
- * SECUREC BUFFER SIZE Can not be less than 23
- * The length of the octal representation of 64-bit integers with zero lead
- */
-#define SECUREC_BUFFER_SIZE    256
-#else
-#define SECUREC_BUFFER_SIZE    512
-#endif
-#endif
-#if SECUREC_BUFFER_SIZE < 23
-#error SECUREC_BUFFER_SIZE Can not be less than 23
-#endif
-/* Buffer size for wchar, use 4 to make the compiler aligns as 8 bytes as possible */
-#define SECUREC_WCHAR_BUFFER_SIZE 4
-
-#define SECUREC_MAX_PRECISION  SECUREC_BUFFER_SIZE
-/* Max. # bytes in multibyte char  ,see MB_LEN_MAX */
-#define SECUREC_MB_LEN 16
-/* The return value of the internal function, which is returned when truncated */
-#define SECUREC_PRINTF_TRUNCATE (-2)
-
-#define SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, maxLimit) \
-    ((format) == NULL || (strDest) == NULL || (destMax) == 0 || (destMax) > (maxLimit))
-
-#define SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, maxLimit) do { \
-    if ((strDest) != NULL && (destMax) > 0 && (destMax) <= (maxLimit)) { \
-        *(strDest) = '\0'; \
-    } \
-} SECUREC_WHILE_ZERO
-
-#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
-#define SECUREC_VSNPRINTF_PARAM_ERROR(format, strDest, destMax, count, maxLimit) \
-    (((format) == NULL || (strDest) == NULL || (destMax) == 0 || (destMax) > (maxLimit)) || \
-    ((count) > (SECUREC_STRING_MAX_LEN - 1) && (count) != (size_t)(-1)))
-
-#else
-#define SECUREC_VSNPRINTF_PARAM_ERROR(format, strDest, destMax, count, maxLimit) \
-    (((format) == NULL || (strDest) == NULL || (destMax) == 0 || (destMax) > (maxLimit)) || \
-    ((count) > (SECUREC_STRING_MAX_LEN - 1)))
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-    int SecVsnprintfImpl(char *string, size_t count, const char *format, va_list argList);
-#ifdef SECUREC_FOR_WCHAR
-    int SecVswprintfImpl(wchar_t *string, size_t sizeInWchar, const wchar_t *format, va_list argList);
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-

components/bounds_checking_function/src/secureprintoutput_a.c

@@ -1,174 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: By defining corresponding macro for ANSI string and including "output.inl",
- *              this file generates real underlying function used by printf family API.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#define SECUREC_FORMAT_OUTPUT_INPUT 1
-
-#ifdef SECUREC_FOR_WCHAR
-#undef SECUREC_FOR_WCHAR
-#endif
-
-#include "secureprintoutput.h"
-#if SECUREC_WARP_OUTPUT
-#define SECUREC_FORMAT_FLAG_TABLE_SIZE 128
-SECUREC_INLINE const char *SecSkipKnownFlags(const char *format)
-{
-    static const unsigned char flagTable[SECUREC_FORMAT_FLAG_TABLE_SIZE] = {
-        /*
-         * Known flag is  "0123456789 +-#hlLwZzjqt*I$"
-         */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00,
-        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
-        0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
-    };
-    const char *fmt = format;
-    while (*fmt != '\0') {
-        char fmtChar = *fmt;
-        if ((unsigned char)fmtChar > 0x7f) { /* 0x7f is upper limit of format char value */
-            break;
-        }
-        if (flagTable[(unsigned char)fmtChar] == 0) {
-            break;
-        }
-        ++fmt;
-    }
-    return fmt;
-}
-
-SECUREC_INLINE int SecFormatContainN(const char *format)
-{
-    const char *fmt = format;
-    while (*fmt != '\0') {
-        ++fmt;
-        /* Skip normal char */
-        if (*(fmt - 1) != '%') {
-            continue;
-        }
-        /* Meet %% */
-        if (*fmt == '%') {
-            ++fmt; /* Point to  the character after the %. Correct handling %%xx */
-            continue;
-        }
-        /* Now parse %..., fmt point to the character after the % */
-        fmt = SecSkipKnownFlags(fmt);
-        if (*fmt == 'n') {
-            return 1;
-        }
-    }
-    return 0;
-}
-/*
- * Multi character formatted output implementation, the count include \0 character, must be greater than zero
- */
-int SecVsnprintfImpl(char *string, size_t count, const char *format, va_list argList)
-{
-    int retVal;
-    if (SecFormatContainN(format) != 0) {
-        string[0] = '\0';
-        return -1;
-    }
-    retVal = vsnprintf(string, count, format, argList);
-    if (retVal >= (int)count) { /* The size_t to int is ok, count max is SECUREC_STRING_MAX_LEN */
-        /* The buffer was too small; we return truncation */
-        string[count - 1] = '\0';
-        return SECUREC_PRINTF_TRUNCATE;
-    }
-    if (retVal < 0) {
-        string[0] = '\0'; /* Empty the dest strDest */
-        return -1;
-    }
-    return retVal;
-}
-#else
-#if SECUREC_IN_KERNEL
-#include <linux/ctype.h>
-#endif
-
-#ifndef EOF
-#define EOF (-1)
-#endif
-
-#include "output.inl"
-
-/*
- * Multi character formatted output implementation
- */
-int SecVsnprintfImpl(char *string, size_t count, const char *format, va_list argList)
-{
-    SecPrintfStream str;
-    int retVal;
-
-    str.count = (int)count; /* The count include \0 character, must be greater than zero */
-    str.cur = string;
-
-    retVal = SecOutputS(&str, format, argList);
-    if (retVal >= 0) {
-        if (SecPutZeroChar(&str) == 0) {
-            return retVal;
-        }
-    }
-    if (str.count < 0) {
-        /* The buffer was too small, then truncate */
-        string[count - 1] = '\0';
-        return SECUREC_PRINTF_TRUNCATE;
-    }
-    string[0] = '\0'; /* Empty the dest string */
-    return -1;
-}
-
-/*
- * Write a wide character
- */
-SECUREC_INLINE void SecWriteMultiChar(char ch, int num, SecPrintfStream *f, int *pnumwritten)
-{
-    int count;
-    for (count = num; count > 0; --count) {
-        --f->count; /* f -> count may be negative,indicating insufficient space */
-        if (f->count < 0) {
-            *pnumwritten = -1;
-            return;
-        }
-        *(f->cur) = ch;
-        ++f->cur;
-        *pnumwritten = *pnumwritten + 1;
-    }
-}
-
-/*
- * Write string function, where this function is called, make sure that len is greater than 0
- */
-SECUREC_INLINE void SecWriteString(const char *string, int len, SecPrintfStream *f, int *pnumwritten)
-{
-    const char *str = string;
-    int count;
-    for (count = len; count > 0; --count) {
-        --f->count; /* f -> count may be negative,indicating insufficient space */
-        if (f->count < 0) {
-            *pnumwritten = -1;
-            return;
-        }
-        *(f->cur) = *str;
-        ++f->cur;
-        ++str;
-    }
-    *pnumwritten = *pnumwritten + (int)(size_t)(str - string);
-}
-#endif
-

components/bounds_checking_function/src/secureprintoutput_w.c

@@ -1,149 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: By defining corresponding macro for UNICODE string and including "output.inl",
- *              this file generates real underlying function used by printf family API.
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-/* If some platforms don't have wchar.h, dont't include it */
-#if !(defined(SECUREC_VXWORKS_PLATFORM))
-/* If there is no macro above, it will cause compiling alarm */
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-#ifndef _CRTIMP_ALTERNATIVE
-#define _CRTIMP_ALTERNATIVE     /* Comment microsoft *_s function */
-#endif
-#ifndef __STDC_WANT_SECURE_LIB__
-#define __STDC_WANT_SECURE_LIB__ 0
-#endif
-#endif
-#include <wchar.h>
-#endif
-
-/* fix redefined */
-#undef SECUREC_ENABLE_WCHAR_FUNC
-/* Disable wchar func to clear vs warning */
-#define SECUREC_ENABLE_WCHAR_FUNC   0
-#define SECUREC_FORMAT_OUTPUT_INPUT 1
-
-#ifndef SECUREC_FOR_WCHAR
-#define SECUREC_FOR_WCHAR
-#endif
-
-#if defined(SECUREC_WARP_OUTPUT) && SECUREC_WARP_OUTPUT
-#undef SECUREC_WARP_OUTPUT
-#define SECUREC_WARP_OUTPUT 0
-#endif
-
-#include "secureprintoutput.h"
-
-SECUREC_INLINE void SecWriteCharW(wchar_t ch, SecPrintfStream *f, int *pnumwritten);
-SECUREC_INLINE int SecPutWcharStrEndingZero(SecPrintfStream *str, int zeroCount);
-
-#include "output.inl"
-
-/*
- * Wide character formatted output implementation
- */
-int SecVswprintfImpl(wchar_t *string, size_t sizeInWchar, const wchar_t *format, va_list argList)
-{
-    SecPrintfStream str;
-    int retVal; /* If initialization causes  e838 */
-
-    str.cur = (char *)string;
-    /* This count include \0 character, Must be greater than zero */
-    str.count = (int)(sizeInWchar * sizeof(wchar_t));
-
-    retVal = SecOutputSW(&str, format, argList);
-    if (retVal >= 0) {
-        if (SecPutWcharStrEndingZero(&str, (int)sizeof(wchar_t)) == 0) {
-            return retVal;
-        }
-    }
-    if (str.count < 0) {
-        /* The buffer was too small, then truncate */
-        string[sizeInWchar - 1] = L'\0';
-        return SECUREC_PRINTF_TRUNCATE;
-    }
-    string[0] = L'\0'; /* Empty the dest string */
-    return -1;
-}
-
-/*
- * Output a wide character zero end into the SecPrintfStream structure
- */
-SECUREC_INLINE int SecPutWcharStrEndingZero(SecPrintfStream *str, int zeroCount)
-{
-    int count;
-    for (count = zeroCount; count > 0; --count) {
-        if (SecPutZeroChar(str) != 0) {
-            return -1;
-        }
-    }
-    return 0;
-}
-
-/*
- * Output a wide character into the SecPrintfStream structure
- */
-SECUREC_INLINE int SecPutCharW(wchar_t ch, SecPrintfStream *f)
-{
-    f->count -= (int)sizeof(wchar_t); /* f -> count may be negative,indicating insufficient space */
-    if (f->count >= 0) {
-        *(wchar_t *)(void *)(f->cur) = ch;
-        f->cur += sizeof(wchar_t);
-        return 0;
-    }
-    return -1;
-}
-
-/*
- * Output a wide character into the SecPrintfStream structure, returns the number of characters written
- */
-SECUREC_INLINE void SecWriteCharW(wchar_t ch, SecPrintfStream *f, int *pnumwritten)
-{
-    if (SecPutCharW(ch, f) == 0) {
-        *pnumwritten = *pnumwritten + 1;
-    } else {
-        *pnumwritten = -1;
-    }
-}
-
-/*
- * Output multiple wide character into the SecPrintfStream structure,  returns the number of characters written
- */
-SECUREC_INLINE void SecWriteMultiCharW(wchar_t ch, int num, SecPrintfStream *f, int *pnumwritten)
-{
-    int count;
-    for (count = num; count > 0; --count) {
-        SecWriteCharW(ch, f, pnumwritten);
-        if (*pnumwritten == -1) {
-            break;
-        }
-    }
-}
-
-/*
- * Output a wide string into the SecPrintfStream structure,  returns the number of characters written
- */
-SECUREC_INLINE void SecWriteStringW(const wchar_t *string, int len, SecPrintfStream *f, int *pnumwritten)
-{
-    const wchar_t *str = string;
-    int count;
-    for (count = len; count > 0; --count) {
-        SecWriteCharW(*str, f, pnumwritten);
-        ++str;
-        if (*pnumwritten == -1) {
-            break;
-        }
-    }
-}
-

components/bounds_checking_function/src/snprintf_s.c

@@ -1,111 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: snprintf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-#if SECUREC_ENABLE_SNPRINTF
-/*
- * <FUNCTION DESCRIPTION>
- *    The snprintf_s function is equivalent to the snprintf function
- *    except for the parameter destMax/count and the explicit runtime-constraints violation
- *    The snprintf_s function formats and stores count or fewer characters in
- *    strDest and appends a terminating null. Each argument (if any) is converted
- *    and output according to the corresponding format specification in format.
- *    The formatting is consistent with the printf family of functions; If copying
- *    occurs between strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    strDest                 Storage location for the output.
- *    destMax                 The size of the storage location for output. Size
- *                                 in bytes for snprintf_s or size in words for snwprintf_s.
- *    count                    Maximum number of character to store.
- *    format                  Format-control string.
- *    ...                        Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    strDest                 is updated
- *
- * <RETURN VALUE>
- *    return  the number of characters written, not including the terminating null
- *    return -1 if an  error occurs.
- *    return -1 if count < destMax and the output string  has been truncated
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- *
- */
-int snprintf_s(char *strDest, size_t destMax, size_t count, const char *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vsnprintf_s(strDest, destMax, count, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(snprintf_s);
-#endif
-#endif
-
-#if SECUREC_SNPRINTF_TRUNCATED
-/*
- * <FUNCTION DESCRIPTION>
- *    The snprintf_truncated_s function is equivalent to the snprintf function
- *    except for the parameter destMax/count and the explicit runtime-constraints violation
- *    The snprintf_truncated_s function formats and stores count or fewer characters in
- *    strDest and appends a terminating null. Each argument (if any) is converted
- *    and output according to the corresponding format specification in format.
- *    The formatting is consistent with the printf family of functions; If copying
- *    occurs between strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    strDest                 Storage location for the output.
- *    destMax                 The size of the storage location for output. Size
- *                                 in bytes for snprintf_truncated_s or size in words for snwprintf_s.
- *    format                  Format-control string.
- *    ...                        Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    strDest                 is updated
- *
- * <RETURN VALUE>
- *    return  the number of characters written, not including the terminating null
- *    return -1 if an  error occurs.
- *    return destMax-1 if output string  has been truncated
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- *
- */
-int snprintf_truncated_s(char *strDest, size_t destMax, const char *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vsnprintf_truncated_s(strDest, destMax, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(snprintf_truncated_s);
-#endif
-
-#endif
-

components/bounds_checking_function/src/sprintf_s.c

@@ -1,59 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: sprintf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The sprintf_s function is equivalent to the sprintf function
- *    except for the parameter destMax and the explicit runtime-constraints violation
- *    The sprintf_s function formats and stores a series of characters and values
- *    in strDest. Each argument (if any) is converted and output according to
- *    the corresponding format specification in format. The format consists of
- *    ordinary characters and has the same form and function as the format argument
- *    for printf. A null character is appended after the last character written.
- *    If copying occurs between strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    strDest                 Storage location for output.
- *    destMax                Maximum number of characters to store.
- *    format                  Format-control string.
- *    ...                        Optional arguments
- *
- * <OUTPUT PARAMETERS>
- *    strDest                 is updated
- *
- * <RETURN VALUE>
- *    return the number of bytes stored in strDest, not counting the terminating null character.
- *    return -1 if an error occurred.
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-int sprintf_s(char *strDest, size_t destMax, const char *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vsprintf_s(strDest, destMax, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(sprintf_s);
-#endif
-

components/bounds_checking_function/src/sscanf_s.c

@@ -1,59 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: sscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The sscanf_s function is equivalent to fscanf_s,
- *     except that input is obtained from a string (specified by the argument buffer) rather than from a stream
- *    The sscanf function reads data from buffer into the location given by each
- *    argument. Every argument must be a pointer to a variable with a type that
- *    corresponds to a type specifier in format. The format argument controls the
- *    interpretation of the input fields and has the same form and function as
- *    the format argument for the scanf function.
- *    If copying takes place between strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    buffer                 Stored data.
- *    format                 Format control string, see Format Specifications.
- *    ...                    Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    ...                    The converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned.
- *    A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int sscanf_s(const char *buffer, const char *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vsscanf_s(buffer, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(sscanf_s);
-#endif
-

components/bounds_checking_function/src/strcat_s.c

@@ -1,102 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: strcat_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * Befor this function, the basic parameter checking has been done
- */
-SECUREC_INLINE errno_t SecDoCat(char *strDest, size_t destMax, const char *strSrc)
-{
-    size_t destLen;
-    size_t srcLen;
-    size_t maxSrcLen;
-    SECUREC_CALC_STR_LEN(strDest, destMax, &destLen);
-    /* Only optimize strSrc, do not apply this function to strDest */
-    maxSrcLen = destMax - destLen;
-    SECUREC_CALC_STR_LEN_OPT(strSrc, maxSrcLen, &srcLen);
-
-    if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
-        strDest[0] = '\0';
-        if (strDest + destLen <= strSrc && destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("strcat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_BUFFER_OVERLAP("strcat_s");
-        return EOVERLAP_AND_RESET;
-    }
-    if (srcLen + destLen >= destMax || strDest == strSrc) {
-        strDest[0] = '\0';
-        if (destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("strcat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_INVALID_RANGE("strcat_s");
-        return ERANGE_AND_RESET;
-    }
-    SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, srcLen + 1); /* Single character length  include \0 */
-    return EOK;
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *  The strcat_s function appends a copy of the string pointed to by strSrc (including the terminating null character)
- *  to the end of the  string pointed to by strDest.
- *  The initial character of strSrc overwrites the terminating null character of strDest.
- *  strcat_s will return EOVERLAP_AND_RESET if the source and destination strings overlap.
- *
- *  Note that the second parameter is the total size of the buffer, not the
- *  remaining size.
- *
- * <INPUT PARAMETERS>
- *  strDest             Null-terminated destination string buffer.
- *  destMax             Size of the destination string buffer.
- *  strSrc              Null-terminated source string buffer.
- *
- * <OUTPUT PARAMETERS>
- *    strDest             is updated
- *
- * <RETURN VALUE>
- *    EOK                 Success
- *    EINVAL              strDest is  NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
- *    EINVAL_AND_RESET    (strDest unterminated  and all other parameters are valid) or
- *                        (strDest != NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN)
- *    ERANGE              destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
- *    ERANGE_AND_RESET      strDest have not enough space  and all other parameters are valid  and not overlap
- *    EOVERLAP_AND_RESET   dest buffer and source buffer are overlapped and all  parameters are valid
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t strcat_s(char *strDest, size_t destMax, const char *strSrc)
-{
-    if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("strcat_s");
-        return ERANGE;
-    }
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("strcat_s");
-        if (strDest != NULL) {
-            strDest[0] = '\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    return SecDoCat(strDest, destMax, strSrc);
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(strcat_s);
-#endif
-

components/bounds_checking_function/src/strcpy_s.c

@@ -1,349 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: strcpy_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-#ifndef SECUREC_STRCPY_WITH_PERFORMANCE
-#define SECUREC_STRCPY_WITH_PERFORMANCE 1
-#endif
-
-#define SECUREC_STRCPY_PARAM_OK(strDest, destMax, strSrc) ((destMax) > 0 && \
-    (destMax) <= SECUREC_STRING_MAX_LEN && (strDest) != NULL && (strSrc) != NULL && (strDest) != (strSrc))
-
-#if (!SECUREC_IN_KERNEL) && SECUREC_STRCPY_WITH_PERFORMANCE
-#ifndef SECUREC_STRCOPY_THRESHOLD_SIZE
-#define SECUREC_STRCOPY_THRESHOLD_SIZE   32UL
-#endif
-/* The purpose of converting to void is to clean up the alarm */
-#define SECUREC_SMALL_STR_COPY(strDest, strSrc, lenWithTerm) do { \
-    if (SECUREC_ADDR_ALIGNED_8(strDest) && SECUREC_ADDR_ALIGNED_8(strSrc)) { \
-        /* Use struct assignment */ \
-        switch (lenWithTerm) { \
-            case 1: \
-                *(strDest) = *(strSrc); \
-                break; \
-            case 2: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 2); \
-                break; \
-            case 3: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 3); \
-                break; \
-            case 4: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 4); \
-                break; \
-            case 5: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 5); \
-                break; \
-            case 6: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 6); \
-                break; \
-            case 7: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 7); \
-                break; \
-            case 8: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 8); \
-                break; \
-            case 9: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 9); \
-                break; \
-            case 10: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 10); \
-                break; \
-            case 11: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 11); \
-                break; \
-            case 12: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 12); \
-                break; \
-            case 13: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 13); \
-                break; \
-            case 14: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 14); \
-                break; \
-            case 15: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 15); \
-                break; \
-            case 16: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 16); \
-                break; \
-            case 17: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 17); \
-                break; \
-            case 18: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 18); \
-                break; \
-            case 19: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 19); \
-                break; \
-            case 20: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 20); \
-                break; \
-            case 21: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 21); \
-                break; \
-            case 22: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 22); \
-                break; \
-            case 23: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 23); \
-                break; \
-            case 24: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 24); \
-                break; \
-            case 25: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 25); \
-                break; \
-            case 26: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 26); \
-                break; \
-            case 27: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 27); \
-                break; \
-            case 28: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 28); \
-                break; \
-            case 29: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 29); \
-                break; \
-            case 30: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 30); \
-                break; \
-            case 31: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 31); \
-                break; \
-            case 32: \
-                SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 32); \
-                break; \
-            default: \
-                /* Do nothing */ \
-                break; \
-        } /* END switch */ \
-    } else { \
-        char *tmpStrDest_ = (char *)(strDest); \
-        const char *tmpStrSrc_ = (const char *)(strSrc); \
-        switch (lenWithTerm) { \
-            case 32: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 31: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 30: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 29: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 28: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 27: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 26: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 25: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 24: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 23: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 22: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 21: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 20: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 19: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 18: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 17: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 16: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 15: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 14: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 13: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 12: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 11: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 10: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 9: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 8: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 7: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 6: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 5: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 4: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 3: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 2: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            case 1: \
-                *(tmpStrDest_++) = *(tmpStrSrc_++); \
-                /* fall-through */ /* FALLTHRU */ \
-            default: \
-                /* Do nothing */ \
-                break; \
-        } \
-    } \
-} SECUREC_WHILE_ZERO
-#endif
-
-#if SECUREC_IN_KERNEL || (!SECUREC_STRCPY_WITH_PERFORMANCE)
-#define SECUREC_STRCPY_OPT(dest, src, lenWithTerm) SECUREC_MEMCPY_WARP_OPT((dest), (src), (lenWithTerm))
-#else
-/*
- * Performance optimization. lenWithTerm  include '\0'
- */
-#define SECUREC_STRCPY_OPT(dest, src, lenWithTerm) do { \
-    if ((lenWithTerm) > SECUREC_STRCOPY_THRESHOLD_SIZE) { \
-        SECUREC_MEMCPY_WARP_OPT((dest), (src), (lenWithTerm)); \
-    } else { \
-        SECUREC_SMALL_STR_COPY((dest), (src), (lenWithTerm)); \
-    } \
-} SECUREC_WHILE_ZERO
-#endif
-
-/*
- * Check Src Range
- */
-SECUREC_INLINE errno_t CheckSrcRange(char *strDest, size_t destMax, const char *strSrc)
-{
-    size_t tmpDestMax = destMax;
-    const char *tmpSrc = strSrc;
-    /* Use destMax as boundary checker and destMax must be greater than zero */
-    while (*tmpSrc != '\0' && tmpDestMax > 0) {
-        ++tmpSrc;
-        --tmpDestMax;
-    }
-    if (tmpDestMax == 0) {
-        strDest[0] = '\0';
-        SECUREC_ERROR_INVALID_RANGE("strcpy_s");
-        return ERANGE_AND_RESET;
-    }
-    return EOK;
-}
-
-/*
- * Handling errors
- */
-errno_t strcpy_error(char *strDest, size_t destMax, const char *strSrc)
-{
-    if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("strcpy_s");
-        return ERANGE;
-    }
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("strcpy_s");
-        if (strDest != NULL) {
-            strDest[0] = '\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    return CheckSrcRange(strDest, destMax, strSrc);
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The strcpy_s function copies the string pointed to  strSrc
- *          (including the terminating null character) into the array pointed to by strDest
- *    The destination string must be large enough to hold the source string,
- *    including the terminating null character. strcpy_s will return EOVERLAP_AND_RESET
- *    if the source and destination strings overlap.
- *
- * <INPUT PARAMETERS>
- *    strDest                          Location of destination string buffer
- *    destMax                        Size of the destination string buffer.
- *    strSrc                            Null-terminated source string buffer.
- *
- * <OUTPUT PARAMETERS>
- *    strDest                         is updated.
- *
- * <RETURN VALUE>
- *    EOK                               Success
- *    EINVAL                          strDest is  NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
- *    EINVAL_AND_RESET       strDest !=  NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
- *    ERANGE                         destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
- *    ERANGE_AND_RESET      strDest have not enough space  and all other parameters are valid  and not overlap
- *    EOVERLAP_AND_RESET   dest buffer and source buffer are overlapped and all  parameters are valid
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t strcpy_s(char *strDest, size_t destMax, const char *strSrc)
-{
-    if (SECUREC_STRCPY_PARAM_OK(strDest, destMax, strSrc)) {
-        size_t srcStrLen;
-        SECUREC_CALC_STR_LEN(strSrc, destMax, &srcStrLen);
-        ++srcStrLen; /* The length include '\0' */
-
-        if (srcStrLen <= destMax) {
-            /* Use mem overlap check include '\0' */
-            if (SECUREC_MEMORY_NO_OVERLAP(strDest, strSrc, srcStrLen)) {
-                /* Performance optimization srcStrLen include '\0' */
-                SECUREC_STRCPY_OPT(strDest, strSrc, srcStrLen);
-                return EOK;
-            } else {
-                strDest[0] = '\0';
-                SECUREC_ERROR_BUFFER_OVERLAP("strcpy_s");
-                return EOVERLAP_AND_RESET;
-            }
-        }
-    }
-    return strcpy_error(strDest, destMax, strSrc);
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(strcpy_s);
-#endif
-

components/bounds_checking_function/src/strncat_s.c

@@ -1,120 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: strncat_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * Befor this function, the basic parameter checking has been done
- */
-SECUREC_INLINE errno_t SecDoCatLimit(char *strDest, size_t destMax, const char *strSrc, size_t count)
-{
-    size_t destLen;
-    size_t srcLen;
-    SECUREC_CALC_STR_LEN(strDest, destMax, &destLen);
-    /*
-     * The strSrc is no longer optimized. The reason is that when count is small,
-     * the efficiency of strnlen is higher than that of self realization.
-     */
-    SECUREC_CALC_STR_LEN(strSrc, count, &srcLen);
-
-    if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
-        strDest[0] = '\0';
-        if (strDest + destLen <= strSrc && destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("strncat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_BUFFER_OVERLAP("strncat_s");
-        return EOVERLAP_AND_RESET;
-    }
-    if (srcLen + destLen >= destMax || strDest == strSrc) {
-        strDest[0] = '\0';
-        if (destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("strncat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_INVALID_RANGE("strncat_s");
-        return ERANGE_AND_RESET;
-    }
-    SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, srcLen);    /* No terminator */
-    *(strDest + destLen + srcLen) = '\0';
-    return EOK;
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The strncat_s function appends not more than n successive  characters
- *    (not including the terminating null  character)
- *     from the array pointed to by strSrc to the end of the  string pointed to by strDest
- *    The strncat_s function try to append the first D characters of strSrc to
- *    the end of strDest, where D is the lesser of count and the length of strSrc.
- *    If appending those D characters will fit within strDest (whose size is given
- *    as destMax) and still leave room for a null terminator, then those characters
- *    are appended, starting at the original terminating null of strDest, and a
- *    new terminating null is appended; otherwise, strDest[0] is set to the null
- *    character.
- *
- * <INPUT PARAMETERS>
- *    strDest            Null-terminated destination string.
- *    destMax            Size of the destination buffer.
- *    strSrc             Null-terminated source string.
- *    count              Number of character to append, or truncate.
- *
- * <OUTPUT PARAMETERS>
- *    strDest            is updated
- *
- * <RETURN VALUE>
- *    EOK                Success
- *    EINVAL             strDest is  NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
- *    EINVAL_AND_RESET      (strDest unterminated  and all other parameters are valid)or
- *                        (strDest !=  NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN)
- *    ERANGE                         destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
- *    ERANGE_AND_RESET      strDest have not enough space  and all other parameters are valid  and not overlap
- *    EOVERLAP_AND_RESET   dest buffer and source buffer are overlapped and all  parameters are valid
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t strncat_s(char *strDest, size_t destMax, const char *strSrc, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("strncat_s");
-        return ERANGE;
-    }
-
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("strncat_s");
-        if (strDest != NULL) {
-            strDest[0] = '\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    if (count > SECUREC_STRING_MAX_LEN) {
-#ifdef  SECUREC_COMPATIBLE_WIN_FORMAT
-        if (count == (size_t)(-1)) {
-            /* Windows internal functions may pass in -1 when calling this function */
-            return SecDoCatLimit(strDest, destMax, strSrc, destMax);
-        }
-#endif
-        strDest[0] = '\0';
-        SECUREC_ERROR_INVALID_RANGE("strncat_s");
-        return ERANGE_AND_RESET;
-    }
-    return SecDoCatLimit(strDest, destMax, strSrc, count);
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(strncat_s);
-#endif
-

components/bounds_checking_function/src/strncpy_s.c

@@ -1,141 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: strncpy_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-#if defined(SECUREC_COMPATIBLE_WIN_FORMAT)
-#define SECUREC_STRNCPY_PARAM_OK(strDest, destMax, strSrc, count) \
-    (((destMax) > 0 && (destMax) <= SECUREC_STRING_MAX_LEN && (strDest) != NULL && (strSrc) != NULL && \
-    ((count) <= SECUREC_STRING_MAX_LEN || (count) == ((size_t)(-1))) && (count) > 0))
-#else
-#define SECUREC_STRNCPY_PARAM_OK(strDest, destMax, strSrc, count) \
-    (((destMax) > 0 && (destMax) <= SECUREC_STRING_MAX_LEN && (strDest) != NULL && (strSrc) != NULL && \
-    (count) <= SECUREC_STRING_MAX_LEN && (count) > 0))
-#endif
-
-/*
- * Check Src Count Range
- */
-SECUREC_INLINE errno_t CheckSrcCountRange(char *strDest, size_t destMax, const char *strSrc, size_t count)
-{
-    size_t tmpDestMax = destMax;
-    size_t tmpCount = count;
-    const char *endPos = strSrc;
-
-    /* Use destMax and  count as boundary checker and destMax must be greater than zero */
-    while (*(endPos) != '\0' && tmpDestMax > 0 && tmpCount > 0) {
-        ++endPos;
-        --tmpCount;
-        --tmpDestMax;
-    }
-    if (tmpDestMax == 0) {
-        strDest[0] = '\0';
-        SECUREC_ERROR_INVALID_RANGE("strncpy_s");
-        return ERANGE_AND_RESET;
-    }
-    return EOK;
-}
-
-/*
- * Handling errors, when dest euqal src return EOK
- */
-errno_t strncpy_error(char *strDest, size_t destMax, const char *strSrc, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("strncpy_s");
-        return ERANGE;
-    }
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("strncpy_s");
-        if (strDest != NULL) {
-            strDest[0] = '\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    if (count > SECUREC_STRING_MAX_LEN) {
-        strDest[0] = '\0';      /* Clear dest string */
-        SECUREC_ERROR_INVALID_RANGE("strncpy_s");
-        return ERANGE_AND_RESET;
-    }
-    if (count == 0) {
-        strDest[0] = '\0';
-        return EOK;
-    }
-    return CheckSrcCountRange(strDest, destMax, strSrc, count);
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *   The strncpy_s function copies not more than n successive characters (not including the terminating null character)
- *                     from the array pointed to by strSrc to the array pointed to by strDest.
- *
- * <INPUT PARAMETERS>
- *    strDest                          Destination string.
- *    destMax                          The size of the destination string, in characters.
- *    strSrc                            Source string.
- *    count                              Number of characters to be copied.
- *
- * <OUTPUT PARAMETERS>
- *    strDest                           is updated
- *
- * <RETURN VALUE>
- *    EOK                               Success
- *    EINVAL                          strDest is  NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
- *    EINVAL_AND_RESET       strDest !=  NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
- *    ERANGE                         destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
- *    ERANGE_AND_RESET      strDest have not enough space  and all other parameters are valid  and not overlap
- *    EOVERLAP_AND_RESET   dest buffer and source buffer are overlapped and all  parameters are valid
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t strncpy_s(char *strDest, size_t destMax, const char *strSrc, size_t count)
-{
-    if (SECUREC_STRNCPY_PARAM_OK(strDest, destMax, strSrc, count)) {
-        size_t minCpLen;        /* Use it to store the maxi length limit */
-        if (count < destMax) {
-            SECUREC_CALC_STR_LEN(strSrc, count, &minCpLen); /* No ending terminator */
-        } else {
-            size_t tmpCount = destMax;
-#ifdef  SECUREC_COMPATIBLE_WIN_FORMAT
-            if (count == ((size_t)(-1))) {
-                tmpCount = destMax - 1;
-            }
-#endif
-            SECUREC_CALC_STR_LEN(strSrc, tmpCount, &minCpLen); /* No ending terminator */
-            if (minCpLen == destMax) {
-                strDest[0] = '\0';
-                SECUREC_ERROR_INVALID_RANGE("strncpy_s");
-                return ERANGE_AND_RESET;
-            }
-        }
-        if (SECUREC_STRING_NO_OVERLAP(strDest, strSrc, minCpLen) || strDest == strSrc) {
-            /* Not overlap */
-            SECUREC_MEMCPY_WARP_OPT(strDest, strSrc, minCpLen);    /* Copy string without terminator */
-            strDest[minCpLen] = '\0';
-            return EOK;
-        } else {
-            strDest[0] = '\0';
-            SECUREC_ERROR_BUFFER_OVERLAP("strncpy_s");
-            return EOVERLAP_AND_RESET;
-        }
-    }
-    return strncpy_error(strDest, destMax, strSrc, count);
-}
-
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(strncpy_s);
-#endif
-

components/bounds_checking_function/src/strtok_s.c

@@ -1,117 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: strtok_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-SECUREC_INLINE int SecIsInDelimit(char ch, const char *strDelimit)
-{
-    const char *ctl = strDelimit;
-    while (*ctl != '\0' && *ctl != ch) {
-        ++ctl;
-    }
-    return (int)(*ctl != '\0');
-}
-
-/*
- * Find beginning of token (skip over leading delimiters).
- * Note that there is no token if this loop sets string to point to the terminal null.
- */
-SECUREC_INLINE char *SecFindBegin(char *strToken, const char *strDelimit)
-{
-    char *token = strToken;
-    while (*token != '\0') {
-        if (SecIsInDelimit(*token, strDelimit) != 0) {
-            ++token;
-            continue;
-        }
-        /* Don't find any delimiter in string header, break the loop */
-        break;
-    }
-    return token;
-}
-
-/*
- * Find rest of token
- */
-SECUREC_INLINE char *SecFindRest(char *strToken, const char *strDelimit)
-{
-    /* Find the rest of the token. If it is not the end of the string, put a null there */
-    char *token = strToken;
-    while (*token != '\0') {
-        if (SecIsInDelimit(*token, strDelimit) != 0) {
-            /* Find a delimiter, set string termintor */
-            *token = '\0';
-            ++token;
-            break;
-        }
-        ++token;
-    }
-    return token;
-}
-
-/*
- * Find the final position pointer
- */
-SECUREC_INLINE char *SecUpdateToken(char *strToken, const char *strDelimit, char **context)
-{
-    /* Point to updated position. Record string position for next search in the context */
-    *context = SecFindRest(strToken, strDelimit);
-    /* Determine if a token has been found. */
-    if (*context == strToken) {
-        return NULL;
-    }
-    return strToken;
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The strtok_s function parses a string into a sequence of strToken,
- *    replace all characters in strToken string that match to strDelimit set with 0.
- *    On the first call to strtok_s the string to be parsed should be specified in strToken.
- *    In each subsequent call that should parse the same string, strToken should be NULL
- * <INPUT PARAMETERS>
- *    strToken            String containing token or tokens.
- *    strDelimit          Set of delimiter characters.
- *    context             Used to store position information between calls
- *                             to strtok_s
- * <OUTPUT PARAMETERS>
- *   context               is updated
- * <RETURN VALUE>
- *   On the first call returns the address of the first non \0 character, otherwise NULL is returned.
- *   In subsequent calls, the strtoken is set to NULL, and the context set is the same as the previous call,
- *   return NULL if the *context string length is equal 0, otherwise return *context.
- */
-char *strtok_s(char *strToken, const char *strDelimit, char **context)
-{
-    char *orgToken = strToken;
-    /* Validate delimiter and string context */
-    if (context == NULL || strDelimit == NULL) {
-        return NULL;
-    }
-    /* Valid input string and string pointer from where to search */
-    if (orgToken == NULL && *context == NULL) {
-        return NULL;
-    }
-    /* If string is null, continue searching from previous string position stored in context */
-    if (orgToken == NULL) {
-        orgToken = *context;
-    }
-    orgToken = SecFindBegin(orgToken, strDelimit);
-    return SecUpdateToken(orgToken, strDelimit, context);
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(strtok_s);
-#endif
-

components/bounds_checking_function/src/swprintf_s.c

@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: swprintf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *   The  swprintf_s  function  is  the  wide-character  equivalent  of the sprintf_s function
- *
- * <INPUT PARAMETERS>
- *    strDest                   Storage location for the output.
- *    destMax                   Maximum number of characters to store.
- *    format                    Format-control string.
- *    ...                        Optional arguments
- *
- * <OUTPUT PARAMETERS>
- *    strDest                    is updated
- *
- * <RETURN VALUE>
- *    return  the number of wide characters stored in strDest, not  counting the terminating null wide character.
- *    return -1  if an error occurred.
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-int swprintf_s(wchar_t *strDest, size_t destMax, const wchar_t *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vswprintf_s(strDest, destMax, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-

components/bounds_checking_function/src/swscanf_s.c

@@ -1,55 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: swscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The  swscanf_s  function  is  the  wide-character  equivalent  of the sscanf_s function
- *    The swscanf_s function reads data from buffer into the location given by
- *    each argument. Every argument must be a pointer to a variable with a type
- *    that corresponds to a type specifier in format. The format argument controls
- *    the interpretation of the input fields and has the same form and function
- *    as the format argument for the scanf function. If copying takes place between
- *    strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    buffer                 Stored data.
- *    format                 Format control string, see Format Specifications.
- *    ...                    Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    ...                    the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; The return value does not include fields that were read but not
- *    assigned.
- *    A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int swscanf_s(const wchar_t *buffer, const wchar_t *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vswscanf_s(buffer, format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-

components/bounds_checking_function/src/vfscanf_s.c

@@ -1,65 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vfscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "secinput.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The vfscanf_s function is equivalent to fscanf_s, with the variable argument list replaced by argList
- *    The vfscanf_s function reads data from the current position of stream into
- *    the locations given by argument (if any). Each argument must be a pointer
- *    to a variable of a type that corresponds to a type specifier in format.
- *    format controls the interpretation of the input fields and has the same
- *    form and function as the format argument for scanf.
- *
- * <INPUT PARAMETERS>
- *    stream               Pointer to FILE structure.
- *    format               Format control string, see Format Specifications.
- *    argList              pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    argList              the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned. A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int vfscanf_s(FILE *stream, const char *format, va_list argList)
-{
-    int retVal;                 /* If initialization causes  e838 */
-    SecFileStream fStr;
-
-    if (stream == NULL || format == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("vfscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    if (stream == SECUREC_STREAM_STDIN) {
-        return vscanf_s(format, argList);
-    }
-
-    SECUREC_LOCK_FILE(stream);
-    SECUREC_FILE_STREAM_FROM_FILE(&fStr, stream);
-    retVal = SecInputS(&fStr, format, argList);
-    SECUREC_UNLOCK_FILE(stream);
-    if (retVal < 0) {
-        SECUREC_ERROR_INVALID_PARAMTER("vfscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-
-    return retVal;
-}
-

components/bounds_checking_function/src/vfwscanf_s.c

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vfwscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECUREC_FOR_WCHAR
-#define SECUREC_FOR_WCHAR
-#endif
-
-#include "secinput.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The  vfwscanf_s  function  is  the  wide-character  equivalent  of the vfscanf_s function
- *    The vfwscanf_s function reads data from the current position of stream into
- *    the locations given by argument (if any). Each argument must be a pointer
- *    to a variable of a type that corresponds to a type specifier in format.
- *    format controls the interpretation of the input fields and has the same form
- *    and function as the format argument for scanf.
- *
- * <INPUT PARAMETERS>
- *    stream               Pointer to FILE structure.
- *    format               Format control string, see Format Specifications.
- *    argList              pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    argList              the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned. A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int vfwscanf_s(FILE *stream, const wchar_t *format, va_list argList)
-{
-    int retVal; /* If initialization causes  e838 */
-    SecFileStream fStr;
-
-    if (stream == NULL || format == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("vfwscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    if (stream == SECUREC_STREAM_STDIN) {
-        return vwscanf_s(format, argList);
-    }
-
-    SECUREC_LOCK_FILE(stream);
-    SECUREC_FILE_STREAM_FROM_FILE(&fStr, stream);
-    retVal = SecInputSW(&fStr, format, argList);
-    SECUREC_UNLOCK_FILE(stream);
-    if (retVal < 0) {
-        SECUREC_ERROR_INVALID_PARAMTER("vfwscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    return retVal;
-}
-

components/bounds_checking_function/src/vscanf_s.c

@@ -1,64 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "secinput.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *     The vscanf_s function is equivalent to scanf_s, with the variable argument list replaced by argList,
- *     The vscanf_s function reads data from the standard input stream stdin and
- *    writes the data into the location that's given by argument. Each argument
- *    must be a pointer to a variable of a type that corresponds to a type specifier
- *    in format. If copying occurs between strings that overlap, the behavior is
- *    undefined.
- *
- * <INPUT PARAMETERS>
- *    format                Format control string.
- *    argList               pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    argList               the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Returns the number of fields successfully converted and assigned;
- *    the return value does not include fields that were read but not assigned.
- *    A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int vscanf_s(const char *format, va_list argList)
-{
-    int retVal;                 /* If initialization causes  e838 */
-    SecFileStream fStr;
-    SECUREC_FILE_STREAM_FROM_STDIN(&fStr);
-    /*
-     * The "va_list" has different definition on different platform, so we can't use argList == NULL
-     * To determine it's invalid. If you has fixed platform, you can check some fields to validate it,
-     * such as "argList == NULL" or argList.xxx != NULL or *(size_t *)&argList != 0.
-     */
-    if (format == NULL || fStr.pf == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("vscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-
-    SECUREC_LOCK_STDIN(0, fStr.pf);
-    retVal = SecInputS(&fStr, format, argList);
-    SECUREC_UNLOCK_STDIN(0, fStr.pf);
-    if (retVal < 0) {
-        SECUREC_ERROR_INVALID_PARAMTER("vscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    return retVal;
-}
-

components/bounds_checking_function/src/vsnprintf_s.c

@@ -1,139 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vsnprintf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "secureprintoutput.h"
-
-#if SECUREC_ENABLE_VSNPRINTF
-/*
- * <FUNCTION DESCRIPTION>
- *    The vsnprintf_s function is equivalent to the vsnprintf function
- *     except for the parameter destMax/count and the explicit runtime-constraints violation
- *    The vsnprintf_s function takes a pointer to an argument list, then formats
- *    and writes up to count characters of the given data to the memory pointed
- *    to by strDest and appends a terminating null.
- *
- * <INPUT PARAMETERS>
- *    strDest                  Storage location for the output.
- *    destMax                The size of the strDest for output.
- *    count                    Maximum number of character to write(not including
- *                                the terminating NULL)
- *    format                   Format-control string.
- *    argList                     pointer to list of arguments.
- *
- * <OUTPUT PARAMETERS>
- *    strDest                is updated
- *
- * <RETURN VALUE>
- *    return  the number of characters written, not including the terminating null
- *    return -1 if an  error occurs.
- *    return -1 if count < destMax and the output string  has been truncated
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-int vsnprintf_s(char *strDest, size_t destMax, size_t count, const char *format, va_list argList)
-{
-    int retVal;
-
-    if (SECUREC_VSNPRINTF_PARAM_ERROR(format, strDest, destMax, count, SECUREC_STRING_MAX_LEN)) {
-        SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_STRING_MAX_LEN);
-        SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_s");
-        return -1;
-    }
-
-    if (destMax > count) {
-        retVal = SecVsnprintfImpl(strDest, count + 1, format, argList);
-        if (retVal == SECUREC_PRINTF_TRUNCATE) {  /* To keep dest buffer not destroyed 2014.2.18 */
-            /* The string has been truncated, return  -1 */
-            return -1;          /* To skip error handler,  return strlen(strDest) or -1 */
-        }
-    } else {
-        retVal = SecVsnprintfImpl(strDest, destMax, format, argList);
-#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
-        if (retVal == SECUREC_PRINTF_TRUNCATE && count == (size_t)(-1)) {
-            return -1;
-        }
-#endif
-    }
-
-    if (retVal < 0) {
-        strDest[0] = '\0';      /* Empty the dest strDest */
-        if (retVal == SECUREC_PRINTF_TRUNCATE) {
-            /* Buffer too small */
-            SECUREC_ERROR_INVALID_RANGE("vsnprintf_s");
-        }
-        SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_s");
-        return -1;
-    }
-
-    return retVal;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(vsnprintf_s);
-#endif
-#endif
-
-#if SECUREC_SNPRINTF_TRUNCATED
-/*
- * <FUNCTION DESCRIPTION>
- *    The vsnprintf_truncated_s function is equivalent to the vsnprintf function
- *     except for the parameter destMax/count and the explicit runtime-constraints violation
- *    The vsnprintf_truncated_s function takes a pointer to an argument list, then formats
- *    and writes up to count characters of the given data to the memory pointed
- *    to by strDest and appends a terminating null.
- *
- * <INPUT PARAMETERS>
- *    strDest                  Storage location for the output.
- *    destMax                The size of the strDest for output.
- *                                the terminating NULL)
- *    format                   Format-control string.
- *    argList                     pointer to list of arguments.
- *
- * <OUTPUT PARAMETERS>
- *    strDest                is updated
- *
- * <RETURN VALUE>
- *    return  the number of characters written, not including the terminating null
- *    return -1 if an  error occurs.
- *    return destMax-1 if output string  has been truncated
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-int vsnprintf_truncated_s(char *strDest, size_t destMax, const char *format, va_list argList)
-{
-    int retVal;
-
-    if (SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, SECUREC_STRING_MAX_LEN)) {
-        SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_STRING_MAX_LEN);
-        SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_truncated_s");
-        return -1;
-    }
-
-    retVal = SecVsnprintfImpl(strDest, destMax, format, argList);
-    if (retVal < 0) {
-        if (retVal == SECUREC_PRINTF_TRUNCATE) {
-            return (int)(destMax - 1);  /* To skip error handler,  return strlen(strDest) */
-        }
-        strDest[0] = '\0';      /* Empty the dest strDest */
-        SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_truncated_s");
-        return -1;
-    }
-
-    return retVal;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(vsnprintf_truncated_s);
-#endif
-#endif
-

components/bounds_checking_function/src/vsprintf_s.c

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vsprintf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "secureprintoutput.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The vsprintf_s function is equivalent to the vsprintf function
- *    except for the parameter destMax and the explicit runtime-constraints violation
- *    The vsprintf_s function takes a pointer to an argument list, and then formats
- *    and writes the given data to the memory pointed to by strDest.
- *    The function differ from the non-secure versions only in that the secure
- *    versions support positional parameters.
- *
- * <INPUT PARAMETERS>
- *    strDest                Storage location for the output.
- *    destMax                Size of strDest
- *    format                 Format specification.
- *    argList                pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    strDest                is updated
- *
- * <RETURN VALUE>
- *    return  the number of characters written, not including the terminating null character,
- *    return -1  if an  error occurs.
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-int vsprintf_s(char *strDest, size_t destMax, const char *format, va_list argList)
-{
-    int retVal;               /* If initialization causes  e838 */
-
-    if (SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, SECUREC_STRING_MAX_LEN)) {
-        SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_STRING_MAX_LEN);
-        SECUREC_ERROR_INVALID_PARAMTER("vsprintf_s");
-        return -1;
-    }
-
-    retVal = SecVsnprintfImpl(strDest, destMax, format, argList);
-    if (retVal < 0) {
-        strDest[0] = '\0';
-        if (retVal == SECUREC_PRINTF_TRUNCATE) {
-            /* Buffer is too small */
-            SECUREC_ERROR_INVALID_RANGE("vsprintf_s");
-        }
-        SECUREC_ERROR_INVALID_PARAMTER("vsprintf_s");
-        return -1;
-    }
-
-    return retVal;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(vsprintf_s);
-#endif
-

components/bounds_checking_function/src/vsscanf_s.c

@@ -1,88 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vsscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "secinput.h"
-#if defined(SECUREC_VXWORKS_PLATFORM) && !SECUREC_IN_KERNEL && \
-    (!defined(SECUREC_SYSAPI4VXWORKS) && !defined(SECUREC_CTYPE_MACRO_ADAPT))
-#include <ctype.h>
-#endif
-
-/*
- * <NAME>
- *    vsscanf_s
- *
- *
- * <FUNCTION DESCRIPTION>
- *    The vsscanf_s function is equivalent to sscanf_s, with the variable argument list replaced by argList
- *    The vsscanf_s function reads data from buffer into the location given by
- *    each argument. Every argument must be a pointer to a variable with a type
- *    that corresponds to a type specifier in format. The format argument controls
- *    the interpretation of the input fields and has the same form and function
- *    as the format argument for the scanf function.
- *    If copying takes place between strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    buffer                Stored data
- *    format                Format control string, see Format Specifications.
- *    argList               pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    argList               the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned. A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int vsscanf_s(const char *buffer, const char *format, va_list argList)
-{
-    size_t count;               /* If initialization causes  e838 */
-    int retVal;
-    SecFileStream fStr;
-
-    /* Validation section */
-    if (buffer == NULL || format == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("vsscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    count = strlen(buffer);
-    if (count == 0 || count > SECUREC_STRING_MAX_LEN) {
-        SecClearDestBuf(buffer, format, argList);
-        SECUREC_ERROR_INVALID_PARAMTER("vsscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-#if defined(SECUREC_VXWORKS_PLATFORM) && !SECUREC_IN_KERNEL
-    /*
-     * On vxworks platform when buffer is white string, will set first %s argument tu zero.like following useage:
-     * "   \v\f\t\r\n", "%s", str, strSize
-     * Do not check all character, just first and last character then consider it is white string
-     */
-    if (isspace((int)(unsigned char)buffer[0]) != 0 && isspace((int)(unsigned char)buffer[count - 1]) != 0) {
-        SecClearDestBuf(buffer, format, argList);
-    }
-#endif
-    SECUREC_FILE_STREAM_FROM_STRING(&fStr, buffer, count);
-    retVal = SecInputS(&fStr, format, argList);
-    if (retVal < 0) {
-        SECUREC_ERROR_INVALID_PARAMTER("vsscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    return retVal;
-}
-#if SECUREC_IN_KERNEL
-EXPORT_SYMBOL(vsscanf_s);
-#endif
-

components/bounds_checking_function/src/vswprintf_s.c

@@ -1,63 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vswprintf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECUREC_FOR_WCHAR
-#define SECUREC_FOR_WCHAR
-#endif
-
-#include "secureprintoutput.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The  vswprintf_s  function  is  the  wide-character  equivalent  of the vsprintf_s function
- *
- * <INPUT PARAMETERS>
- *    strDest                  Storage location for the output.
- *    destMax                  Maximum number of characters to store
- *    format                   Format specification.
- *    argList                  pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    strDest                 is updated
- *
- * <RETURN VALUE>
- *    return  the number of wide characters stored in strDest, not  counting the terminating null wide character.
- *    return -1  if an error occurred.
- *
- * If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-int vswprintf_s(wchar_t *strDest, size_t destMax, const wchar_t *format, va_list argList)
-{
-    int retVal;               /* If initialization causes  e838 */
-    if (SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, SECUREC_WCHAR_STRING_MAX_LEN)) {
-        SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_WCHAR_STRING_MAX_LEN);
-        SECUREC_ERROR_INVALID_PARAMTER("vswprintf_s");
-        return -1;
-    }
-
-    retVal = SecVswprintfImpl(strDest, destMax, format, argList);
-    if (retVal < 0) {
-        strDest[0] = L'\0';
-        if (retVal == SECUREC_PRINTF_TRUNCATE) {
-            /* Buffer too small */
-            SECUREC_ERROR_INVALID_RANGE("vswprintf_s");
-        }
-        SECUREC_ERROR_INVALID_PARAMTER("vswprintf_s");
-        return -1;
-    }
-
-    return retVal;
-}
-

components/bounds_checking_function/src/vswscanf_s.c

@@ -1,80 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vswscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECUREC_FOR_WCHAR
-#define SECUREC_FOR_WCHAR
-#endif
-
-#include "secinput.h"
-
-SECUREC_INLINE size_t SecWcslen(const wchar_t *s)
-{
-    const wchar_t *end = s;
-    while (*end != L'\0') {
-        ++end;
-    }
-    return ((size_t)((end - s)));
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The  vswscanf_s  function  is  the  wide-character  equivalent  of the vsscanf_s function
- *    The vsscanf_s function reads data from buffer into the location given by
- *    each argument. Every argument must be a pointer to a variable with a type
- *    that corresponds to a type specifier in format.
- *    The format argument controls the interpretation of the input fields and
- *    has the same form and function as the format argument for the scanf function.
- *    If copying takes place between strings that overlap, the behavior is undefined.
- *
- * <INPUT PARAMETERS>
- *    buffer                Stored data
- *    format                Format control string, see Format Specifications.
- *    argList               pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    argList               the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Each of these functions returns the number of fields successfully converted
- *    and assigned; the return value does not include fields that were read but
- *    not assigned. A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int vswscanf_s(const wchar_t *buffer, const wchar_t *format, va_list argList)
-{
-    size_t count; /* If initialization causes  e838 */
-    SecFileStream fStr;
-    int retVal;
-
-    /* Validation section */
-    if (buffer == NULL || format == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("vswscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    count = SecWcslen(buffer);
-    if (count == 0 || count > SECUREC_WCHAR_STRING_MAX_LEN) {
-        SecClearDestBufW(buffer, format, argList);
-        SECUREC_ERROR_INVALID_PARAMTER("vswscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    SECUREC_FILE_STREAM_FROM_STRING(&fStr, (const char *)buffer, count * sizeof(wchar_t));
-    retVal = SecInputSW(&fStr, format, argList);
-    if (retVal < 0) {
-        SECUREC_ERROR_INVALID_PARAMTER("vswscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-    return retVal;
-}
-

components/bounds_checking_function/src/vwscanf_s.c

@@ -1,65 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: vwscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#ifndef SECUREC_FOR_WCHAR
-#define SECUREC_FOR_WCHAR
-#endif
-
-#include "secinput.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The  vwscanf_s  function  is  the  wide-character  equivalent  of the vscanf_s function
- *    The vwscanf_s function is the wide-character version of vscanf_s. The
- *    function reads data from the standard input stream stdin and writes the
- *    data into the location that's given by argument. Each argument  must be a
- *    pointer to a variable of a type that corresponds to a type specifier in
- *    format. If copying occurs between strings that overlap, the behavior is
- *    undefined.
- *
- * <INPUT PARAMETERS>
- *    format                 Format control string.
- *    argList                pointer to list of arguments
- *
- * <OUTPUT PARAMETERS>
- *    argList                the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Returns the number of fields successfully converted and assigned;
- *    the return value does not include fields that were read but not assigned.
- *    A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int vwscanf_s(const wchar_t *format, va_list argList)
-{
-    int retVal;                 /* If initialization causes  e838 */
-    SecFileStream fStr;
-    SECUREC_FILE_STREAM_FROM_STDIN(&fStr);
-    if (format == NULL || fStr.pf == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("vwscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-
-    SECUREC_LOCK_STDIN(0, fStr.pf);
-    retVal = SecInputSW(&fStr, format, argList);
-    SECUREC_UNLOCK_STDIN(0, fStr.pf);
-    if (retVal < 0) {
-        SECUREC_ERROR_INVALID_PARAMTER("vwscanf_s");
-        return SECUREC_SCANF_EINVAL;
-    }
-
-    return retVal;
-}
-

components/bounds_checking_function/src/wcscat_s.c

@@ -1,108 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wcscat_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * Befor this function, the basic parameter checking has been done
- */
-SECUREC_INLINE errno_t SecDoCatW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
-{
-    size_t destLen;
-    size_t srcLen;
-    size_t maxCount; /* Store the maximum available count */
-
-    /* To calculate the length of a wide character, the parameter must be a wide character */
-    SECUREC_CALC_WSTR_LEN(strDest, destMax, &destLen);
-    maxCount = destMax - destLen;
-    SECUREC_CALC_WSTR_LEN(strSrc, maxCount, &srcLen);
-
-    if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
-        strDest[0] = L'\0';
-        if (strDest + destLen <= strSrc && destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("wcscat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_BUFFER_OVERLAP("wcscat_s");
-        return EOVERLAP_AND_RESET;
-    }
-    if (srcLen + destLen >= destMax || strDest == strSrc) {
-        strDest[0] = L'\0';
-        if (destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("wcscat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_INVALID_RANGE("wcscat_s");
-        return ERANGE_AND_RESET;
-    }
-    /* Copy single character length  include \0 */
-    SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, (srcLen + 1) * sizeof(wchar_t));
-    return EOK;
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The wcscat_s function appends a copy of the wide string pointed to by strSrc
-*      (including the terminating null wide character)
- *     to the end of the wide string pointed to by strDest.
- *    The arguments and return value of wcscat_s are wide-character strings.
- *
- *    The wcscat_s function appends strSrc to strDest and terminates the resulting
- *    string with a null character. The initial character of strSrc overwrites the
- *    terminating null character of strDest. wcscat_s will return EOVERLAP_AND_RESET if the
- *    source and destination strings overlap.
- *
- *    Note that the second parameter is the total size of the buffer, not the
- *    remaining size.
- *
- * <INPUT PARAMETERS>
- *    strDest              Null-terminated destination string buffer.
- *    destMax              Size of the destination string buffer.
- *    strSrc               Null-terminated source string buffer.
- *
- * <OUTPUT PARAMETERS>
- *    strDest               is updated
- *
- * <RETURN VALUE>
- *    EOK                   Success
- *    EINVAL                strDest is  NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *    EINVAL_AND_RESET      (strDest unterminated and all other parameters are valid) or
- *                          (strDest != NULL and strSrc is NULLL and destMax != 0
- *                           and destMax <= SECUREC_WCHAR_STRING_MAX_LEN)
- *    ERANGE                destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
- *    ERANGE_AND_RESET      strDest have not enough space  and all other parameters are valid  and not overlap
- *    EOVERLAP_AND_RESET     dest buffer and source buffer are overlapped and all  parameters are valid
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t wcscat_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
-{
-    if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("wcscat_s");
-        return ERANGE;
-    }
-
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("wcscat_s");
-        if (strDest != NULL) {
-            strDest[0] = L'\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-
-    return SecDoCatW(strDest, destMax, strSrc);
-}
-

components/bounds_checking_function/src/wcscpy_s.c

@@ -1,87 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wcscpy_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-SECUREC_INLINE errno_t SecDoCpyW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
-{
-    size_t srcStrLen;
-    SECUREC_CALC_WSTR_LEN(strSrc, destMax, &srcStrLen);
-
-    if (srcStrLen == destMax) {
-        strDest[0] = L'\0';
-        SECUREC_ERROR_INVALID_RANGE("wcscpy_s");
-        return ERANGE_AND_RESET;
-    }
-    if (strDest == strSrc) {
-        return EOK;
-    }
-
-    if (SECUREC_STRING_NO_OVERLAP(strDest, strSrc, srcStrLen)) {
-        /* Performance optimization, srcStrLen is single character length  include '\0' */
-        SECUREC_MEMCPY_WARP_OPT(strDest, strSrc, (srcStrLen + 1) * sizeof(wchar_t));
-        return EOK;
-    } else {
-        strDest[0] = L'\0';
-        SECUREC_ERROR_BUFFER_OVERLAP("wcscpy_s");
-        return EOVERLAP_AND_RESET;
-    }
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *   The wcscpy_s function copies the wide string pointed to by strSrc
- *   (including theterminating null wide character) into the array pointed to by strDest
-
- * <INPUT PARAMETERS>
- *    strDest               Destination string buffer
- *    destMax               Size of the destination string buffer.
- *    strSrc                Null-terminated source string buffer.
- *
- * <OUTPUT PARAMETERS>
- *    strDest               is updated.
- *
- * <RETURN VALUE>
- *    EOK                   Success
- *    EINVAL                strDest is  NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *    EINVAL_AND_RESET      strDest != NULL and strSrc is NULLL and destMax != 0
- *                          and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *    ERANGE                destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
- *    ERANGE_AND_RESET      destMax <= length of strSrc and strDest != strSrc
- *                          and strDest != NULL and strSrc != NULL and destMax != 0
- *                          and destMax <= SECUREC_WCHAR_STRING_MAX_LEN and not overlap
- *    EOVERLAP_AND_RESET    dest buffer and source buffer are overlapped and destMax != 0
- *                          and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *                          and strDest != NULL and strSrc !=NULL and strDest != strSrc
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t wcscpy_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
-{
-    if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("wcscpy_s");
-        return ERANGE;
-    }
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("wcscpy_s");
-        if (strDest != NULL) {
-            strDest[0] = L'\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    return SecDoCpyW(strDest, destMax, strSrc);
-}
-

components/bounds_checking_function/src/wcsncat_s.c

@@ -1,114 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wcsncat_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * Befor this function, the basic parameter checking has been done
- */
-SECUREC_INLINE errno_t SecDoCatLimitW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
-{
-    /* To calculate the length of a wide character, the parameter must be a wide character */
-    size_t destLen;
-    size_t srcLen;
-    SECUREC_CALC_WSTR_LEN(strDest, destMax, &destLen);
-    SECUREC_CALC_WSTR_LEN(strSrc, count, &srcLen);
-
-    if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
-        strDest[0] = L'\0';
-        if (strDest + destLen <= strSrc && destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("wcsncat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_BUFFER_OVERLAP("wcsncat_s");
-        return EOVERLAP_AND_RESET;
-    }
-    if (srcLen + destLen >= destMax || strDest == strSrc) {
-        strDest[0] = L'\0';
-        if (destLen == destMax) {
-            SECUREC_ERROR_INVALID_PARAMTER("wcsncat_s");
-            return EINVAL_AND_RESET;
-        }
-        SECUREC_ERROR_INVALID_RANGE("wcsncat_s");
-        return ERANGE_AND_RESET;
-    }
-    SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, srcLen * sizeof(wchar_t)); /* no  terminator */
-    *(strDest + destLen + srcLen) = L'\0';
-    return EOK;
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The wcsncat_s function appends not more than n successive wide characters
- *     (not including the terminating null wide character)
- *     from the array pointed to by strSrc to the end of the wide string pointed to by strDest.
- *
- *    The wcsncat_s function try to append the first D characters of strSrc to
- *    the end of strDest, where D is the lesser of count and the length of strSrc.
- *    If appending those D characters will fit within strDest (whose size is
- *    given as destMax) and still leave room for a null terminator, then those
- *    characters are appended, starting at the original terminating null of
- *    strDest, and a new terminating null is appended; otherwise, strDest[0] is
- *    set to the null character.
- *
- * <INPUT PARAMETERS>
- *    strDest               Null-terminated destination string.
- *    destMax               Size of the destination buffer.
- *    strSrc                Null-terminated source string.
- *    count                 Number of character to append, or truncate.
- *
- * <OUTPUT PARAMETERS>
- *    strDest               is updated
- *
- * <RETURN VALUE>
- *    EOK                   Success
- *    EINVAL                strDest is  NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *    EINVAL_AND_RESET      (strDest unterminated and all other parameters are valid) or
- *                          (strDest != NULL and strSrc is NULLL and destMax != 0 and
- *                           destMax <= SECUREC_WCHAR_STRING_MAX_LEN)
- *    ERANGE                destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
- *    ERANGE_AND_RESET      strDest have not enough space  and all other parameters are valid  and not overlap
- *    EOVERLAP_AND_RESET     dest buffer and source buffer are overlapped and all  parameters are valid
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t wcsncat_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("wcsncat_s");
-        return ERANGE;
-    }
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("wcsncat_s");
-        if (strDest != NULL) {
-            strDest[0] = L'\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    if (count > SECUREC_WCHAR_STRING_MAX_LEN) {
-#ifdef  SECUREC_COMPATIBLE_WIN_FORMAT
-        if (count == ((size_t)(-1))) {
-            /* Windows internal functions may pass in -1 when calling this function */
-            return SecDoCatLimitW(strDest, destMax, strSrc, destMax);
-        }
-#endif
-        strDest[0] = L'\0';
-        SECUREC_ERROR_INVALID_RANGE("wcsncat_s");
-        return ERANGE_AND_RESET;
-    }
-    return SecDoCatLimitW(strDest, destMax, strSrc, count);
-}
-

components/bounds_checking_function/src/wcsncpy_s.c

@@ -1,108 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wcsncpy_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-SECUREC_INLINE errno_t SecDoCpyLimitW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
-{
-    size_t srcStrLen;
-    if (count < destMax) {
-        SECUREC_CALC_WSTR_LEN(strSrc, count, &srcStrLen);
-    } else {
-        SECUREC_CALC_WSTR_LEN(strSrc, destMax, &srcStrLen);
-    }
-    if (srcStrLen == destMax) {
-        strDest[0] = L'\0';
-        SECUREC_ERROR_INVALID_RANGE("wcsncpy_s");
-        return ERANGE_AND_RESET;
-    }
-    if (strDest == strSrc) {
-        return EOK;
-    }
-    if (SECUREC_STRING_NO_OVERLAP(strDest, strSrc, srcStrLen)) {
-        /* Performance optimization srcStrLen not include '\0' */
-        SECUREC_MEMCPY_WARP_OPT(strDest, strSrc, srcStrLen * sizeof(wchar_t));
-        *(strDest + srcStrLen) = L'\0';
-        return EOK;
-    } else {
-        strDest[0] = L'\0';
-        SECUREC_ERROR_BUFFER_OVERLAP("wcsncpy_s");
-        return EOVERLAP_AND_RESET;
-    }
-}
-
-/*
- * <FUNCTION DESCRIPTION>
- *    The wcsncpy_s function copies not more than n successive wide characters
- *     (not including the terminating null wide character)
- *     from the array pointed to by strSrc to the array pointed to by strDest
- *
- * <INPUT PARAMETERS>
- *    strDest             Destination string.
- *    destMax             The size of the destination string, in characters.
- *    strSrc              Source string.
- *    count                Number of characters to be copied.
- *
- * <OUTPUT PARAMETERS>
- *    strDest              is updated
- *
- * <RETURN VALUE>
- *    EOK                  Success
- *    EINVAL               strDest is  NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *    EINVAL_AND_RESET     strDest != NULL and strSrc is NULLL and destMax != 0
- *                         and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
- *    ERANGE               destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
- *    ERANGE_AND_RESET     count > SECUREC_WCHAR_STRING_MAX_LEN or
- *                         (destMax <= length of strSrc and destMax <= count and strDest != strSrc
- *                          and strDest != NULL and strSrc != NULL and destMax != 0 and
- *                          destMax <= SECUREC_WCHAR_STRING_MAX_LEN and not overlap)
- *    EOVERLAP_AND_RESET     dest buffer and source buffer are overlapped and  all  parameters are valid
- *
- *
- *    If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
- */
-errno_t wcsncpy_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
-        SECUREC_ERROR_INVALID_RANGE("wcsncpy_s");
-        return ERANGE;
-    }
-    if (strDest == NULL || strSrc == NULL) {
-        SECUREC_ERROR_INVALID_PARAMTER("wcsncpy_s");
-        if (strDest != NULL) {
-            strDest[0] = L'\0';
-            return EINVAL_AND_RESET;
-        }
-        return EINVAL;
-    }
-    if (count > SECUREC_WCHAR_STRING_MAX_LEN) {
-#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
-        if (count == (size_t)(-1)) {
-            return SecDoCpyLimitW(strDest, destMax, strSrc, destMax - 1);
-        }
-#endif
-        strDest[0] = L'\0';      /* Clear dest string */
-        SECUREC_ERROR_INVALID_RANGE("wcsncpy_s");
-        return ERANGE_AND_RESET;
-    }
-
-    if (count == 0) {
-        strDest[0] = L'\0';
-        return EOK;
-    }
-
-    return SecDoCpyLimitW(strDest, destMax, strSrc, count);
-}
-

components/bounds_checking_function/src/wcstok_s.c

@@ -1,113 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wcstok_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-SECUREC_INLINE int SecIsInDelimitW(wchar_t ch, const wchar_t *strDelimit)
-{
-    const wchar_t *ctl = strDelimit;
-    while (*ctl != L'\0' && *ctl != ch) {
-        ++ctl;
-    }
-    return (int)(*ctl != L'\0');
-}
-
-/*
- * Find beginning of token (skip over leading delimiters).
- * Note that there is no token if this loop sets string to point to the terminal null.
- */
-SECUREC_INLINE wchar_t *SecFindBeginW(wchar_t *strToken, const wchar_t *strDelimit)
-{
-    wchar_t *token = strToken;
-    while (*token != L'\0') {
-        if (SecIsInDelimitW(*token, strDelimit) != 0) {
-            ++token;
-            continue;
-        }
-        /* Don't find any delimiter in string header, break the loop */
-        break;
-    }
-    return token;
-}
-
-/*
- * Find the end of the token. If it is not the end of the string, put a null there.
- */
-SECUREC_INLINE wchar_t *SecFindRestW(wchar_t *strToken, const wchar_t *strDelimit)
-{
-    wchar_t *token = strToken;
-    while (*token != L'\0') {
-        if (SecIsInDelimitW(*token, strDelimit) != 0) {
-            /* Find a delimiter, set string termintor */
-            *token = L'\0';
-            ++token;
-            break;
-        }
-        ++token;
-    }
-    return token;
-}
-
-/*
- * Update Token wide character  function
- */
-SECUREC_INLINE wchar_t *SecUpdateTokenW(wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context)
-{
-    /* Point to updated position.  Record string position for next search in the context */
-    *context = SecFindRestW(strToken, strDelimit);
-    /* Determine if a token has been found */
-    if (*context == strToken) {
-        return NULL;
-    }
-    return strToken;
-}
-
-/*
- * <NAME>
- *    wcstok_s
- *
- *
- * <FUNCTION DESCRIPTION>
- *   The  wcstok_s  function  is  the  wide-character  equivalent  of the strtok_s function
- *
- * <INPUT PARAMETERS>
- *    strToken               String containing token or tokens.
- *    strDelimit             Set of delimiter characters.
- *    context                Used to store position information between calls to
- *                               wcstok_s.
- *
- * <OUTPUT PARAMETERS>
- *    context               is updated
- * <RETURN VALUE>
- *   The  wcstok_s  function  is  the  wide-character  equivalent  of the strtok_s function
- */
-wchar_t *wcstok_s(wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context)
-{
-    wchar_t *orgToken = strToken;
-    /* Validation section */
-    if (context == NULL || strDelimit == NULL) {
-        return NULL;
-    }
-    if (orgToken == NULL && *context == NULL) {
-        return NULL;
-    }
-    /* If string==NULL, continue with previous string */
-    if (orgToken == NULL) {
-        orgToken = *context;
-    }
-    orgToken = SecFindBeginW(orgToken, strDelimit);
-    return SecUpdateTokenW(orgToken, strDelimit, context);
-}
-

components/bounds_checking_function/src/wmemcpy_s.c

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wmemcpy_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *   The wmemcpy_s function copies n successive wide characters
- *    from the object pointed to by src into the object pointed to by dest.t.
- *
- * <INPUT PARAMETERS>
- *    dest                   Destination buffer.
- *    destMax                Size of the destination buffer.
- *    src                     Buffer to copy from.
- *    count                  Number of characters to copy.
- *
- * <OUTPUT PARAMETERS>
- *    dest buffer            is uptdated.
- *
- * <RETURN VALUE>
- *    EOK                    Success
- *    EINVAL                 dest is  NULL  and destMax != 0 and count <= destMax
- *                           and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
- *    EINVAL_AND_RESET       dest != NULL and src is NULLL and destMax != 0
- *                           and destMax <= SECUREC_WCHAR_MEM_MAX_LEN and count <= destMax
- *    ERANGE                 destMax > SECUREC_WCHAR_MEM_MAX_LEN or destMax is 0 or
- *                           (count > destMax and dest is  NULL and destMax != 0
- *                            and destMax <= SECUREC_WCHAR_MEM_MAX_LEN)
- *    ERANGE_AND_RESET       count > destMax and dest  !=  NULL and destMax != 0
- *                           and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
- *    EOVERLAP_AND_RESET     dest buffer and source buffer are overlapped and
- *                           count <= destMax destMax != 0 and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
- *                           and dest  !=  NULL  and src != NULL and dest != src
- *
- *    if an error occured, dest will be filled with 0 when dest and destMax valid .
- *    If the source and destination overlap, the behavior of wmemcpy_s is undefined.
- *    Use wmemmove_s to handle overlapping regions.
- */
-errno_t wmemcpy_s(wchar_t *dest, size_t destMax, const wchar_t *src, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_WCHAR_MEM_MAX_LEN) {
-        SECUREC_ERROR_INVALID_PARAMTER("wmemcpy_s");
-        return ERANGE;
-    }
-    if (count > destMax) {
-        SECUREC_ERROR_INVALID_PARAMTER("wmemcpy_s");
-        if (dest != NULL) {
-            (void)memset(dest, 0, destMax * sizeof(wchar_t));
-            return ERANGE_AND_RESET;
-        }
-        return ERANGE;
-    }
-    return memcpy_s(dest, destMax * sizeof(wchar_t), src, count * sizeof(wchar_t));
-}
-

components/bounds_checking_function/src/wmemmove_s.c

@@ -1,66 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wmemmove_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securecutil.h"
-
-/*
- * <FUNCTION DESCRIPTION>
- *   The wmemmove_s function copies n successive wide characters from the object pointed
- *   to by src into the object pointed to by dest.
- *
- * <INPUT PARAMETERS>
- *    dest                     Destination buffer.
- *    destMax                  Size of the destination buffer.
- *    src                      Source object.
- *    count                    Number of bytes or character to copy.
- *
- * <OUTPUT PARAMETERS>
- *    dest                     is updated.
- *
- * <RETURN VALUE>
- *    EOK                      Success
- *    EINVAL                   dest is  NULL and destMax != 0 and count <= destMax
- *                             and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
- *    EINVAL_AND_RESET         dest != NULL and src is NULLL and destMax != 0
- *                             and destMax <= SECUREC_WCHAR_MEM_MAX_LEN and count <= destMax
- *    ERANGE                   destMax > SECUREC_WCHAR_MEM_MAX_LEN or destMax is 0 or
- *                             (count > destMax and dest is  NULL and destMax != 0
- *                             and destMax <= SECUREC_WCHAR_MEM_MAX_LEN)
- *    ERANGE_AND_RESET        count > destMax and dest  !=  NULL and destMax != 0
- *                             and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
- *
- *
- *     If an error occured, dest will  be filled with 0 when dest and destMax valid.
- *     If some regions of the source area and the destination overlap, wmemmove_s
- *     ensures that the original source bytes in the overlapping region are copied
- *     before being overwritten
- */
-errno_t wmemmove_s(wchar_t *dest, size_t destMax, const wchar_t *src, size_t count)
-{
-    if (destMax == 0 || destMax > SECUREC_WCHAR_MEM_MAX_LEN) {
-        SECUREC_ERROR_INVALID_PARAMTER("wmemmove_s");
-        return ERANGE;
-    }
-    if (count > destMax) {
-        SECUREC_ERROR_INVALID_PARAMTER("wmemmove_s");
-        if (dest != NULL) {
-            (void)memset(dest, 0, destMax * sizeof(wchar_t));
-            return ERANGE_AND_RESET;
-        }
-        return ERANGE;
-    }
-    return memmove_s(dest, destMax * sizeof(wchar_t), src, count * sizeof(wchar_t));
-}
-

components/bounds_checking_function/src/wscanf_s.c

@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved.
- * Licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *          http://license.coscl.org.cn/MulanPSL2
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- * Description: wscanf_s  function
- * Author: lishunda
- * Create: 2014-02-25
- */
-
-#include "securec.h"
-
-/*
- * <NAME>
- * <FUNCTION DESCRIPTION>
- *    The  wscanf_s  function  is  the  wide-character  equivalent  of the scanf_s function
- *    The wscanf_s function reads data from the standard input stream stdin and
- *    writes the data into the location that's given by argument. Each argument
- *    must be a pointer to a variable of a type that corresponds to a type specifier
- *    in format. If copying occurs between strings that overlap, the behavior is
- *    undefined.
- *
- * <INPUT PARAMETERS>
- *    format                  Format control string.
- *    ...                         Optional arguments.
- *
- * <OUTPUT PARAMETERS>
- *    ...                     the converted value stored in user assigned address
- *
- * <RETURN VALUE>
- *    Returns the number of fields successfully converted and assigned;
- *    the return value does not include fields that were read but not assigned.
- *    A return value of 0 indicates that no fields were assigned.
- *    return -1 if an error occurs.
- */
-int wscanf_s(const wchar_t *format, ...)
-{
-    int ret;                    /* If initialization causes  e838 */
-    va_list argList;
-
-    va_start(argList, format);
-    ret = vwscanf_s(format, argList);
-    va_end(argList);
-    (void)argList;              /* To clear e438 last value assigned not used , the compiler will optimize this code */
-
-    return ret;
-}
-

components/cppsupport/BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -27,11 +27,10 @@
 # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import("//kernel/liteos_m/config.gni")
+
 static_library("cppsupport") {
   sources = [ "los_cppsupport.c" ]
 
-  include_dirs = [
-    "../../utils",
-    "./",
-  ]
+  configs += [ "$LITEOSTOPDIR:los_config" ]
 }

components/cppsupport/los_cppsupport.c

@@ -31,12 +31,6 @@
 
 #include "los_cppsupport.h"
 
-#ifdef __cplusplus
-#if __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-#endif /* __cplusplus */
-
 typedef VOID (*InitFunc)(VOID);
 
 INT32 LOS_CppSystemInit(UINTPTR initArrayStart, UINTPTR initArrayEnd)
@@ -44,17 +38,10 @@ INT32 LOS_CppSystemInit(UINTPTR initArrayStart, UINTPTR initArrayEnd)
     UINTPTR *start;
     InitFunc initFunc = NULL;
 
-    for (start = (UINTPTR *)initArrayStart; start < (UINTPTR *)initArrayEnd; start++){
+    for (start = (UINTPTR *)initArrayStart; start < (UINTPTR *)initArrayEnd; start++) {
         initFunc = (InitFunc)(*start);
         initFunc();
     }
 
     return 0;
 }
-
-
-#ifdef __cplusplus
-#if __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* __cplusplus */

components/cpup/BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -27,14 +27,10 @@
 # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import("//kernel/liteos_m/config.gni")
+
 static_library("cpup") {
   sources = [ "los_cpup.c" ]
 
-  include_dirs = [
-    "../../kernel/include",
-    "../../kernel/arch/include",
-    "../../utils",
-    "./",
-    "//third_party/bounds_checking_function/include",
-  ]
+  configs += [ "$LITEOSTOPDIR:los_config" ]
 }

components/cpup/los_cpup.c

@@ -33,12 +33,7 @@
 #include "securec.h"
 #include "los_memory.h"
 #include "los_debug.h"
-#include "los_timer.h"
-#ifdef __cplusplus
-#if __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-#endif /* __cplusplus */
+#include "los_tick.h"
 
 #if (LOSCFG_BASE_CORE_CPUP == 1)
 
@@ -61,15 +56,6 @@ LITE_OS_SEC_BSS OsCpupCB  *g_cpup = NULL;
 LITE_OS_SEC_BSS UINT64    g_lastRecordTime;
 LITE_OS_SEC_BSS UINT16    g_hisPos; /* <current Sampling point of historyTime */
 
-
-LITE_OS_SEC_TEXT_MINOR STATIC INLINE UINT64 OsGetCurrentCyclesCount(VOID)
-{
-    UINT32 high = 0;
-    UINT32 low = 0;
-    HalGetCpuCycle(&high, &low);
-    return (((UINT64)high << 32) + low); // 32 means bits of word
-}
-
 /*****************************************************************************
 Function   : OsCpupInit
 Description: initialization of CPUP
@@ -110,7 +96,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsTskCycleStart(VOID)
 
     taskID = g_losTask.newTask->taskID;
     g_cpup[taskID].cpupID = taskID;
-    g_cpup[taskID].startTime = OsGetCurrentCyclesCount();
+    g_cpup[taskID].startTime = LOS_SysCycleGet();
 
     return;
 }
@@ -135,7 +121,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsTskCycleEnd(VOID)
         return;
     }
 
-    cpuCycle = OsGetCurrentCyclesCount();
+    cpuCycle = LOS_SysCycleGet();
 
     if (cpuCycle < g_cpup[taskID].startTime) {
         cpuCycle += g_cyclesPerTick;
@@ -163,7 +149,7 @@ LITE_OS_SEC_TEXT_MINOR VOID OsTskCycleEndStart(VOID)
     }
 
     taskID = g_losTask.runTask->taskID;
-    cpuCycle = OsGetCurrentCyclesCount();
+    cpuCycle = LOS_SysCycleGet();
 
     if (g_cpup[taskID].startTime != 0) {
         if (cpuCycle < g_cpup[taskID].startTime) {
@@ -229,7 +215,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_SysCpuUsage(VOID)
     UINT64  cpuCycleAll = 0;
     UINT32  cpupRet = 0;
     UINT16  loopNum;
-    UINTPTR intSave;
+    UINT32 intSave;
 
     if (g_cpupInitFlg == 0) {
         return LOS_ERRNO_CPUP_NO_INIT;
@@ -268,7 +254,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistorySysCpuUsage(UINT16 mode)
     UINT16  loopNum;
     UINT16  curPos;
     UINT16  prePos = 0;
-    UINTPTR intSave;
+    UINT32 intSave;
 
     if (g_cpupInitFlg == 0) {
         return LOS_ERRNO_CPUP_NO_INIT;
@@ -315,7 +301,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_TaskCpuUsage(UINT32 taskID)
 {
     UINT64  cpuCycleAll = 0;
     UINT16  loopNum;
-    UINTPTR intSave;
+    UINT32 intSave;
     UINT32  cpupRet = 0;
 
     if (g_cpupInitFlg == 0) {
@@ -364,7 +350,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskID, UINT16 mode
     UINT64  cpuCycleCurTsk = 0;
     UINT16  loopNum, curPos;
     UINT16  prePos = 0;
-    UINTPTR intSave;
+    UINT32 intSave;
     UINT32  cpupRet = 0;
 
     if (g_cpupInitFlg == 0) {
@@ -417,7 +403,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_AllTaskCpuUsage(CPUP_INFO_S *cpupInfo, UINT16
     UINT16  loopNum;
     UINT16  curPos;
     UINT16  prePos = 0;
-    UINTPTR intSave;
+    UINT32 intSave;
     UINT64  cpuCycleAll = 0;
     UINT64  cpuCycleCurTsk = 0;
 
@@ -495,7 +481,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CpupUsageMonitor(CPUP_TYPE_E type, CPUP_MODE_E
                 PRINTK("\nSysCpuUsage in <1s: ");
             }
             ret = LOS_HistorySysCpuUsage(mode);
-            PRINTK("%d.%d", ret / LOS_CPUP_PRECISION_MULT, ret % LOS_CPUP_PRECISION_MULT);
+            PRINTK("%u.%u", ret / LOS_CPUP_PRECISION_MULT, ret % LOS_CPUP_PRECISION_MULT);
             break;
 
         case TASK_CPU_USAGE:
@@ -509,11 +495,11 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CpupUsageMonitor(CPUP_TYPE_E type, CPUP_MODE_E
                 return OS_ERROR;
             }
             if (mode == CPUP_IN_10S) {
-                PRINTK("\nCPUusage of taskID %d in 10s: ", taskID);
+                PRINTK("\nCPUusage of taskID %u in 10s: ", taskID);
             } else if (mode == CPUP_IN_1S) {
-                PRINTK("\nCPUusage of taskID %d in 1s: ", taskID);
+                PRINTK("\nCPUusage of taskID %u in 1s: ", taskID);
             } else {
-                PRINTK("\nCPUusage of taskID %d in <1s: ", taskID);
+                PRINTK("\nCPUusage of taskID %u in <1s: ", taskID);
             }
             ret = LOS_HistoryTaskCpuUsage(taskID, mode);
             PRINTK("%u.%u", ret / LOS_CPUP_PRECISION_MULT, ret % LOS_CPUP_PRECISION_MULT);
@@ -528,10 +514,3 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CpupUsageMonitor(CPUP_TYPE_E type, CPUP_MODE_E
 }
 
 #endif /* LOSCFG_BASE_CORE_CPUP */
-
-
-#ifdef __cplusplus
-#if __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* __cplusplus */

components/cpup/los_cpup.h

@@ -179,7 +179,183 @@ extern UINT32 OsCpupInit(VOID);
  */
 extern VOID OsTskCycleEndStart(VOID);
 
+/**
+ * @ingroup los_cpup
+ * Count the CPU usage structures of all tasks.
+ */
+typedef struct tagCpupInfo {
+    UINT16 usStatus;            /**< save the cur task status     */
+    UINT32 uwUsage;             /**< Usage. The value range is [0,1000].   */
+} CPUP_INFO_S;
 
+/**
+ * @ingroup los_monitor
+ * Type of the CPU usage query.
+ */
+typedef enum {
+    SYS_CPU_USAGE = 0,   /* system cpu occupancy rate */
+    TASK_CPU_USAGE,      /* task cpu occupancy rate */
+} CPUP_TYPE_E;
+
+/**
+ * @ingroup los_monitor
+ * Mode of the CPU usage query.
+ */
+typedef enum {
+    CPUP_IN_10S = 0,     /* cpu occupancy rate in 10s */
+    CPUP_IN_1S,          /* cpu occupancy rate in 1s */
+    CPUP_LESS_THAN_1S,   /* cpu occupancy rate less than 1s, if the input mode is none of them, it will be this. */
+} CPUP_MODE_E;
+
+/**
+ * @ingroup los_cpup
+ * @brief Obtain the current CPU usage.
+ *
+ * @par Description:
+ * This API is used to obtain the current CPU usage.
+ * @attention
+ * <ul>
+ * <li>This API can be called only after the CPU usage is initialized. Otherwise, error codes will be returned.</li>
+ * <li> The precision of the CPU usage can be adjusted by changing the value of the CPUP_PRECISION macro.</li>
+ * </ul>
+ *
+ * @param None.
+ *
+ * @retval #OS_ERRNO_CPUP_NO_INIT           0x02001e02: The CPU usage is not initialized.
+ * @retval #cpup                            [0,1000], current CPU usage, of which the precision is adjustable.
+ * @par Dependency:
+ * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_SysCpuUsage
+ */
+extern UINT32 LOS_SysCpuUsage(VOID);
+
+/**
+ * @ingroup los_cpup
+ * @brief Obtain the historical CPU usage.
+ *
+ * @par Description:
+ * This API is used to obtain the historical CPU usage.
+ * @attention
+ * <ul>
+ * <li>This API can be called only after the CPU usage is initialized. Otherwise, the CPU usage fails to be obtained.</li>
+ * </ul>
+ *
+ * @param  mode     [IN] UINT16. Task mode. The parameter value 0 indicates that the CPU usage within 10s will be
+ * obtained, and the parameter value 1 indicates that the CPU usage in the former 1s will be obtained. Other values
+ * indicate that the CPU usage in the period that is less than 1s will be obtained.
+ *
+ * @retval #OS_ERRNO_CPUP_NO_INIT           0x02001e02: The CPU usage is not initialized.
+ * @retval #cpup                            [0,1000], historical CPU usage, of which the precision is adjustable.
+ * @par Dependency:
+ * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_HistoryTaskCpuUsage
+ */
+extern UINT32 LOS_HistorySysCpuUsage(UINT16 mode);
+
+/**
+ * @ingroup los_cpup
+ * @brief Obtain the CPU usage of a specified task.
+ *
+ * @par Description:
+ * This API is used to obtain the CPU usage of a task specified by a passed-in task ID.
+ * @attention
+ * <ul>
+ * <li>This API can be called only after the CPU usage is initialized. Otherwise, the CPU usage fails to be obtained.</li>
+ * <li>The passed-in task ID must be valid and the task specified by the task ID must be created. Otherwise,
+ * the CPU usage fails to be obtained.</li>
+ * </ul>
+ *
+ * @param taskID   [IN] UINT32. Task ID.
+ *
+ * @retval #OS_ERRNO_CPUP_NO_INIT             0x02001e02: The CPU usage is not initialized.
+ * @retval #OS_ERRNO_CPUP_TSK_ID_INVALID      0x02001e05: The target task ID is invalid.
+ * @retval #OS_ERRNO_CPUP_THREAD_NO_CREATED   0x02001e04: The target thread is not created.
+ * @retval #cpup                              [0,1000], CPU usage of the specified task.
+ * @par Dependency:
+ * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_HistoryTaskCpuUsage
+ */
+extern UINT32 LOS_TaskCpuUsage(UINT32 taskID);
+
+/**
+ * @ingroup los_cpup
+ * @brief  Obtain the historical CPU usage of a specified task.
+ *
+ * @par Description:
+ * This API is used to obtain the historical CPU usage of a task specified by a passed-in task ID.
+ * @attention
+ * <ul>
+ * <li>This API can be called only after the CPU usage is initialized. Otherwise,
+ * the CPU usage fails to be obtained.</li>
+ * <li>The passed-in task ID must be valid and the task specified by the task ID must be created. Otherwise,
+ * the CPU usage fails to be obtained.</li>
+ * </ul>
+ *
+ * @param taskID   [IN] UINT32. Task ID.
+ * @param mode     [IN] UINT16. Task mode. The parameter value 0 indicates that the CPU usage within 10s
+ * will be obtained, and the parameter value 1 indicates that the CPU usage in the former 1s will be obtained.
+ * Other values indicate that the CPU usage in the period that is less than 1s will be obtained.
+ *
+ * @retval #OS_ERRNO_CPUP_NO_INIT             0x02001e02: The CPU usage is not initialized.
+ * @retval #OS_ERRNO_CPUP_TSK_ID_INVALID      0x02001e05: The target task ID is invalid.
+ * @retval #OS_ERRNO_CPUP_THREAD_NO_CREATED   0x02001e04: The target thread is not created.
+ * @retval #cpup                              [0,1000], CPU usage of the specified task.
+ * @par Dependency:
+ * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_HistorySysCpuUsage
+ */
+extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskID, UINT16 mode);
+
+/**
+ * @ingroup los_cpup
+ * @brief Obtain the CPU usage of all tasks.
+ *
+ * @par Description:
+ * This API is used to obtain the CPU usage of all tasks according to maximum number of threads.
+ * @attention
+ * <ul>
+ * <li>This API can be called only after the CPU usage is initialized. Otherwise, the CPU usage fails to be obtained.</li>
+ * <li>The input parameter pointer must not be NULL, Otherwise, the CPU usage fails to be obtained.</li>
+ * </ul>
+ *
+ * @param cpupInfo    [OUT]Type.   CPUP_INFO_S* Pointer to the task CPUP information structure to be obtained.
+ * @param mode        [IN] UINT16. Task mode. The parameter value 0 indicates that the CPU usage within 10s
+ * will be obtained, and the parameter value 1 indicates that the CPU usage in the former 1s will be obtained.
+ * Other values indicate that the CPU usage in the period that is less than 1s will be obtained.
+ *
+ * @retval #OS_ERRNO_CPUP_NO_INIT           0x02001e02: The CPU usage is not initialized.
+ * @retval #OS_ERRNO_CPUP_TASK_PTR_NULL     0x02001e01: The input parameter pointer is NULL.
+ * @retval #LOS_OK                          0x00000000: The CPU usage of all tasks is successfully obtained.
+ * @par Dependency:
+ * <ul><li>los_cpup.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_SysCpuUsage
+ */
+extern UINT32 LOS_AllTaskCpuUsage(CPUP_INFO_S *cpupInfo, UINT16 mode);
+
+/**
+ * @ingroup los_monitor
+ * @brief Obtain CPU usage history of certain task.
+ *
+ * @par Description:
+ * This API is used to obtain CPU usage history of certain task.
+ * @attention
+ * <ul>
+ * <li>This API can be called only after the CPU usage is initialized. Otherwise, -1 will be returned.</li>
+ * <li> Only in SYS_CPU_USAGE type, uwTaskID is invalid.</li>
+ * </ul>
+ *
+ * @param type        [IN] cpup type, SYS_CPU_USAGE and TASK_CPU_USAGE
+ * @param mode        [IN] mode,CPUP_IN_10S = usage in 10s,CPUP_IN_1S = usage in last 1s,
+ * CPUP_LESS_THAN_1S = less than 1s, if the input mode is none of them, it will be as CPUP_LESS_THAN_1S.
+ * @param taskID      [IN] task ID, Only in SYS_CPU_USAGE type, taskID is invalid
+ *
+ * @retval #OS_ERROR           -1:CPU usage info obtain failed.
+ * @retval #LOS_OK              0:CPU usage info is successfully obtained.
+ * @par Dependency:
+ * <ul><li>los_monitor.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_CpupUsageMonitor
+ */
+extern UINT32 LOS_CpupUsageMonitor(CPUP_TYPE_E type, CPUP_MODE_E mode, UINT32 taskID);
 
 #ifdef __cplusplus
 #if __cplusplus

components/dynlink/BUILD.gn

@@ -0,0 +1,48 @@
+# Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/config.gni")
+
+config("dynlink_config") {
+  include_dirs = [ "./" ]
+  if (arch == "arm") {
+    include_dirs += [ "../../kernel/arch/arm/include" ]
+  } else {
+    assert(false,
+           "Dynlink module does not support for other archs except for arm!")
+  }
+}
+
+static_library("dynlink") {
+  sources = [ "los_dynlink.c" ]
+
+  public_configs = [ ":dynlink_config" ]
+  configs += [ "$LITEOSTOPDIR:los_config" ]
+
+  deps = [ "//kernel/liteos_m/kal/posix" ]
+}

components/dynlink/los_dynlink.c

@@ -0,0 +1,935 @@
+/*
+ * Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "los_dynlink.h"
+#include "stdlib.h"
+#include "string.h"
+#include "unistd.h"
+#include "fcntl.h"
+#include "errno.h"
+#include "limits.h"
+#include "sys/stat.h"
+#include "securec.h"
+#include "arch_elf.h"
+#include "los_task.h"
+#include "los_debug.h"
+#include "los_mux.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#if (LOSCFG_DYNLINK == 1)
+
+#if defined(__ICCARM__) || defined(__CC_ARM)
+/**
+ * Place instructions below in .icf linker file:
+ *
+ * keep {section .TABLE.START};
+ * keep {section .sym.*};
+ * keep {section .table.end};
+ * define block SYMBOL_TABLE with fixed order
+ * {
+ *     section .TABLE.START,
+ *     section .sym.*,
+ *     section .table.end
+ * };
+ * place in ROM_region {readonly, block SYMBOL_TABLE};
+ */
+const SymInfo symTableStart __attribute__((section(".TABLE.START"))) = {
+    .name = "start",
+    .addr = 0
+};
+
+const SymInfo symTableEnd __attribute__((section(".table.end"))) = {
+    .name = "end",
+    .addr = 0
+};
+#pragma section=".TABLE.START"
+#pragma section=".table.end"
+#elif defined(__CLANG_ARM) || defined(__GNUC__)
+/**
+ * Place instructions below in rodata segment of .ld linker file:
+ *
+ *  __sym_table_start = .;
+ *  KEEP(*( SORT (.sym.*)));
+ *  __sym_table_end = .;
+ */
+extern char __sym_table_start[];
+extern char __sym_table_end[];
+#else
+#error Unknown compiler.
+#endif
+
+STATIC LOS_DL_LIST g_dynSharedObjLink;
+STATIC UINT32 g_dynlinkMux;
+
+STATIC DynSharedObj *OsIsPreLoaded(const CHAR *fileName)
+{
+    DynSharedObj *dso = NULL;
+
+    LOS_DL_LIST_FOR_EACH_ENTRY(dso, &g_dynSharedObjLink, DynSharedObj, dsoNode) {
+        if (!strcmp(fileName, dso->fileName)) {
+            ++dso->ref;
+            return dso;
+        }
+    }
+
+    return NULL;
+}
+
+STATIC INT32 OsVerifyEhdr(const LD_ELF_EHDR *ehdr, UINT32 fileLen)
+{
+    if (memcmp(ehdr->e_ident, LD_ELFMAG, LD_SELFMAG) != LOS_OK) {
+        PRINT_ERR("The file is not elf format\n");
+        return LOS_NOK;
+    }
+    if (ehdr->e_type != ET_DYN) {
+        PRINT_ERR("The file is not shared library\n");
+        return LOS_NOK;
+    }
+    if (!check_arch(ehdr)) {
+        PRINT_ERR("The file can not load in current platform\n");
+        return LOS_NOK;
+    }
+    if (ehdr->e_phnum > PHDR_NUM_MAX) {
+        PRINT_ERR("The num of program header is out of limit\n");
+        return LOS_NOK;
+    }
+    if (ehdr->e_phoff > fileLen) {
+        PRINT_ERR("The offset of program header is invalid, elf file is bad\n");
+        return LOS_NOK;
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsReadELFInfo(INT32 fd, UINT8 *buffer, size_t readSize, off_t offset)
+{
+    ssize_t byteNum;
+    off_t returnPos;
+
+    if (readSize > 0) {
+        returnPos = lseek(fd, offset, SEEK_SET);
+        if (returnPos != offset) {
+            PRINT_ERR("Failed to seek the position!, offset: %#x\n", offset);
+            return LOS_NOK;
+        }
+
+        byteNum = read(fd, buffer, readSize);
+        if (byteNum <= 0) {
+            PRINT_ERR("Failed to read from offset: %#x!\n", offset);
+            return LOS_NOK;
+        }
+    }
+    return LOS_OK;
+}
+
+STATIC INT32 OsGetFileLength(UINT32 *fileLen, const CHAR *fileName)
+{
+    struct stat buf;
+    INT32 ret;
+
+    ret = stat(fileName, &buf);
+    if (ret < 0) {
+        PRINT_ERR("Failed to stat file: %s, errno: %d\n", fileName, errno);
+        return LOS_NOK;
+    }
+
+    if (buf.st_size > FILE_LENGTH_MAX) {
+        PRINT_ERR("The file: %s length is out of limit!\n", fileName);
+        return LOS_NOK;
+    }
+
+    *fileLen = (UINT32)buf.st_size;
+    return LOS_OK;
+}
+
+STATIC INT32 OsReadEhdr(INT32 fd, UINT32 fileLen, DynLinkInfo *dlInfo)
+{
+    INT32 ret;
+
+    ret = OsReadELFInfo(fd, (UINT8 *)&dlInfo->elfEhdr, sizeof(LD_ELF_EHDR), 0);
+    if (ret != LOS_OK) {
+        return -EIO;
+    }
+
+    ret = OsVerifyEhdr(&dlInfo->elfEhdr, fileLen);
+    if (ret != LOS_OK) {
+        return -ELIBBAD;
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsReadPhdrs(INT32 fd, UINT32 fileLen, DynLinkInfo *dlInfo)
+{
+    INT32 ret;
+    UINT32 size;
+    LD_ELF_EHDR *ehdr = &dlInfo->elfEhdr;
+
+    if ((ehdr->e_phnum == 0) || (ehdr->e_phentsize != sizeof(LD_ELF_PHDR))) {
+        goto ERR;
+    }
+
+    size = sizeof(LD_ELF_PHDR) * ehdr->e_phnum;
+    if ((ehdr->e_phoff + size) > fileLen) {
+        goto ERR;
+    }
+
+    dlInfo->elfPhdr = (LD_ELF_PHDR *)LOS_MemAlloc(OS_SYS_MEM_ADDR, size);
+    if (dlInfo->elfPhdr == NULL) {
+        return -ENOMEM;
+    }
+
+    ret = OsReadELFInfo(fd, (UINT8 *)dlInfo->elfPhdr, size, ehdr->e_phoff);
+    if (ret != LOS_OK) {
+        LOS_MemFree(OS_SYS_MEM_ADDR, dlInfo->elfPhdr);
+        return -EIO;
+    }
+
+    return LOS_OK;
+
+ERR:
+    PRINT_ERR("the file is bad\n");
+    return -ELIBBAD;
+}
+
+STATIC DynSharedObj *OsLoadInit(const CHAR *fileName, VOID *pool)
+{
+    DynSharedObj *dso = NULL;
+    UINT32 allocSize, nameLen;
+    UINT32 fileLen = 0;
+    INT32 ret;
+
+    nameLen = strlen(fileName);
+    if (nameLen > PATH_MAX) {
+        PRINT_ERR("file name length is too long\n");
+        errno = ENAMETOOLONG;
+        return NULL;
+    }
+    allocSize = sizeof(DynSharedObj) + nameLen + 1;
+
+    dso = (DynSharedObj *)LOS_MemAlloc(OS_SYS_MEM_ADDR, allocSize);
+    if (dso == NULL) {
+        PRINT_ERR("failed to alloc for dso\n");
+        errno = ENOMEM;
+        return NULL;
+    }
+    (VOID)memset_s(dso, allocSize, 0, allocSize);
+
+    dso->dlInfo = (DynLinkInfo *)LOS_MemAlloc(OS_SYS_MEM_ADDR, sizeof(DynLinkInfo));
+    if (dso->dlInfo == NULL) {
+        LOS_MemFree(OS_SYS_MEM_ADDR, dso);
+        PRINT_ERR("failed to alloc for loadInfo\n");
+        errno = ENOMEM;
+        return NULL;
+    }
+    (VOID)memset_s(dso->dlInfo, sizeof(DynLinkInfo), 0, sizeof(DynLinkInfo));
+
+    ret = OsGetFileLength(&fileLen, fileName);
+    if (ret != LOS_OK) {
+        errno = ENOENT;
+        goto ERR1;
+    }
+
+    dso->fd = open(fileName, O_RDONLY);
+    if (dso->fd < 0) {
+        PRINT_ERR("Failed to open ELF file: %s!\n", fileName);
+        goto ERR1;
+    }
+
+    ret = OsReadEhdr(dso->fd, fileLen, dso->dlInfo);
+    if (ret != LOS_OK) {
+        errno = -ret;
+        goto ERR2;
+    }
+
+    ret = OsReadPhdrs(dso->fd, fileLen, dso->dlInfo);
+    if (ret != LOS_OK) {
+        errno = -ret;
+        goto ERR2;
+    }
+
+    strcpy(dso->buf, fileName);
+    dso->fileName = dso->buf;
+    dso->ref = 1;
+    dso->pool = (pool ? pool : OS_SYS_MEM_ADDR);
+    LOS_ListInit(&dso->dsoNode);
+
+    return dso;
+
+ERR2:
+    close(dso->fd);
+ERR1:
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso);
+    return NULL;
+}
+
+STATIC INT32 OsReserveSpace(const DynLinkInfo *dlInfo, UINT32 *boundary)
+{
+    const LD_ELF_PHDR *elfPhdrTemp = dlInfo->elfPhdr;
+    INT32 phdrNum = dlInfo->elfEhdr.e_phnum;
+    UINTPTR addrMin = SIZE_MAX;
+    UINTPTR addrMax = 0;
+    UINT32 offStart = 0;
+    UINT64 size;
+    INT32 i;
+
+    for (i = 0; i < phdrNum; ++i, ++elfPhdrTemp) {
+        if (elfPhdrTemp->p_type == PT_TLS) {
+            PRINT_ERR("unsupport tls\n");
+            return 0;
+        }
+        if (elfPhdrTemp->p_type != PT_LOAD) {
+            continue;
+        }
+
+        if (*boundary == 0) {
+            *boundary = elfPhdrTemp->p_align;
+        }
+
+        if (elfPhdrTemp->p_vaddr < addrMin) {
+            addrMin = elfPhdrTemp->p_vaddr;
+            offStart = elfPhdrTemp->p_offset;
+        }
+        if ((elfPhdrTemp->p_vaddr + elfPhdrTemp->p_memsz) > addrMax) {
+            addrMax = elfPhdrTemp->p_vaddr + elfPhdrTemp->p_memsz;
+        }
+    }
+
+    if ((addrMin == addrMax) || (addrMax < addrMin)) {
+        return 0;
+    }
+    size = ELF_ALIGN_UP(addrMax, *boundary) - ELF_ALIGN_DOWN(addrMin, *boundary) + ELF_ALIGN_DOWN(offStart, *boundary);
+
+    return  (size > UINT_MAX) ? 0 : (UINT32)size;
+}
+
+STATIC UINTPTR OsDoLoadFile(INT32 fd, UINTPTR addr, const LD_ELF_PHDR *elfPhdr, UINT32 boundary)
+{
+    INT32 ret;
+    UINT32 offset = elfPhdr->p_offset - ELF_ALIGN_OFFSET(elfPhdr->p_vaddr, boundary);
+    UINT32 size = elfPhdr->p_filesz + ELF_ALIGN_OFFSET(elfPhdr->p_vaddr, boundary);
+    if (size == 0) {
+        return 0;
+    }
+
+    addr = ELF_ALIGN_DOWN(addr, boundary);
+    ret = OsReadELFInfo(fd, (UINT8 *)addr, size, offset);
+    if (ret != LOS_OK) {
+        return 0;
+    }
+
+    return addr;
+}
+
+STATIC INT32 OsLoadELFFile(DynSharedObj *dso, UINT32 boundary)
+{
+    DynLinkInfo *dlInfo = dso->dlInfo;
+    const LD_ELF_PHDR *elfPhdrTemp = dlInfo->elfPhdr;
+    const LD_ELF_EHDR *elfEhdr = &dlInfo->elfEhdr;
+    UINTPTR loadBase = dso->loadBase;
+    UINTPTR vAddr, loadAddr, bssStart, bssEnd;
+    INT32 i;
+
+    for (i = 0; i < elfEhdr->e_phnum; ++i, ++elfPhdrTemp) {
+        if (elfPhdrTemp->p_type != PT_LOAD) {
+            continue;
+        }
+
+        if ((elfPhdrTemp->p_flags & PF_R) == 0) {
+            return -ENOEXEC;
+        }
+        vAddr = elfPhdrTemp->p_vaddr;
+
+        loadAddr = OsDoLoadFile(dso->fd, (vAddr + loadBase), elfPhdrTemp, boundary);
+        if (loadAddr == 0) {
+            return -EFAULT;
+        }
+
+        if ((elfPhdrTemp->p_memsz > elfPhdrTemp->p_filesz) && (elfPhdrTemp->p_flags & PF_W)) {
+            bssStart = loadAddr + ELF_ALIGN_OFFSET(vAddr, boundary) + elfPhdrTemp->p_filesz;
+            bssEnd = loadAddr + ELF_ALIGN_OFFSET(vAddr, boundary) + elfPhdrTemp->p_memsz;
+            (VOID)memset_s((VOID *)bssStart, bssEnd - bssStart, 0, bssEnd - bssStart);
+        }
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsLoadLibrary(DynSharedObj *dso)
+{
+    UINT32 loadSize;
+    UINT32 boundary = 0;
+    INT32 ret;
+
+    loadSize = OsReserveSpace(dso->dlInfo, &boundary);
+    if (loadSize == 0) {
+        PRINT_ERR("failed to reserve space!\n");
+        return -EINVAL;
+    }
+
+    dso->loadBase = (UINTPTR)LOS_MemAllocAlign(dso->pool, loadSize, boundary);
+    if (dso->loadBase == 0) {
+        PRINT_ERR("failed to alloc memory for loading shared library\n");
+        return -ENOMEM;
+    }
+
+    ret = OsLoadELFFile(dso, boundary);
+    if (ret != LOS_OK) {
+        LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
+        PRINT_ERR("failed to load shared library\n");
+        return ret;
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsGetDynBase(DynSharedObj *dso)
+{
+    DynLinkInfo *dlInfo = dso->dlInfo;
+    const LD_ELF_PHDR *elfPhdrTemp = dlInfo->elfPhdr;
+    INT32 phdrNum = dlInfo->elfEhdr.e_phnum;
+    INT32 i;
+
+    for (i = 0; i < phdrNum; ++i, ++elfPhdrTemp) {
+        if (elfPhdrTemp->p_type != PT_DYNAMIC) {
+            continue;
+        }
+        dlInfo->dynBase = dso->loadBase + elfPhdrTemp->p_vaddr;
+        return LOS_OK;
+    }
+
+    return LOS_NOK;
+}
+
+STATIC INT32 OsParseDynamic(DynSharedObj *dso)
+{
+    LD_ELF_DYN *dyn = NULL;
+    DynLinkInfo *dlInfo = dso->dlInfo;
+    RelocInfoTab *relInfoTab = &dlInfo->relInfoTab;
+
+    for (dyn = (LD_ELF_DYN *)dlInfo->dynBase; dyn->d_tag != DT_NULL; ++dyn) {
+        switch (dyn->d_tag) {
+            case DT_NEEDED:
+                PRINT_ERR("shared library should not depend on others\n");
+                return -ENOTSUP;
+            case DT_TEXTREL:
+                PRINT_ERR("you should recompile shared library with -fPIC\n");
+                return -EFAULT;
+            case DT_HASH:
+                dlInfo->hashTab = (UINT32 *)(dso->loadBase + dyn->d_un.d_ptr);
+                break;
+            case DT_SYMTAB:
+                dlInfo->symTab = (LD_ELF_SYM *)(dso->loadBase + dyn->d_un.d_ptr);
+                break;
+            case DT_STRTAB:
+                dlInfo->symStrings = (CHAR *)(dso->loadBase + dyn->d_un.d_ptr);
+                break;
+            case DT_REL:
+                relInfoTab->rel.relTab = dso->loadBase + dyn->d_un.d_ptr;
+                relInfoTab->rel.relEntSize = sizeof(LD_ELF_REL);
+                break;
+            case DT_RELSZ:
+                relInfoTab->rel.relTabSize = dyn->d_un.d_val;
+                break;
+            case DT_RELA:
+                relInfoTab->rela.relTab = dso->loadBase + dyn->d_un.d_ptr;
+                relInfoTab->rela.relEntSize = sizeof(LD_ELF_RELA);
+                break;
+            case DT_RELASZ:
+                relInfoTab->rela.relTabSize = dyn->d_un.d_val;
+                break;
+            case DT_JMPREL:
+                relInfoTab->jmpRel.relTab = dso->loadBase + dyn->d_un.d_ptr;
+                break;
+            case DT_PLTRELSZ:
+                relInfoTab->jmpRel.relTabSize = dyn->d_un.d_val;
+                break;
+            case DT_PLTREL:
+                relInfoTab->jmpRel.relEntSize = (dyn->d_un.d_val == DT_REL) ? sizeof(LD_ELF_REL) : sizeof(LD_ELF_RELA);
+            default:
+                break;
+        }
+    }
+
+    return LOS_OK;
+}
+
+STATIC UINT32 OsGetHashVal(const CHAR *name)
+{
+    UINT32 hashVal = 0;
+    UINT32 tmp;
+    const UINT8 *str = (const UINT8 *)name;
+
+    while (*str) {
+        hashVal = (*str) + (hashVal << WORD_SHIFT);
+        tmp = hashVal & HASH_MASK;
+        if (tmp != 0) {
+            hashVal ^= tmp >> HASH_SHIFT;
+        }
+
+        hashVal &= ~tmp;
+        ++str;
+    }
+
+    return hashVal;
+}
+
+STATIC LD_ELF_SYM *OsFindSymInDso(const DynLinkInfo *dlInfo, const CHAR *name)
+{
+    LD_ELF_SYM *symTab = dlInfo->symTab;
+    LD_ELF_SYM *sym = NULL;
+    CHAR *symStr = dlInfo->symStrings;
+    UINT32 *hashTab = dlInfo->hashTab;
+    UINT32 bucketNum = hashTab[0];
+    UINT32 *bucket = &hashTab[BUCKET_IDX];
+    UINT32 *chain = &bucket[bucketNum];
+    UINT32 hashVal = OsGetHashVal(name);
+    UINT32 symIdx;
+
+    for (symIdx = bucket[hashVal % bucketNum]; symIdx; symIdx = chain[symIdx]) {
+        if (strcmp(name, symStr + symTab[symIdx].st_name) != 0) {
+            continue;
+        }
+
+        sym = symTab + symIdx;
+        if ((sym->st_value == 0) || (sym->st_shndx == 0)) {
+            return NULL;
+        }
+        return symTab + symIdx;
+    }
+
+    return NULL;
+}
+
+STATIC SymInfo *OsFindSymInTable(const CHAR *name)
+{
+#if defined(__ICCARM__) || defined(__CC_ARM)
+    SymInfo *symTab = (SymInfo *)__section_end(".TABLE.START");
+    UINT32 symTableSize = ((UINTPTR)__section_begin(".table.end") -
+                          (UINTPTR)__section_end(".TABLE.START")) / sizeof(SymInfo);
+#elif defined(__CLANG_ARM) || defined(__GNUC__)
+    SymInfo *symTab = (SymInfo *)__sym_table_start;
+    UINT32 symTableSize = (__sym_table_end - __sym_table_start) / sizeof(SymInfo);
+#endif
+    INT32 startIdx = 0;
+    INT32 endIdx = symTableSize - 1;
+    INT32 ret, midIdx;
+
+    while (startIdx <= endIdx) {
+        midIdx = startIdx + ((UINT32)(endIdx - startIdx) >> 1);
+        ret = strcmp(symTab[midIdx].name, name);
+        if (ret > 0) {
+            endIdx = midIdx - 1;
+        } else if (ret < 0) {
+            startIdx = midIdx + 1;
+        } else {
+            return symTab + midIdx;
+        }
+    }
+
+    return NULL;
+}
+
+STATIC UINTPTR OsFindSym(const DynSharedObj *dso, INT32 symIdx)
+{
+    DynLinkInfo *dlInfo = dso->dlInfo;
+    CHAR *symStrings = dlInfo->symStrings;
+    CHAR *symStr = NULL;
+    LD_ELF_SYM *symTab = dlInfo->symTab;
+    LD_ELF_SYM *sym = NULL;
+    LD_ELF_SYM *symInDso = NULL;
+    SymInfo *symInTab = NULL;
+
+    sym = symTab + symIdx;
+    symStr = symStrings + sym->st_name;
+    if ((symInDso = OsFindSymInDso(dlInfo, symStr)) != NULL) {
+        return dso->loadBase + symInDso->st_value;
+    } else if ((symInTab = OsFindSymInTable(symStr)) != NULL) {
+        return symInTab->addr;
+    } else {
+        PRINT_ERR("failed to relocate %s, symbol: %s not found\n", dso->fileName, symStr);
+        return 0;
+    }
+}
+
+STATIC INT32 OsDoReloc(const DynSharedObj *dso, INT32 type, UINTPTR relocAddr, UINT32 addend, UINTPTR symAddr)
+{
+    switch (type) {
+        case R_ARCH_NONE:
+            break;
+        case R_ARCH_GLOB_DAT:
+        case R_ARCH_JUMP_SLOT:
+            *(UINTPTR *)relocAddr = symAddr + addend;
+            break;
+        case R_ARCH_ABS32:
+            *(UINTPTR *)relocAddr = symAddr + ((addend != 0) ? addend : *(UINTPTR *)relocAddr);
+            break;
+        case R_ARCH_RELATIVE:
+            *(UINTPTR *)relocAddr = dso->loadBase + ((addend != 0) ?  addend : *(UINTPTR *)relocAddr);
+            break;
+        default:
+            PRINT_ERR("failed to relocate %s, unsupported reloc type: %d\n", dso->fileName, type);
+            return -ENOTSUP;
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsDoRelocSyms(DynSharedObj *dso, RelocInfo *relInfo)
+{
+    UINT32 relStride = relInfo->relEntSize / sizeof(UINT32);
+    UINT32 *relTab = (UINT32 *)relInfo->relTab;
+    UINT32 addend;
+    UINTPTR relocAddr, symAddr;
+    INT32 i, symIdx, ret, type;
+
+    for (i = 0; i < relInfo->relTabSize; i += relInfo->relEntSize, relTab += relStride) {
+        type = REL_TYPE(relTab[1]);
+        if (type == R_ARCH_NONE) {
+            continue;
+        }
+
+        symIdx = REL_SYM(relTab[1]);
+        if (symIdx == 0) {
+            symAddr = 0;
+        } else {
+            symAddr = OsFindSym(dso, symIdx);
+            if (symAddr == 0) {
+                return -EFAULT;
+            }
+        }
+
+        relocAddr = dso->loadBase + relTab[0];
+        addend = (relInfo->relEntSize == sizeof(LD_ELF_REL)) ? 0 : relTab[relStride - 1];
+        ret = OsDoReloc(dso, type, relocAddr, addend, symAddr);
+        if (ret != LOS_OK) {
+            return ret;
+        }
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsRelocSyms(DynSharedObj *dso)
+{
+    DynLinkInfo *dlInfo = dso->dlInfo;
+    RelocInfo *relInfo = (RelocInfo *)&dlInfo->relInfoTab;
+    INT32 relTypes = sizeof(RelocInfoTab) / sizeof(RelocInfo);
+    INT32 i, ret;
+
+    for (i = 0; i < relTypes; ++i, ++relInfo) {
+        if (relInfo->relTab == 0) {
+            continue;
+        }
+
+        ret = OsDoRelocSyms(dso, relInfo);
+        if (ret != LOS_OK) {
+            return ret;
+        }
+    }
+
+    return LOS_OK;
+}
+
+STATIC INT32 OsDoDynLink(DynSharedObj *dso)
+{
+    INT32 ret;
+
+    ret = OsGetDynBase(dso);
+    if (ret != LOS_OK) {
+        PRINT_ERR("there are no dynamic segments in elf file\n");
+        return -ELIBBAD;
+    }
+
+    ret = OsParseDynamic(dso);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    ret = OsRelocSyms(dso);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    return LOS_OK;
+}
+
+STATIC VOID OsDeLoadInit(DynSharedObj *dso)
+{
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo->elfPhdr);
+    dso->dlInfo->elfPhdr = NULL;
+    close(dso->fd);
+}
+
+STATIC VOID OsGetInitFini(DynSharedObj *dso)
+{
+    LD_ELF_DYN *dyn = NULL;
+    DynLinkInfo *dlInfo = dso->dlInfo;
+    InitFiniTab *initFiniTab = &dso->initFiniTab;
+
+    for (dyn = (LD_ELF_DYN *)dlInfo->dynBase; dyn->d_tag != DT_NULL; ++dyn) {
+        switch (dyn->d_tag) {
+            case DT_INIT:
+                initFiniTab->init.func = dyn->d_un.d_ptr;
+                break;
+            case DT_INIT_ARRAY:
+                initFiniTab->init.array = dyn->d_un.d_ptr;
+                break;
+            case DT_INIT_ARRAYSZ:
+                initFiniTab->init.arraySz = dyn->d_un.d_val;
+                break;
+            case DT_FINI:
+                initFiniTab->fini.func = dyn->d_un.d_ptr;
+                break;
+            case DT_FINI_ARRAY:
+                initFiniTab->fini.array = dyn->d_un.d_ptr;
+                break;
+            case DT_FINI_ARRAYSZ:
+                initFiniTab->fini.arraySz = dyn->d_un.d_val;
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+STATIC VOID OsDoInit(DynSharedObj *dso)
+{
+    InitFiniTab *initFiniTab = &dso->initFiniTab;
+    INIT_FINI_FUNC initFunc = NULL;
+    UINTPTR *func = NULL;
+    UINT32 funcNum;
+
+    OsGetInitFini(dso);
+    if (initFiniTab->init.func != 0) {
+        initFunc = (INIT_FINI_FUNC)(dso->loadBase + initFiniTab->init.func);
+        initFunc();
+    }
+
+    if (initFiniTab->init.array == 0) {
+        return;
+    }
+
+    funcNum = initFiniTab->init.arraySz / sizeof(UINTPTR);
+    func = (UINTPTR *)(dso->loadBase + initFiniTab->init.array);
+    while (funcNum--) {
+        initFunc = (INIT_FINI_FUNC)(*func);
+        initFunc();
+        ++func;
+    }
+}
+
+VOID *LOS_SoLoad(const CHAR *fileName, VOID *pool)
+{
+    INT32 ret;
+    DynSharedObj *dso = NULL;
+
+    if (fileName == NULL) {
+        PRINT_ERR("invalid file name\n");
+        errno = EINVAL;
+        return NULL;
+    }
+
+    (VOID)LOS_MuxPend(g_dynlinkMux, LOS_WAIT_FOREVER);
+    dso = OsIsPreLoaded(fileName);
+    if (dso != NULL) {
+        (VOID)LOS_MuxPost(g_dynlinkMux);
+        return dso;
+    }
+
+    dso = OsLoadInit(fileName, pool);
+    if (dso == NULL) {
+        (VOID)LOS_MuxPost(g_dynlinkMux);
+        return NULL;
+    }
+
+    ret = OsLoadLibrary(dso);
+    if (ret != LOS_OK) {
+        errno = -ret;
+        goto ERR1;
+    }
+
+    ret = OsDoDynLink(dso);
+    if (ret != LOS_OK) {
+        errno = -ret;
+        goto ERR2;
+    }
+
+    OsDoInit(dso);
+
+    LOS_ListAdd(&g_dynSharedObjLink, &dso->dsoNode);
+    (VOID)LOS_MuxPost(g_dynlinkMux);
+    OsDeLoadInit(dso);
+
+    return dso;
+
+ERR2:
+    LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
+ERR1:
+    close(dso->fd);
+    (VOID)LOS_MuxPost(g_dynlinkMux);
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo->elfPhdr);
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso);
+    return NULL;
+}
+
+STATIC DynSharedObj *OsCheckHandle(VOID *handle)
+{
+    DynSharedObj *dso = NULL;
+
+    LOS_DL_LIST_FOR_EACH_ENTRY(dso, &g_dynSharedObjLink, DynSharedObj, dsoNode) {
+        if (handle == dso) {
+            return dso;
+        }
+    }
+
+    return NULL;
+}
+
+VOID *LOS_FindSym(VOID *handle, const CHAR *name)
+{
+    LD_ELF_SYM *sym = NULL;
+    DynSharedObj *dso = NULL;
+    VOID *symAddr = NULL;
+
+    if ((handle == NULL) || (name == NULL)) {
+        goto ERR;
+    }
+
+    (VOID)LOS_MuxPend(g_dynlinkMux, LOS_WAIT_FOREVER);
+    dso = OsCheckHandle(handle);
+    if (dso == NULL) {
+        (VOID)LOS_MuxPost(g_dynlinkMux);
+        goto ERR;
+    }
+
+    sym = OsFindSymInDso(dso->dlInfo, name);
+    if (sym == NULL) {
+        (VOID)LOS_MuxPost(g_dynlinkMux);
+        PRINT_ERR("failed to find symbol: %s\n", name);
+        errno = EFAULT;
+        return NULL;
+    }
+    symAddr = (VOID *)(dso->loadBase + sym->st_value);
+    (VOID)LOS_MuxPost(g_dynlinkMux);
+    return symAddr;
+
+ERR:
+    PRINT_ERR("invalid input param\n");
+    errno = EINVAL;
+    return NULL;
+}
+
+STATIC VOID OsDoFini(DynSharedObj *dso)
+{
+    InitFiniTab *initFiniTab = &dso->initFiniTab;
+    INIT_FINI_FUNC finiFunc = NULL;
+    UINTPTR *func = NULL;
+    UINT32 funcNum;
+
+    if (initFiniTab->fini.array != 0) {
+        funcNum = initFiniTab->fini.arraySz / sizeof(UINTPTR);
+        func = (UINTPTR *)(dso->loadBase + initFiniTab->fini.array) + funcNum;
+        while (funcNum--) {
+            --func;
+            finiFunc = (INIT_FINI_FUNC)(*func);
+            finiFunc();
+       }
+    }
+
+    if (initFiniTab->fini.func != 0) {
+        finiFunc = (INIT_FINI_FUNC)(dso->loadBase + initFiniTab->fini.func);
+        finiFunc();
+    }
+}
+
+INT32 LOS_SoUnload(VOID *handle)
+{
+    DynSharedObj *dso = NULL;
+
+    if (handle == NULL) {
+        goto ERR;
+    }
+
+    (VOID)LOS_MuxPend(g_dynlinkMux, LOS_WAIT_FOREVER);
+    dso = OsCheckHandle(handle);
+    if (dso == NULL) {
+        (VOID)LOS_MuxPost(g_dynlinkMux);
+        goto ERR;
+    }
+
+    if (dso->ref > 1) {
+        --dso->ref;
+        (VOID)LOS_MuxPost(g_dynlinkMux);
+        return LOS_OK;
+    }
+
+    OsDoFini(dso);
+
+    LOS_ListDelete(&dso->dsoNode);
+    (VOID)LOS_MuxPost(g_dynlinkMux);
+
+    LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
+    LOS_MemFree(OS_SYS_MEM_ADDR, dso);
+
+    return LOS_OK;
+ERR:
+    PRINT_ERR("invalid handle\n");
+    errno = EINVAL;
+    return LOS_NOK;
+}
+
+INT32 LOS_DynlinkInit(VOID)
+{
+    UINT32 ret;
+
+    LOS_ListInit(&g_dynSharedObjLink);
+    ret = LOS_MuxCreate(&g_dynlinkMux);
+    if (ret != LOS_OK) {
+        return LOS_NOK;
+    }
+    return LOS_OK;
+}
+
+#endif /* LOSCFG_DYNLINK */
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+

components/dynlink/los_dynlink.h

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _LOS_DYNLINK_H
+#define _LOS_DYNLINK_H
+
+#include "elf.h"
+#include "los_compiler.h"
+#include "los_list.h"
+#include "los_memory.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#ifdef LOSCFG_AARCH64
+typedef Elf64_Ehdr      LD_ELF_EHDR;
+typedef Elf64_Phdr      LD_ELF_PHDR;
+typedef Elf64_Sym       LD_ELF_SYM;
+typedef Elf64_Dyn       LD_ELF_DYN;
+typedef Elf64_Rel       LD_ELF_REL;
+typedef Elf64_Rela      LD_ELF_RELA;
+#define REL_TYPE(x)     ELF64_R_TYPE(x)
+#define REL_SYM(x)      ELF64_R_SYM(x)
+#define REL_INFO        ELF64_R_INFO
+#else
+typedef Elf32_Ehdr      LD_ELF_EHDR;
+typedef Elf32_Phdr      LD_ELF_PHDR;
+typedef Elf32_Sym       LD_ELF_SYM;
+typedef Elf32_Dyn       LD_ELF_DYN;
+typedef Elf32_Rel       LD_ELF_REL;
+typedef Elf32_Rela      LD_ELF_RELA;
+#define REL_TYPE(x)     ELF32_R_TYPE(x)
+#define REL_SYM(x)      ELF32_R_SYM(x)
+#define REL_INFO        ELF32_R_INFO
+#endif
+
+#define LD_ELFMAG       "\177ELF"
+#define LD_SELFMAG      4
+#define PHDR_NUM_MAX    128
+#define DYNAMIC_CNT     32
+#define HASH_MASK       0xf0000000
+#define WORD_SHIFT      4
+#define HASH_SHIFT      24
+#define BUCKET_IDX      2
+
+#define ELF_ALIGN_UP(a, b)          (((a) + ((b) - 1)) & ~((b) - 1))
+#define ELF_ALIGN_DOWN(a, b)        ((a) & ~((b) - 1))
+#define ELF_ALIGN_OFFSET(a, b)      ((a) & ((b) - 1))
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+#ifndef FILE_LENGTH_MAX
+#define FILE_LENGTH_MAX  0x40000
+#endif
+typedef VOID (*INIT_FINI_FUNC)(VOID);
+
+typedef struct {
+    UINTPTR relTab;
+    UINT32  relTabSize;
+    UINT32  relEntSize;
+} RelocInfo;
+
+typedef struct {
+    RelocInfo rel;
+    RelocInfo rela;
+    RelocInfo jmpRel;
+} RelocInfoTab;
+
+typedef struct {
+    UINTPTR func;
+    UINTPTR array;
+    UINT32  arraySz;
+} InitFiniInfo;
+
+typedef struct {
+    InitFiniInfo init;
+    InitFiniInfo fini;
+} InitFiniTab;
+
+typedef struct {
+    LD_ELF_EHDR  elfEhdr;
+    LD_ELF_PHDR  *elfPhdr;
+    UINTPTR      dynBase;
+    UINT32       *hashTab;
+    LD_ELF_SYM   *symTab;
+    CHAR         *symStrings;
+    RelocInfoTab relInfoTab;
+} DynLinkInfo;
+
+typedef struct {
+    CHAR         *fileName;
+    INT32        fd;
+    DynLinkInfo  *dlInfo;
+    UINTPTR      loadBase;
+    InitFiniTab  initFiniTab;
+    LOS_DL_LIST  dsoNode;
+    UINT32       ref;
+    VOID         *pool;
+    CHAR         buf[];
+} DynSharedObj;
+
+typedef struct {
+  CHAR    *name;
+  UINTPTR addr;
+} SymInfo;
+
+#define SYM_EXPORT(func)                                            \
+const SymInfo sym_##func __attribute__((section(".sym."#func))) = { \
+    .name = #func,                                                  \
+    .addr = (UINTPTR)func                                           \
+};
+
+/*
+ * @brief Load the shared library file named by the NULL-terminated string filename and
+ * return a valid handle for the loaded library.
+ *
+ * @param fileName The name pointer of shared library.
+ * @param pool The heap for shared library to load. If the parameter, pool, is NULL, then
+ * the dynamic loader & linker module will use the default heap and the pool is not NULL,
+ * then the shared library will be loaded to the heap by pool.
+ *
+ * @note When the heap, pool, is not NULL, you should call LOS_MemInit() to initialize the
+ * pool before calling LOS_SoLoad(). By the way, the system will comsume a certain amount
+ * of memory to initialize the pool. LOS_SoLoad must not be called in interrupt callback.
+ *
+ * @return Return NULL if error. Return non-NULL if success.
+ */
+VOID *LOS_SoLoad(const CHAR *fileName, VOID *pool);
+
+/*
+ * @brief Get the address of symbol named by the parameter, name, from the parameter, handle.
+ *
+ * @param handle The handle for the loaded shared library.
+ * @param name   The name of symbol to search.
+ *
+ * @note LOS_FindSym must not be called in interrupt callback.
+ *
+ * @return Return NULL if error. Return non-NULL if success.
+ */
+VOID *LOS_FindSym(VOID *handle, const CHAR *name);
+
+/*
+ * @brief Decrement the reference count on the loaded shared library refered to by handle.
+ * If the reference count drops to zero, then the library is unloaded.
+ *
+ * This function validates that the handle is valid.
+ *
+ * @param handle The handle for the loaded shared library by LOS_SoLoad() interface.
+ *
+ * @note LOS_SoUnload must not be called in interrupt callback.
+ *
+ * @return Return 1 if error. Return 0 if success.
+ */
+INT32 LOS_SoUnload(VOID *handle);
+
+/*
+ * @brief Initialization for dynamic loader & linker module.
+ *
+ * @param VOID.
+ *
+ * @return Return LOS_NOK if error. Return LOS_OK if success.
+ */
+INT32 LOS_DynlinkInit(VOID);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif /* _LOS_DYNLINK_H */
+

components/dynlink/script/so_parse

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+# Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Description: The script is used to calculate the memory size that the specified shared library
+# will occupy when loading to the RAM.
+
+READELF=readelf
+RM=rm
+SIZE=0x0
+SIZE_ALL=0x0
+SIZE_MAX=0
+TMP_FILE=tmp.txt
+
+if [ $# -lt 1 ]; then
+    echo "Usage: ./so_parse lib.so"
+    exit 1
+fi
+
+parse_line()
+{
+    MEM_SIZE=$(echo $1 | awk '{print $6}')
+    echo ${MEM_SIZE}
+}
+
+${READELF} -l $1 | while read line; do
+    HEAD_STRING=$(echo ${line} | awk '{print $1}')
+    if [[ "${HEAD_STRING}" == *"LOAD"* ]]; then
+        SIZE=`parse_line "${line}"`
+        SIZE=`echo ${SIZE}`
+        SIZE_ALL=$((SIZE_ALL+SIZE))
+    fi
+    echo ${SIZE_ALL} >> ${TMP_FILE}
+done
+
+NEED_SIZE=`tail -n 1 ${TMP_FILE}`
+echo "${NEED_SIZE} kb memory to reserve for $1!"
+${RM} -f ${TMP_FILE}
+

components/exchook/BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -27,16 +27,13 @@
 # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import("//kernel/liteos_m/config.gni")
+
 static_library("exchook") {
   sources = [
     "los_exc_info.c",
     "los_exchook.c",
   ]
-  include_dirs = [
-    "../../kernel/arch/include",
-    "../../kernel/include",
-    "../../utils",
-    "./",
-    "//third_party/bounds_checking_function/include",
-  ]
+
+  configs += [ "$LITEOSTOPDIR:los_config" ]
 }

components/exchook/los_exc_info.c

@@ -38,11 +38,6 @@
 #include "los_membox.h"
 #include "los_memory.h"
 
-#ifdef __cplusplus
-#if __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-#endif /* __cplusplus */
 
 #if (LOSCFG_PLATFORM_EXC == 1)
 #define EXC_MSG_ARRAY_INIT_VALUE   0xff
@@ -300,9 +295,4 @@ VOID OsExcMsgDumpInit(VOID)
 }
 #endif
 
-#ifdef __cplusplus
-#if __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* __cplusplus */
 

components/exchook/los_exchook.c

@@ -54,7 +54,7 @@ STATIC VOID DoExcHookInRegOrder(EXC_TYPE excType, struct Node *node)
 
 STATIC VOID DoExcHook(EXC_TYPE excType)
 {
-    UINTPTR intSave;
+    UINT32 intSave;
     if (excType >= EXC_TYPE_END) {
         return;
     }
@@ -88,7 +88,7 @@ STATIC struct Node *GetFreeNode(VOID)
 
 UINT32 LOS_RegExcHook(EXC_TYPE excType, ExcHookFn excHookFn)
 {
-    UINTPTR intSave;
+    UINT32 intSave;
     struct Node *node = NULL;
     if (excType >= EXC_TYPE_END || excHookFn == NULL) {
         return LOS_ERRNO_SYS_PTR_NULL;
@@ -110,7 +110,7 @@ UINT32 LOS_RegExcHook(EXC_TYPE excType, ExcHookFn excHookFn)
 
 UINT32 LOS_UnRegExcHook(EXC_TYPE excType, ExcHookFn excHookFn)
 {
-    UINTPTR intSave;
+    UINT32 intSave;
     struct Node *node = NULL;
     struct Node *preNode = NULL;
     if (excType >= EXC_TYPE_END || excHookFn == NULL) {

components/fs/BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -27,13 +27,32 @@
 # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+static_library("fs_operations") {
+  sources = [ "./fs.c" ]
+
+  include_dirs = [
+    "../../../kernel/arch/include",
+    "../../../kernel/include",
+    "../../../utils",
+    "../../../kal/posix/include",
+    "./",
+  ]
+
+  deps = [ "//kernel/liteos_m/kal/posix" ]
+}
+
 declare_args() {
   enable_ohos_kernel_liteos_m_fatfs = true
+  enable_ohos_kernel_liteos_m_littlefs = true
 }
 
 group("fs") {
   deps = []
-  if (enable_ohos_kernel_liteos_m_fatfs == true) {
+  deps += [ ".:fs_operations" ]
+  if (enable_ohos_kernel_liteos_m_fatfs) {
     deps += [ "fatfs:fatfs" ]
   }
+  if (enable_ohos_kernel_liteos_m_littlefs) {
+    deps += [ "littlefs:littlefs" ]
+  }
 }

components/fs/fatfs/BUILD.gn

@@ -1,5 +1,5 @@
-# Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021, Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -29,19 +29,23 @@
 
 static_library("fatfs") {
   sources = [
+    "//third_party/FatFs/source/diskio.c",
+    "//third_party/FatFs/source/ff.c",
+    "//third_party/FatFs/source/ffsystem.c",
+    "//third_party/FatFs/source/ffunicode.c",
     "fatfs.c",
-    "fs.c",
   ]
 
   include_dirs = [
+    "../",
     "../../../kernel/arch/include",
     "../../../kernel/include",
     "../../../utils",
     "../../../kal/cmsis",
-    "../../../kal",
     "../../../kal/posix/include",
-    "./",
     "//third_party/bounds_checking_function/include",
     "//third_party/FatFs/source/",
   ]
+
+  deps = [ "//kernel/liteos_m/kal/posix" ]
 }

components/fs/fatfs/fatfs.c

@@ -29,22 +29,20 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#define _GNU_SOURCE 1
 #include "ff.h"
-#if FF_USE_EXPAND
-#define _GNU_SOURCE
-#endif
 #include "fatfs.h"
 #include "errno.h"
+#include "stdbool.h"
 #include "limits.h"
 #include "pthread.h"
 #include "time.h"
 #include "securec.h"
 #include "los_compiler.h"
 #include "los_debug.h"
-#include "cmsis_os.h"
+#include "cmsis_os2.h"
+#include "fs_operations.h"
 
-#define FS_SUCCESS            0
-#define FS_FAILURE            (-1)
 /* the max name length of different parts should not bigger than 32 */
 #define FS_DRIVE_NAME_MAX_LEN 32
 
@@ -52,9 +50,9 @@
 #define FAT_MAX_OPEN_DIRS     8
 #endif /* FAT_MAX_OPEN_DIRS */
 
-#ifndef FS_LOCK_TIMEMOUT_SEC
-#define FS_LOCK_TIMEMOUT_SEC  15
-#endif /* FS_LOCK_TIMEMOUT_SEC */
+#ifndef FS_LOCK_TIMEOUT_SEC
+#define FS_LOCK_TIMEOUT_SEC  15
+#endif /* FS_LOCK_TIMEOUT_SEC */
 
 #define PART_NAME   0x0
 #define VOLUME_NAME 0x1
@@ -90,7 +88,7 @@ static int FsLock(void)
         PRINTK("clock gettime err 0x%x!\r\n", errno);
         return errno;
     }
-    absTimeout.tv_sec += FS_LOCK_TIMEMOUT_SEC;
+    absTimeout.tv_sec += FS_LOCK_TIMEOUT_SEC;
     ret = pthread_mutex_timedlock(&g_fsMutex, &absTimeout);
     return ret;
 }
@@ -624,14 +622,21 @@ int fatfs_close(int fd)
     FRESULT res;
     INT32 ret;
 
+    ret = FsLock();
+    if (ret != 0) {
+        errno = ret;
+        return FS_FAILURE;
+    }
+
     if (!IsValidFd(fd)) {
+        FsUnlock();
         errno = EBADF;
         return FS_FAILURE;
     }
 
-    ret = FsLock();
-    if (ret != 0) {
-        errno = ret;
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        FsUnlock();
+        errno = ENOENT;
         return FS_FAILURE;
     }
 
@@ -670,10 +675,6 @@ ssize_t fatfs_read(int fd, void *buf, size_t nbyte)
         errno = EFAULT;
         return FS_FAILURE;
     }
-    if (!IsValidFd(fd)) {
-        errno = EBADF;
-        return FS_FAILURE;
-    }
 
     ret = FsLock();
     if (ret != 0) {
@@ -681,6 +682,18 @@ ssize_t fatfs_read(int fd, void *buf, size_t nbyte)
         return FS_FAILURE;
     }
 
+    if (!IsValidFd(fd)) {
+        FsUnlock();
+        errno = EBADF;
+        return FS_FAILURE;
+    }
+
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        FsUnlock();
+        errno = ENOENT;
+        return FS_FAILURE;
+    }
+
     res = f_read(&g_handle[fd].fil, buf, nbyte, &lenRead);
     if (res != FR_OK) {
         FsUnlock();
@@ -703,10 +716,6 @@ ssize_t fatfs_write(int fd, const void *buf, size_t nbyte)
         errno = EFAULT;
         return FS_FAILURE;
     }
-    if (!IsValidFd(fd)) {
-        errno = EBADF;
-        return FS_FAILURE;
-    }
 
     ret = FsLock();
     if (ret != 0) {
@@ -714,15 +723,27 @@ ssize_t fatfs_write(int fd, const void *buf, size_t nbyte)
         return FS_FAILURE;
     }
 
+    if (!IsValidFd(fd)) {
+        errno = EBADF;
+        goto ERROUT;
+    }
+
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        errno = ENOENT;
+        goto ERROUT;
+    }
+
     if (!FsCheckByID(g_handle[fd].fil.obj.fs->id)) {
         errno = EACCES;
         goto ERROUT;
     }
+
     res = f_write(&g_handle[fd].fil, buf, nbyte, &lenWrite);
     if ((res == FR_OK) && (lenWrite == 0) && (nbyte != 0) && (overFlow == FALSE)) {
         overFlow = TRUE;
         PRINTK("FAT write err 0x%x!\r\n", fd);
     }
+
     if ((res != FR_OK) || (nbyte != lenWrite)) {
         errno = FatfsErrno(res);
         goto ERROUT;
@@ -742,17 +763,22 @@ off_t fatfs_lseek(int fd, off_t offset, int whence)
     INT32 ret;
     off_t pos;
 
-    if (!IsValidFd(fd)) {
-        errno = EBADF;
-        return FS_FAILURE;
-    }
-
     ret = FsLock();
     if (ret != 0) {
         errno = ret;
         return FS_FAILURE;
     }
 
+    if (!IsValidFd(fd)) {
+        errno = EBADF;
+        goto ERROUT;
+    }
+
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        errno = ENOENT;
+        goto ERROUT;
+    }
+
     if (whence == SEEK_SET) {
         pos = 0;
     } else if (whence == SEEK_CUR) {
@@ -834,10 +860,6 @@ int fatfs_fstat(int fd, struct stat *buf)
         errno = EFAULT;
         return FS_FAILURE;
     }
-    if (!IsValidFd(fd)) {
-        errno = EBADF;
-        return FS_FAILURE;
-    }
 
     ret = FsLock();
     if (ret != 0) {
@@ -845,6 +867,18 @@ int fatfs_fstat(int fd, struct stat *buf)
         return FS_FAILURE;
     }
 
+    if (!IsValidFd(fd)) {
+        FsUnlock();
+        errno = EBADF;
+        return FS_FAILURE;
+    }
+
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        FsUnlock();
+        errno = ENOENT;
+        return FS_FAILURE;
+    }
+
     buf->st_size = f_size(&g_handle[fd].fil);
     buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
                    S_IWUSR | S_IWGRP | S_IWOTH |
@@ -881,6 +915,7 @@ int fatfs_stat(const char *path, struct stat *buf)
         ret = FS_FAILURE;
         goto OUT;
     }
+
     res = f_stat(path, &fileInfo);
     if (res != FR_OK) {
         PRINTK("FAT stat err 0x%x!\r\n", res);
@@ -916,22 +951,30 @@ int fatfs_fsync(int fd)
     FRESULT res;
     INT32 ret;
 
-    if (!IsValidFd(fd)) {
-        errno = EBADF;
-        return FS_FAILURE;
-    }
-
     ret = FsLock();
     if (ret != 0) {
         errno = ret;
         return FS_FAILURE;
     }
 
+    if (!IsValidFd(fd)) {
+        errno = EBADF;
+        ret = FS_FAILURE;
+        goto OUT;
+    }
+
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        errno = ENOENT;
+        ret = FS_FAILURE;
+        goto OUT;
+    }
+
     if (!FsCheckByID(g_handle[fd].fil.obj.fs->id)) {
         errno = EACCES;
         ret = FS_FAILURE;
         goto OUT;
     }
+
     res = f_sync(&g_handle[fd].fil);
     if (res != FR_OK) {
         errno = FatfsErrno(res);
@@ -1259,8 +1302,8 @@ OUT:
 
 static int do_truncate(int fd, off_t length, UINT count)
 {
-    FRESULT res;
-    INT32 ret = FR_OK;
+    FRESULT res = FR_OK;
+    INT32 ret = FS_SUCCESS;
     DWORD csz;
 
     csz = (DWORD)(g_handle[fd].fil.obj.fs)->csize * SS(g_handle[fd].fil.obj.fs); /* Cluster size */
@@ -1295,11 +1338,6 @@ int fatfs_ftruncate(int fd, off_t length)
     UINT count;
     DWORD fclust;
 
-    if (!IsValidFd(fd)) {
-        errno = EBADF;
-        return FS_FAILURE;
-    }
-
     if ((length < 0) || (length > UINT_MAX)) {
         errno = EINVAL;
         return FS_FAILURE;
@@ -1311,6 +1349,18 @@ int fatfs_ftruncate(int fd, off_t length)
         return FS_FAILURE;
     }
 
+    if (!IsValidFd(fd)) {
+        errno = EBADF;
+        ret = FS_FAILURE;
+        goto OUT;
+    }
+
+    if (g_handle[fd].fil.obj.fs == NULL) {
+        errno = ENOENT;
+        ret = FS_FAILURE;
+        goto OUT;
+    }
+
     if (!FsCheckByID(g_handle[fd].fil.obj.fs->id)) {
         errno = EACCES;
         ret = FS_FAILURE;
@@ -1382,6 +1432,7 @@ int fatfs_format(const char *dev, int sectors, int option)
     INT32 index;
     FRESULT res;
     INT32 ret;
+    MKFS_PARM opt = {0};
 
     if (dev == NULL) {
         errno = EFAULT;
@@ -1408,7 +1459,9 @@ int fatfs_format(const char *dev, int sectors, int option)
         goto OUT;
     }
 
-    res = f_mkfs(dev, option, sectors, g_workBuffer, FF_MAX_SS);
+    opt.n_sect = sectors;
+    opt.fmt = (BYTE)option;
+    res = f_mkfs(dev, &opt, g_workBuffer, FF_MAX_SS);
     if (res != FR_OK) {
         errno = FatfsErrno(res);
         ret = FS_FAILURE;
@@ -1421,3 +1474,28 @@ OUT:
     FsUnlock();
     return ret;
 }
+
+struct MountOps g_fatfsMnt = {
+    .Mount = fatfs_mount,
+    .Umount = fatfs_umount,
+    .Umount2 = fatfs_umount2,
+    .Statfs = fatfs_statfs,
+};
+
+struct FileOps g_fatfsFops = {
+    .Mkdir = fatfs_mkdir,
+    .Unlink = fatfs_unlink,
+    .Rmdir = fatfs_rmdir,
+    .Opendir = fatfs_opendir,
+    .Readdir = fatfs_readdir,
+    .Closedir = fatfs_closedir,
+    .Open = fatfs_open,
+    .Close = fatfs_close,
+    .Write = fatfs_write,
+    .Read = fatfs_read,
+    .Seek = fatfs_lseek,
+    .Rename = fatfs_rename,
+    .Getattr = fatfs_stat,
+    .Fsync = fatfs_fsync,
+    .Fstat = fatfs_fstat,
+};

components/fs/fs.c

@@ -28,8 +28,11 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
+#include "fs_operations.h"
+#include "los_config.h"
+#if (LOSCFG_SUPPORT_FATFS == 1)
 #include "fatfs.h"
+#endif
 #include "dirent.h"
 #include "errno.h"
 #include "fcntl.h"
@@ -42,6 +45,9 @@
 #include "sys/stat.h"
 #include "unistd.h"
 
+struct FsMap g_fsmap[MAX_FILESYSTEM_LEN] = {0};
+struct FsMap *g_fs = NULL;
+
 #ifdef LOSCFG_NET_LWIP_SACK
 #include "lwip/lwipopts.h"
 #include "lwip/sockets.h"
@@ -92,12 +98,12 @@ static size_t GetCanonicalPath(const char *cwd, const char *path, char *buf, siz
     size_t tmpLen = strlen(cwd) + strlen(path) + offset;
     char *tmpBuf = (char *)malloc(tmpLen);
     if (tmpBuf == NULL) {
-        return 0;
+        return FS_SUCCESS;
     }
 
     if (-1 == sprintf_s(tmpBuf, tmpLen, "/%s/%s/", cwd, path)) {
         free(tmpBuf);
-        return 0;
+        return FS_SUCCESS;
     }
 
     char *p;
@@ -106,7 +112,7 @@ static size_t GetCanonicalPath(const char *cwd, const char *path, char *buf, siz
     while ((p = strstr(tmpBuf, "/./")) != NULL) {
         if (EOK != memmove_s(p, tmpLen - (p - tmpBuf), p + offset, tmpLen - (p - tmpBuf) - offset)) {
             free(tmpBuf);
-            return 0;
+            return FS_SUCCESS;
         }
     }
 
@@ -114,7 +120,7 @@ static size_t GetCanonicalPath(const char *cwd, const char *path, char *buf, siz
     while ((p = strstr(tmpBuf, "//")) != NULL) {
         if (EOK != memmove_s(p, tmpLen - (p - tmpBuf), p + 1, tmpLen - (p - tmpBuf) - 1)) {
             free(tmpBuf);
-            return 0;
+            return FS_SUCCESS;
         }
     }
 
@@ -127,7 +133,7 @@ static size_t GetCanonicalPath(const char *cwd, const char *path, char *buf, siz
         }
         if (EOK != memmove_s(start, tmpLen - (start - tmpBuf), p + offset, tmpLen - (p - tmpBuf) - offset)) {
             free(tmpBuf);
-            return 0;
+            return FS_SUCCESS;
         }
     }
 
@@ -144,7 +150,7 @@ static size_t GetCanonicalPath(const char *cwd, const char *path, char *buf, siz
 
     if (EOK != memcpy_s(buf, bufSize, tmpBuf, (((totalLen + 1) > bufSize) ? bufSize : (totalLen + 1)))) {
         free(tmpBuf);
-        return 0;
+        return FS_SUCCESS;
     }
 
     buf[bufSize - 1] = 0;
@@ -153,21 +159,87 @@ static size_t GetCanonicalPath(const char *cwd, const char *path, char *buf, siz
 }
 #endif
 
+static void InitMountInfo(void)
+{
+#if (LOSCFG_SUPPORT_FATFS == 1)
+    extern struct MountOps g_fatfsMnt;
+    extern struct FileOps g_fatfsFops;
+    g_fsmap[0].fileSystemtype = strdup("fat");
+    g_fsmap[0].fsMops = &g_fatfsMnt;
+    g_fsmap[0].fsFops = &g_fatfsFops;
+#endif
+#if (LOSCFG_SUPPORT_LITTLEFS == 1)
+    extern struct MountOps g_lfsMnt;
+    extern struct FileOps g_lfsFops;
+    g_fsmap[1].fileSystemtype = strdup("littlefs");
+    g_fsmap[1].fsMops = &g_lfsMnt;
+    g_fsmap[1].fsFops = &g_lfsFops;
+#endif
+}
+
+static struct FsMap *MountFindfs(const char *fileSystemtype)
+{
+    struct FsMap *m = NULL;
+
+    for (int i = 0; i < MAX_FILESYSTEM_LEN; i++) {
+        m = &(g_fsmap[i]);
+        if (m->fileSystemtype && strcmp(fileSystemtype, m->fileSystemtype) == 0) {
+            return m;
+        }
+    }
+
+    return NULL;
+}
+
 int mount(const char *source, const char *target,
           const char *filesystemtype, unsigned long mountflags,
           const void *data)
 {
-    return fatfs_mount(source, target, filesystemtype, mountflags, data);
+    static int initFlag = 0;
+
+    if (initFlag == 0) {
+        InitMountInfo();
+        initFlag = 1;
+    }
+
+    g_fs = MountFindfs(filesystemtype);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+
+    if (g_fs->fsMops == NULL || g_fs->fsMops->Mount == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+
+    return g_fs->fsMops->Mount(source, target, filesystemtype, mountflags, data);
 }
 
 int umount(const char *target)
 {
-    return fatfs_umount(target);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsMops == NULL || g_fs->fsMops->Umount == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsMops->Umount(target);
 }
 
 int umount2(const char *target, int flag)
 {
-    return fatfs_umount2(target, flag);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsMops == NULL || g_fs->fsMops->Umount2 == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsMops->Umount2(target, flag);
 }
 
 int open(const char *path, int oflag, ...)
@@ -176,30 +248,30 @@ int open(const char *path, int oflag, ...)
     unsigned flags = O_RDONLY | O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_LARGEFILE | O_TRUNC | O_EXCL | O_DIRECTORY;
     if ((unsigned)oflag & ~flags) {
         errno = EINVAL;
-        return -1;
+        return FS_FAILURE;
     }
 
     size_t pathLen = strlen(path) + 1;
     char *canonicalPath = (char *)malloc(pathLen);
     if (!canonicalPath) {
         errno = ENOMEM;
-        return -1;
+        return FS_FAILURE;
     }
     if (GetCanonicalPath(NULL, path, canonicalPath, pathLen) == 0) {
         FREE_AND_SET_NULL(canonicalPath);
         errno = ENOMEM;
-        return -1;
+        return FS_FAILURE;
     }
 
     if (strcmp(canonicalPath, RANDOM_DEV_PATH) == 0) {
         FREE_AND_SET_NULL(canonicalPath);
         if ((O_ACCMODE & (unsigned)oflag) != O_RDONLY) {
             errno = EPERM;
-            return -1;
+            return FS_FAILURE;
         }
         if ((unsigned)oflag & O_DIRECTORY) {
             errno = ENOTDIR;
-            return -1;
+            return FS_FAILURE;
         }
         return RANDOM_DEV_FD;
     }
@@ -207,21 +279,29 @@ int open(const char *path, int oflag, ...)
         FREE_AND_SET_NULL(canonicalPath);
         if ((unsigned)oflag & O_DIRECTORY) {
             errno = EPERM;
-            return -1;
+            return FS_FAILURE;
         }
         errno = EISDIR;
-        return -1;
+        return FS_FAILURE;
     }
     FREE_AND_SET_NULL(canonicalPath);
 #endif
-    return fatfs_open(path, oflag);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Open == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Open(path, oflag);
 }
 
 int close(int fd)
 {
 #ifdef LOSCFG_RANDOM_DEV
     if (fd == RANDOM_DEV_FD) {
-        return 0;
+        return FS_SUCCESS;
     }
 #endif
 #ifdef LOSCFG_NET_LWIP_SACK
@@ -229,7 +309,15 @@ int close(int fd)
         return closesocket(fd);
     }
 #endif
-    return fatfs_close(fd);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Close == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Close(fd);
 }
 
 ssize_t read(int fd, void *buf, size_t nbyte)
@@ -237,19 +325,19 @@ ssize_t read(int fd, void *buf, size_t nbyte)
 #ifdef LOSCFG_RANDOM_DEV
     if (fd == RANDOM_DEV_FD) {
         if (nbyte == 0) {
-            return 0;
+            return FS_SUCCESS;
         }
         if (buf == NULL) {
             errno = EINVAL;
-            return -1;
+            return FS_FAILURE;
         }
-        if (nbyte > 1024) {
+        if (nbyte > 1024) { /* 1024, max random_size */
             nbyte = 1024; /* hks_generate_random: random_size must <= 1024 */
         }
         struct hks_blob key = {HKS_BLOB_TYPE_RAW, (uint8_t *)buf, nbyte};
         if (hks_generate_random(&key) != 0) {
             errno = EIO;
-            return -1;
+            return FS_FAILURE;
         }
         return (ssize_t)nbyte;
     }
@@ -259,7 +347,15 @@ ssize_t read(int fd, void *buf, size_t nbyte)
         return recv(fd, buf, nbyte, 0);
     }
 #endif
-    return fatfs_read(fd, buf, nbyte);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Read == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Read(fd, buf, nbyte);
 }
 
 ssize_t write(int fd, const void *buf, size_t nbyte)
@@ -267,7 +363,7 @@ ssize_t write(int fd, const void *buf, size_t nbyte)
 #ifdef LOSCFG_RANDOM_DEV
     if (fd == RANDOM_DEV_FD) {
         errno = EBADF; /* "/dev/random" is readonly */
-        return -1;
+        return FS_FAILURE;
     }
 #endif
 #ifdef LOSCFG_NET_LWIP_SACK
@@ -275,70 +371,182 @@ ssize_t write(int fd, const void *buf, size_t nbyte)
         return send(fd, buf, nbyte, 0);
     }
 #endif
-    return fatfs_write(fd, buf, nbyte);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Write == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Write(fd, buf, nbyte);
 }
 
 off_t lseek(int fd, off_t offset, int whence)
 {
-    return fatfs_lseek(fd, offset, whence);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Seek == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Seek(fd, offset, whence);
 }
 
 int unlink(const char *path)
 {
-    return fatfs_unlink(path);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Unlink == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Unlink(path);
 }
 
 int fstat(int fd, struct stat *buf)
 {
-    return fatfs_fstat(fd, buf);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Fstat == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Fstat(fd, buf);
 }
 
 int stat(const char *path, struct stat *buf)
 {
-    return fatfs_stat(path, buf);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Getattr == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Getattr(path, buf);
 }
 
 int fsync(int fd)
 {
-    return fatfs_fsync(fd);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Fsync == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Fsync(fd);
 }
 
 int mkdir(const char *path, mode_t mode)
 {
-    return fatfs_mkdir(path, mode);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Mkdir == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Mkdir(path, mode);
 }
 
 DIR *opendir(const char *dirName)
 {
-    return fatfs_opendir(dirName);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return NULL;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Opendir == NULL) {
+        errno = ENOSYS;
+        return NULL;
+    }
+    return g_fs->fsFops->Opendir(dirName);
 }
 
 struct dirent *readdir(DIR *dir)
 {
-    return fatfs_readdir(dir);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return NULL;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Readdir == NULL) {
+        errno = ENOSYS;
+        return NULL;
+    }
+    return g_fs->fsFops->Readdir(dir);
 }
 
 int closedir(DIR *dir)
 {
-    return fatfs_closedir(dir);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Closedir == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Closedir(dir);
 }
 
 int rmdir(const char *path)
 {
-    return fatfs_rmdir(path);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Rmdir == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Rmdir(path);
 }
 
 int rename(const char *oldName, const char *newName)
 {
-    return fatfs_rename(oldName, newName);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Rename == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Rename(oldName, newName);
 }
 
 int statfs(const char *path, struct statfs *buf)
 {
-    return fatfs_statfs(path, buf);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsMops == NULL || g_fs->fsMops->Statfs == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsMops->Statfs(path, buf);
 }
 
 int ftruncate(int fd, off_t length)
 {
-    return fatfs_ftruncate(fd, length);
+    if (g_fs == NULL) {
+        errno = ENODEV;
+        return FS_FAILURE;
+    }
+    if (g_fs->fsFops == NULL || g_fs->fsFops->Ftruncate == NULL) {
+        errno = ENOSYS;
+        return FS_FAILURE;
+    }
+    return g_fs->fsFops->Ftruncate(fd, length);
 }

components/fs/fs_operations.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _FS_OPERATIONS_H_
+#define _FS_OPERATIONS_H_
+
+#include "fcntl.h"
+#include "dirent.h"
+#include "unistd.h"
+#include "sys/mount.h"
+#include "sys/stat.h"
+#include "sys/statfs.h"
+
+#define FS_SUCCESS            0
+#define FS_FAILURE            (-1)
+#define MAX_FILESYSTEM_LEN 2
+
+struct MountOps {
+    int (*Mount)(const char *source, const char *target, const char *filesystemtype, unsigned long mountflags,
+        const void *data);
+    int (*Umount)(const char* target);
+    int (*Umount2)(const char* target, int flag);
+    int (*Statfs)(const char *path, struct statfs *buf);
+};
+
+struct FsMap {
+    const char *fileSystemtype;
+    const struct MountOps *fsMops;
+    const struct FileOps *fsFops;
+};
+
+struct FileOps {
+    int (*Open)(const char *path, int openFlag, ...);
+    int (*Close)(int fd);
+    int (*Unlink)(const char *fileName);
+    int (*Rmdir)(const char *dirName);
+    int (*Mkdir)(const char *dirName, mode_t mode);
+    struct dirent *(*Readdir)(DIR *dir);
+    DIR *(*Opendir)(const char *dirName);
+    int (*Closedir)(DIR *dir);
+    int (*Read)(int fd, void *buf, size_t len);
+    int (*Write)(int fd, const void *buf, size_t len);
+    off_t (*Seek)(int fd, off_t offset, int whence);
+    int (*Getattr)(const char *path, struct stat *buf);
+    int (*Rename)(const char *oldName, const char *newName);
+    int (*Fsync)(int fd);
+    int (*Fstat)(int fd, struct stat *buf);
+    int (*Stat)(const char *path, struct stat *buf);
+    int (*Ftruncate)(int fd, off_t length);
+};
+
+#endif /* _FS_OPERATIONS_H_ */

components/fs/littlefs/BUILD.gn

@@ -0,0 +1,49 @@
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+static_library("littlefs") {
+  sources = [
+    "//third_party/littlefs/lfs.c",
+    "//third_party/littlefs/lfs_util.c",
+    "lfs_api.c",
+  ]
+
+  include_dirs = [
+    "../../../kernel/arch/include",
+    "../../../kernel/include",
+    "../../../utils",
+    "../../../kal/cmsis",
+    "../../../kal/posix/include",
+    "./",
+    "../",
+    "//third_party/littlefs",
+  ]
+
+  deps = [ "//kernel/liteos_m/kal/posix" ]
+}

components/fs/littlefs/lfs_api.c

@@ -0,0 +1,869 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define _GNU_SOURCE 1
+#include "lfs_api.h"
+#include "los_config.h"
+#include "los_mux.h"
+#include "los_debug.h"
+#include "securec.h"
+
+lfs_t g_lfs;
+FileDirInfo g_lfsDir[LFS_MAX_OPEN_DIRS] = {0};
+
+struct FileOpInfo g_fsOp[LOSCFG_LFS_MAX_MOUNT_SIZE] = {0};
+static LittleFsHandleStruct g_handle[LITTLE_FS_MAX_OPEN_FILES] = {0};
+struct dirent g_nameValue;
+static const char *g_littlefsMntName[LOSCFG_LFS_MAX_MOUNT_SIZE] = {"/a", "/b", "/c"};
+#define LFS_MUTEX_UNINIT (-1)
+static UINT32 g_lfsMutex = LFS_MUTEX_UNINIT;
+
+static int LfsLock(void)
+{
+    if (LOS_MuxPend(g_lfsMutex, LOS_WAIT_FOREVER) != LOS_OK) {
+        PRINT_ERR("LfsLock failed!");
+        return LOS_NOK;
+    }
+
+    return LOS_OK;
+}
+
+static void LfsUnlock(void)
+{
+    (void)LOS_MuxPost(g_lfsMutex);
+}
+
+LittleFsHandleStruct *LfsAllocFd(const char *fileName, int *fd)
+{
+    for (int i = 0; i < LITTLE_FS_MAX_OPEN_FILES; i++) {
+        if (g_handle[i].useFlag == 0) {
+            *fd = i;
+            g_handle[i].useFlag = 1;
+            g_handle[i].pathName = strdup(fileName);
+            return &(g_handle[i]);
+        }
+    }
+    *fd = INVALID_FD;
+    return NULL;
+}
+
+static void LfsFreeFd(int fd)
+{
+    g_handle[fd].useFlag = 0;
+    if (g_handle[fd].pathName != NULL) {
+        free((void *)g_handle[fd].pathName);
+        g_handle[fd].pathName = NULL;
+    }
+
+    if (g_handle[fd].lfsHandle != NULL) {
+        g_handle[fd].lfsHandle = NULL;
+    }
+}
+
+BOOL CheckFileIsOpen(const char *fileName)
+{
+    for (int i = 0; i < LITTLE_FS_MAX_OPEN_FILES; i++) {
+        if (g_handle[i].useFlag == 1) {
+            if (strcmp(g_handle[i].pathName, fileName) == 0) {
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+static BOOL LfsFdIsValid(int fd)
+{
+    if (fd >= LITTLE_FS_MAX_OPEN_FILES || fd < 0) {
+        return FALSE;
+    }
+    if (g_handle[fd].lfsHandle == NULL) {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+FileDirInfo *GetFreeDir(const char *dirName)
+{
+    for (int i = 0; i < LFS_MAX_OPEN_DIRS; i++) {
+        if (g_lfsDir[i].useFlag == 0) {
+            g_lfsDir[i].useFlag = 1;
+            g_lfsDir[i].dirName = strdup(dirName);
+            return &(g_lfsDir[i]);
+        }
+    }
+    return NULL;
+}
+
+void FreeDirInfo(const char *dirName)
+{
+    for (int i = 0; i < LFS_MAX_OPEN_DIRS; i++) {
+        if (g_lfsDir[i].useFlag == 1 && strcmp(g_lfsDir[i].dirName, dirName) == 0) {
+            g_lfsDir[i].useFlag = 0;
+            if (g_lfsDir[i].dirName) {
+                free(g_lfsDir[i].dirName);
+                g_lfsDir[i].dirName = NULL;
+            }
+        }
+    }
+}
+
+BOOL CheckDirIsOpen(const char *dirName)
+{
+    for (int i = 0; i < LFS_MAX_OPEN_DIRS; i++) {
+        if (g_lfsDir[i].useFlag == 1) {
+            if (strcmp(g_lfsDir[i].dirName, dirName) == 0) {
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+int GetFirstLevelPathLen(const char *pathName)
+{
+    int len = 1;
+    for (int i = 1; i < strlen(pathName) + 1; i++) {
+        if (pathName[i] == '/') {
+            break;
+        }
+        len++;
+    }
+
+    return len;
+}
+
+BOOL CheckPathIsMounted(const char *pathName, struct FileOpInfo **fileOpInfo)
+{
+    char tmpName[LITTLEFS_MAX_LFN_LEN] = {0};
+    int len = GetFirstLevelPathLen(pathName);
+
+    for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
+        if (g_fsOp[i].useFlag == 1) {
+            (void)strncpy_s(tmpName, LITTLEFS_MAX_LFN_LEN, pathName, len);
+            if (strcmp(tmpName, g_fsOp[i].dirName) == 0) {
+                *fileOpInfo = &(g_fsOp[i]);
+                return TRUE;
+            }
+        }
+    }
+    return FALSE;
+}
+
+struct FileOpInfo *AllocMountRes(const char* target, const struct FileOps *fileOps)
+{
+    for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
+        if (g_fsOp[i].useFlag == 0 && strcmp(target, g_littlefsMntName[i]) == 0) {
+            g_fsOp[i].useFlag = 1;
+            g_fsOp[i].fsVops = fileOps;
+            g_fsOp[i].dirName = strdup(target);
+            return &(g_fsOp[i]);
+        }
+    }
+
+    return NULL;
+}
+
+int SetDefaultMountPath(int pathNameIndex, const char* target)
+{
+    if (pathNameIndex >= LOSCFG_LFS_MAX_MOUNT_SIZE) {
+        return VFS_ERROR;
+    }
+
+    g_littlefsMntName[pathNameIndex] = strdup(target);
+    return VFS_OK;
+}
+
+struct FileOpInfo *GetMountRes(const char *target, int *mountIndex)
+{
+    for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
+        if (g_fsOp[i].useFlag == 1) {
+            if (g_fsOp[i].dirName && strcmp(target, g_fsOp[i].dirName) == 0) {
+                *mountIndex = i;
+                return &(g_fsOp[i]);
+            }
+        }
+    }
+
+    return NULL;
+}
+
+int FreeMountResByIndex(int mountIndex)
+{
+    if (mountIndex < 0 || mountIndex >= LOSCFG_LFS_MAX_MOUNT_SIZE) {
+        return VFS_ERROR;
+    }
+
+    if (g_fsOp[mountIndex].useFlag == 1 && g_fsOp[mountIndex].dirName != NULL) {
+        g_fsOp[mountIndex].useFlag = 0;
+        free(g_fsOp[mountIndex].dirName);
+        g_fsOp[mountIndex].dirName = NULL;
+    }
+
+    return VFS_OK;
+}
+
+int FreeMountRes(const char *target)
+{
+    for (int i = 0; i < LOSCFG_LFS_MAX_MOUNT_SIZE; i++) {
+        if (g_fsOp[i].useFlag == 1) {
+            if (g_fsOp[i].dirName && strcmp(target, g_fsOp[i].dirName) == 0) {
+                g_fsOp[i].useFlag = 0;
+                free(g_fsOp[i].dirName);
+                g_fsOp[i].dirName = NULL;
+                return VFS_OK;
+            }
+        }
+    }
+
+    return VFS_ERROR;
+}
+
+static int ConvertFlagToLfsOpenFlag (int oflags)
+{
+    int lfsOpenFlag = 0;
+
+    if (oflags & O_CREAT) {
+        lfsOpenFlag |= LFS_O_CREAT;
+    }
+
+    if (oflags & O_EXCL) {
+        lfsOpenFlag |= LFS_O_EXCL;
+    }
+
+    if (oflags & O_TRUNC) {
+        lfsOpenFlag |= LFS_O_TRUNC;
+    }
+
+    if (oflags & O_APPEND) {
+        lfsOpenFlag |= LFS_O_APPEND;
+    }
+
+    if (oflags & O_RDWR) {
+        lfsOpenFlag |= LFS_O_RDWR;
+    }
+
+    if (oflags & O_WRONLY) {
+        lfsOpenFlag |= LFS_O_WRONLY;
+    }
+
+    if (oflags & O_RDONLY) {
+        lfsOpenFlag |= LFS_O_RDONLY;
+    }
+
+    return lfsOpenFlag;
+}
+
+static int LittlefsErrno(int result)
+{
+    return (result < 0) ? -result : result;
+}
+
+const struct MountOps g_lfsMnt = {
+    .Mount = LfsMount,
+    .Umount = LfsUmount,
+};
+
+const struct FileOps g_lfsFops = {
+    .Mkdir = LfsMkdir,
+    .Unlink = LfsUnlink,
+    .Rmdir = LfsRmdir,
+    .Opendir = LfsOpendir,
+    .Readdir = LfsReaddir,
+    .Closedir = LfsClosedir,
+    .Open = LfsOpen,
+    .Close = LfsClose,
+    .Write = LfsWrite,
+    .Read = LfsRead,
+    .Seek = LfsSeek,
+    .Rename = LfsRename,
+    .Getattr = LfsStat,
+    .Fsync = LfsFsync,
+};
+
+int LfsMount(const char *source, const char *target, const char *fileSystemType, unsigned long mountflags,
+    const void *data)
+{
+    int ret;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (g_lfsMutex == LFS_MUTEX_UNINIT) {
+        if (LOS_MuxCreate(&g_lfsMutex) != LOS_OK) {
+            errno = EBUSY;
+            return VFS_ERROR;
+        }
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (target == NULL || fileSystemType == NULL || data == NULL) {
+        errno = EFAULT;
+        ret = VFS_ERROR;
+        goto errout;
+    }
+
+    if (strcmp(fileSystemType, "littlefs") != 0) {
+        errno = ENODEV;
+        ret = VFS_ERROR;
+        goto errout;
+    }
+
+    if (CheckPathIsMounted(target, &fileOpInfo)) {
+        errno = EBUSY;
+        ret = VFS_ERROR;
+        goto errout;
+    }
+
+    // select free mount resource
+    fileOpInfo = AllocMountRes(target, &g_lfsFops);
+    if (fileOpInfo == NULL) {
+        errno = ENODEV;
+        ret = VFS_ERROR;
+        goto errout;
+    }
+
+    ret = lfs_mount(&(fileOpInfo->lfsInfo), (struct lfs_config*)data);
+    if (ret != 0) {
+        ret = lfs_format(&(fileOpInfo->lfsInfo), (struct lfs_config*)data);
+        if (ret == 0) {
+            ret = lfs_mount(&(fileOpInfo->lfsInfo), (struct lfs_config*)data);
+        }
+    }
+
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+errout:
+    LfsUnlock();
+    return ret;
+}
+
+int LfsUmount(const char *target)
+{
+    int ret;
+    int mountIndex = -1;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (target == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    fileOpInfo = GetMountRes(target, &mountIndex);
+    if (fileOpInfo == NULL) {
+        errno = ENOENT;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_unmount(&(fileOpInfo->lfsInfo));
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    (void)FreeMountResByIndex(mountIndex);
+    LfsUnlock();
+    return ret;
+}
+
+int LfsUnlink(const char *fileName)
+{
+    int ret;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (fileName == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (CheckPathIsMounted(fileName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_remove(&(fileOpInfo->lfsInfo), fileName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    LfsUnlock();
+    return ret;
+}
+
+int LfsMkdir(const char *dirName, mode_t mode)
+{
+    int ret;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (dirName == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_mkdir(&(fileOpInfo->lfsInfo), dirName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    LfsUnlock();
+    return ret;
+}
+
+int LfsRmdir(const char *dirName)
+{
+    int ret;
+
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (dirName == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_remove(&(fileOpInfo->lfsInfo), dirName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    LfsUnlock();
+    return ret;
+}
+
+DIR *LfsOpendir(const char *dirName)
+{
+    int ret;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (dirName == NULL) {
+        errno = EFAULT;
+        return NULL;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return NULL;
+    }
+
+    if (CheckPathIsMounted(dirName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        goto errout;
+    }
+
+    if (CheckDirIsOpen(dirName)) {
+        errno = EBUSY;
+        goto errout;
+    }
+
+    FileDirInfo *dirInfo = GetFreeDir(dirName);
+    if (dirInfo == NULL) {
+        errno = ENFILE;
+        goto errout;
+    }
+
+    ret = lfs_dir_open(&(fileOpInfo->lfsInfo), (lfs_dir_t *)(&(dirInfo->dir)), dirName);
+
+    if (ret != 0) {
+        FreeDirInfo(dirName);
+        errno = LittlefsErrno(ret);
+        goto errout;
+    }
+
+    dirInfo->lfsHandle = &(fileOpInfo->lfsInfo);
+
+    LfsUnlock();
+    return (DIR *)dirInfo;
+
+errout:
+    LfsUnlock();
+    return NULL;
+}
+
+struct dirent *LfsReaddir(DIR *dir)
+{
+    int ret;
+    struct lfs_info lfsInfo;
+
+    FileDirInfo *dirInfo = (FileDirInfo *)dir;
+
+    if (dirInfo == NULL || dirInfo->lfsHandle == NULL) {
+        errno = EBADF;
+        return NULL;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return NULL;
+    }
+
+    ret = lfs_dir_read(dirInfo->lfsHandle, (lfs_dir_t *)(&(dirInfo->dir)), &lfsInfo);
+    if (ret == TRUE) {
+        (void)strncpy_s(g_nameValue.d_name, sizeof(g_nameValue.d_name), lfsInfo.name, strlen(lfsInfo.name) + 1);
+        if (lfsInfo.type == LFS_TYPE_DIR) {
+            g_nameValue.d_type = DT_DIR;
+        } else if (lfsInfo.type == LFS_TYPE_REG) {
+            g_nameValue.d_type = DT_REG;
+        }
+
+        g_nameValue.d_reclen = lfsInfo.size;
+        LfsUnlock();
+        return &g_nameValue;
+    }
+
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+    }
+
+    LfsUnlock();
+    return NULL;
+}
+
+int LfsClosedir(DIR *dir)
+{
+    int ret;
+    FileDirInfo *dirInfo = (FileDirInfo *)dir;
+
+    if (dirInfo == NULL || dirInfo->lfsHandle == NULL) {
+        errno = EBADF;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    ret = lfs_dir_close(dirInfo->lfsHandle, (lfs_dir_t *)(&(dirInfo->dir)));
+
+    FreeDirInfo(dirInfo->dirName);
+
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    LfsUnlock();
+    return ret;
+}
+
+int LfsOpen(const char *pathName, int openFlag, int mode)
+{
+    int fd = INVALID_FD;
+    int err = INVALID_FD;
+
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (pathName == NULL) {
+        errno = EFAULT;
+        return INVALID_FD;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (CheckPathIsMounted(pathName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        goto errout;
+    }
+    // if file is already open, return invalid fd
+    if (CheckFileIsOpen(pathName)) {
+        errno = EBUSY;
+        goto errout;
+    }
+
+    LittleFsHandleStruct *fsHandle = LfsAllocFd(pathName, &fd);
+    if (fd == INVALID_FD) {
+        errno = ENFILE;
+        goto errout;
+    }
+
+    int lfsOpenFlag = ConvertFlagToLfsOpenFlag(openFlag);
+    err = lfs_file_open(&(fileOpInfo->lfsInfo), &(fsHandle->file), pathName, lfsOpenFlag);
+    if (err != 0) {
+        LfsFreeFd(fd);
+        errno = LittlefsErrno(err);
+        goto errout;
+    }
+
+    g_handle[fd].lfsHandle = &(fileOpInfo->lfsInfo);
+    LfsUnlock();
+    return fd;
+
+errout:
+    LfsUnlock();
+    return INVALID_FD;
+}
+
+int LfsRead(int fd, void *buf, unsigned int len)
+{
+    int ret;
+
+    if (buf == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (LfsFdIsValid(fd) == FALSE) {
+        errno = EBADF;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_file_read(g_handle[fd].lfsHandle, &(g_handle[fd].file), buf, len);
+    if (ret < 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+    LfsUnlock();
+    return ret;
+}
+
+int LfsWrite(int fd, const void *buf, unsigned int len)
+{
+    int ret;
+
+    if (buf == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (LfsFdIsValid(fd) == FALSE) {
+        errno = EBADF;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_file_write(g_handle[fd].lfsHandle, &(g_handle[fd].file), buf, len);
+    if (ret < 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+    LfsUnlock();
+    return ret;
+}
+
+off_t LfsSeek(int fd, off_t offset, int whence)
+{
+    off_t ret;
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (LfsFdIsValid(fd) == FALSE) {
+        errno = EBADF;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = (off_t)lfs_file_seek(g_handle[fd].lfsHandle, &(g_handle[fd].file), offset, whence);
+    if (ret < 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    LfsUnlock();
+    return ret;
+}
+
+int LfsClose(int fd)
+{
+    int ret;
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (LfsFdIsValid(fd) == FALSE) {
+        errno = EBADF;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_file_close(g_handle[fd].lfsHandle, &(g_handle[fd].file));
+
+    LfsFreeFd(fd);
+
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+    LfsUnlock();
+    return ret;
+}
+
+int LfsRename(const char *oldName, const char *newName)
+{
+    int ret;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (oldName == NULL || newName == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (CheckPathIsMounted(oldName, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_rename(&(fileOpInfo->lfsInfo), oldName, newName);
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+
+    LfsUnlock();
+    return ret;
+}
+
+int LfsStat(const char *path, struct stat *buf)
+{
+    int ret;
+    struct lfs_info info;
+    struct FileOpInfo *fileOpInfo = NULL;
+
+    if (path == NULL || buf == NULL) {
+        errno = EFAULT;
+        return VFS_ERROR;
+    }
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (CheckPathIsMounted(path, &fileOpInfo) == FALSE || fileOpInfo == NULL) {
+        errno = ENOENT;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_stat(&(fileOpInfo->lfsInfo), path, &info);
+    if (ret == 0) {
+        buf->st_size = info.size;
+        if (info.type == LFS_TYPE_REG) {
+            buf->st_mode = S_IFREG;
+        } else {
+            buf->st_mode = S_IFDIR;
+        }
+    } else {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+    LfsUnlock();
+    return ret;
+}
+
+int LfsFsync(int fd)
+{
+    int ret;
+
+    if (LfsLock() != LOS_OK) {
+        errno = EAGAIN;
+        return VFS_ERROR;
+    }
+
+    if (LfsFdIsValid(fd) == FALSE) {
+        errno = EBADF;
+        LfsUnlock();
+        return VFS_ERROR;
+    }
+
+    ret = lfs_file_sync(g_handle[fd].lfsHandle, &(g_handle[fd].file));
+    if (ret != 0) {
+        errno = LittlefsErrno(ret);
+        ret = VFS_ERROR;
+    }
+    LfsUnlock();
+    return ret;
+}

components/fs/littlefs/lfs_api.h

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LFS_API_H_
+#define _LFS_API_H_
+
+#include "bits/alltypes.h"
+#include "fcntl.h"
+#include "sys/stat.h"
+
+#include "dirent.h"
+#include "errno.h"
+#include "fs_operations.h"
+#include "lfs.h"
+#include "lfs_util.h"
+#include "memory.h"
+
+#define INVALID_FD (-1)
+
+typedef unsigned mode_t;
+
+#ifndef VFS_ERROR
+#define VFS_ERROR (-1)
+#endif
+
+#ifndef VFS_OK
+#define VFS_OK  0
+#endif
+
+typedef struct {
+    uint8_t useFlag;
+    const char *pathName;
+    lfs_t *lfsHandle;
+    lfs_file_t file;
+} LittleFsHandleStruct;
+
+struct FileOpInfo {
+    uint8_t useFlag;
+    const struct FileOps *fsVops;
+    char *dirName;
+    lfs_t lfsInfo;
+};
+
+typedef struct {
+    uint8_t useFlag;
+    char *dirName;
+    lfs_t *lfsHandle;
+    lfs_dir_t dir;
+} FileDirInfo;
+
+#define LITTLE_FS_MAX_OPEN_FILES 100
+#define LITTLE_FS_STANDARD_NAME_LENGTH 50
+#define LITTLE_FS_MAX_NAME_LEN 255
+
+#define MAX_DEF_BUF_NUM 21
+#define MAX_BUFFER_LEN 100
+#define MAX_WRITE_FILE_LEN 500
+#define MAX_READ_FILE_LEN 500
+#define LITTLEFS_MAX_LFN_LEN 255
+
+#ifndef LFS_MAX_OPEN_DIRS
+#define LFS_MAX_OPEN_DIRS 10
+#endif
+
+LittleFsHandleStruct *GetFreeFd(int *fd);
+
+int InitMountInfo(const char *fileSystemType, const struct MountOps *fsMops);
+int LfsMount(const char *source, const char *target, const char *fileSystemType, unsigned long mountflags,
+    const void *data);
+
+int LfsUmount(const char *target);
+int LfsUnlink(const char *fileName);
+int LfsMkdir(const char *dirName, mode_t mode);
+int LfsRmdir(const char *dirName);
+DIR *LfsOpendir(const char *dirName);
+struct dirent *LfsReaddir(DIR *dir);
+int LfsClosedir(DIR *dir);
+int LfsOpen(const char *pathName, int openFlag, int mode);
+int LfsRead(int fd, void *buf, unsigned int len);
+int LfsWrite(int fd, const void *buf, unsigned int len);
+off_t LfsSeek(int fd, off_t offset, int whence);
+int LfsClose(int fd);
+int LfsRename(const char *oldName, const char *newName);
+int LfsStat(const char *path, struct stat *buf);
+int LfsFsync(int fd);
+int SetDefaultMountPath(int pathNameIndex, const char* target);
+
+const struct FsMap *MountFindfs(const char *filesystemtype);
+
+#endif /* _LFS_API_H_ */
+

components/net/lwip-2.1/BUILD.gn

@@ -0,0 +1,52 @@
+# Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//third_party/lwip/lwip.gni")
+import("lwip_porting.gni")
+
+config("lwip_depends") {
+  defines = [ "_BSD_SOURCE = 1" ]
+}
+
+static_library("lwip") {
+  include_dirs = [
+    "//kernel/liteos_m/kal/posix/include",
+    "//kernel/liteos_m/kernel/arch/include",
+  ]
+
+  include_dirs += LWIP_PORTING_INCLUDE_DIRS
+  include_dirs += LWIP_INCLUDE_DIRS
+
+  sources = LWIP_PORTING_FILES + LWIPNOAPPSFILES
+
+  sources -= [ "$LWIPDIR/api/sockets.c" ]
+
+  configs += [ ":lwip_depends" ]
+
+  deps = [ "//kernel/liteos_m/kal/posix" ]
+}

components/net/lwip-2.1/enhancement/src/fixme.c

@@ -39,6 +39,27 @@
 #define NETIFAPI_VAR_ALLOC(name)    API_VAR_ALLOC(struct netifapi_msg, MEMP_NETIFAPI_MSG, name, ERR_MEM)
 #define NETIFAPI_VAR_FREE(name)     API_VAR_FREE(MEMP_NETIFAPI_MSG, name)
 
+#if LWIP_DHCP
+#include <lwip/dhcp.h>
+#include <lwip/prot/dhcp.h>
+
+err_t dhcp_is_bound(struct netif *netif)
+{
+    struct dhcp *dhcp = NULL;
+
+    LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG);
+
+    dhcp = netif_dhcp_data(netif);
+    LWIP_ERROR("netif->dhcp != NULL", (dhcp != NULL), return ERR_ARG);
+
+    if (dhcp->state == DHCP_STATE_BOUND) {
+        return ERR_OK;
+    } else {
+        return ERR_INPROGRESS;
+    }
+}
+#endif /* LWIP_DHCP */
+
 static struct netif *netif_find_by_name(const char *name)
 {
     struct netif *netif = NULL;

components/net/lwip-2.1/enhancement/src/lwip_ifaddrs.c

@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "lwip/opt.h"
+
+#if LWIP_IFADDRS
+#if (LWIP_IPV4 || LWIP_IPV6) && LWIP_SOCKET
+#include "ifaddrs.h"
+
+#include <stdlib.h>
+
+#include "lwip/sys.h"
+#include "lwip/tcpip.h"
+#include "lwip/priv/sockets_priv.h"
+#include "lwip/mem.h"
+#include "lwip/netif.h"
+#include "lwip/dhcp.h"
+
+struct ifaddrs_storage {
+    struct ifaddrs ifa;
+    union {
+        struct sockaddr sa;
+        struct sockaddr_in s4;
+#if LWIP_IPV6
+        struct sockaddr_in6 s6;
+#endif
+    } addr, netmask, dstaddr;
+    char name[IFNAMSIZ];
+};
+
+struct getifaddrs_arg {
+    struct ifaddrs **ifap;
+    sys_sem_t cb_completed;
+    int ret;
+};
+
+static int tcpip_init_finish = 1;
+void lwip_freeifaddrs(struct ifaddrs *ifa);
+static void ifaddrs_add_tail(struct ifaddrs **ifap, struct ifaddrs *ifaddr)
+{
+    struct ifaddrs *temp = NULL;
+
+    ifaddr->ifa_next = NULL;
+    if (*ifap == NULL) {
+        *ifap = ifaddr;
+        return;
+    }
+
+    for (temp = *ifap; temp->ifa_next != NULL; temp = temp->ifa_next) {
+        /* nothing */
+    }
+
+    temp->ifa_next = ifaddr;
+}
+
+static struct ifaddrs_storage *new_ifaddrs_storage(void)
+{
+    struct ifaddrs *ifaddr = NULL;
+    struct ifaddrs_storage *if_storage = NULL;
+
+    if_storage = (struct ifaddrs_storage *)mem_malloc(sizeof(struct ifaddrs_storage));
+    if (if_storage != NULL) {
+        (void)memset_s((void*)if_storage, sizeof(struct ifaddrs_storage), 0, sizeof(struct ifaddrs_storage));
+        ifaddr = &if_storage->ifa;
+        ifaddr->ifa_name = if_storage->name;
+        ifaddr->ifa_addr = &if_storage->addr.sa;
+        ifaddr->ifa_netmask = &if_storage->netmask.sa;
+        ifaddr->ifa_dstaddr = &if_storage->dstaddr.sa;
+    }
+
+    return if_storage;
+}
+
+static int get_ifa_name(struct netif *netif, struct ifaddrs *ifaddr)
+{
+    int ret;
+
+    if (netif->link_layer_type == LOOPBACK_IF) {
+        ifaddr->ifa_flags |= IFF_LOOPBACK;
+        ret = snprintf_s(ifaddr->ifa_name, NETIF_NAMESIZE, (NETIF_NAMESIZE - 1), "%.2s", netif->name);
+    } else {
+        ret = snprintf_s(ifaddr->ifa_name, NETIF_NAMESIZE, (NETIF_NAMESIZE - 1), "%s", netif_get_name(netif));
+    }
+
+    return ret;
+}
+
+#if LWIP_IPV4
+static int get_ipv4_ifaddr(struct netif *netif, struct ifaddrs *ifaddr)
+{
+    struct sockaddr_in *addr_in = NULL;
+
+    if (netif->flags & NETIF_FLAG_UP) {
+        ifaddr->ifa_flags |= IFF_UP;
+    }
+
+    if (netif->flags & NETIF_FLAG_ETHARP) {
+        ifaddr->ifa_flags = ifaddr->ifa_flags & ((unsigned int)(~IFF_NOARP));
+    } else {
+        ifaddr->ifa_flags |= IFF_NOARP;
+    }
+
+    if (netif->flags & NETIF_FLAG_BROADCAST) {
+        ifaddr->ifa_flags |= IFF_BROADCAST;
+    }
+
+#if LWIP_DHCP
+    if (dhcp_supplied_address(netif)) {
+        ifaddr->ifa_flags |= IFF_DYNAMIC;
+    }
+#endif
+
+#if LWIP_IGMP
+    if (netif->flags & NETIF_FLAG_IGMP) {
+        ifaddr->ifa_flags |= IFF_MULTICAST;
+    }
+#endif
+
+    if (netif->flags & NETIF_FLAG_LINK_UP) {
+        ifaddr->ifa_flags |= IFF_RUNNING;
+    }
+
+#if LWIP_HAVE_LOOPIF
+    if (netif->link_layer_type == LOOPBACK_IF) {
+        addr_in = (struct sockaddr_in *)ifaddr->ifa_addr;
+        addr_in->sin_family = AF_INET;
+        addr_in->sin_addr.s_addr = ((ip4_addr_t *)&netif->ip_addr)->addr;
+    } else
+#endif
+    {
+        addr_in = (struct sockaddr_in *)ifaddr->ifa_addr;
+        addr_in->sin_family = AF_INET;
+        addr_in->sin_addr.s_addr = ((ip4_addr_t *)&netif->ip_addr)->addr;
+
+        addr_in = (struct sockaddr_in *)ifaddr->ifa_netmask;
+        addr_in->sin_family = AF_INET;
+        addr_in->sin_addr.s_addr = ((ip4_addr_t *)&netif->netmask)->addr;
+
+        addr_in = (struct sockaddr_in *)ifaddr->ifa_broadaddr;
+        addr_in->sin_family = AF_INET;
+        addr_in->sin_addr.s_addr = (((ip4_addr_t *)&netif->ip_addr)->addr & ((ip4_addr_t *)&netif->netmask)->addr) |
+                                  ~((ip4_addr_t *)&netif->netmask)->addr;
+    }
+
+    return get_ifa_name(netif, ifaddr);
+}
+#endif /* LWIP_IPV4 */
+
+#if LWIP_IPV6
+/* Stack support to retrieve the below flags for ipv6
+IFF_UP
+IFF_MULTICAST
+IFF_RUNNING
+IFF_LOOPBACK
+*/
+static int get_ipv6_ifaddr(struct netif *netif, struct ifaddrs *ifaddr, int tmp_index)
+{
+    struct sockaddr_in6 *addr_in6 = NULL;
+
+    /* As of now supports the below falgs only */
+    if (netif->flags & NETIF_FLAG_UP) {
+        ifaddr->ifa_flags |= IFF_UP;
+    }
+
+#if LWIP_IPV6_MLD
+    if (netif->flags & NETIF_FLAG_MLD6) {
+        ifaddr->ifa_flags |= IFF_MULTICAST;
+    }
+#endif
+
+    if (netif->flags & NETIF_FLAG_LINK_UP) {
+        ifaddr->ifa_flags |= IFF_RUNNING;
+    }
+
+    addr_in6 = (struct sockaddr_in6 *)ifaddr->ifa_addr;
+    addr_in6->sin6_family = AF_INET6;
+    inet6_addr_from_ip6addr(&addr_in6->sin6_addr, (ip6_addr_t *)&netif->ip6_addr[tmp_index]);
+
+    return get_ifa_name(netif, ifaddr);
+}
+#endif
+
+static void getifaddrs_internal(struct getifaddrs_arg *arg)
+{
+    struct netif *netif = NULL;
+    struct ifaddrs *ifaddr = NULL;
+    struct ifaddrs_storage *if_storage = NULL;
+
+#if LWIP_IPV6
+    int n;
+#endif
+
+    arg->ret = ENOMEM;
+    for (netif = netif_list; netif != NULL; netif = netif->next) {
+#if LWIP_IPV4
+        if_storage = new_ifaddrs_storage();
+        if (if_storage == NULL) {
+            lwip_freeifaddrs(
+                *(arg->ifap)); /* ifap is assigned to NULL in getifaddrs, so garbage value will not be there */
+            arg->ret = ENOMEM;
+            goto RETURN;
+        }
+
+        /* if get one or more netif info, then getifaddrs return 0(OK) */
+        arg->ret = 0;
+        ifaddr = &if_storage->ifa;
+        (void)get_ipv4_ifaddr(netif, ifaddr);
+        ifaddrs_add_tail(arg->ifap, ifaddr);
+#endif /* LWIP_IPV4 */
+#if LWIP_IPV6
+        for (n = 0; n < LWIP_IPV6_NUM_ADDRESSES; n++) {
+            if ((netif->ip6_addr_state[n] & IP6_ADDR_VALID) == 0) {
+                continue;
+            }
+            if_storage = new_ifaddrs_storage();
+            if (if_storage == NULL) {
+                lwip_freeifaddrs(
+                    *(arg->ifap)); /* ifap is assigned to NULL in getifaddrs, so garbage value will not be there */
+                arg->ret = ENOMEM;
+                goto RETURN;
+            }
+
+            /* if get one or more netif info, then getifaddrs return 0(OK) */
+            arg->ret = 0;
+            ifaddr = &if_storage->ifa;
+            (void)get_ipv6_ifaddr(netif, ifaddr, n);
+            ifaddrs_add_tail(arg->ifap, ifaddr);
+        }
+#endif
+    }
+
+RETURN:
+#if !LWIP_TCPIP_CORE_LOCKING
+    sys_sem_signal(&arg->cb_completed);
+#endif
+    return;
+}
+
+int lwip_getifaddrs(struct ifaddrs **ifap)
+{
+    struct getifaddrs_arg arg;
+
+    LWIP_ERROR("lwip_getifaddrs : ifap is NULL", (ifap != NULL), return ERR_ARG);
+    *ifap = NULL;
+
+    if (!tcpip_init_finish) {
+        set_errno(EACCES);
+        return -1;
+    }
+    arg.ret = 0;
+    arg.ifap = ifap;
+
+#if LWIP_TCPIP_CORE_LOCKING
+    LOCK_TCPIP_CORE();
+    getifaddrs_internal(&arg);
+    UNLOCK_TCPIP_CORE();
+#else
+
+    if (sys_sem_new(&arg.cb_completed, 0) != ERR_OK) {
+        set_errno(ENOMEM);
+        return -1;
+    }
+
+    tcpip_callback((tcpip_callback_fn)getifaddrs_internal, &arg);
+    (void)sys_arch_sem_wait(&arg.cb_completed, 0);
+    sys_sem_free(&arg.cb_completed);
+#endif
+
+    if (arg.ret != 0) {
+        set_errno(arg.ret);
+        *ifap = NULL;
+        return -1;
+    }
+
+    return 0;
+}
+
+static void freeifaddrs_iteration(struct ifaddrs *ifa)
+{
+    if (ifa == NULL) {
+        return;
+    }
+
+    if (ifa->ifa_next != NULL) {
+        freeifaddrs_iteration(ifa->ifa_next);
+    }
+
+    mem_free(ifa);
+}
+
+void lwip_freeifaddrs(struct ifaddrs *ifa)
+{
+    freeifaddrs_iteration(ifa);
+}
+
+int getifaddrs(struct ifaddrs **ifap)
+{
+    return lwip_getifaddrs(ifap);
+}
+
+void freeifaddrs(struct ifaddrs *ifa)
+{
+    lwip_freeifaddrs(ifa);
+}
+
+#endif /* (LWIP_IPV4 || LWIP_IPV6) && LWIP_SOCKET */
+#endif /* LWIP_IFADDRS */

components/net/lwip-2.1/lwip_porting.gni

@@ -0,0 +1,45 @@
+# Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import("//kernel/liteos_m/config.gni")
+LWIP_PORTING_DIR = "//kernel/liteos_m/components/net/lwip-2.1"
+
+LWIP_PORTING_INCLUDE_DIRS = [ "$LWIP_PORTING_DIR/porting/include" ]
+
+LWIP_PORTING_FILES = [
+  "$LWIP_PORTING_DIR/porting/src/driverif.c",
+  "$LWIP_PORTING_DIR/porting/src/lwip_init.c",
+  "$LWIP_PORTING_DIR/porting/src/netdb_porting.c",
+  "$LWIP_PORTING_DIR/porting/src/sockets_porting.c",
+  "$LWIP_PORTING_DIR/porting/src/sys_arch.c",
+  "$LWIP_PORTING_DIR/enhancement/src/fixme.c",
+  "$LWIP_PORTING_DIR/enhancement/src/lwip_ifaddrs.c",
+]
+
+if (enable_ohos_kernel_liteos_m_shell) {
+  LWIP_PORTING_FILES += [ "$LWIP_PORTING_DIR/porting/src/api_shell.c" ]
+}

components/net/lwip-2.1/porting/include/arch/cc.h

@@ -44,7 +44,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "securec.h"
-#include "memory_pool.h"
 
 #ifdef htons
 #define LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS
@@ -94,33 +93,17 @@
 
 #define LWIP_RAND rand
 
-extern void HilogPrintf(const char *fmt, ...);
-
-#ifndef HILOG_INFO
-#define HILOG_INFO(...)
-#ifndef HILOG_MODULE_APP
-#define HILOG_MODULE_APP 0
-#endif
+#ifndef LWIP_LOGGER
+#define LWIP_LOGGER(msg)
 #endif
 
-#ifndef HILOG_ERROR
-#define HILOG_ERROR(...)
-#endif
-
-#define LWIP_PLATFORM_DIAG(vars) HilogPrintf vars
-#define LWIP_PLATFORM_ASSERT(x) do {HILOG_ERROR(HILOG_MODULE_APP, \
-                                    "Assertion \"%s\" errno %d line %d in %s\n", \
-                                    x, errno, __LINE__, __FILE__);} while (0)
-
-#define mem_clib_malloc LWIP_MEM_ALLOC
-#define mem_clib_free LWIP_MEM_FREE
-#define mem_clib_calloc LWIP_MEM_CALLOC
+extern void LwipLogPrintf(const char *fmt, ...);
+#define LWIP_PLATFORM_DIAG(vars) LwipLogPrintf vars
+#define LWIP_PLATFORM_ASSERT(x) do { \
+        LWIP_PLATFORM_DIAG(("Assertion \"%s\" failed at line %d in %s\n", x, __LINE__, __FILE__)); \
+    } while (0)
 
 #define init_waitqueue_head(...)
 #define poll_check_waiters(...)
-#define IOCTL_CMD_CASE_HANDLER()
-
-#define DNS_SERVER_ADDRESS(ipaddr)        (ip4_addr_set_u32(ipaddr, ipaddr_addr("114.114.114.114")))
-#define DNS_SERVER_ADDRESS_SECONDARY(ipaddr)        (ip4_addr_set_u32(ipaddr, ipaddr_addr("114.114.115.115")))
 
 #endif /* _LWIP_PORTING_CC_H_ */

components/net/lwip-2.1/porting/include/lwip/api_shell.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LWIP_API_SHELL_H
+#define LWIP_API_SHELL_H
+
+#include "arch/cc.h"
+#include "lwip/opt.h"
+
+#if defined (__cplusplus) && __cplusplus
+extern "C" {
+#endif
+
+u32_t lwip_ifconfig(int argc, const char **argv);
+u32_t OsShellPing(int argc, const char **argv);
+LWIP_STATIC int OsPingFunc(u32_t *parg);
+
+#if defined (__cplusplus) && __cplusplus
+}
+#endif
+#endif /* LWIP_HDR_API_SHELL_H */

components/net/lwip-2.1/porting/include/lwip/dhcp.h

@@ -1,38 +1,38 @@
-/*
- * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice, this list of
- *    conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice, this list
- *    of conditions and the following disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its contributors may be used
- *    to endorse or promote products derived from this software without specific prior written
- *    permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
-  * @brief  Configures the USART Peripheral.
-  * @param  None
-  * @retval None
-  */
-void USART_Config(void);
-
+/*
+ * Copyright (c) 2021-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LWIP_PORTING_DHCP_H_
+#define _LWIP_PORTING_DHCP_H_
+
+#include_next <lwip/dhcp.h>
+
+err_t dhcp_is_bound(struct netif *netif);
+
+#endif /* _LWIP_PORTING_DHCP_H_ */

components/net/lwip-2.1/porting/include/lwip/inet.h

@@ -43,9 +43,6 @@
             (ip4_addr_set_u32(target_ipaddr, (source_inaddr)->s_addr))
 
 /* directly map this to the lwip internal functions */
-#define inet_addr(cp)                   ipaddr_addr(cp)
-#define inet_aton(cp, addr)             ip4addr_aton(cp, (ip4_addr_t*)addr)
-#define inet_ntoa(addr)                 ip4addr_ntoa((const ip4_addr_t*)&(addr))
 #define inet_ntoa_r(addr, buf, buflen)  ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen)
 #endif /* LWIP_IPV4 */
 #if LWIP_IPV6

components/net/lwip-2.1/porting/include/lwip/lwipopts.h

@@ -134,7 +134,7 @@
 #define LWIP_NETIF_LOOPBACK             1
 #define LWIP_POSIX_SOCKETS_IO_NAMES     0
 #define LWIP_RAW                        1
-#define LWIP_SOCKET_OFFSET              FAT_MAX_OPEN_FILES
+#define LWIP_SOCKET_OFFSET              0
 #define LWIP_SO_RCVBUF                  1
 #define LWIP_SO_RCVTIMEO                1
 #define LWIP_SO_SNDTIMEO                1
@@ -216,79 +216,15 @@
 #define LWIP_ENABLE_NET_CAPABILITY      1
 #define LWIP_ENABLE_CAP_NET_BROADCAST   0
 
-// Options for GT
+// Options for liteos_m
 #undef LWIP_NETIF_PROMISC
 #define LWIP_NETIF_PROMISC              0
 
-#undef LWIP_ICMP
-#define LWIP_ICMP                       0
-
-#undef LWIP_DHCP
-#define LWIP_DHCP                       0
-
-#undef LWIP_IGMP
-#define LWIP_IGMP                       0
+#define MEMP_MEM_MALLOC                 1
 
 #undef LWIP_IPV6
 #define LWIP_IPV6                       0
 
-#undef LWIP_IPV6_DHCP6
-#define LWIP_IPV6_DHCP6                 0
-
-#undef TCP_SND_BUF
-#define TCP_SND_BUF                     (65535 / 3)
-
-#undef TCP_WND
-#define TCP_WND                         ((TCP_SND_BUF * 2) / 3)
-
-#undef TCP_SND_QUEUELEN
-#define TCP_SND_QUEUELEN                (2 * (TCP_SND_BUF / TCP_MSS))
-
-#undef MEMP_NUM_NETDB
-#define MEMP_NUM_NETDB                  1
-
-#undef MEMP_NUM_ARP_QUEUE
-#define MEMP_NUM_ARP_QUEUE              4
-
-#undef MEMP_NUM_NETBUF
-#define MEMP_NUM_NETBUF                 12
-
-#undef MEMP_NUM_NETCONN
-#define MEMP_NUM_NETCONN                32
-
-#undef MEMP_NUM_PBUF
-#define MEMP_NUM_PBUF                   0
-
-#undef PBUF_POOL_SIZE
-#define PBUF_POOL_SIZE                  0
-
-#undef MEMP_NUM_RAW_PCB
-#define MEMP_NUM_RAW_PCB                8
-
-#undef MEMP_NUM_REASSDATA
-#define MEMP_NUM_REASSDATA              12
-
-#undef MEMP_NUM_TCPIP_MSG_API
-#define MEMP_NUM_TCPIP_MSG_API          32
-
-#undef MEMP_NUM_TCPIP_MSG_INPKT
-#define MEMP_NUM_TCPIP_MSG_INPKT        32
-
-#undef MEMP_NUM_TCP_PCB
-#define MEMP_NUM_TCP_PCB                8
-
-#undef MEMP_NUM_TCP_PCB_LISTEN
-#define MEMP_NUM_TCP_PCB_LISTEN         4
-
-#undef MEMP_NUM_TCP_SEG
-#define MEMP_NUM_TCP_SEG                64
-
-#undef MEMP_NUM_UDP_PCB
-#define MEMP_NUM_UDP_PCB                4
-
-#undef TCPIP_THREAD_STACKSIZE
-#define TCPIP_THREAD_STACKSIZE          0x1000
-
 #undef LWIP_SOCKET_SELECT
 #define LWIP_SOCKET_SELECT              1
 

components/net/lwip-2.1/porting/include/lwip/netif.h

@@ -72,6 +72,8 @@ extern "C" {
 err_t driverif_init(struct netif *netif);
 void driverif_input(struct netif *netif, struct pbuf *p);
 
+#define netif_get_name(netif) ((netif)->full_name)
+
 #ifdef __cplusplus
 }
 #endif

components/net/lwip-2.1/porting/include/lwip/sockets.h

@@ -41,7 +41,6 @@
 #include <limits.h>
 #include <fcntl.h>
 #include_next <lwip/sockets.h>
-#include <fatfs.h>
 
 #ifdef __cplusplus
 extern "C" {

components/net/lwip-2.1/porting/src/api_shell.c

@@ -0,0 +1,613 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define LWIP_STATIC static
+#define DHCP_STATE_OFF 0
+#define LWIP_EXT_POLL_SUPPORT 1
+
+#include "lwip/api.h"
+#include "lwip/netdb.h"
+#include "lwip/stats.h"
+#include "lwip/err.h"
+#include "lwip/ip_addr.h"
+#include "lwip/icmp.h"
+#include "los_config.h"
+#include <string.h>
+
+#include "shcmd.h"
+#include "shell.h"
+#include "los_debug.h"
+#include "los_task.h"
+
+/* Forward Declarations [START] */
+#ifndef LWIP_TESTBED
+LWIP_STATIC
+#endif
+int print_netif(struct netif *netif, char *print_buf, unsigned int buf_len);
+
+#ifndef LWIP_TESTBED
+LWIP_STATIC
+#endif
+void lwip_ifconfig_show_internal(void *arg);
+
+#if LWIP_DNS
+LWIP_STATIC unsigned int get_hostip(const char *hname);
+
+#ifndef LWIP_TESTBED
+LWIP_STATIC
+#endif
+struct hostent *gethostnameinfo(const char *host, char *tmphstbuf, size_t hstbuflen);
+#endif /* LWIP_DNS */
+
+#define PRINT_BUF_LEN 1024
+
+struct ifconfig_option {
+    char iface[IFNAMSIZ];
+    unsigned int option;
+    ip_addr_t ip_addr;
+    ip_addr_t netmask;
+    ip_addr_t gw;
+    unsigned char ethaddr[6];
+    u16_t mtu;
+    /* when using telnet, print to the telnet socket will result in system  */
+    /* deadlock. So we cahe the prinf data to a buf, and when the tcpip      */
+    /* callback returns, then print the data out to the telnet socket       */
+    sys_sem_t cb_completed;
+    char cb_print_buf[PRINT_BUF_LEN];
+    unsigned int print_len;
+};
+
+#ifndef LWIP_TESTBED
+LWIP_STATIC
+#endif
+int print_netif(struct netif *netif, char *print_buf, unsigned int buf_len)
+{
+    int i, ret;
+    char *tmp = print_buf;
+
+    if (buf_len < 1) {
+        goto out;
+    }
+    if (netif->link_layer_type == LOOPBACK_IF) {
+        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%s\t", netif->name);
+    } else {
+        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%s%u\t", netif->name, netif->num);
+    }
+
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+#if LWIP_IPV4
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "ip:%s ", ipaddr_ntoa(&netif->ip_addr));
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "netmask:%s ", ipaddr_ntoa(&netif->netmask));
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "gateway:%s\n", ipaddr_ntoa(&netif->gw));
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+#endif
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "\tHWaddr ");
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+
+    for (i = 0; i < netif->hwaddr_len - 1; i++) {
+        ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%02x:", netif->hwaddr[i]);
+        if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+            goto out;
+        tmp += ret;
+        buf_len -= (unsigned int)ret;
+    }
+
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), "%02x", netif->hwaddr[i]);
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), " MTU:%d %s", netif->mtu,
+                     netif->flags & NETIF_FLAG_UP ? "Running" : "Stop");
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+    buf_len -= (unsigned int)ret;
+
+    if (netif_default == netif && netif_is_up(netif)) {
+        ret = snprintf_s(tmp, buf_len, (buf_len - 1), " %s", "Default");
+        if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+            goto out;
+        tmp += ret;
+        buf_len -= (unsigned int)ret;
+    }
+
+    ret = snprintf_s(tmp, buf_len, (buf_len - 1), " %s\n", netif->flags & NETIF_FLAG_LINK_UP ? "Link UP" : "Link Down");
+    if ((ret <= 0) || ((unsigned int)ret >= buf_len))
+        goto out;
+    tmp += ret;
+
+out:
+    return (int)(tmp - print_buf);
+}
+
+#ifndef LWIP_TESTBED
+LWIP_STATIC
+#endif
+void lwip_ifconfig_show_internal(void *arg)
+{
+    struct netif *netif = NULL;
+    struct ifconfig_option *ifconfig_cmd = (struct ifconfig_option *)arg;
+    int ret;
+
+    if (netif_list == NULL) {
+        ret = snprintf_s(ifconfig_cmd->cb_print_buf, PRINT_BUF_LEN - ifconfig_cmd->print_len,
+                         ((PRINT_BUF_LEN - ifconfig_cmd->print_len) - 1), "Device not init\n");
+        if ((ret > 0) && ((unsigned int)ret < (PRINT_BUF_LEN - ifconfig_cmd->print_len))) {
+            ifconfig_cmd->print_len += (unsigned int)ret;
+        }
+        sys_sem_signal(&ifconfig_cmd->cb_completed);
+        return;
+    }
+
+    if (ifconfig_cmd->iface[0] == '\0') {
+        /* display all netif */
+        for (netif = netif_list; netif != NULL; netif = netif->next) {
+            ret = print_netif(netif, ifconfig_cmd->cb_print_buf + ifconfig_cmd->print_len,
+                              PRINT_BUF_LEN - ifconfig_cmd->print_len);
+            ifconfig_cmd->print_len += (unsigned int)ret;
+        }
+    } else {
+        netif = netif_find(ifconfig_cmd->iface);
+        if (netif == NULL) {
+            ret = snprintf_s(ifconfig_cmd->cb_print_buf + ifconfig_cmd->print_len,
+                             (PRINT_BUF_LEN - ifconfig_cmd->print_len),
+                             ((PRINT_BUF_LEN - ifconfig_cmd->print_len) - 1), "Device not found\n");
+            if ((ret > 0) && ((unsigned int)ret < (PRINT_BUF_LEN - ifconfig_cmd->print_len))) {
+                ifconfig_cmd->print_len += (unsigned int)ret;
+            }
+
+            sys_sem_signal(&ifconfig_cmd->cb_completed);
+            return;
+        }
+
+        ret = print_netif(netif, ifconfig_cmd->cb_print_buf + ifconfig_cmd->print_len,
+                          PRINT_BUF_LEN - ifconfig_cmd->print_len);
+        ifconfig_cmd->print_len += (unsigned int)ret;
+    }
+    sys_sem_signal(&ifconfig_cmd->cb_completed);
+}
+
+/*lint -e838 -e438*/
+u32_t lwip_ifconfig(int argc, const char **argv)
+{
+    static struct ifconfig_option ifconfig_cmd;
+    err_t ret;
+
+#if LWIP_STATS
+    u32_t stat_err_cnt;
+    u32_t stat_drop_cnt;
+    u32_t stat_rx_or_tx_cnt;
+    u32_t stat_rx_or_tx_bytes;
+#endif
+
+    (void)memset_s(&ifconfig_cmd, sizeof(ifconfig_cmd), 0, sizeof(ifconfig_cmd));
+    if (sys_sem_new(&ifconfig_cmd.cb_completed, 0) != ERR_OK) {
+        PRINTK("%s: sys_sem_new fail\n", __FUNCTION__);
+        return 1;
+    }
+
+    /* Get the interface */
+
+    /* no more arguments, show all the interface state. */
+    ret = tcpip_callback(lwip_ifconfig_show_internal, &ifconfig_cmd);
+    if (ret != ERR_OK) {
+        sys_sem_free(&ifconfig_cmd.cb_completed);
+        PRINTK("ifconfig : internal error, l:%d err:%d\n", __LINE__, ret);
+        return 1;
+    }
+    (void)sys_arch_sem_wait(&ifconfig_cmd.cb_completed, 0);
+    sys_sem_free(&ifconfig_cmd.cb_completed);
+    ifconfig_cmd.cb_print_buf[PRINT_BUF_LEN - 1] = '\0';
+    PRINTK("%s", ifconfig_cmd.cb_print_buf);
+
+    return 0;
+}
+/*lint +e838 +e438*/
+
+#if LWIP_DNS
+#ifndef LWIP_TESTBED
+LWIP_STATIC
+#endif
+struct hostent *gethostnameinfo(const char *host, char *tmphstbuf, size_t hstbuflen)
+{
+    static struct hostent hostbuf;
+    struct hostent *hp = NULL;
+    int res;
+    int herr;
+
+    if (tmphstbuf == NULL)
+        return NULL;
+    res = lwip_gethostbyname_r(host, &hostbuf, tmphstbuf, hstbuflen, &hp, &herr);
+    /*  Check for errors.  */
+    if (res || hp == NULL) {
+        return NULL;
+    }
+    return hp;
+}
+
+LWIP_STATIC unsigned int get_hostip(const char *hname)
+{
+    unsigned int ip = 0;
+    int ret;
+    const size_t hstbuflen = 1024;
+    char *tmphstbuf = NULL;
+
+    tmphstbuf = (char *)zalloc(sizeof(char) * hstbuflen);
+    if (tmphstbuf == NULL)
+        return 0;
+
+    struct hostent *pent = gethostnameinfo(hname, tmphstbuf, hstbuflen);
+    if (pent == NULL || pent->h_addr == NULL) {
+        free(tmphstbuf);
+        return 0;
+    }
+    ret = memcpy_s(&ip, sizeof(ip), pent->h_addr, 4);
+    if (ret != 0) {
+        free(tmphstbuf);
+        return 0;
+    }
+    free(tmphstbuf);
+    return ip;
+}
+
+#endif
+
+static int ping_taskid = -1;
+static int ping_kill = 0;
+#define LWIP_SHELL_CMD_PING_TIMEOUT 2000
+#define LWIP_SHELL_CMD_PING_RETRY_TIMES 4
+#define PING_ZERO_DATA_LEN 8
+
+static void lwip_ping_usage(void)
+{
+    PRINTK("Usage:\n  ping [ip]\n");
+}
+
+LWIP_STATIC int OsPingFunc(u32_t *parg)
+{
+    int sfd;
+    struct sockaddr_in to;
+    struct pbuf *pbuf_resp = NULL;
+    struct icmp_echo_hdr *iecho = NULL;
+    struct icmp_echo_hdr *iecho_resp = NULL;
+    struct ip_hdr *iphdr_resp = NULL;
+    u32_t iecho_len;
+    s16_t ip_hlen;
+    u32_t forever;
+    u32_t i;
+    u32_t succ_cnt = 0;
+    u32_t failed_cnt = 0;
+    struct timespec start, end;
+    long timout_ms;
+    struct pollfd pfd;
+    long rtt;
+    int ret = 0;
+    u32_t intrvl;
+    char *data_buf = NULL;
+    BOOL timeout_flag = FALSE;
+    char buf[50];
+
+    u32_t destip = parg[0];
+    u32_t cnt = parg[1];
+    u32_t interval = parg[2];
+    u32_t data_len = parg[3];
+
+    iecho_len = sizeof(struct icmp_echo_hdr) + data_len;
+    sfd = lwip_socket(PF_INET, SOCK_RAW, IPPROTO_ICMP);
+    if (sfd < 0) {
+        perror("Ping socket");
+        return -1;
+    }
+    pbuf_resp = pbuf_alloc(PBUF_RAW, IP_HLEN + sizeof(struct icmp_echo_hdr), PBUF_RAM);
+    if (pbuf_resp == NULL) {
+        PRINTK("Ping: pbuf_resp malloc failed\n");
+        ret = -1;
+        goto FAILURE;
+    }
+    iecho = (struct icmp_echo_hdr *)mem_malloc(iecho_len);
+    if (iecho == NULL) {
+        PRINTK("Ping: echo request malloc failed\n");
+        ret = -1;
+        goto FAILURE;
+    }
+
+    to.sin_family = AF_INET;
+    to.sin_addr.s_addr = destip; /* already in network order */
+    to.sin_port = 0;
+
+    if (data_len > PING_ZERO_DATA_LEN) {
+        (void)memset_s(iecho, sizeof(struct icmp_echo_hdr) + PING_ZERO_DATA_LEN,
+                       0, sizeof(struct icmp_echo_hdr) + PING_ZERO_DATA_LEN);
+        data_buf = (char *)iecho + sizeof(struct icmp_echo_hdr) + PING_ZERO_DATA_LEN;
+        for (i = 0; i < data_len - PING_ZERO_DATA_LEN; i++) {
+            *(data_buf + i) = i + 0x10;
+        }
+    } else {
+        (void)memset_s(iecho, sizeof(struct icmp_echo_hdr) + data_len, 0, sizeof(struct icmp_echo_hdr) + data_len);
+    }
+    iecho->id = htons((u16_t)LOS_CurTaskIDGet());
+    ICMPH_TYPE_SET(iecho, (u8_t)ICMP_ECHO);
+    forever = (cnt ? 0 : 1);
+    i = 0;
+    while (!ping_kill && (forever || (i < cnt))) {
+        iecho->seqno = htons((u16_t)i);
+        iecho->chksum = 0;
+        iecho->chksum = inet_chksum((void *)iecho, iecho_len);
+
+        ret = sendto(sfd, iecho, iecho_len, 0, (struct sockaddr *)&to, (socklen_t)sizeof(to));
+        if (ret < 0) {
+            perror("Ping: sending ICMP echo request failed\n");
+            goto FAILURE;
+        }
+
+        /* capture the start time to calculate RTT */
+        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &start);
+
+        /* poll for ICMP echo response msg */
+        pfd.fd = sfd;
+
+        do {
+            pfd.events = POLLIN;
+            pfd.revents = 0;
+            timeout_flag = FALSE;
+            ret = poll(&pfd, 1, LWIP_SHELL_CMD_PING_TIMEOUT);
+            if (ret < 0) {
+                perror("Ping: poll\n");
+                goto FAILURE;
+            } else if (ret == 0) {
+                /* first type timeout event */
+                timeout_flag = TRUE;
+                break;
+            }
+
+            ret = recv(sfd, pbuf_resp->payload, pbuf_resp->len, MSG_DONTWAIT);
+            if (ret < 0) {
+                perror("Ping: recv echo reply failed\n");
+                goto FAILURE;
+            }
+
+            /* Accessing ip header and icmp header */
+            iphdr_resp = pbuf_resp->payload;
+
+            ip_hlen = (IPH_HL(iphdr_resp) << 2);
+            if (pbuf_header(pbuf_resp, -ip_hlen)) {
+                /* this failure will never happen, but failure handle is written just to be in safe side */
+                PRINTK("Ping : memory management failure\n");
+                goto FAILURE;
+            }
+            iecho_resp = (struct icmp_echo_hdr *)pbuf_resp->payload;
+            /* Reverting back pbuf to its original state */
+            if (pbuf_header(pbuf_resp, ip_hlen)) {
+                /* this failure will never happen, but failure handle is written just to be in safe side */
+                PRINTK("ping : memory management failure\n");
+                goto FAILURE;
+            }
+
+            if ((iphdr_resp->src.addr != to.sin_addr.s_addr) ||
+                ((ICMPH_TYPE(iecho_resp) == ICMP_ECHO) && (iphdr_resp->src.addr == to.sin_addr.s_addr))) {
+                /* second type timeout event */
+                (void)clock_gettime(CLOCK_MONOTONIC_RAW, &end);
+                timout_ms = ((end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000);
+                timout_ms = LWIP_SHELL_CMD_PING_TIMEOUT - timout_ms;
+            } else {
+                timout_ms = 0;
+                break;
+            }
+        } while (timout_ms >= 0);
+
+        /* all timeout events are true timeout */
+        if ((timout_ms < 0) || (timeout_flag == TRUE)) {
+            failed_cnt++;
+            i++;
+            PRINTK("\nPing: destination unreachable ...");
+            continue;
+        }
+        /* capture the end time to calculate round trip time */
+        (void)clock_gettime(CLOCK_MONOTONIC_RAW, &end);
+        rtt = ((end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000);
+
+        if (iphdr_resp->src.addr == to.sin_addr.s_addr) {
+            switch (ICMPH_TYPE(iecho_resp)) {
+                case ICMP_ER:
+                    PRINTK("\n[%u]Reply from %s: ", i, inet_ntop(AF_INET, &to.sin_addr, buf, sizeof(buf)));
+                    if (rtt > 0) {
+                        PRINTK("time=%ims ", rtt);
+                    } else {
+                        PRINTK("time<1ms ");
+                    }
+                    PRINTK("TTL=%u", iphdr_resp->_ttl);
+
+                    /* delay 1s for every successful ping */
+                    intrvl = interval;
+                    do {
+                        if (intrvl < 1000) {
+                            sys_msleep(intrvl);
+                            break;
+                        }
+                        intrvl -= 1000;
+                        sys_msleep(1000);
+                        if (ping_kill == 1)
+                            break;
+                    } while (intrvl > 0);
+                    succ_cnt++;
+                    break;
+                case ICMP_DUR:
+                    PRINTK("\nPing: destination host unreachable ...");
+                    break;
+                case ICMP_SQ:
+                    PRINTK("\nPing: source quench ...");
+                    break;
+                case ICMP_RD:
+                    PRINTK("\nPing: redirect ...");
+                    break;
+                case ICMP_TE:
+                    PRINTK("\nPing: time exceeded ...");
+                    break;
+                case ICMP_PP:
+                    PRINTK("\nPing: parameter problem ...");
+                    break;
+                default:
+                    PRINTK("\nPing: unknow error ...");
+                    break;
+            }
+            i++;
+        }
+    }
+
+    PRINTK("\n--- %s ping statistics ---\n", inet_ntop(AF_INET, &to.sin_addr, buf, sizeof(buf)));
+    PRINTK("%u packets transmitted, %u received, %u loss\n", i, succ_cnt, failed_cnt);
+
+FAILURE:
+    ping_kill = 0;
+    (void)lwip_close(sfd);
+    if (pbuf_resp != NULL) {
+        (void)pbuf_free(pbuf_resp);
+    }
+    if (iecho != NULL) {
+        mem_free(iecho);
+    }
+    return ret;
+}
+
+static void ping_cmd(u32_t *parg)
+{
+    int ret;
+
+    ret = OsPingFunc(parg);
+    if (ret < 0) {
+        PRINTK("Ping cmd failed due to some errors\n");
+    }
+
+    ping_taskid = -1;
+}
+
+u32_t OsShellPing(int argc, const char **argv)
+{
+    int ret;
+    u32_t i = 0;
+    u32_t count = 0;
+    int count_set = 0;
+    u32_t interval = 1000; /* default ping interval */
+    u32_t data_len = 48; /* default data length */
+    ip4_addr_t dst_ipaddr;
+    TSK_INIT_PARAM_S stPingTask;
+    u32_t *parg = NULL;
+
+    if ((argc < 1) || (argv == NULL)) {
+        PRINTK("Ping: require dest ipaddr at least\n");
+        goto ping_error;
+    }
+
+    if (!count_set) {
+        count = LWIP_SHELL_CMD_PING_RETRY_TIMES;
+    }
+
+    /* initialize dst IP address */
+    if (argc <= 0) {
+        goto ping_error;
+    }
+#if LWIP_DNS
+    dst_ipaddr.addr = get_hostip(argv[i]);
+#endif /* LWIP_DNS */
+
+    if (dst_ipaddr.addr == IPADDR_NONE || dst_ipaddr.addr == IPADDR_ANY) {
+        PRINTK("Invalid dest ipaddr: NONE or ANY\n");
+        return LOS_NOK;
+    }
+
+    parg = (u32_t *)malloc(4 * sizeof(int));
+    if (parg == NULL) {
+        return LOS_NOK;
+    }
+    parg[0] = dst_ipaddr.addr;
+    parg[1] = count;
+    parg[2] = interval;
+    parg[3] = data_len;
+
+    /* start one task if ping forever or ping count greater than 60 */
+    if (count == 0 || count > LWIP_SHELL_CMD_PING_RETRY_TIMES) {
+        if (ping_taskid > 0) {
+            free(parg);
+            PRINTK("Ping task already running and only support one now\n");
+            return LOS_NOK;
+        }
+        stPingTask.pfnTaskEntry = (TSK_ENTRY_FUNC)ping_cmd;
+        stPingTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
+        stPingTask.pcName = "ping_task";
+        stPingTask.usTaskPrio = 8; /* higher than shell */
+        stPingTask.uwResved = LOS_TASK_STATUS_DETACHED;
+        stPingTask.uwArg = (UINTPTR)parg;
+        ret = LOS_TaskCreate((UINT32 *)(&ping_taskid), &stPingTask);
+        if (ret != LOS_OK) {
+            PRINTK("ping_task create failed 0x%08x.\n", ret);
+            count = LWIP_SHELL_CMD_PING_RETRY_TIMES;
+        } else {
+            return LOS_OK;
+        }
+    }
+
+    /* two cases:
+     1, ping cout less than LWIP_SHELL_CMD_PING_RETRY_TIMES;
+     2, ping task create failed;
+    */
+    if (OsPingFunc(parg) < 0) {
+        PRINTK("Ping cmd failed due some errors\n");
+    }
+
+    free(parg);
+
+    return LOS_OK;
+ping_error:
+    lwip_ping_usage();
+    return LOS_NOK;
+}
+

components/net/lwip-2.1/porting/src/netdb_porting.c

@@ -31,10 +31,31 @@
 
 #include "lwip/netdb.h"
 
+#if LWIP_DNS && LWIP_SOCKET
+
 struct hostent *gethostbyname(const char *name)
 {
     if (name == NULL) {
         return NULL;
     }
     return lwip_gethostbyname(name);
-}
+}
+
+int gethostbyname_r(const char *name, struct hostent *ret, char *buf, size_t buflen, struct hostent **result,
+    int *h_errnop)
+{
+    return lwip_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
+}
+
+void freeaddrinfo(struct addrinfo *res)
+{
+    lwip_freeaddrinfo(res);
+}
+
+int getaddrinfo(const char *restrict nodename, const char *restrict servname, const struct addrinfo *restrict hints,
+    struct addrinfo **restrict res)
+{
+    return lwip_getaddrinfo(nodename, servname, hints, res);
+}
+
+#endif

components/net/lwip-2.1/porting/src/sockets_porting.c

@@ -29,10 +29,12 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "lwip/sockets.h"
+#include "lwip/priv/tcpip_priv.h"
 #include "lwip/priv/sockets_priv.h"
-#include <lwip/sockets.h>
 
 #if !LWIP_COMPAT_SOCKETS
+#if LWIP_SOCKET
 
 #define CHECK_NULL_PTR(ptr) do { if ((ptr) == NULL) { set_errno(EFAULT); return -1; } } while (0)
 
@@ -159,6 +161,27 @@ int inet_pton(int af, const char *src, void *dst)
     return lwip_inet_pton(af, src, dst);
 }
 
+#ifndef LWIP_INET_ADDR_FUNC
+in_addr_t inet_addr(const char *cp)
+{
+    return ipaddr_addr(cp);
+}
+#endif
+
+#ifndef LWIP_INET_NTOA_FUNC
+char *inet_ntoa(struct in_addr addr)
+{
+    return ip4addr_ntoa((const ip4_addr_t*)&(addr));
+}
+#endif
+
+#ifndef LWIP_INET_ATON_FUNC
+int inet_aton(const char *cp, struct in_addr *addr)
+{
+    return ip4addr_aton(cp, (ip4_addr_t*)addr);
+}
+#endif
+
 int ioctlsocket(int s, long cmd, void *argp)
 {
     return lwip_ioctl(s, cmd, argp);
@@ -178,4 +201,87 @@ int poll(struct pollfd *fds, nfds_t nfds, int timeout)
 }
 #endif
 
-#endif /* !LWIP_COMPAT_SOCKETS */
+unsigned int if_nametoindex(const char *ifname)
+{
+    return lwip_if_nametoindex(ifname);
+}
+
+#endif
+#endif /* !LWIP_COMPAT_SOCKETS */
+
+#define IOCTL_CMD_CASE_HANDLER() do {                      \
+    err_t  err;                                            \
+    struct lwip_ioctl_apimsg msg;                          \
+    msg.sock = sock;                                       \
+    msg.cmd = cmd;                                         \
+    msg.argp = argp;                                       \
+                                                           \
+    err = tcpip_api_call(lwip_do_ioctl_impl, &msg.call);   \
+    if (err != ENOSYS) {                                   \
+        sock_set_errno(sock, err);                         \
+        done_socket(sock);                                 \
+        return -(err != ERR_OK);                           \
+    }                                                      \
+} while (0)
+
+struct lwip_ioctl_apimsg {
+    struct tcpip_api_call_data call;
+    struct lwip_sock *sock;
+    long cmd;
+    void *argp;
+};
+
+static err_t lwip_do_ioctl_impl(struct tcpip_api_call_data *call);
+
+#include "../api/sockets.c"
+
+static u8_t lwip_ioctl_internal_SIOCGIFBRDADDR(struct ifreq *ifr)
+{
+    struct netif *netif = NULL;
+    struct sockaddr_in *sock_in = NULL;
+
+    /* get netif subnet broadcast addr */
+    netif = netif_find(ifr->ifr_name);
+    if (netif == NULL) {
+        return ENODEV;
+    }
+    if (ip4_addr_isany_val(*(ip_2_ip4(&netif->netmask)))) {
+        return ENXIO;
+    }
+    sock_in = (struct sockaddr_in *)&ifr->ifr_addr;
+    sock_in->sin_family = AF_INET;
+    sock_in->sin_addr.s_addr = (ip_2_ip4(&((netif)->ip_addr))->addr | ~(ip_2_ip4(&netif->netmask)->addr));
+    return 0;
+}
+
+static u8_t lwip_ioctl_impl(const struct lwip_sock *sock, long cmd, void *argp)
+{
+    u8_t err = 0;
+    struct ifreq *ifr = (struct ifreq *)argp;
+    bool is_ipv6 = 0;
+
+    /* allow it only on IPv6 sockets... */
+    is_ipv6 = NETCONNTYPE_ISIPV6((unsigned int)(sock->conn->type));
+
+    switch ((u32_t)cmd) {
+        case SIOCGIFBRDADDR:
+            if (is_ipv6 != 0) {
+                err = EINVAL;
+            } else {
+                err = lwip_ioctl_internal_SIOCGIFBRDADDR(ifr);
+            }
+            break;
+        default:
+            err = ENOSYS;
+            LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(UNIMPL: 0x%lx)\n", cmd));
+            break;
+    }
+
+    return err;
+}
+
+static err_t lwip_do_ioctl_impl(struct tcpip_api_call_data *call)
+{
+    struct lwip_ioctl_apimsg *msg = (struct lwip_ioctl_apimsg *)(void *)call;
+    return lwip_ioctl_impl(msg->sock, msg->cmd, msg->argp);
+}

components/net/lwip-2.1/porting/src/sys_arch.c

@@ -38,7 +38,7 @@
 #include <los_sem.h>
 #include <los_mux.h>
 #include "cmsis_os2.h"
-#include <los_timer.h>
+#include <los_tick.h>
 #include <los_config.h>
 
 #ifndef LOSCFG_KERNEL_SMP
@@ -82,8 +82,7 @@ sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg,
 void sys_init(void)
 {
     /* set rand seed to make random sequence diff on every startup */
-    UINT32 seedhsb, seedlsb;
-    HalGetCpuCycle(&seedhsb, &seedlsb);
+    UINT32 seedlsb = (UINT32)LOS_SysCycleGet();
     srand(seedlsb);
 }
 
@@ -181,7 +180,10 @@ err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
     return ERR_ARG;
 }
 
-err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg);
+err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg)
+{
+    return ERR_ARG;
+}
 
 u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeoutMs)
 {
@@ -322,7 +324,7 @@ void sys_mutex_set_invalid(sys_mutex_t *mutex)
     *mutex = LOSCFG_BASE_IPC_MUX_LIMIT;
 }
 
-void HilogPrintf(const char *fmt, ...)
+void LwipLogPrintf(const char *fmt, ...)
 {
     if ((fmt == NULL) || (strlen(fmt) == 0)) {
         return;
@@ -335,8 +337,8 @@ void HilogPrintf(const char *fmt, ...)
     len = vsprintf_s(buf, sizeof(buf) - 1, fmt, ap);
     va_end(ap);
     if (len < 0) {
-        HILOG_INFO(HILOG_MODULE_APP, "log param invalid or buf is not enough.");
+        LWIP_LOGGER("log param invalid or buf is not enough.");
         return;
     }
-    HILOG_INFO(HILOG_MODULE_APP, buf);
+    LWIP_LOGGER(buf);
 }