@ohos-graphics/stability-code-review 0.1.0

package/references/MemoryStability/StabilityCodeReview_MemoryStability_002.md

@@ -0,0 +1,261 @@
+---
+rule_id: "StabilityCodeReview_MemoryStability_002"
+name: "指针解引用前判空"
+category: "内存稳定性"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 指针解引用前判空
+
+## 问题描述
+
+对指针进行解引用操作（*ptr、ptr->、ptr[index]）前未进行空指针检查，可能导致空指针解引用崩溃（SIGSEGV）。这是OpenHarmony系统中最常见的稳定性问题之一，会导致服务崩溃、用户数据丢失。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：函数参数指针未判空直接解引用
+void ProcessData(Data* data)
+{
+    data->Process();  // 错误：未判空直接使用成员
+    data->value = 100;
+}
+
+// 场景2：返回值指针未判空
+void HandleResult()
+{
+    Result* result = GetResult();
+    result->Print();  // 错误：GetResult可能返回nullptr
+}
+
+// 场景3：数组指针未判空访问元素
+void ProcessArray(int* arr, int size)
+{
+    for (int i = 0; i < size; i++) {
+        arr[i] = i * 2;  // 错误：arr可能为nullptr
+    }
+}
+
+// 场景4：链式指针解引用
+void ChainAccess(Node* node)
+{
+    node->next->value = 100;  // 错误：node或node->next可能为nullptr
+}
+
+// 场景5：智能指针get()后未判空
+void SmartPtrGet()
+{
+    std::unique_ptr<Data> ptr = GetData();
+    Data* raw = ptr.get();
+    raw->Process();  // 错误：ptr可能为空，raw为nullptr
+}
+
+// 场景6：条件分支遗漏判空
+void ConditionalAccess(Data* data, bool flag)
+{
+    if (flag) {
+        data->Process();  // 错误：即使flag=true，data可能仍为nullptr
+    }
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：函数参数判空
+void ProcessData(Data* data)
+{
+    if (data == nullptr) {  // 正确：入口判空
+        LOGE("data is nullptr");
+        return;
+    }
+    data->Process();
+    data->value = 100;
+}
+
+// 修复场景2：返回值判空
+void HandleResult()
+{
+    Result* result = GetResult();
+    if (result == nullptr) {  // 正确：判空后使用
+        LOGE("GetResult failed");
+        return;
+    }
+    result->Print();
+}
+
+// 修复场景3：数组指针判空
+void ProcessArray(int* arr, int size)
+{
+    if (arr == nullptr || size <= 0) {  // 正确：判空+边界检查
+        LOGE("Invalid array parameters");
+        return;
+    }
+    for (int i = 0; i < size; i++) {
+        arr[i] = i * 2;
+    }
+}
+
+// 修复场景4：链式指针逐级判空
+void ChainAccess(Node* node)
+{
+    if (node == nullptr) {  // 正确：第一级判空
+        return;
+    }
+    if (node->next == nullptr) {  // 正确：第二级判空
+        return;
+    }
+    node->next->value = 100;
+}
+
+// 修复场景5：智能指针直接使用
+void SmartPtrGet()
+{
+    std::unique_ptr<Data> ptr = GetData();
+    if (!ptr) {  // 正确：智能指针判空
+        LOGE("GetData returned empty");
+        return;
+    }
+    ptr->Process();  // 直接使用智能指针，无需get()
+}
+
+// 修复场景6：条件分支中判空
+void ConditionalAccess(Data* data, bool flag)
+{
+    if (data == nullptr) {  // 正确：先判空
+        return;
+    }
+    if (flag) {
+        data->Process();  // 安全：已判空
+    }
+}
+
+// 修复场景7：使用assert断言（调试阶段）
+void DebugAssert(Data* data)
+{
+    assert(data != nullptr && "data must not be nullptr");
+    data->Process();  // 注意：assert在生产环境可能被禁用
+}
+
+// 修复场景8：使用引用代替指针
+void UseReference(Data& data)
+{
+    data.Process();  // 安全：引用不能为空
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- 指针参数在函数入口未判空直接解引用
+- 返回值指针未判空直接解引用
+- 数组指针未判空直接访问元素
+- 链式指针解引用（ptr->member->subMember）
+- 智能指针get()返回的裸指针未判空
+- 条件分支中遗漏的判空
+
+## 检测要点
+
+1. 识别指针变量（通过类型声明或推断）
+2. 检测解引用操作（->、*、[index]）
+3. 向上搜索是否有判空语句（if ptr == nullptr 等）
+4. 检查是否在判空保护范围内
+5. 排除NOPROTECT标记和引用类型
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：可能为nullptr的指针变量
+- **RISK_TYPE**：空指针解引用（SIGSEGV）
+- **RISK_PATH**：指针为nullptr -> 未判空解引用 -> 内存访问违规 -> 程序崩溃
+- **IMPACT_POINT**：进程崩溃、服务中断、系统不稳定
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：指针值为nullptr时执行解引用操作
+- **Propagation**：访问非法内存地址（0x0或附近）
+- **Consequence**：SIGSEGV信号导致进程终止，服务崩溃
+- **Mitigation**：解引用前强制判空，或使用引用/智能指针
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 已判空 | 之前有 if (ptr == nullptr) return | 不报 |
+| 引用类型 | 参数类型为 Type& 或 Type& | 不报 |
+| 智能指针直接用 | unique_ptr/shared_ptr->method() | 不报 |
+| 确信非空指针 | assert(ptr) 或 constexpr | 上下文分析 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| this指针 | this->member | 不报（this不能为空） |
+| 成员函数内 | 在类成员函数内访问成员 | 上下文分析 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_MemoryStability_002_trigger.cpp
+void trigger_bad_1(Data* data)
+{
+    data->Process();  // 应该报：参数指针未判空
+}
+
+void trigger_bad_2()
+{
+    Node* node = GetNode();
+    node->value = 100;  // 应该报：返回值未判空
+}
+
+void trigger_bad_3(int* arr)
+{
+    arr[0] = 1;  // 应该报：数组指针未判空
+}
+
+void trigger_bad_4(Node* node)
+{
+    node->next->value = 100;  // 应该报：链式解引用未逐级判空
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_MemoryStability_002_safe.cpp
+void safe_good_1(Data* data)
+{
+    if (data == nullptr) {  // 安全：入口判空
+        return;
+    }
+    data->Process();
+}
+
+void safe_good_2()
+{
+    Node* node = GetNode();
+    if (node != nullptr) {  // 安全：判空后使用
+        node->value = 100;
+    }
+}
+
+void safe_good_3(Data& data)
+{
+    data.Process();  // 安全：使用引用，不能为空
+}
+
+void safe_good_4()
+{
+    auto ptr = std::make_unique<Data>();
+    if (ptr) {  // 安全：智能指针判空
+        ptr->Process();
+    }
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case(Data* data)
+{
+    data->Process();  // NOPROTECT标记，不报
+}
+```

package/references/MemoryStability/StabilityCodeReview_MemoryStability_003.md

@@ -0,0 +1,428 @@
+---
+rule_id: "StabilityCodeReview_MemoryStability_003"
+name: "异常分支内存未及时释放"
+category: "内存稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 异常分支内存未及时释放
+
+## 问题描述
+
+在代码的异常分支（如提前return、break、continue等）退出前，已分配的内存（malloc/new）未及时释放，导致内存泄漏。这类问题在复杂的控制流中容易被忽略，是内存泄漏的常见原因之一。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：条件分支提前return未释放
+void ProcessData(int size)
+{
+    char* buffer = (char*)malloc(size);
+    if (buffer == nullptr) {
+        return;  // 错误：分配失败，无内存可释放，此处正确
+    }
+    
+    if (size > MAX_SIZE) {
+        return;  // 错误：提前return未释放buffer
+    }
+    
+    // 处理数据
+    free(buffer);
+}
+
+// 场景2：错误处理分支未释放
+int LoadConfig(const char* path)
+{
+    Config* config = new Config();
+    
+    if (!FileExists(path)) {
+        return -1;  // 错误：config未释放
+    }
+    
+    if (!ParseConfig(config, path)) {
+        return -2;  // 错误：config未释放
+    }
+    
+    delete config;
+    return 0;
+}
+
+// 场景3：循环中break未释放
+void ProcessItems(int count)
+{
+    int* items = (int*)malloc(count * sizeof(int));
+    
+    for (int i = 0; i < count; i++) {
+        if (items[i] < 0) {
+            break;  // 错误：break前未释放items
+        }
+        ProcessItem(items[i]);
+    }
+    
+    free(items);
+}
+
+// 场景4：嵌套条件多个退出点
+int HandleRequest(Request* req)
+{
+    char* temp = (char*)malloc(1024);
+    
+    if (req == nullptr) {
+        return -1;  // 错误：temp未释放
+    }
+    
+    if (req->type == TYPE_INVALID) {
+        return -2;  // 错误：temp未释放
+    }
+    
+    if (req->size > MAX_SIZE) {
+        return -3;  // 错误：temp未释放
+    }
+    
+    // 处理请求
+    free(temp);
+    return 0;
+}
+
+// 场景5：switch case中提前return
+int ProcessCommand(int cmd)
+{
+    char* buffer = (char*)malloc(256);
+    
+    switch (cmd) {
+        case CMD_EXIT:
+            return -1;  // 错误：buffer未释放
+        case CMD_RESET:
+            return -2;  // 错误：buffer未释放
+        case CMD_PROCESS:
+            // 处理
+            break;
+    }
+    
+    free(buffer);
+    return 0;
+}
+
+// 场景6：异常检查后多处返回
+bool ValidateData(Data* data)
+{
+    char* temp = new char[512];
+    
+    if (data == nullptr) {
+        return false;  // 错误：temp未释放
+    }
+    
+    if (data->size <= 0) {
+        return false;  // 错误：temp未释放
+    }
+    
+    if (data->type == TYPE_UNKNOWN) {
+        return false;  // 错误：temp未释放
+    }
+    
+    delete[] temp;
+    return true;
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：提前return前释放内存
+void ProcessData(int size)
+{
+    char* buffer = (char*)malloc(size);
+    if (buffer == nullptr) {
+        return;
+    }
+    
+    if (size > MAX_SIZE) {
+        free(buffer);  // 正确：return前释放
+        return;
+    }
+    
+    // 处理数据
+    free(buffer);
+}
+
+// 修复场景2：使用智能指针(RAII)
+int LoadConfig(const char* path)
+{
+    std::unique_ptr<Config> config = std::make_unique<Config>();
+    
+    if (!FileExists(path)) {
+        return -1;  // 安全：智能指针自动释放
+    }
+    
+    if (!ParseConfig(config.get(), path)) {
+        return -2;  // 安全：智能指针自动释放
+    }
+    
+    return 0;  // 安全：智能指针自动释放
+}
+
+// 修复场景3：使用goto集中释放（C风格）
+void ProcessItems(int count)
+{
+    int* items = (int*)malloc(count * sizeof(int));
+    if (items == nullptr) {
+        return;
+    }
+    
+    for (int i = 0; i < count; i++) {
+        if (items[i] < 0) {
+            goto cleanup;  // 跳转到释放点
+        }
+        ProcessItem(items[i]);
+    }
+    
+cleanup:
+    free(items);
+}
+
+// 修复场景4：使用do-while(0)模式
+int HandleRequest(Request* req)
+{
+    char* temp = (char*)malloc(1024);
+    int result = 0;
+    
+    do {
+        if (req == nullptr) {
+            result = -1;
+            break;
+        }
+        
+        if (req->type == TYPE_INVALID) {
+            result = -2;
+            break;
+        }
+        
+        if (req->size > MAX_SIZE) {
+            result = -3;
+            break;
+        }
+        
+        // 处理请求
+    } while (0);
+    
+    free(temp);
+    return result;
+}
+
+// 修复场景5：switch中使用统一出口
+int ProcessCommand(int cmd)
+{
+    char* buffer = (char*)malloc(256);
+    int result = 0;
+    
+    switch (cmd) {
+        case CMD_EXIT:
+            result = -1;
+            break;  // 正确：跳转到统一释放点
+        case CMD_RESET:
+            result = -2;
+            break;  // 正确：跳转到统一释放点
+        case CMD_PROCESS:
+            // 处理
+            break;
+    }
+    
+    free(buffer);
+    return result;
+}
+
+// 修复场景6：使用std::vector代替手动管理
+bool ValidateData(Data* data)
+{
+    std::vector<char> temp(512);  // RAII自动管理
+    
+    if (data == nullptr) {
+        return false;  // 安全：vector自动释放
+    }
+    
+    if (data->size <= 0) {
+        return false;  // 安全：vector自动释放
+    }
+    
+    if (data->type == TYPE_UNKNOWN) {
+        return false;  // 安全：vector自动释放
+    }
+    
+    return true;
+}
+
+// 修复场景7：使用lambda封装资源
+void ProcessFile(const char* path)
+{
+    auto cleanup = [](char* p) { if (p) free(p); };
+    char* buffer = (char*)malloc(1024);
+    std::unique_ptr<char, decltype(cleanup)> ptr(buffer, cleanup);
+    
+    if (!FileExists(path)) {
+        return;  // 安全：unique_ptr调用cleanup
+    }
+    
+    // 处理文件
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. **malloc/calloc/realloc** 分配后在分支退出未释放
+2. **new** 分配后在分支退出未释放（非智能指针）
+3. **条件分支提前return** 前内存未释放
+4. **循环中break/continue** 前内存未释放
+5. **switch case中return** 前内存未释放
+
+## 检测要点
+
+1. 识别内存分配函数调用（malloc、calloc、realloc、new）
+2. 跟踪分配变量名，检查是否存储到容器或成员变量
+3. 检测分支退出语句（return、break、continue）
+4. 在分配点和退出点之间检查是否存在释放操作
+5. 排除智能指针（unique_ptr、shared_ptr）使用场景
+6. 排除NOPROTECT标记场景
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：malloc/new分配的内存块
+- **RISK_TYPE**：内存泄漏
+- **RISK_PATH**：内存分配 → 异常分支退出 → 跳过释放 → 孤儿内存块 → 内存泄漏累积
+- **IMPACT_POINT**：系统内存资源耗尽，服务不可用，OOM崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：异常条件触发分支退出，跳过内存释放代码
+- **Propagation**：分配的内存块成为孤儿内存，无法被任何指针引用
+- **Consequence**：内存泄漏累积导致可用内存减少，最终OOM崩溃
+- **Mitigation**：使用RAII智能指针，或确保每个退出点都有释放代码
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 使用智能指针 | unique_ptr/shared_ptr/make_unique | 不报 |
+| 存入容器 | vector/push_back/insert | 不报 |
+| 赋值给成员变量 | this->/m_xxx | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| 全局/静态变量 | static/global | 不报 |
+| 测试代码 | 文件名包含 _test.cpp | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_MemoryStability_003_trigger.cpp
+#include <cstdlib>
+
+void trigger_bad_1(int size)
+{
+    char* buffer = (char*)malloc(1024);
+    if (size > 100) {
+        return;  // 应该报：malloc后提前return未释放
+    }
+    free(buffer);
+}
+
+void trigger_bad_2()
+{
+    int* data = new int[100];
+    if (data == nullptr) {
+        return;
+    }
+    if (condition) {
+        return;  // 应该报：new后提前return未释放
+    }
+    delete[] data;
+}
+
+void trigger_bad_3(int count)
+{
+    int* items = (int*)malloc(count * sizeof(int));
+    for (int i = 0; i < count; i++) {
+        if (items[i] < 0) {
+            break;  // 应该报：break前未释放
+        }
+    }
+    free(items);
+}
+
+int trigger_bad_4(int cmd)
+{
+    char* buffer = (char*)malloc(256);
+    switch (cmd) {
+        case 1:
+            return -1;  // 应该报：switch case return未释放
+        case 2:
+            return -2;  // 应该报：switch case return未释放
+    }
+    free(buffer);
+    return 0;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_MemoryStability_003_safe.cpp
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+void safe_good_1(int size)
+{
+    char* buffer = (char*)malloc(1024);
+    if (size > 100) {
+        free(buffer);  // 安全：return前释放
+        return;
+    }
+    free(buffer);
+}
+
+void safe_good_2()
+{
+    std::unique_ptr<int[]> data = std::make_unique<int[]>(100);
+    if (condition) {
+        return;  // 安全：智能指针自动释放
+    }
+}
+
+void safe_good_3()
+{
+    std::vector<int> items(100);
+    if (condition) {
+        return;  // 安全：vector自动释放
+    }
+}
+
+void safe_good_4(int count)
+{
+    int* items = (int*)malloc(count * sizeof(int));
+    int result = 0;
+    
+    do {
+        if (count <= 0) {
+            result = -1;
+            break;  // 安全：跳转到统一释放点
+        }
+    } while (0);
+    
+    free(items);
+}
+
+// NOPROTECT: 特殊场景，内存由调用者管理
+void noprotect_case()
+{
+    char* buffer = (char*)malloc(256);
+    if (condition) {
+        return;  // NOPROTECT: 不报
+    }
+    free(buffer);
+}
+```