Linux C程序Tab补全：遍历目录找可执行文件报错排查

嘿，我看了你的代码和运行输出，马上就发现了几个关键问题，咱们一步步来解决：

问题根源分析 #

从你的运行输出能明显看到，程序在遍历PATH路径时，把各个路径段错误地拼接在一起了——比如第一个PATH段是/home/user/bin，下一个是/usr/sbin，结果程序拼成了/home/user/bin/usr/sbin，这肯定不存在啊！最后还因为strtok返回NULL后依然去拼接，直接触发了段错误。除此之外，代码还有几个其他问题：

• filesCatch每次被调用都会重新mallocfiles，完全没有内存管理的意识，会造成内存泄漏
• 没有筛选可执行文件，只是把目录下所有文件都列出来了
• 不符合readline补全函数的状态机逻辑（state参数完全没用到，每次调用都重新遍历，没法逐个返回匹配项）

修复后的完整代码 #

#include "header.h"
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <stdio.h>

// 全局变量保存遍历状态和结果，避免每次调用重新遍历
char **files = NULL;
size_t file_count = 0;
size_t file_capacity = 0;
size_t current_index = 0;
char **path_list = NULL;
size_t path_count = 0;
size_t path_capacity = 0;

// 释放全局资源
void cleanup_resources() {
    if (files) {
        for (size_t i = 0; i < file_count; i++) {
            free(files[i]);
        }
        free(files);
    }
    if (path_list) {
        for (size_t i = 0; i < path_count; i++) {
            free(path_list[i]);
        }
        free(path_list);
    }
}

// 拆分PATH环境变量为独立路径数组
void split_path() {
    char *path_env = getenv("PATH");
    if (!path_env) return;

    char *path_copy = strdup(path_env);
    char *token = strtok(path_copy, ":");
    while (token) {
        // 扩容路径数组
        if (path_count >= path_capacity) {
            path_capacity = path_capacity == 0 ? 10 : path_capacity * 2;
            path_list = realloc(path_list, path_capacity * sizeof(char *));
        }
        path_list[path_count++] = strdup(token);
        token = strtok(NULL, ":");
    }
    free(path_copy);
}

// 检查文件是否为可执行文件
int is_executable(const char *path) {
    struct stat st;
    if (stat(path, &st) != 0) return 0;
    // 检查是否为普通文件，且拥有可执行权限（用户、组、其他任意一个）
    return (S_ISREG(st.st_mode)) && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH));
}

// 遍历单个目录，收集可执行文件
void collect_executables(const char *dir_path) {
    DIR *dir = opendir(dir_path);
    if (!dir) {
        // 忽略无法打开的目录，比如权限不足或者不存在的路径
        return;
    }

    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        // 跳过.和..
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }

        // 构建完整文件路径
        char full_path[1024];
        snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);

        // 检查是否为可执行文件
        if (is_executable(full_path)) {
            // 动态扩容文件数组
            if (file_count >= file_capacity) {
                file_capacity = file_capacity == 0 ? 10 : file_capacity * 2;
                files = realloc(files, file_capacity * sizeof(char *));
            }
            files[file_count++] = strdup(entry->d_name);
        }
    }
    closedir(dir);
}

char *filesCatch(const char *text, int state) {
    // 第一次调用（state=0）时初始化，收集所有可执行文件
    if (state == 0) {
        // 清理之前的资源
        cleanup_resources();
        file_count = 0;
        file_capacity = 0;
        current_index = 0;
        path_count = 0;
        path_capacity = 0;

        // 拆分PATH路径
        split_path();

        // 遍历所有PATH路径，收集可执行文件
        for (size_t i = 0; i < path_count; i++) {
            collect_executables(path_list[i]);
        }
    }

    // 逐个返回匹配的文件（匹配text开头的项）
    while (current_index < file_count) {
        char *file = files[current_index++];
        if (strstr(file, text) == file) { // 前缀匹配
            return strdup(file);
        }
        free(file); // 不匹配的直接释放
    }

    // 所有项都处理完了
    cleanup_resources();
    return NULL;
}

char **tabActivation(const char *text, int start, int end) {
    rl_attempted_completion_over = 1;
    return rl_completion_matches(text, filesCatch);
}

int main(int argc, const char *argv[]) {
    char *line;
    rl_attempted_completion_function = tabActivation;

    // 注册退出时的资源清理
    atexit(cleanup_resources);

    while (1) {
        line = readline("msh$ ");
        if (line == NULL) {
            perror("readline error");
            exit(EXIT_FAILURE);
        }
        if (strcmp(line, "exit") == 0) {
            free(line);
            exit(EXIT_SUCCESS);
        }
        if (strlen(line) == 0) {
            free(line);
            continue;
        }
        add_history(line);
        CMD *root = parse_line(line);
        print_command_list(root);
        free_command_list(root);
        free(line);
    }
}

关键修复点说明 #

1. 修复PATH遍历逻辑：

   • 用strdup复制PATH环境变量，然后逐个拆分出独立路径，不再错误拼接
   • 每个PATH路径单独处理，直接遍历该路径下的文件

2. 实现状态机逻辑：

   • 利用state参数，第一次调用时收集所有可执行文件，后续调用逐个返回匹配项
   • 避免每次TAB都重新遍历所有路径，提升效率

3. 内存管理：

   • 添加cleanup_resources函数，负责释放所有动态分配的内存
   • 注册atexit确保程序退出时自动清理资源，避免内存泄漏
   • 动态数组采用扩容策略（初始10个，满了就翻倍），避免固定大小限制

4. 筛选可执行文件：

   • 使用stat检查文件类型（普通文件）和可执行权限
   • 跳过.和..目录，避免无效项

5. 避免段错误：

   • 处理strtok的边界情况，拆分PATH时确保不会访问空指针
   • 所有动态分配的内存都有对应的释放逻辑

现在你编译运行这个代码，应该就能正常实现TAB补全可执行文件的功能，不会再出现路径错误和段错误了！

内容的提问来源于stack exchange，提问作者CodeOnce