#include <sys/stat.h> // 必需

int chmod(const char *pathname, mode_t mode);

#include <sys/stat.h>  // chmod, stat, struct stat
#include <stdio.h>     // perror, printf
#include <stdlib.h>    // exit
#include <errno.h>     // errno
#include <string.h>    // strerror

// 辅助函数：将 mode_t 转换为可读的权限字符串
void print_permissions(mode_t mode) {
    char perms&#91;11];
    // 初始化字符数组
    strcpy(perms, "----------");

    // 用户权限
    if (mode & S_IRUSR) perms&#91;1] = 'r';
    if (mode & S_IWUSR) perms&#91;2] = 'w';
    if (mode & S_IXUSR) perms&#91;3] = 'x';

    // 组权限
    if (mode & S_IRGRP) perms&#91;4] = 'r';
    if (mode & S_IWGRP) perms&#91;5] = 'w';
    if (mode & S_IXGRP) perms&#91;6] = 'x';

    // 其他用户权限
    if (mode & S_IROTH) perms&#91;7] = 'r';
    if (mode & S_IWOTH) perms&#91;8] = 'w';
    if (mode & S_IXOTH) perms&#91;9] = 'x';

    // 特殊位
    if (mode & S_ISUID) perms&#91;3] = (perms&#91;3] == 'x') ? 's' : 'S';
    if (mode & S_ISGID) perms&#91;6] = (perms&#91;6] == 'x') ? 's' : 'S';
    if (mode & S_ISVTX) perms&#91;9] = (perms&#91;9] == 'x') ? 't' : 'T';

    printf("%s", perms);
}

// 辅助函数：打印文件的详细信息
void print_file_info(const char *pathname) {
    struct stat sb;
    if (stat(pathname, &sb) == -1) {
        perror("stat");
        return;
    }

    printf("文件 '%s' 的信息:\n", pathname);
    printf("  Inode: %ld\n", sb.st_ino);
    printf("  权限: ", pathname);
    print_permissions(sb.st_mode);
    printf(" (八进制: %o)\n", sb.st_mode & 0777);
    printf("  大小: %ld 字节\n", sb.st_size);
}

int main(int argc, char *argv&#91;]) {
    if (argc != 3) {
        fprintf(stderr, "用法: %s <文件路径> <新权限>\n", argv&#91;0]);
        fprintf(stderr, "      权限可以是八进制 (如 0644) 或符号 (如 u+r)\n");
        fprintf(stderr, "      示例: %s myfile.txt 0644\n", argv&#91;0]);
        fprintf(stderr, "            %s script.sh 0755\n", argv&#91;0]);
        exit(EXIT_FAILURE);
    }

    const char *pathname = argv&#91;1];
    const char *mode_str = argv&#91;2];

    printf("准备更改文件 '%s' 的权限\n", pathname);

    // 打印更改前的信息
    print_file_info(pathname);

    // 解析权限模式
    mode_t new_mode;
    char *endptr;

    // 尝试解析为八进制数
    new_mode = (mode_t) strtol(mode_str, &endptr, 8);
    if (*endptr != '\0') {
        fprintf(stderr, "错误: 不支持的权限格式 '%s'。请使用八进制数（如 0644）。\n", mode_str);
        exit(EXIT_FAILURE);
    }

    printf("\n新的权限模式: ");
    print_permissions(new_mode);
    printf(" (八进制: %o)\n", new_mode);

    // 执行 chmod 操作
    if (chmod(pathname, new_mode) == -1) {
        perror("chmod 失败");
        exit(EXIT_FAILURE);
    }

    printf("\nchmod 操作成功!\n");

    // 打印更改后的信息
    print_file_info(pathname);

    return 0;
}

#define _GNU_SOURCE
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <fnmatch.h> // 用于模式匹配

// 递归更改目录下匹配模式的文件权限
int change_permissions_recursive(const char *dir_path, const char *pattern, mode_t mode, int verbose) {
    DIR *dir;
    struct dirent *entry;
    char full_path&#91;1024];
    int changed_count = 0;
    int error_count = 0;

    dir = opendir(dir_path);
    if (!dir) {
        fprintf(stderr, "无法打开目录 '%s': %s\n", dir_path, strerror(errno));
        return -1;
    }

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

        // 构造完整路径
        snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);

        // 检查是否匹配模式
        if (fnmatch(pattern, entry->d_name, 0) == 0) {
            // 匹配，尝试更改权限
            if (chmod(full_path, mode) == -1) {
                fprintf(stderr, "警告: 无法更改 '%s' 的权限: %s\n", full_path, strerror(errno));
                error_count++;
            } else {
                if (verbose) {
                    printf("已更改 '%s' 的权限\n", full_path);
                }
                changed_count++;
            }
        }

        // 如果是目录，则递归处理
        struct stat sb;
        if (stat(full_path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
            int sub_result = change_permissions_recursive(full_path, pattern, mode, verbose);
            if (sub_result >= 0) {
                changed_count += sub_result;
            } else {
                error_count++;
            }
        }
    }

    closedir(dir);
    
    if (error_count > 0) {
        return -1;
    }
    return changed_count;
}

// 打印权限更改的摘要
void print_mode_summary(mode_t mode) {
    printf("权限设置为: ");
    // 用户权限
    printf((mode & S_IRUSR) ? "r" : "-");
    printf((mode & S_IWUSR) ? "w" : "-");
    printf((mode & S_IXUSR) ? "x" : "-");
    // 组权限
    printf((mode & S_IRGRP) ? "r" : "-");
    printf((mode & S_IWGRP) ? "w" : "-");
    printf((mode & S_IXGRP) ? "x" : "-");
    // 其他用户权限
    printf((mode & S_IROTH) ? "r" : "-");
    printf((mode & S_IWOTH) ? "w" : "-");
    printf((mode & S_IXOTH) ? "x" : "-");
    printf(" (八进制: %04o)\n", mode);
}

int main(int argc, char *argv&#91;]) {
    if (argc < 4) {
        fprintf(stderr, "用法: %s <目录路径> <文件模式> <权限> &#91;-r] &#91;-v] &#91;-p pattern]\n", argv&#91;0]);
        fprintf(stderr, "      -r: 递归处理子目录\n");
        fprintf(stderr, "      -v: 详细输出\n");
        fprintf(stderr, "      -p pattern: 只处理匹配模式的文件 (支持通配符)\n");
        fprintf(stderr, "      示例: %s /home/user *.txt 0644 -r -v\n", argv&#91;0]);
        fprintf(stderr, "            %s /var/log 0600 -p \"*.log\"\n", argv&#91;0]);
        exit(EXIT_FAILURE);
    }

    const char *dir_path = argv&#91;1];
    const char *pattern = argv&#91;2];
    const char *mode_str = argv&#91;3];
    int recursive = 0;
    int verbose = 0;
    const char *file_pattern = "*"; // 默认匹配所有文件

    // 解析选项
    for (int i = 4; i < argc; i++) {
        if (strcmp(argv&#91;i], "-r") == 0) {
            recursive = 1;
        } else if (strcmp(argv&#91;i], "-v") == 0) {
            verbose = 1;
        } else if (strcmp(argv&#91;i], "-p") == 0 && i + 1 < argc) {
            file_pattern = argv&#91;++i];
        } else {
            fprintf(stderr, "未知选项: %s\n", argv&#91;i]);
            exit(EXIT_FAILURE);
        }
    }

    // 解析权限模式
    mode_t mode;
    char *endptr;
    mode = (mode_t) strtol(mode_str, &endptr, 8);
    if (*endptr != '\0') {
        fprintf(stderr, "错误: 无效的权限模式 '%s'。请使用八进制数（如 0644）。\n", mode_str);
        exit(EXIT_FAILURE);
    }

    printf("=== 批量权限更改工具 ===\n");
    printf("目录: %s\n", dir_path);
    printf("文件模式: %s\n", pattern);
    printf("文件名匹配: %s\n", file_pattern);
    print_mode_summary(mode);
    printf("递归: %s\n", recursive ? "是" : "否");
    printf("详细输出: %s\n", verbose ? "是" : "否");

    // 执行权限更改
    int result;
    if (recursive) {
        result = change_permissions_recursive(dir_path, file_pattern, mode, verbose);
    } else {
        // 非递归处理
        DIR *dir = opendir(dir_path);
        if (!dir) {
            perror("opendir");
            exit(EXIT_FAILURE);
        }
        
        struct dirent *entry;
        char full_path&#91;1024];
        int changed_count = 0;
        int error_count = 0;
        
        while ((entry = readdir(dir)) != NULL) {
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
                continue;
            }
            
            // 检查文件名是否匹配模式
            if (fnmatch(pattern, entry->d_name, 0) == 0) {
                // 检查文件名是否匹配文件模式
                if (fnmatch(file_pattern, entry->d_name, 0) == 0) {
                    snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);
                    if (chmod(full_path, mode) == -1) {
                        fprintf(stderr, "警告: 无法更改 '%s' 的权限: %s\n", full_path, strerror(errno));
                        error_count++;
                    } else {
                        if (verbose) {
                            printf("已更改 '%s' 的权限\n", full_path);
                        }
                        changed_count++;
                    }
                }
            }
        }
        closedir(dir);
        
        if (error_count > 0) {
            result = -1;
        } else {
            result = changed_count;
        }
    }

    if (result == -1) {
        fprintf(stderr, "\n权限更改过程中遇到错误。\n");
        exit(EXIT_FAILURE);
    } else {
        printf("\n权限更改完成。成功更改了 %d 个文件的权限。\n", result);
    }

    return 0;
}

#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <pwd.h>
#include <grp.h>

// 创建具有特定权限的测试文件
void create_test_files() {
    printf("=== 创建测试文件 ===\n");
    
    // 1. 创建普通文件
    FILE *fp = fopen("normal_file.txt", "w");
    if (fp) {
        fprintf(fp, "This is a normal file for permission testing.\n");
        fclose(fp);
        printf("创建普通文件: normal_file.txt\n");
    }
    
    // 2. 创建私密文件
    fp = fopen("private_file.txt", "w");
    if (fp) {
        fprintf(fp, "This is a private file containing sensitive data.\n");
        fclose(fp);
        printf("创建私密文件: private_file.txt\n");
    }
    
    // 3. 创建脚本文件
    fp = fopen("test_script.sh", "w");
    if (fp) {
        fprintf(fp, "#!/bin/bash\necho \"This is a test script.\"\n");
        fclose(fp);
        printf("创建脚本文件: test_script.sh\n");
    }
    
    // 4. 创建目录
    if (mkdir("test_directory", 0755) == 0) {
        printf("创建目录: test_directory\n");
    }
    
    printf("\n");
}

// 演示安全的权限设置
void demonstrate_secure_permissions() {
    printf("=== 安全权限设置演示 ===\n");
    
    // 1. 设置普通文件权限 (0644)
    printf("1. 设置普通文件权限为 0644 (rw-r--r--)\n");
    if (chmod("normal_file.txt", 0644) == 0) {
        printf("   成功: normal_file.txt 现在是 rw-r--r--\n");
    } else {
        printf("   失败: %s\n", strerror(errno));
    }
    
    // 2. 设置私密文件权限 (0600)
    printf("2. 设置私密文件权限为 0600 (rw-------)\n");
    if (chmod("private_file.txt", 0600) == 0) {
        printf("   成功: private_file.txt 现在是 rw-------\n");
    } else {
        printf("   失败: %s\n", strerror(errno));
    }
    
    // 3. 设置脚本文件权限 (0755)
    printf("3. 设置脚本文件权限为 0755 (rwxr-xr-x)\n");
    if (chmod("test_script.sh", 0755) == 0) {
        printf("   成功: test_script.sh 现在是 rwxr-xr-x\033&#91;0m\n");
    } else {
        printf("   失败: %s\n", strerror(errno));
    }
    
    // 4. 设置目录权限 (0755)
    printf("4. 设置目录权限为 0755 (rwxr-xr-x)\n");
    if (chmod("test_directory", 0755) == 0) {
        printf("   成功: test_directory 现在是 rwxr-xr-x\033&#91;0m\n");
    } else {
        printf("   失败: %s\n", strerror(errno));
    }
    
    printf("\n");
}

// 演示危险的权限设置
void demonstrate_dangerous_permissions() {
    printf("=== 危险权限设置警告 ===\n");
    
    printf("以下权限设置可能存在安全风险:\n");
    
    // 1. 世界可写的文件
    printf("1. 世界可写的普通文件 (0666)\n");
    printf("   风险: 任何用户都可以修改文件内容\n");
    printf("   建议: 使用 0644 代替\n");
    
    // 2. 世界可执行的文件
    printf("2. 世界可执行的敏感脚本 (0777)\n");
    printf("   风险: 任何用户都可以执行，可能存在安全漏洞\n");
    printf("   建议: 使用 0755 并确保脚本安全\n");
    
    // 3. 私密文件设置不当
    printf("3. 私密文件权限过于宽松 (0644)\n");
    printf("   风险: 组用户和其他用户可以读取私密信息\n");
    printf("   建议: 使用 0600 确保只有所有者可访问\n");
    
    printf("\n");
}

// 演示权限检查
void demonstrate_permission_checking() {
    printf("=== 权限检查最佳实践 ===\n");
    
    struct stat sb;
    
    // 检查私密文件权限
    if (stat("private_file.txt", &sb) == 0) {
        mode_t mode = sb.st_mode & 0777;
        printf("检查 private_file.txt 当前权限: %04o\n", mode);
        
        if (mode == 0600) {
            printf("✓ 权限设置正确，只有所有者可读写\n");
        } else if (mode & (S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) {
            printf("✗ 警告: 权限过于宽松，组用户或其他用户有访问权限\n");
        } else {
            printf("- 权限设置合理\n");
        }
    }
    
    // 检查脚本文件权限
    if (stat("test_script.sh", &sb) == 0) {
        mode_t mode = sb.st_mode & 0777;
        printf("检查 test_script.sh 当前权限: %04o\n", mode);
        
        if (mode & S_IXUSR) {
            printf("✓ 所有者有执行权限\n");
        } else {
            printf("✗ 所有者没有执行权限，脚本可能无法运行\n");
        }
    }
    
    printf("\n");
}

// 清理测试文件
void cleanup_test_files() {
    printf("=== 清理测试文件 ===\n");
    unlink("normal_file.txt");
    unlink("private_file.txt");
    unlink("test_script.sh");
    rmdir("test_directory");
    printf("清理完成\n");
}

int main() {
    printf("当前用户: UID=%d, GID=%d\n", getuid(), getgid());
    printf("\n");
    
    // 创建测试文件
    create_test_files();
    
    // 演示安全权限设置
    demonstrate_secure_permissions();
    
    // 演示危险权限设置
    demonstrate_dangerous_permissions();
    
    // 演示权限检查
    demonstrate_permission_checking();
    
    // 清理
    cleanup_test_files();
    
    printf("\n=== 权限设置最佳实践总结 ===\n");
    printf("普通文件: 0644 (rw-r--r--)\n");
    printf("私密文件: 0600 (rw-------)\n");
    printf("可执行文件: 0755 (rwxr-xr-x)\n");
    printf("私密可执行文件: 0700 (rwx------)\n");
    printf("目录: 0755 (rwxr-xr-x)\n");
    printf("私密目录: 0700 (rwx------)\n");
    printf("\n安全建议:\n");
    printf("1. 遵循最小权限原则\n");
    printf("2. 定期检查重要文件的权限\n");
    printf("3. 避免使用 0777 或 0666 等过于宽松的权限\n");
    printf("4. 对于敏感文件，使用 0600 或 0700\n");
    printf("5. 理解权限位的含义，避免误操作\n");
    
    return 0;
}

# 编译示例
gcc -o chmod_example1 chmod_example1.c
gcc -o chmod_example2 chmod_example2.c -lpthread
gcc -o chmod_example3 chmod_example3.c

# 运行示例
# 示例1: 基本用法
touch testfile.txt
./chmod_example1 testfile.txt 0644
./chmod_example1 script.sh 0755

# 示例2: 批量处理
mkdir testdir
touch testdir/file1.txt testdir/file2.log
./chmod_example2 testdir "*.txt" 0644 -r -v

# 示例3: 安全演示
./chmod_example3

#include <unistd.h> // 必需

int chown(const char *pathname, uid_t owner, gid_t group);

#include <unistd.h>     // chown
#include <stdio.h>      // perror, printf
#include <stdlib.h>     // exit
#include <sys/stat.h>   // struct stat, stat
#include <pwd.h>        // getpwuid
#include <grp.h>        // getgrgid
#include <errno.h>      // errno
#include <string.h>     // strerror

// 辅助函数：打印文件的当前所有权
void print_file_owner(const char *pathname) {
    struct stat sb;
    if (stat(pathname, &sb) == -1) {
        perror("stat");
        return;
    }

    struct passwd *pw = getpwuid(sb.st_uid);
    struct group  *gr = getgrgid(sb.st_gid);

    printf("文件 '%s' 的当前所有权:\n", pathname);
    printf("  UID: %d", sb.st_uid);
    if (pw) {
        printf(" (用户: %s)", pw->pw_name);
    }
    printf("\n");

    printf("  GID: %d", sb.st_gid);
    if (gr) {
        printf(" (组: %s)", gr->gr_name);
    }
    printf("\n");
}

int main(int argc, char *argv&#91;]) {
    if (argc != 4) {
        fprintf(stderr, "用法: %s <文件路径> <新UID> <新GID>\n", argv&#91;0]);
        fprintf(stderr, "      使用 -1 表示不更改相应的ID。\n");
        fprintf(stderr, "      示例: %s myfile.txt 1000 1000\n", argv&#91;0]);
        fprintf(stderr, "            %s myfile.txt -1 1000  (仅更改组)\n", argv&#91;0]);
        exit(EXIT_FAILURE);
    }

    const char *pathname = argv&#91;1];
    uid_t new_uid;
    gid_t new_gid;

    // 解析 UID 和 GID 参数
    if (strcmp(argv&#91;2], "-1") == 0) {
        new_uid = (uid_t) -1; // 不更改 UID
    } else {
        new_uid = (uid_t) atoi(argv&#91;2]);
    }

    if (strcmp(argv&#91;3], "-1") == 0) {
        new_gid = (gid_t) -1; // 不更改 GID
    } else {
        new_gid = (gid_t) atoi(argv&#91;3]);
    }

    printf("准备更改文件 '%s' 的所有权:\n", pathname);
    printf("  新 UID: %d (不更改则为-1)\n", (int)new_uid);
    printf("  新 GID: %d (不更改则为-1)\n", (int)new_gid);

    // 打印更改前的所有权
    print_file_owner(pathname);

    // 执行 chown 操作
    if (chown(pathname, new_uid, new_gid) == -1) {
        perror("chown 失败");
        exit(EXIT_FAILURE);
    }

    printf("\nchown 操作成功!\n");

    // 打印更改后的所有权
    print_file_owner(pathname);

    return 0;
}

#define _GNU_SOURCE // 为了使用一些 GNU 扩展
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h> // 用于遍历目录

// 检查当前用户是否为 root (UID 0)
int is_root() {
    return (geteuid() == 0);
}

// 递归更改目录下所有文件的所有权
int change_ownership_recursive(const char *dir_path, uid_t uid, gid_t gid) {
    DIR *dir;
    struct dirent *entry;
    char full_path&#91;1024];

    dir = opendir(dir_path);
    if (!dir) {
        perror("opendir");
        return -1;
    }

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

        // 构造完整路径
        snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);

        // 更改当前文件/目录的所有权
        if (chown(full_path, uid, gid) == -1) {
            fprintf(stderr, "警告: 无法更改 '%s' 的所有权: %s\n", full_path, strerror(errno));
            // 不要因为单个文件失败而停止整个过程
        } else {
            printf("已更改 '%s' 的所有权\n", full_path);
        }

        // 如果是目录，则递归处理
        struct stat sb;
        if (stat(full_path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
            change_ownership_recursive(full_path, uid, gid);
        }
    }

    closedir(dir);
    return 0;
}

int main(int argc, char *argv&#91;]) {
    if (argc < 4) {
        fprintf(stderr, "用法: %s <目录路径> <用户名或UID> <组名或GID> &#91;-r]\n", argv&#91;0]);
        fprintf(stderr, "      -r: 递归更改子目录中所有文件\n");
        fprintf(stderr, "      使用 -1 表示不更改 UID 或 GID\n");
        fprintf(stderr, "      示例: %s /home/newuser alice developers\n", argv&#91;0]);
        fprintf(stderr, "            %s /data -1 mygroup -r\n", argv&#91;0]);
        exit(EXIT_FAILURE);
    }

    if (!is_root()) {
        fprintf(stderr, "警告: 你可能需要 root 权限来更改文件所有权。\n");
        fprintf(stderr, "当前有效 UID: %d\n", geteuid());
    }

    const char *path = argv&#91;1];
    const char *user_str = argv&#91;2];
    const char *group_str = argv&#91;3];
    int recursive = 0;

    // 检查是否有 -r 标志
    for (int i = 4; i < argc; i++) {
        if (strcmp(argv&#91;i], "-r") == 0) {
            recursive = 1;
            break;
        }
    }

    uid_t uid = (uid_t) -1;
    gid_t gid = (gid_t) -1;

    // 解析用户
    if (strcmp(user_str, "-1") != 0) {
        struct passwd *pw = getpwnam(user_str); // 按用户名查找
        if (pw) {
            uid = pw->pw_uid;
        } else {
            // 尝试按 UID 解析
            char *endptr;
            uid = (uid_t) strtoul(user_str, &endptr, 10);
            if (*endptr != '\0') {
                fprintf(stderr, "错误: 无效的用户名或 UID: %s\n", user_str);
                exit(EXIT_FAILURE);
            }
        }
    }

    // 解析组
    if (strcmp(group_str, "-1") != 0) {
        struct group *gr = getgrnam(group_str); // 按组名查找
        if (gr) {
            gid = gr->gr_gid;
        } else {
            // 尝试按 GID 解析
            char *endptr;
            gid = (gid_t) strtoul(group_str, &endptr, 10);
            if (*endptr != '\0') {
                fprintf(stderr, "错误: 无效的组名或 GID: %s\n", group_str);
                exit(EXIT_FAILURE);
            }
        }
    }

    printf("准备更改 '%s' 的所有权:\n", path);
    printf("  UID: %d (%s)\n", (int)uid, (uid==(uid_t)-1) ? "不更改" : user_str);
    printf("  GID: %d (%s)\n", (int)gid, (gid==(gid_t)-1) ? "不更改" : group_str);
    printf("  递归: %s\n", recursive ? "是" : "否");

    // 执行所有权更改
    int result;
    if (recursive) {
        result = change_ownership_recursive(path, uid, gid);
    } else {
        result = chown(path, uid, gid);
        if (result != -1) {
            printf("已更改 '%s' 的所有权\n", path);
        }
    }

    if (result == -1) {
        perror("chown 失败");
        exit(EXIT_FAILURE);
    }

    printf("所有权更改操作完成。\n");
    return 0;
}

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>

void demonstrate_chown_errors() {
    printf("=== Chown 错误处理演示 ===\n");

    // 1. 尝试更改不存在的文件
    printf("\n1. 尝试更改不存在的文件:\n");
    if (chown("/nonexistent/file.txt", 1000, 1000) == -1) {
        printf("   错误: %s\n", strerror(errno));
        // 通常返回 ENOENT
    }

    // 2. 创建一个测试文件
    const char *test_file = "chown_test.txt";
    FILE *fp = fopen(test_file, "w");
    if (fp) {
        fprintf(fp, "Test file for chown\n");
        fclose(fp);
        printf("\n2. 创建测试文件: %s\n", test_file);
    } else {
        perror("创建测试文件失败");
        return;
    }

    // 3. 非特权用户尝试将文件给其他用户 (通常会失败)
    printf("\n3. 非特权用户尝试将文件所有权转移给其他用户:\n");
    uid_t current_uid = getuid();
    uid_t target_uid = (current_uid == 1000) ? 1001 : 1000; // 假设另一个用户
    
    printf("   当前用户 UID: %d\n", current_uid);
    printf("   尝试更改为 UID: %d\n", target_uid);
    
    if (chown(test_file, target_uid, (gid_t)-1) == -1) {
        printf("   错误: %s\n", strerror(errno));
        if (errno == EPERM) {
            printf("   说明: 非特权用户不能将文件所有权转移给其他用户\n");
        }
    } else {
        printf("   更改成功 (这在非 root 用户下不太可能)\n");
    }

    // 4. 尝试更改只读文件系统上的文件
    printf("\n4. 尝试更改只读文件系统上的文件:\n");
    // 注意：这需要一个实际的只读文件系统挂载点来测试
    // 在 /proc 或 /sys 上尝试通常会返回 EROFS
    if (chown("/proc/version", 0, 0) == -1) {
        printf("   错误: %s\n", strerror(errno));
        if (errno == EROFS) {
            printf("   说明: 不能更改只读文件系统上的文件所有权\n");
        }
    }

    // 5. 正常的组更改（如果可能）
    printf("\n5. 尝试更改文件组所有权:\n");
    gid_t current_gid = getgid();
    printf("   当前组 GID: %d\n", current_gid);
    
    // 尝试更改为自己所在的组（更可能成功）
    if (chown(test_file, (uid_t)-1, current_gid) == -1) {
        printf("   更改组失败: %s\n", strerror(errno));
    } else {
        printf("   组所有权更改成功\n");
    }

    // 清理测试文件
    unlink(test_file);
    printf("\n6. 清理完成\n");
}

int main() {
    printf("当前进程信息:\n");
    printf("  实际 UID: %d\n", getuid());
    printf("  有效 UID: %d\n", geteuid());
    printf("  实际 GID: %d\n", getgid());
    printf("  有效 GID: %d\n", getegid());
    
    demonstrate_chown_errors();
    
    printf("\n=== 总结 ===\n");
    printf("chown 常见错误:\n");
    printf("  EPERM: 权限不足（非 root 用户试图更改所有者）\n");
    printf("  ENOENT: 文件不存在\n");
    printf("  EROFS: 只读文件系统\n");
    printf("  EACCES: 搜索路径被拒绝\n");
    printf("  EIO: I/O 错误\n\n");
    
    printf("权限规则:\n");
    printf("  - Root 用户可以更改任何文件的所有者和组\n");
    printf("  - 普通用户通常只能更改自己拥有的文件的组\n");
    printf("  - 普通用户不能将文件所有权转移给其他用户\n");
    
    return 0;
}

# 编译示例
gcc -o chown_example1 chown_example1.c
gcc -o chown_example2 chown_example2.c
gcc -o chown_example3 chown_example3.c

# 运行示例 (需要适当权限)
# 示例1: 基本用法
touch testfile.txt
./chown_example1 testfile.txt 1000 1000  # 需要 root 权限
./chown_example1 testfile.txt -1 1000    # 可能不需要 root 权限

# 示例2: 系统管理
./chown_example2 /tmp/mydir alice developers -r

# 示例3: 错误处理
./chown_example3

#include <unistd.h>

int chroot(const char *path);

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>

// 创建chroot环境
int create_chroot_environment(const char* chroot_path) {
    printf("创建chroot环境: %s\n", chroot_path);
    
    // 创建根目录
    if (mkdir(chroot_path, 0755) == -1 && errno != EEXIST) {
        perror("创建根目录失败");
        return -1;
    }
    
    // 创建基本目录结构
    const char* dirs&#91;] = {
        "bin", "lib", "lib64", "usr", "etc", "dev", "tmp", "proc"
    };
    
    for (int i = 0; i < 8; i++) {
        char full_path&#91;256];
        snprintf(full_path, sizeof(full_path), "%s/%s", chroot_path, dirs&#91;i]);
        if (mkdir(full_path, 0755) == -1 && errno != EEXIST) {
            perror("创建目录失败");
            return -1;
        }
    }
    
    // 创建基本设备文件（简化版本）
    char dev_path&#91;256];
    snprintf(dev_path, sizeof(dev_path), "%s/dev", chroot_path);
    
    // 创建null设备节点
    char null_path&#91;256];
    snprintf(null_path, sizeof(null_path), "%s/dev/null", chroot_path);
    if (mknod(null_path, S_IFCHR | 0666, makedev(1, 3)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/null失败: %s\n", strerror(errno));
    }
    
    // 创建zero设备节点
    char zero_path&#91;256];
    snprintf(zero_path, sizeof(zero_path), "%s/dev/zero", chroot_path);
    if (mknod(zero_path, S_IFCHR | 0666, makedev(1, 5)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/zero失败: %s\n", strerror(errno));
    }
    
    printf("chroot环境创建完成\n");
    return 0;
}

// 显示当前目录结构
void show_directory_tree(const char* path, int depth) {
    DIR* dir = opendir(path);
    if (dir == NULL) {
        printf("无法打开目录: %s\n", path);
        return;
    }
    
    // 显示缩进
    for (int i = 0; i < depth; i++) {
        printf("  ");
    }
    printf("%s/\n", path);
    
    struct dirent* entry;
    while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }
        
        // 显示文件/目录
        for (int i = 0; i < depth + 1; i++) {
            printf("  ");
        }
        printf("%s%s\n", entry->d_name, 
               entry->d_type == DT_DIR ? "/" : "");
    }
    
    closedir(dir);
}

// 显示文件系统信息
void show_filesystem_info() {
    char cwd&#91;1024];
    if (getcwd(cwd, sizeof(cwd)) != NULL) {
        printf("当前工作目录: %s\n", cwd);
    }
    
    // 显示根目录内容
    printf("根目录内容:\n");
    DIR* root_dir = opendir("/");
    if (root_dir) {
        struct dirent* entry;
        int count = 0;
        while ((entry = readdir(root_dir)) != NULL && count < 10) {
            if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
                printf("  %s%s\n", entry->d_name, 
                       entry->d_type == DT_DIR ? "/" : "");
                count++;
            }
        }
        if (count >= 10) {
            printf("  ... (更多文件)\n");
        }
        closedir(root_dir);
    }
}

int main() {
    printf("=== 基础chroot使用示例 ===\n");
    
    const char* chroot_dir = "/tmp/my_chroot";
    
    // 检查是否具有root权限
    if (geteuid() != 0) {
        printf("警告: chroot需要root权限运行\n");
        printf("请使用sudo运行此程序\n");
        exit(EXIT_FAILURE);
    }
    
    // 创建chroot环境
    if (create_chroot_environment(chroot_dir) == -1) {
        exit(EXIT_FAILURE);
    }
    
    printf("\n1. chroot前的文件系统状态:\n");
    show_filesystem_info();
    show_directory_tree(chroot_dir, 0);
    
    // 获取当前工作目录
    char original_cwd&#91;1024];
    if (getcwd(original_cwd, sizeof(original_cwd)) == NULL) {
        perror("获取当前目录失败");
        exit(EXIT_FAILURE);
    }
    printf("原始工作目录: %s\n", original_cwd);
    
    // 执行chroot
    printf("\n2. 执行chroot操作:\n");
    printf("切换根目录到: %s\n", chroot_dir);
    
    if (chroot(chroot_dir) == -1) {
        perror("chroot失败");
        exit(EXIT_FAILURE);
    }
    
    printf("✓ chroot操作成功\n");
    
    // 改变工作目录到新的根目录
    if (chdir("/") == -1) {
        perror("改变工作目录失败");
        exit(EXIT_FAILURE);
    }
    
    printf("\n3. chroot后的文件系统状态:\n");
    show_filesystem_info();
    
    // 创建一些测试文件
    printf("\n4. 在chroot环境中创建文件:\n");
    int fd = open("/test_file.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        write(fd, "这是chroot环境中的测试文件\n", 26);
        close(fd);
        printf("创建文件: /test_file.txt\n");
    }
    
    // 创建目录
    if (mkdir("/mydir", 0755) == 0) {
        printf("创建目录: /mydir\n");
    }
    
    // 显示chroot环境内容
    show_directory_tree("/", 0);
    
    // 尝试访问原始系统文件（应该失败）
    printf("\n5. 尝试访问原始系统文件:\n");
    if (access("/etc/passwd", F_OK) == -1) {
        printf("✓ 无法访问原始系统文件 /etc/passwd (预期行为)\n");
    } else {
        printf("✗ 仍然可以访问原始系统文件\n");
    }
    
    // 清理测试文件
    unlink("/test_file.txt");
    rmdir("/mydir");
    
    printf("\n=== 基础chroot演示完成 ===\n");
    printf("注意: 此程序在chroot环境中结束\n");
    
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>
#include <pwd.h>

// 安全chroot函数
int secure_chroot(const char* new_root) {
    struct stat root_stat, cwd_stat;
    char cwd&#91;4096];
    
    printf("执行安全chroot到: %s\n", new_root);
    
    // 1. 验证新根目录存在且是目录
    if (stat(new_root, &root_stat) == -1) {
        perror("无法访问根目录");
        return -1;
    }
    
    if (!S_ISDIR(root_stat.st_mode)) {
        fprintf(stderr, "指定路径不是目录\n");
        return -1;
    }
    
    // 2. 验证新根目录权限
    if (access(new_root, R_OK | X_OK) == -1) {
        perror("根目录权限不足");
        return -1;
    }
    
    // 3. 改变当前工作目录到根目录
    if (chdir(new_root) == -1) {
        perror("改变到根目录失败");
        return -1;
    }
    
    // 4. 获取当前目录的inode信息
    if (getcwd(cwd, sizeof(cwd)) == NULL) {
        perror("获取当前目录失败");
        return -1;
    }
    
    if (stat(".", &cwd_stat) == -1) {
        perror("获取当前目录状态失败");
        return -1;
    }
    
    // 5. 执行chroot
    if (chroot(".") == -1) {
        perror("chroot失败");
        return -1;
    }
    
    // 6. 再次改变到根目录（防止某些逃逸技术）
    if (chdir("/") == -1) {
        perror("最终改变目录失败");
        return -1;
    }
    
    printf("✓ 安全chroot完成\n");
    return 0;
}

// 在chroot环境中运行的函数
void run_in_chroot() {
    printf("\n=== 在chroot环境中运行 ===\n");
    
    // 显示环境信息
    printf("进程ID: %d\n", getpid());
    printf("父进程ID: %d\n", getppid());
    
    char cwd&#91;4096];
    if (getcwd(cwd, sizeof(cwd)) != NULL) {
        printf("当前工作目录: %s\n", cwd);
    }
    
    // 显示用户信息
    printf("用户ID: %d\n", getuid());
    printf("有效用户ID: %d\n", geteuid());
    printf("组ID: %d\n", getgid());
    
    // 显示根目录内容
    printf("根目录内容:\n");
    DIR* dir = opendir("/");
    if (dir) {
        struct dirent* entry;
        while ((entry = readdir(dir)) != NULL) {
            if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
                printf("  %s%s\n", entry->d_name, 
                       entry->d_type == DT_DIR ? "/" : "");
            }
        }
        closedir(dir);
    }
    
    // 创建测试文件
    int fd = open("/chroot_test.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        const char* test_content = "Chroot环境测试文件\n创建时间: ";
        write(fd, test_content, strlen(test_content));
        
        // 添加时间戳
        time_t now = time(NULL);
        char time_str&#91;64];
        snprintf(time_str, sizeof(time_str), "%s", ctime(&now));
        // 移除换行符
        char* newline = strchr(time_str, '\n');
        if (newline) *newline = '\0';
        write(fd, time_str, strlen(time_str));
        write(fd, "\n", 1);
        close(fd);
        printf("创建测试文件: /chroot_test.txt\n");
    }
    
    // 显示测试文件内容
    fd = open("/chroot_test.txt", O_RDONLY);
    if (fd != -1) {
        char buffer&#91;256];
        ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
        if (bytes_read > 0) {
            buffer&#91;bytes_read] = '\0';
            printf("测试文件内容:\n%s", buffer);
        }
        close(fd);
    }
    
    // 演示环境隔离
    printf("\n环境隔离测试:\n");
    
    // 尝试访问原始系统文件
    const char* system_files&#91;] = {
        "/etc/passwd",
        "/etc/shadow",
        "/proc/1/cmdline",
        "/sys/kernel",
        "/dev/sda"
    };
    
    for (int i = 0; i < 5; i++) {
        if (access(system_files&#91;i], F_OK) == 0) {
            printf("  能够访问: %s\n", system_files&#91;i]);
        } else {
            printf("  无法访问: %s (%s)\n", system_files&#91;i], strerror(errno));
        }
    }
    
    // 清理测试文件
    unlink("/chroot_test.txt");
}

// 演示chroot逃逸防护
void demonstrate_escape_protection() {
    printf("\n=== chroot逃逸防护演示 ===\n");
    
    // 这些是常见的chroot逃逸尝试
    printf("尝试常见的逃逸方法:\n");
    
    // 1. 尝试通过..访问上级目录
    if (chdir("..") == 0) {
        char cwd&#91;4096];
        if (getcwd(cwd, sizeof(cwd)) != NULL) {
            printf("  cd .. 后的目录: %s\n", cwd);
        }
        // 回到根目录
        chdir("/");
    } else {
        printf("  cd .. 失败 (预期行为)\n");
    }
    
    // 2. 尝试通过绝对路径访问
    if (access("/etc/passwd", F_OK) == 0) {
        printf("  能够访问 /etc/passwd (可能存在问题)\n");
    } else {
        printf("  无法访问 /etc/passwd (正常隔离)\n");
    }
    
    // 3. 尝试创建符号链接到外部
    if (symlink("/etc/passwd", "/passwd_link") == 0) {
        printf("  创建符号链接成功\n");
        // 测试符号链接是否有效
        if (access("/passwd_link", F_OK) == 0) {
            printf("  符号链接指向有效文件\n");
        } else {
            printf("  符号链接无效或被隔离\n");
        }
        unlink("/passwd_link");
    } else {
        printf("  无法创建符号链接 (正常)\n");
    }
}

int main() {
    printf("=== 安全chroot实现示例 ===\n");
    
    // 检查权限
    if (geteuid() != 0) {
        printf("错误: 此程序需要root权限运行\n");
        exit(EXIT_FAILURE);
    }
    
    const char* chroot_path = "/tmp/secure_chroot";
    
    // 创建安全的chroot环境
    printf("1. 创建安全chroot环境:\n");
    
    // 创建基本目录结构
    const char* dirs&#91;] = {"bin", "etc", "dev", "tmp", "usr", "lib", "lib64"};
    if (mkdir(chroot_path, 0755) == -1 && errno != EEXIST) {
        perror("创建根目录失败");
        exit(EXIT_FAILURE);
    }
    
    for (int i = 0; i < 7; i++) {
        char full_path&#91;256];
        snprintf(full_path, sizeof(full_path), "%s/%s", chroot_path, dirs&#91;i]);
        if (mkdir(full_path, 0755) == -1 && errno != EEXIST) {
            perror("创建目录失败");
            exit(EXIT_FAILURE);
        }
    }
    
    // 创建基本设备文件
    char null_path&#91;256];
    snprintf(null_path, sizeof(null_path), "%s/dev/null", chroot_path);
    if (mknod(null_path, S_IFCHR | 0666, makedev(1, 3)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/null失败\n");
    }
    
    printf("chroot环境创建完成: %s\n", chroot_path);
    
    // 执行安全chroot
    printf("\n2. 执行安全chroot:\n");
    if (secure_chroot(chroot_path) == -1) {
        exit(EXIT_FAILURE);
    }
    
    // 在chroot环境中运行
    run_in_chroot();
    
    // 演示逃逸防护
    demonstrate_escape_protection();
    
    // 显示最终状态
    printf("\n=== chroot环境演示完成 ===\n");
    printf("当前仍在chroot环境中\n");
    
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>
#include <sys/wait.h>

// 复制文件到chroot环境
int copy_file_to_chroot(const char* src, const char* dst_chroot, const char* dst_path) {
    char full_dst_path&#91;512];
    snprintf(full_dst_path, sizeof(full_dst_path), "%s%s", dst_chroot, dst_path);
    
    // 确保目标目录存在
    char* last_slash = strrchr(full_dst_path, '/');
    if (last_slash) {
        *last_slash = '\0';
        // 创建目录（简化实现）
        mkdir(full_dst_path, 0755);
        *last_slash = '/';
    }
    
    // 打开源文件
    int src_fd = open(src, O_RDONLY);
    if (src_fd == -1) {
        printf("警告: 无法打开源文件 %s: %s\n", src, strerror(errno));
        return -1;
    }
    
    // 创建目标文件
    int dst_fd = open(full_dst_path, O_CREAT | O_WRONLY | O_TRUNC, 0755);
    if (dst_fd == -1) {
        printf("警告: 无法创建目标文件 %s: %s\n", full_dst_path, strerror(errno));
        close(src_fd);
        return -1;
    }
    
    // 复制文件内容
    char buffer&#91;8192];
    ssize_t bytes_read, bytes_written;
    
    while ((bytes_read = read(src_fd, buffer, sizeof(buffer))) > 0) {
        bytes_written = write(dst_fd, buffer, bytes_read);
        if (bytes_written != bytes_read) {
            perror("写入目标文件失败");
            close(src_fd);
            close(dst_fd);
            return -1;
        }
    }
    
    close(src_fd);
    close(dst_fd);
    
    printf("复制文件: %s -> %s\n", src, full_dst_path);
    return 0;
}

// 构建基本的chroot环境
int build_basic_chroot(const char* chroot_path) {
    printf("构建基本chroot环境: %s\n", chroot_path);
    
    // 创建目录结构
    const char* dirs&#91;] = {
        "", "bin", "sbin", "etc", "dev", "usr", "usr/bin", 
        "usr/sbin", "lib", "lib64", "tmp", "var", "var/tmp"
    };
    
    for (int i = 0; i < 13; i++) {
        char full_path&#91;256];
        snprintf(full_path, sizeof(full_path), "%s/%s", chroot_path, dirs&#91;i]);
        if (mkdir(full_path, 0755) == -1 && errno != EEXIST) {
            if (errno != EEXIST) {
                printf("警告: 创建目录失败 %s: %s\n", full_path, strerror(errno));
            }
        }
    }
    
    // 创建基本设备文件
    char dev_path&#91;256];
    snprintf(dev_path, sizeof(dev_path), "%s/dev/null", chroot_path);
    if (mknod(dev_path, S_IFCHR | 0666, makedev(1, 3)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/null失败\n");
    }
    
    snprintf(dev_path, sizeof(dev_path), "%s/dev/zero", chroot_path);
    if (mknod(dev_path, S_IFCHR | 0666, makedev(1, 5)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/zero失败\n");
    }
    
    snprintf(dev_path, sizeof(dev_path), "%s/dev/random", chroot_path);
    if (mknod(dev_path, S_IFCHR | 0666, makedev(1, 8)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/random失败\n");
    }
    
    snprintf(dev_path, sizeof(dev_path), "%s/dev/urandom", chroot_path);
    if (mknod(dev_path, S_IFCHR | 0666, makedev(1, 9)) == -1 && errno != EEXIST) {
        printf("警告: 创建/dev/urandom失败\n");
    }
    
    // 复制基本命令（根据系统实际情况调整）
    printf("复制基本命令...\n");
    
    // 复制shell
    copy_file_to_chroot("/bin/sh", chroot_path, "/bin/sh");
    
    // 复制基本命令
    const char* basic_commands&#91;] = {
        "/bin/ls", "/bin/cat", "/bin/echo", "/bin/pwd",
        "/usr/bin/id", "/bin/ps"
    };
    
    for (int i = 0; i < 6; i++) {
        copy_file_to_chroot(basic_commands&#91;i], chroot_path, basic_commands&#91;i]);
    }
    
    // 创建基本配置文件
    char etc_passwd&#91;256];
    snprintf(etc_passwd, sizeof(etc_passwd), "%s/etc/passwd", chroot_path);
    int fd = open(etc_passwd, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        const char* passwd_content = 
            "root:x:0:0:root:/root:/bin/sh\n"
            "nobody:x:65534:65534:nobody:/:/bin/sh\n";
        write(fd, passwd_content, strlen(passwd_content));
        close(fd);
        printf("创建 /etc/passwd\n");
    }
    
    char etc_group&#91;256];
    snprintf(etc_group, sizeof(etc_group), "%s/etc/group", chroot_path);
    fd = open(etc_group, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        const char* group_content = 
            "root:x:0:\n"
            "nobody:x:65534:\n";
        write(fd, group_content, strlen(group_content));
        close(fd);
        printf("创建 /etc/group\n");
    }
    
    printf("基本chroot环境构建完成\n");
    return 0;
}

// 在chroot环境中执行命令
int execute_in_chroot(const char* chroot_path, const char* command) {
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork失败");
        return -1;
    }
    
    if (pid == 0) {
        // 子进程
        // 执行chroot
        if (chroot(chroot_path) == -1) {
            perror("chroot失败");
            exit(EXIT_FAILURE);
        }
        
        // 改变到根目录
        if (chdir("/") == -1) {
            perror("chdir失败");
            exit(EXIT_FAILURE);
        }
        
        // 执行命令
        execl("/bin/sh", "sh", "-c", command, (char*)NULL);
        perror("执行命令失败");
        exit(EXIT_FAILURE);
    } else {
        // 父进程等待子进程结束
        int status;
        waitpid(pid, &status, 0);
        
        if (WIFEXITED(status)) {
            int exit_code = WEXITSTATUS(status);
            printf("命令执行完成，退出码: %d\n", exit_code);
            return exit_code;
        } else if (WIFSIGNALED(status)) {
            int signal = WTERMSIG(status);
            printf("命令被信号终止: %d\n", signal);
            return -1;
        }
    }
    
    return 0;
}

// 显示chroot环境内容
void show_chroot_contents(const char* chroot_path) {
    printf("\nchroot环境内容:\n");
    
    DIR* dir = opendir(chroot_path);
    if (dir) {
        struct dirent* entry;
        while ((entry = readdir(dir)) != NULL) {
            if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
                printf("  /%s%s\n", entry->d_name, 
                       entry->d_type == DT_DIR ? "/" : "");
                
                // 显示子目录内容（仅一层）
                if (entry->d_type == DT_DIR) {
                    char sub_path&#91;512];
                    snprintf(sub_path, sizeof(sub_path), "%s/%s", chroot_path, entry->d_name);
                    DIR* sub_dir = opendir(sub_path);
                    if (sub_dir) {
                        struct dirent* sub_entry;
                        int count = 0;
                        while ((sub_entry = readdir(sub_dir)) != NULL && count < 5) {
                            if (strcmp(sub_entry->d_name, ".") != 0 && 
                                strcmp(sub_entry->d_name, "..") != 0) {
                                printf("    %s%s\n", sub_entry->d_name, 
                                       sub_entry->d_type == DT_DIR ? "/" : "");
                                count++;
                            }
                        }
                        if (count >= 5) {
                            printf("    ...\n");
                        }
                        closedir(sub_dir);
                    }
                }
            }
        }
        closedir(dir);
    }
}

int main() {
    printf("=== chroot环境构建与程序执行示例 ===\n");
    
    if (geteuid() != 0) {
        printf("错误: 此程序需要root权限运行\n");
        exit(EXIT_FAILURE);
    }
    
    const char* chroot_path = "/tmp/full_chroot";
    
    // 构建chroot环境
    printf("1. 构建完整的chroot环境:\n");
    if (build_basic_chroot(chroot_path) == -1) {
        exit(EXIT_FAILURE);
    }
    
    show_chroot_contents(chroot_path);
    
    // 在chroot环境中执行命令
    printf("\n2. 在chroot环境中执行命令:\n");
    
    // 执行基本命令
    const char* commands&#91;] = {
        "echo 'Hello from chroot!'",
        "ls -la /",
        "pwd",
        "id",
        "cat /etc/passwd"
    };
    
    for (int i = 0; i < 5; i++) {
        printf("\n执行命令: %s\n", commands&#91;i]);
        printf("--- 输出开始 ---\n");
        execute_in_chroot(chroot_path, commands&#91;i]);
        printf("--- 输出结束 ---\n");
    }
    
    // 创建和运行简单脚本
    printf("\n3. 创建和运行脚本:\n");
    
    // 创建脚本文件
    char script_path&#91;256];
    snprintf(script_path, sizeof(script_path), "%s/test_script.sh", chroot_path);
    int fd = open(script_path, O_CREAT | O_WRONLY | O_TRUNC, 0755);
    if (fd != -1) {
        const char* script_content = 
            "#!/bin/sh\n"
            "echo '=== 测试脚本开始 ==='\n"
            "echo '当前时间:' $(date)\n"
            "echo '当前用户:' $(id)\n"
            "echo '当前目录:' $(pwd)\n"
            "ls -la /\n"
            "echo '=== 测试脚本结束 ==='\n";
        write(fd, script_content, strlen(script_content));
        close(fd);
        printf("创建测试脚本: /test_script.sh\n");
    }
    
    // 执行脚本
    printf("执行测试脚本:\n");
    printf("--- 脚本输出开始 ---\n");
    execute_in_chroot(chroot_path, "/test_script.sh");
    printf("--- 脚本输出结束 ---\n");
    
    // 演示安全性
    printf("\n4. 安全性演示:\n");
    
    // 尝试访问宿主系统文件
    printf("尝试访问宿主系统文件:\n");
    const char* dangerous_commands&#91;] = {
        "ls -la /etc",
        "cat /etc/shadow 2>/dev/null || echo '无法访问/etc/shadow'",
        "ls -la /root 2>/dev/null || echo '无法访问/root'",
        "find /proc -maxdepth 2 2>/dev/null | head -5"
    };
    
    for (int i = 0; i < 4; i++) {
        printf("\n执行安全测试命令: %s\n", dangerous_commands&#91;i]);
        printf("--- 输出开始 ---\n");
        execute_in_chroot(chroot_path, dangerous_commands&#91;i]);
        printf("--- 输出结束 ---\n");
    }
    
    // 清理测试脚本
    unlink(script_path);
    
    printf("\n=== chroot环境演示完成 ===\n");
    printf("环境路径: %s\n", chroot_path);
    printf("注意: 环境文件仍保留在系统中\n");
    
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>
#include <sys/mount.h>
#include <sys/wait.h>
#include <mntent.h>

// chroot环境管理器
typedef struct {
    char path&#91;512];
    int is_active;
    pid_t original_pid;
    time_t create_time;
} chroot_manager_t;

static chroot_manager_t manager = {0};

// 创建完整的系统恢复环境
int create_recovery_environment(const char* chroot_path) {
    printf("创建系统恢复环境: %s\n", chroot_path);
    
    // 创建完整的目录结构
    const char* essential_dirs&#91;] = {
        "", "bin", "sbin", "etc", "dev", "proc", "sys", "tmp",
        "var", "var/log", "var/run", "usr", "usr/bin", "usr/sbin",
        "usr/lib", "lib", "lib64", "mnt", "media", "root", "home"
    };
    
    for (int i = 0; i < 21; i++) {
        char full_path&#91;512];
        snprintf(full_path, sizeof(full_path), "%s/%s", chroot_path, essential_dirs&#91;i]);
        if (mkdir(full_path, 0755) == -1 && errno != EEXIST) {
            printf("警告: 创建目录失败 %s: %s\n", full_path, strerror(errno));
        }
    }
    
    // 创建设备文件
    printf("创建基本设备文件...\n");
    struct {
        const char* path;
        int major, minor;
        mode_t mode;
    } devices&#91;] = {
        {"/dev/null", 1, 3, S_IFCHR | 0666},
        {"/dev/zero", 1, 5, S_IFCHR | 0666},
        {"/dev/full", 1, 7, S_IFCHR | 0666},
        {"/dev/random", 1, 8, S_IFCHR | 0666},
        {"/dev/urandom", 1, 9, S_IFCHR | 0666},
        {"/dev/tty", 5, 0, S_IFCHR | 0666}
    };
    
    for (int i = 0; i < 6; i++) {
        char full_path&#91;512];
        snprintf(full_path, sizeof(full_path), "%s%s", chroot_path, devices&#91;i].path);
        if (mknod(full_path, devices&#91;i].mode, makedev(devices&#91;i].major, devices&#91;i].minor)) == -1 && errno != EEXIST) {
            printf("警告: 创建设备文件失败 %s: %s\n", full_path, strerror(errno));
        }
    }
    
    // 复制系统管理工具
    printf("复制系统管理工具...\n");
    const char* sysadmin_tools&#91;] = {
        "/bin/sh", "/bin/bash", "/bin/ls", "/bin/cat", "/bin/cp",
        "/bin/mv", "/bin/rm", "/bin/mkdir", "/bin/rmdir", "/bin/ln",
        "/bin/find", "/bin/grep", "/bin/ps", "/bin/kill", "/sbin/ifconfig",
        "/sbin/ip", "/sbin/fsck", "/sbin/mkfs", "/bin/mount", "/bin/umount",
        "/usr/bin/vi", "/usr/bin/nano", "/bin/tar", "/usr/bin/gzip",
        "/usr/bin/bzip2", "/bin/df", "/bin/du", "/usr/bin/top"
    };
    
    int copied_count = 0;
    for (int i = 0; i < 28; i++) {
        if (access(sysadmin_tools&#91;i], F_OK) == 0) {
            if (copy_file_to_chroot(sysadmin_tools&#91;i], chroot_path, sysadmin_tools&#91;i]) == 0) {
                copied_count++;
            }
        }
    }
    printf("成功复制 %d 个系统工具\n", copied_count);
    
    // 创建配置文件
    printf("创建基本配置文件...\n");
    
    // /etc/passwd
    char passwd_path&#91;512];
    snprintf(passwd_path, sizeof(passwd_path), "%s/etc/passwd", chroot_path);
    int fd = open(passwd_path, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        const char* passwd_content = 
            "root:x:0:0:root:/root:/bin/bash\n"
            "admin:x:1000:1000:Admin User:/home/admin:/bin/bash\n";
        write(fd, passwd_content, strlen(passwd_content));
        close(fd);
    }
    
    // /etc/group
    char group_path&#91;512];
    snprintf(group_path, sizeof(group_path), "%s/etc/group", chroot_path);
    fd = open(group_path, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        const char* group_content = 
            "root:x:0:\n"
            "admin:x:1000:\n";
        write(fd, group_content, strlen(group_content));
        close(fd);
    }
    
    // /etc/hosts
    char hosts_path&#91;512];
    snprintf(hosts_path, sizeof(hosts_path), "%s/etc/hosts", chroot_path);
    fd = open(hosts_path, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        const char* hosts_content = 
            "127.0.0.1\tlocalhost\n"
            "::1\tlocalhost ip6-localhost ip6-loopback\n";
        write(fd, hosts_content, strlen(hosts_content));
        close(fd);
    }
    
    printf("系统恢复环境创建完成\n");
    return 0;
}

// 在chroot中挂载特殊文件系统
int mount_special_filesystems(const char* chroot_path) {
    printf("挂载特殊文件系统...\n");
    
    char proc_path&#91;512], sys_path&#91;512], dev_path&#91;512];
    snprintf(proc_path, sizeof(proc_path), "%s/proc", chroot_path);
    snprintf(sys_path, sizeof(sys_path), "%s/sys", chroot_path);
    snprintf(dev_path, sizeof(dev_path), "%s/dev", chroot_path);
    
    // 挂载/proc
    if (mount("proc", proc_path, "proc", 0, NULL) == -1) {
        printf("警告: 挂载/proc失败: %s\n", strerror(errno));
    } else {
        printf("挂载 /proc 到 %s\n", proc_path);
    }
    
    // 挂载/sys
    if (mount("sysfs", sys_path, "sysfs", 0, NULL) == -1) {
        printf("警告: 挂载/sys失败: %s\n", strerror(errno));
    } else {
        printf("挂载 /sys 到 %s\n", sys_path);
    }
    
    // 创建并挂载tmpfs到/tmp
    char tmp_path&#91;512];
    snprintf(tmp_path, sizeof(tmp_path), "%s/tmp", chroot_path);
    if (mount("tmpfs", tmp_path, "tmpfs", 0, "size=100M") == -1) {
        printf("警告: 挂载/tmp失败: %s\n", strerror(errno));
    } else {
        printf("挂载 tmpfs 到 %s\n", tmp_path);
    }
    
    return 0;
}

// 卸载特殊文件系统
int unmount_special_filesystems(const char* chroot_path) {
    printf("卸载特殊文件系统...\n");
    
    char mounts&#91;]&#91;512] = {
        "%s/tmp",
        "%s/sys",
        "%s/proc"
    };
    
    for (int i = 0; i < 3; i++) {
        char mount_point&#91;512];
        snprintf(mount_point, sizeof(mount_point), mounts&#91;i], chroot_path);
        if (umount(mount_point) == -1) {
            if (errno != EINVAL) {  // 忽略未挂载的错误
                printf("警告: 卸载 %s 失败: %s\n", mount_point, strerror(errno));
            }
        } else {
            printf("卸载 %s\n", mount_point);
        }
    }
    
    return 0;
}

// 初始化chroot管理器
int init_chroot_manager(const char* chroot_path) {
    strncpy(manager.path, chroot_path, sizeof(manager.path) - 1);
    manager.is_active = 0;
    manager.original_pid = getpid();
    manager.create_time = time(NULL);
    
    printf("初始化chroot管理器\n");
    printf("  环境路径: %s\n", manager.path);
    printf("  管理器PID: %d\n", manager.original_pid);
    
    return 0;
}

// 激活chroot环境
int activate_chroot_environment() {
    if (manager.is_active) {
        printf("chroot环境已激活\n");
        return 0;
    }
    
    printf("激活chroot环境: %s\n", manager.path);
    
    // 挂载特殊文件系统
    mount_special_filesystems(manager.path);
    
    // 执行chroot
    if (chroot(manager.path) == -1) {
        perror("chroot失败");
        return -1;
    }
    
    // 改变到根目录
    if (chdir("/") == -1) {
        perror("chdir失败");
        return -1;
    }
    
    manager.is_active = 1;
    printf("✓ chroot环境已激活\n");
    
    return 0;
}

// 交互式shell
int start_interactive_shell() {
    printf("\n=== 启动交互式shell ===\n");
    printf("提示: 输入 'exit' 退出shell\n");
    printf("当前环境: chroot @ %s\n", manager.path);
    printf("========================\n");
    
    // 启动shell
    execl("/bin/bash", "bash", "--norc", "--noprofile", (char*)NULL);
    
    // 如果execl失败
    perror("启动shell失败");
    return -1;
}

// 执行系统维护任务
int perform_system_maintenance() {
    printf("=== 系统维护任务 ===\n");
    
    // 检查文件系统
    printf("1. 检查文件系统:\n");
    system("df -h");
    
    // 检查磁盘使用情况
    printf("\n2. 磁盘使用情况:\n");
    system("du -sh /* 2>/dev/null | head -10");
    
    // 检查进程
    printf("\n3. 当前进程:\n");
    system("ps aux --forest | head -15");
    
    // 检查网络
    printf("\n4. 网络状态:\n");
    system("ip link show | head -10");
    
    // 检查系统日志
    printf("\n5. 系统日志检查:\n");
    system("dmesg | tail -10");
    
    return 0;
}

int main(int argc, char* argv&#91;]) {
    printf("=== chroot高级应用 - 系统维护工具 ===\n");
    
    if (geteuid() != 0) {
        printf("错误: 此工具需要root权限运行\n");
        exit(EXIT_FAILURE);
    }
    
    const char* chroot_path = "/tmp/recovery_chroot";
    
    // 初始化管理器
    init_chroot_manager(chroot_path);
    
    // 检查命令行参数
    if (argc > 1) {
        if (strcmp(argv&#91;1], "create") == 0) {
            // 创建恢复环境
            printf("创建恢复环境...\n");
            if (create_recovery_environment(chroot_path) == -1) {
                exit(EXIT_FAILURE);
            }
            printf("恢复环境创建完成: %s\n", chroot_path);
            return 0;
        } else if (strcmp(argv&#91;1], "shell") == 0) {
            // 激活并启动shell
            printf("启动恢复shell...\n");
            if (activate_chroot_environment() == -1) {
                exit(EXIT_FAILURE);
            }
            start_interactive_shell();
            return 0;
        } else if (strcmp(argv&#91;1], "maintain") == 0) {
            // 执行维护任务
            if (activate_chroot_environment() == -1) {
                exit(EXIT_FAILURE);
            }
            perform_system_maintenance();
            return 0;
        } else {
            printf("用法: %s &#91;create|shell|maintain]\n", argv&#91;0]);
            printf("  create  - 创建恢复环境\n");
            printf("  shell   - 启动交互式shell\n");
            printf("  maintain - 执行系统维护任务\n");
            return 1;
        }
    }
    
    // 交互式菜单
    printf("\n系统维护工具菜单:\n");
    printf("1. 创建恢复环境\n");
    printf("2. 启动恢复shell\n");
    printf("3. 执行系统维护\n");
    printf("4. 退出\n");
    
    int choice;
    printf("请选择操作 (1-4): ");
    if (scanf("%d", &choice) != 1) {
        printf("输入错误\n");
        return 1;
    }
    
    switch (choice) {
        case 1:
            printf("创建恢复环境...\n");
            create_recovery_environment(chroot_path);
            break;
        case 2:
            printf("启动恢复shell...\n");
            activate_chroot_environment();
            start_interactive_shell();
            break;
        case 3:
            printf("执行系统维护...\n");
            activate_chroot_environment();
            perform_system_maintenance();
            break;
        case 4:
            printf("退出工具\n");
            break;
        default:
            printf("无效选择\n");
            return 1;
    }
    
    printf("\n=== 系统维护工具结束 ===\n");
    
    return 0;
}