@ohos-graphics/stability-code-review 0.1.0

package/references/MemoryStability/StabilityCodeReview_MemoryStability_004.md

@@ -0,0 +1,400 @@
+---
+rule_id: "StabilityCodeReview_MemoryStability_004"
+name: "多返回路径资源泄漏"
+category: "内存稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 多返回路径资源泄漏
+
+## 问题描述
+
+代码使用裸指针 new / malloc 或需显式关闭的资源（句柄、文件描述符、互斥锁）时，在函数存在多条返回路径（早返回、失败分支、异常传播）时未在所有路径上释放，造成内存泄漏、句柄泄漏、锁未释放或 use-after-free / double-free。长时间运行可致 OOM、资源耗尽、死锁，甚至被用作触发崩溃或提权的前提条件。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：多条return路径导致内存泄漏
+int ProcessRequest(Request* req)
+{
+    char* buffer = (char*)malloc(1024);
+    if (req == nullptr) {
+        return -1;  // 错误：buffer未释放
+    }
+    
+    if (req->type == TYPE_INVALID) {
+        return -2;  // 错误：buffer未释放
+    }
+    
+    if (req->size > MAX_SIZE) {
+        return -3;  // 错误：buffer未释放
+    }
+    
+    ProcessBuffer(buffer);
+    free(buffer);
+    return 0;
+}
+
+// 场景2：文件句柄多路径泄漏
+int ReadConfig(const char* path, Config* config)
+{
+    FILE* file = fopen(path, "r");
+    if (file == nullptr) {
+        return -1;  // 正确：打开失败，无需关闭
+    }
+    
+    if (!ValidateConfig(config)) {
+        return -2;  // 错误：file未关闭
+    }
+    
+    if (!ParseFile(file, config)) {
+        return -3;  // 错误：file未关闭
+    }
+    
+    fclose(file);
+    return 0;
+}
+
+// 场景3：互斥锁多路径未释放
+void ProcessSharedData(pthread_mutex_t* mutex, Data* data)
+{
+    pthread_mutex_lock(mutex);
+    
+    if (data == nullptr) {
+        return;  // 错误：锁未释放，其他线程无法获取
+    }
+    
+    if (!ValidateData(data)) {
+        return;  // 错误：锁未释放
+    }
+    
+    UpdateData(data);
+    pthread_mutex_unlock(mutex);
+}
+
+// 场景4：动态库句柄泄漏
+void* LoadFunction(const char* libPath, const char* funcName)
+{
+    void* handle = dlopen(libPath, RTLD_NOW);
+    if (handle == nullptr) {
+        return nullptr;  // 正确：打开失败，无需关闭
+    }
+    
+    if (!ValidatePath(funcName)) {
+        return nullptr;  // 错误：handle未关闭
+    }
+    
+    void* func = dlsym(handle, funcName);
+    if (func == nullptr) {
+        return nullptr;  // 错误：handle未关闭
+    }
+    
+    return func;
+}
+
+// 场景5：嵌套条件多路径泄漏
+int HandleCommand(Command* cmd)
+{
+    int* temp = new int[256];
+    
+    if (cmd == nullptr) {
+        return -1;  // 错误：temp未释放
+    }
+    
+    if (cmd->type == CMD_EXIT) {
+        return -2;  // 错误：temp未释放
+    }
+    
+    if (cmd->type == CMD_RESET) {
+        if (!ResetSystem()) {
+            return -3;  // 错误：temp未释放
+        }
+    }
+    
+    ProcessCommand(cmd, temp);
+    delete[] temp;
+    return 0;
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：使用智能指针自动管理内存
+int ProcessRequest(Request* req)
+{
+    std::unique_ptr<char[]> buffer = std::make_unique<char[]>(1024);
+    if (req == nullptr) {
+        return -1;  // 安全：智能指针自动释放
+    }
+    
+    if (req->type == TYPE_INVALID) {
+        return -2;  // 安全：智能指针自动释放
+    }
+    
+    if (req->size > MAX_SIZE) {
+        return -3;  // 安全：智能指针自动释放
+    }
+    
+    ProcessBuffer(buffer.get());
+    return 0;  // 安全：智能指针自动释放
+}
+
+// 修复场景2：使用RAII管理文件句柄
+int ReadConfig(const char* path, Config* config)
+{
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        return -1;  // 安全：ifstream自动关闭
+    }
+    
+    if (!ValidateConfig(config)) {
+        return -2;  // 安全：ifstream自动关闭
+    }
+    
+    if (!ParseFile(file, config)) {
+        return -3;  // 安全：ifstream自动关闭
+    }
+    
+    return 0;  // 安全：ifstream自动关闭
+}
+
+// 修复场景3：使用锁守卫自动释放
+void ProcessSharedData(pthread_mutex_t* mutex, Data* data)
+{
+    std::lock_guard<std::mutex> lock(*mutex);  // RAII锁管理
+    
+    if (data == nullptr) {
+        return;  // 安全：lock_guard自动释放锁
+    }
+    
+    if (!ValidateData(data)) {
+        return;  // 安全：lock_guard自动释放锁
+    }
+    
+    UpdateData(data);
+}
+
+// 修复场景4：使用统一清理点
+void* LoadFunction(const char* libPath, const char* funcName)
+{
+    void* handle = dlopen(libPath, RTLD_NOW);
+    if (handle == nullptr) {
+        return nullptr;
+    }
+    
+    void* func = nullptr;
+    
+    if (ValidatePath(funcName)) {
+        func = dlsym(handle, funcName);
+    }
+    
+    if (func == nullptr) {
+        dlclose(handle);  // 正确：统一清理点
+        return nullptr;
+    }
+    
+    return func;
+}
+
+// 修复场景5：使用do-while(0)统一出口
+int HandleCommand(Command* cmd)
+{
+    int* temp = new int[256];
+    int result = 0;
+    
+    do {
+        if (cmd == nullptr) {
+            result = -1;
+            break;  // 正确：跳转到统一释放点
+        }
+        
+        if (cmd->type == CMD_EXIT) {
+            result = -2;
+            break;  // 正确：跳转到统一释放点
+        }
+        
+        if (cmd->type == CMD_RESET) {
+            if (!ResetSystem()) {
+                result = -3;
+                break;  // 正确：跳转到统一释放点
+            }
+        }
+        
+        ProcessCommand(cmd, temp);
+    } while (0);
+    
+    delete[] temp;
+    return result;
+}
+
+// 修复场景6：使用lambda封装资源清理
+void ProcessFile(const char* path)
+{
+    auto cleanup = [](FILE* f) { if (f) fclose(f); };
+    FILE* file = fopen(path, "r");
+    std::unique_ptr<FILE, decltype(cleanup)> fileGuard(file, cleanup);
+    
+    if (!file) {
+        return;  // 安全：fileGuard调用cleanup
+    }
+    
+    ProcessData(file);
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. **malloc/calloc/realloc** 在多条return路径未释放
+2. **new** 在多条return路径未释放（非智能指针）
+3. **文件句柄**（fopen、open）在多条return路径未关闭
+4. **动态库句柄**（dlopen）在多条return路径未关闭
+5. **互斥锁**（pthread_mutex_lock）在多条return路径未释放
+6. **数据库连接**在多条return路径未关闭
+7. **socket描述符**在多条return路径未关闭
+
+## 检测要点
+
+1. 识别资源分配函数调用（malloc、new、fopen、dlopen、pthread_mutex_lock等）
+2. 构建函数控制流图，识别所有退出点（return、break、continue）
+3. 在分配点和每个退出点之间检查是否存在释放操作
+4. 排除智能指针、RAII类、容器存储等自动管理场景
+5. 排除NOPROTECT标记场景
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：手动管理的资源（内存、句柄、锁）
+- **RISK_TYPE**：资源泄漏
+- **RISK_PATH**：资源分配 → 异常分支提前退出 → 跳过释放 → 资源累积泄漏 → OOM/资源耗尽/死锁
+- **IMPACT_POINT**：系统资源耗尽，服务不可用，系统崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：异常条件触发分支退出，跳过资源释放代码
+- **Propagation**：分配的资源成为孤儿资源，无法被释放，累积占用系统资源
+- **Consequence**：内存泄漏导致OOM，句柄泄漏导致资源耗尽，锁未释放导致死锁
+- **Mitigation**：使用RAII智能指针、锁守卫、文件流等自动管理资源
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 使用智能指针 | unique_ptr/shared_ptr/make_unique | 不报 |
+| 使用RAII类 | ifstream/ofstream/lock_guard | 不报 |
+| 存入容器 | vector/push_back/insert | 不报 |
+| 赋值给成员变量 | this->/m_xxx | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| 全局/静态变量 | static/global | 不报 |
+| 测试代码 | 文件名包含 _test.cpp | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_MemoryStability_004_trigger.cpp
+#include <cstdlib>
+#include <cstdio>
+#include <dlfcn.h>
+#include <pthread.h>
+
+void trigger_bad_1(Request* req)
+{
+    char* buffer = (char*)malloc(1024);
+    if (req == nullptr) {
+        return;  // 应该报：malloc后提前return未释放
+    }
+    free(buffer);
+}
+
+void trigger_bad_2(const char* path, Config* config)
+{
+    FILE* file = fopen(path, "r");
+    if (!ValidateConfig(config)) {
+        return;  // 应该报：fopen后提前return未关闭
+    }
+    fclose(file);
+}
+
+void trigger_bad_3(pthread_mutex_t* mutex)
+{
+    pthread_mutex_lock(mutex);
+    if (condition) {
+        return;  // 应该报：锁未释放
+    }
+    pthread_mutex_unlock(mutex);
+}
+
+void* trigger_bad_4(const char* libPath)
+{
+    void* handle = dlopen(libPath, RTLD_NOW);
+    if (!condition) {
+        return nullptr;  // 应该报：dlopen后未关闭
+    }
+    dlclose(handle);
+    return nullptr;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_MemoryStability_004_safe.cpp
+#include <cstdlib>
+#include <memory>
+#include <fstream>
+#include <mutex>
+
+void safe_good_1(Request* req)
+{
+    std::unique_ptr<char[]> buffer = std::make_unique<char[]>(1024);
+    if (req == nullptr) {
+        return;  // 安全：智能指针自动释放
+    }
+}
+
+void safe_good_2(const char* path)
+{
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        return;  // 安全：ifstream自动关闭
+    }
+}
+
+void safe_good_3(pthread_mutex_t* mutex)
+{
+    std::lock_guard<std::mutex> lock(*mutex);
+    if (condition) {
+        return;  // 安全：lock_guard自动释放
+    }
+}
+
+void safe_good_4(int* temp)
+{
+    int result = 0;
+    
+    do {
+        if (condition) {
+            result = -1;
+            break;  // 安全：跳转到统一释放点
+        }
+    } while (0);
+    
+    delete[] temp;
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case()
+{
+    char* buffer = (char*)malloc(1024);
+    if (condition) {
+        return;  // NOPROTECT标记，不报
+    }
+    free(buffer);
+}
+```