Статический ИИ-анализ: устранение утечек памяти в C с помощью DeepCode

void process_transaction(char* data) {
    char* copy = (char*)malloc(strlen(data) + 1);
    strcpy(copy, data);
    
    if (validate_data(copy)) {
        // А вот и наш злодей - забытый free(copy)
        return;
    }
    
    free(copy);
}

char* create_string() {
    char* str = malloc(100);
    return str;  // Передаем ответственность за память вызывающему коду
}
 
void process() {
    char* data = create_string();
    // Теперь наша ответственность освободить память
}

int process_file(const char* path) {
    FILE* f = fopen(path, "r");
    if (!f) return ERROR_OPEN;
    
    char* buffer = malloc(1024);
    if (!buffer) {
        fclose(f);  // Правильно закрываем файл
        return ERROR_MEMORY;
    }
    
    if (fread(buffer, 1, 1024, f) < 10) {
        fclose(f);
        // Упс, забыли free(buffer)
        return ERROR_READ;
    }
    
    // Обрабатываем данные...
    free(buffer);
    fclose(f);
    return SUCCESS;
}

void conditional_leak(int* data, size_t size, int threshold) {
char* buffer = malloc(1024);
if (!buffer) return;
 
process_data(buffer, data, size);
 
if (compute_checksum(data, size) > threshold) {
    // Здесь memory_manager_register может не вызваться из-за ошибки
    if (!prepare_for_storage(buffer)) {
        // Утечка: мы забыли free(buffer) при ошибке подготовки
        return;
    }
    memory_manager_register(buffer);
    return;
}
 
// Нормальный путь выполнения
free(buffer);
}

char* get_formatted_data() {
char* data = malloc(1024);
if (!data) return NULL;
// Заполняем данные...
return data;  // Передаем владение вызывающей стороне
}
 
void process_request(Request* req) {
char* data = get_formatted_data();
if (validate_request(req)) {
    send_response(req, data);
    // Функция send_response не освобождает память,
    // но мы забыли сделать free(data) здесь
    return;
}
free(data);  // Освобождаем только в случае ошибки валидации
}

void* worker_thread(void* arg) {
WorkerContext* ctx = (WorkerContext*)arg;
Resource* res = allocate_resource();
 
pthread_mutex_lock(&ctx->mutex);
if (ctx->shutdown_requested) {
    pthread_mutex_unlock(&ctx->mutex);
    // Упс, забыли освободить ресурс при запросе завершения
    return NULL;
}
pthread_mutex_unlock(&ctx->mutex);
 
// Используем ресурс...
free_resource(res);
return NULL;
}

int initialize_subsystem() {
void* module1 = init_module1();
if (!module1) return ERROR;
 
void* module2 = init_module2();
if (!module2) {
    // Забыли cleanup_module1(module1)
    return ERROR;
}
 
// ... и так далее
return SUCCESS;
}

typedef struct {
char* key;
char* value;
} KeyValuePair;
 
KeyValuePair* parse_json_property(const char* json) {
KeyValuePair* pair = malloc(sizeof(KeyValuePair));
if (!pair) return NULL;
 
// Извлекаем ключ
char* key_start = strchr(json, '"');
if (!key_start) return NULL; // Утечка: pair не освобождается
 
char* key_end = strchr(key_start + 1, '"');
if (!key_end) return NULL; // Утечка: pair не освобождается
 
int key_length = key_end - key_start - 1;
pair->key = malloc(key_length + 1);
if (!pair->key) {
    free(pair);
    return NULL;
}
memcpy(pair->key, key_start + 1, key_length);
pair->key[key_length] = '\0';
 
// Извлекаем значение
char* value_start = strchr(key_end + 1, '"');
if (!value_start) {
    free(pair->key); // Ключ освобождается корректно
    free(pair);      // Пара освобождается корректно
    return NULL;
}
 
char* value_end = strchr(value_start + 1, '"');
if (!value_end) return NULL; // Утечка: pair->key и pair не освобождаются
 
int value_length = value_end - value_start - 1;
pair->value = malloc(value_length + 1);
// Отсутствует проверка на NULL для pair->value
 
memcpy(pair->value, value_start + 1, value_length);
pair->value[value_length] = '\0';
 
return pair;
}

typedef struct {
char* key;
char* value;
} KeyValuePair;
 
KeyValuePair* parse_json_property(const char* json) {
KeyValuePair* pair = malloc(sizeof(KeyValuePair));
if (!pair) return NULL;
 
// Инициализируем нулями для безопасной очистки
pair->key = NULL;
pair->value = NULL;
 
// Извлекаем ключ
char* key_start = strchr(json, '"');
if (!key_start) {
    free(pair); // Исправлено: освобождаем pair
    return NULL;
}
 
char* key_end = strchr(key_start + 1, '"');
if (!key_end) {
    free(pair); // Исправлено: освобождаем pair
    return NULL;
}
 
int key_length = key_end - key_start - 1;
pair->key = malloc(key_length + 1);
if (!pair->key) {
    free(pair);
    return NULL;
}
memcpy(pair->key, key_start + 1, key_length);
pair->key[key_length] = '\0';
 
// Извлекаем значение
char* value_start = strchr(key_end + 1, '"');
if (!value_start) {
    free(pair->key);
    free(pair);
    return NULL;
}
 
char* value_end = strchr(value_start + 1, '"');
if (!value_end) {
    free(pair->key); // Исправлено: освобождаем key
    free(pair);      // Исправлено: освобождаем pair
    return NULL;
}
 
int value_length = value_end - value_start - 1;
pair->value = malloc(value_length + 1);
if (!pair->value) {  // Исправлено: добавлена проверка
    free(pair->key);
    free(pair);
    return NULL;
}
 
memcpy(pair->value, value_start + 1, value_length);
pair->value[value_length] = '\0';
 
return pair;
}

typedef struct NodeA {
struct NodeB* ref;
// другие поля...
} NodeA;
 
typedef struct NodeB {
struct NodeA* ref;
// другие поля...
} NodeB;
 
void create_cycle() {
NodeA* a = malloc(sizeof(NodeA));
NodeB* b = malloc(sizeof(NodeB));
a->ref = b;
b->ref = a;
// Кто должен освобождать память?
// Если освободить a, то b->ref станет висячим указателем
// Если освободить b, то a->ref станет висячим указателем
}

void* worker(void* arg) {
ThreadContext* ctx = (ThreadContext*)arg;
Resource* res = allocate_resource();
 
pthread_mutex_lock(&ctx->mutex);
if (ctx->should_terminate) {
pthread_mutex_unlock(&ctx->mutex);
// Забыли free(res) при завершении
return NULL;
}
ctx->resources[ctx->count++] = res;
pthread_mutex_unlock(&ctx->mutex);
 
// Продолжаем работу...
return NULL;
}

typedef struct {
int ref_count;
void (*destroy)(void*);
// данные...
} SharedObject;
 
SharedObject* shared_create(size_t size, void (*destroy_fn)(void*)) {
SharedObject* obj = malloc(size);
if (!obj) return NULL;
obj->ref_count = 1;
obj->destroy = destroy_fn;
return obj;
}
 
void shared_acquire(SharedObject* obj) {
if (obj) obj->ref_count++;
}
 
void shared_release(SharedObject* obj) {
if (!obj) return;
if (--obj->ref_count == 0) {
    if (obj->destroy) obj->destroy(obj);
    free(obj);
}
}

void complex_operation(SharedObject* obj) {
if (condition1()) {
    shared_acquire(obj);
    if (condition2()) {
        // обработка...
        shared_release(obj);
        return;
    }
    // Упс, забыли shared_release(obj) здесь при !condition2()
}
// продолжение кода...
}

Buffer* get_buffer(int type, size_t size) {
Buffer* buf;
if (type == TEMP_BUFFER) {
    buf = temp_pool_get(size);
    if (!buf) buf = malloc(size + BUFFER_HEADER);
    buf->flags = TEMP_FLAG;
} else if (type == PERSISTENT_BUFFER) {
    buf = persistent_pool_get(size);
    if (!buf) buf = malloc(size + BUFFER_HEADER);
    buf->flags = PERSISTENT_FLAG;
} else {
    buf = malloc(size + BUFFER_HEADER);
    buf->flags = NORMAL_FLAG;
}
return buf;
}
 
void release_buffer(Buffer* buf) {
if (!buf) return;
if (buf->flags & TEMP_FLAG) {
    temp_pool_release(buf);
} else if (buf->flags & PERSISTENT_FLAG) {
    persistent_pool_release(buf);
} else {
    free(buf);
}
}

void* temp_alloc(size_t size) {
static __thread char* buffer = NULL;
static __thread size_t remaining = 0;
static __thread size_t total = 0;
 
// Первый вызов или буфер недостаточного размера
if (!buffer || remaining < size) {
    // Размер нового буфера - максимум из запрошенного и PAGE_SIZE
    size_t alloc_size = size > PAGE_SIZE ? size : PAGE_SIZE;
    buffer = malloc(alloc_size);
    if (!buffer) return NULL;
    remaining = alloc_size;
    total += alloc_size;
    
    // Если общий размер слишком велик, попробуем освободить старые буферы
    if (total > MAX_THREAD_HEAP) {
        // Какая-то логика очистки...
    }
}
 
void* result = buffer;
buffer += size;
remaining -= size;
return result;
}

int complex_initialization() {
Resource1* r1 = init_resource1();
if (!r1) goto error_r1;
 
Resource2* r2 = init_resource2();
if (!r2) goto error_r2;
 
Resource3* r3 = init_resource3();
if (!r3) goto error_r3;
 
// Успешная инициализация
return SUCCESS;
 
error_r3:
cleanup_resource2(r2);
error_r2:
cleanup_resource1(r1);
error_r1:
return ERROR;
}

int process_batch(Batch* items, size_t count) {
for (size_t i = 0; i < count; i++) {
    void* data = process_item(&items[i]);
    if (!data) {
        // При ошибке обработки просто пропускаем элемент
        continue;
    }
    
    // Регистрируем результат
    if (!register_result(data)) {
        // Упс, забыли free(data) при ошибке регистрации
        return ERROR;
    }
}
return SUCCESS;
}

char* process_config_value(const char* line) {
// Пропускаем пробелы
while (*line && isspace(*line)) line++;
if (!*line || *line == '#') return NULL; // Комментарий или пустая строка
 
// Ищем '='
const char* eq = strchr(line, '=');
if (!eq) return NULL; // Неверный формат
 
// Выделяем память под результат
char* result = malloc(strlen(line) + 1);
if (!result) return NULL;
 
// Копируем имя и значение
strncpy(result, line, eq - line);
result[eq - line] = '\0';
 
// Очищаем пробелы в конце имени
char* end = result + (eq - line) - 1;
while (end >= result && isspace(*end)) *end-- = '\0';
 
// Если имя пустое, возвращаем ошибку
if (!*result) {
free(result);
return NULL;
}
 
// И так далее с обработкой значения...
return result;
}

// deepcode:ignore:memory_leak - custom ring buffer with atomic ownership transfer
void* get_next_slot(RingBuffer* rb) {
    size_t idx = atomic_fetch_add(&rb->write_idx, 1) % rb->capacity;
    return rb->slots + (idx * rb->slot_size);
}

// Пул преаллоцированных буферов для реалтайм-обработки
struct BufferPool {
    void* buffers[MAX_BUFFERS];
    int used[MAX_BUFFERS];
    // ...
};
 
// DeepCode часто не понимает, что это не утечка
void* rt_alloc(BufferPool* pool, size_t size) {
    for (int i = 0; i < MAX_BUFFERS; i++) {
        if (!pool->used[i]) {
            pool->used[i] = 1;
            return pool->buffers[i];
        }
    }
    return NULL; // Никаких fallback на malloc!
}