#include <dirent.h>
#include <sys/syscall.h>

int getdents(unsigned int fd, struct linux_dirent *dirp, unsigned int count);

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

// 目录项结构体定义
struct linux_dirent {
    long d_ino;              // inode号
    __kernel_off_t d_off;    // 到下一个目录项的偏移
    unsigned short d_reclen; // 当前目录项长度
    char d_name&#91;];           // 文件名（以null结尾）
};

int main() {
    int fd;
    char buf&#91;4096];
    int nread;
    char *p;
    struct linux_dirent *d;
    
    printf("=== Getdents函数示例 ===\n");
    
    // 示例1: 基本的目录读取操作
    printf("\n示例1: 基本的目录读取操作\n");
    
    // 打开当前目录
    fd = open(".", O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        perror("打开当前目录失败");
        exit(EXIT_FAILURE);
    }
    printf("成功打开当前目录，文件描述符: %d\n", fd);
    
    // 使用getdents读取目录内容
    printf("读取目录内容:\n");
    while (1) {
        nread = syscall(SYS_getdents, fd, buf, sizeof(buf));
        if (nread == -1) {
            perror("getdents失败");
            close(fd);
            exit(EXIT_FAILURE);
        }
        
        if (nread == 0)  // 没有更多的目录项
            break;
        
        // 解析目录项
        for (p = buf; p < buf + nread;) {
            d = (struct linux_dirent *)p;
            
            // 显示目录项信息
            printf("  inode: %ld, ", d->d_ino);
            printf("长度: %d, ", d->d_reclen);
            printf("名称: %s\n", d->d_name);
            
            p += d->d_reclen;
        }
    }
    
    close(fd);
    
    // 示例2: 创建测试目录和文件进行演示
    printf("\n示例2: 创建测试环境进行演示\n");
    
    // 创建测试目录
    if (mkdir("test_getdents_dir", 0755) == -1 && errno != EEXIST) {
        perror("创建测试目录失败");
    } else {
        printf("创建测试目录: test_getdents_dir\n");
        
        // 在测试目录中创建一些文件
        chdir("test_getdents_dir");
        
        // 创建测试文件
        int test_files&#91;] = {1, 2, 3, 4, 5};
        for (int i = 0; i < 5; i++) {
            char filename&#91;20];
            sprintf(filename, "test_file_%d.txt", test_files&#91;i]);
            int file_fd = open(filename, O_CREAT | O_WRONLY, 0644);
            if (file_fd != -1) {
                const char *content = "Test file content";
                write(file_fd, content, strlen(content));
                close(file_fd);
                printf("创建测试文件: %s\n", filename);
            }
        }
        
        // 创建子目录
        if (mkdir("subdir", 0755) == -1 && errno != EEXIST) {
            perror("创建子目录失败");
        } else {
            printf("创建子目录: subdir\n");
        }
        
        // 打开测试目录
        fd = open(".", O_RDONLY | O_DIRECTORY);
        if (fd != -1) {
            printf("\n读取测试目录内容:\n");
            
            while (1) {
                nread = syscall(SYS_getdents, fd, buf, sizeof(buf));
                if (nread == -1) {
                    perror("getdents失败");
                    break;
                }
                
                if (nread == 0)
                    break;
                
                // 解析并显示目录项
                for (p = buf; p < buf + nread;) {
                    d = (struct linux_dirent *)p;
                    
                    // 跳过.和..目录项
                    if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0) {
                        printf("  文件名: %-20s", d->d_name);
                        printf("inode: %ld, ", d->d_ino);
                        printf("长度: %d\n", d->d_reclen);
                    }
                    
                    p += d->d_reclen;
                }
            }
            
            close(fd);
        }
        
        // 返回上级目录并清理
        chdir("..");
    }
    
    // 示例3: 与readdir的对比
    printf("\n示例3: getdents与readdir对比\n");
    
    // 使用getdents读取
    fd = open(".", O_RDONLY | O_DIRECTORY);
    if (fd != -1) {
        printf("使用getdents读取目录:\n");
        nread = syscall(SYS_getdents, fd, buf, sizeof(buf));
        if (nread > 0) {
            int count = 0;
            for (p = buf; p < buf + nread && count < 5;) {
                d = (struct linux_dirent *)p;
                if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0) {
                    printf("  %s\n", d->d_name);
                    count++;
                }
                p += d->d_reclen;
            }
        }
        close(fd);
    }
    
    // 使用readdir读取（标准方法）
    printf("使用readdir读取目录:\n");
    DIR *dir = opendir(".");
    if (dir != NULL) {
        struct dirent *entry;
        int count = 0;
        while ((entry = readdir(dir)) != NULL && count < 5) {
            if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
                printf("  %s\n", entry->d_name);
                count++;
            }
        }
        closedir(dir);
    }
    
    printf("getdents提供更多底层控制，但readdir更易使用\n");
    
    // 示例4: 目录项详细信息解析
    printf("\n示例4: 目录项详细信息解析\n");
    
    fd = open(".", O_RDONLY | O_DIRECTORY);
    if (fd != -1) {
        nread = syscall(SYS_getdents, fd, buf, sizeof(buf));
        if (nread > 0) {
            printf("目录项详细信息:\n");
            for (p = buf; p < buf + nread;) {
                d = (struct linux_dirent *)p;
                
                // 显示所有目录项（包括.和..）
                printf("  名称: %-20s", d->d_name);
                printf("inode: %-10ld", d->d_ino);
                printf("偏移: %-8ld", (long)d->d_off);
                printf("长度: %d\n", d->d_reclen);
                
                p += d->d_reclen;
            }
        }
        close(fd);
    }
    
    // 示例5: 错误处理演示
    printf("\n示例5: 错误处理演示\n");
    
    // 尝试对无效文件描述符操作
    nread = syscall(SYS_getdents, 999, buf, sizeof(buf));
    if (nread == -1) {
        printf("对无效文件描述符操作: %s\n", strerror(errno));
    }
    
    // 尝试对普通文件操作
    int regular_fd = open("regular_file.txt", O_CREAT | O_WRONLY, 0644);
    if (regular_fd != -1) {
        write(regular_fd, "test", 4);
        nread = syscall(SYS_getdents, regular_fd, buf, sizeof(buf));
        if (nread == -1) {
            printf("对普通文件操作: %s\n", strerror(errno));
        }
        close(regular_fd);
        unlink("regular_file.txt");
    }
    
    // 尝试使用无效缓冲区
    fd = open(".", O_RDONLY | O_DIRECTORY);
    if (fd != -1) {
        nread = syscall(SYS_getdents, fd, NULL, sizeof(buf));
        if (nread == -1) {
            printf("使用无效缓冲区: %s\n", strerror(errno));
        }
        close(fd);
    }
    
    // 示例6: 实际应用场景
    printf("\n示例6: 实际应用场景\n");
    
    // 场景1: 快速目录扫描（跳过隐藏文件）
    printf("场景1: 快速目录扫描\n");
    fd = open(".", O_RDONLY | O_DIRECTORY);
    if (fd != -1) {
        printf("非隐藏文件列表:\n");
        int file_count = 0;
        while (1) {
            nread = syscall(SYS_getdents, fd, buf, sizeof(buf));
            if (nread <= 0) break;
            
            for (p = buf; p < buf + nread;) {
                d = (struct linux_dirent *)p;
                
                // 跳过.和..以及隐藏文件（以.开头）
                if (strcmp(d->d_name, ".") != 0 && 
                    strcmp(d->d_name, "..") != 0 && 
                    d->d_name&#91;0] != '.') {
                    printf("  %s\n", d->d_name);
                    file_count++;
                }
                
                p += d->d_reclen;
            }
        }
        printf("总共找到 %d 个非隐藏文件\n", file_count);
        close(fd);
    }
    
    // 场景2: 目录统计信息
    printf("场景2: 目录统计信息\n");
    fd = open(".", O_RDONLY | O_DIRECTORY);
    if (fd != -1) {
        int total_files = 0;
        int total_dirs = 0;
        long long total_size = 0;
        
        while (1) {
            nread = syscall(SYS_getdents, fd, buf, sizeof(buf));
            if (nread <= 0) break;
            
            for (p = buf; p < buf + nread;) {
                d = (struct linux_dirent *)p;
                
                // 跳过.和..
                if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0) {
                    // 检查文件类型（需要stat）
                    struct stat st;
                    if (stat(d->d_name, &st) == 0) {
                        if (S_ISDIR(st.st_mode)) {
                            total_dirs++;
                        } else {
                            total_files++;
                            total_size += st.st_size;
                        }
                    }
                }
                
                p += d->d_reclen;
            }
        }
        
        printf("目录统计:\n");
        printf("  文件数: %d\n", total_files);
        printf("  目录数: %d\n", total_dirs);
        printf("  文件总大小: %lld 字节\n", total_size);
        
        close(fd);
    }
    
    // 清理测试目录
    printf("\n清理测试资源...\n");
    if (access("test_getdents_dir", F_OK) == 0) {
        // 删除测试目录中的文件
        chdir("test_getdents_dir");
        for (int i = 1; i <= 5; i++) {
            char filename&#91;20];
            sprintf(filename, "test_file_%d.txt", i);
            unlink(filename);
        }
        rmdir("subdir");
        chdir("..");
        rmdir("test_getdents_dir");
        printf("删除测试目录完成\n");
    }
    
    return 0;
}

#include <unistd.h>
#include <sys/types.h>

gid_t getegid(void);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>
#include <pwd.h>

void print_group_info(const char *label, gid_t gid) {
    struct group *grp;
    
    printf("%s: %d", label, gid);
    
    // 尝试获取组名
    grp = getgrgid(gid);
    if (grp != NULL) {
        printf(" (%s)", grp->gr_name);
    }
    printf("\n");
}

int main() {
    gid_t real_gid, effective_gid;
    
    printf("=== 进程组 ID 信息 ===\n");
    
    // 获取真实组 ID
    real_gid = getgid();
    print_group_info("真实组 ID", real_gid);
    
    // 获取有效组 ID
    effective_gid = getegid();
    print_group_info("有效组 ID", effective_gid);
    
    // 获取当前用户名
    struct passwd *pwd = getpwuid(getuid());
    if (pwd != NULL) {
        printf("当前用户: %s\n", pwd->pw_name);
    }
    
    // 检查是否为 root 组
    if (effective_gid == 0) {
        printf("注意: 当前进程具有 root 组权限\n");
    }
    
    return 0;
}

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

int main() {
    gid_t original_egid, current_egid;
    int ret;
    
    printf("=== 组 ID 切换演示 ===\n");
    
    // 保存原始有效组 ID
    original_egid = getegid();
    printf("原始有效组 ID: %d\n", original_egid);
    
    // 尝试切换到不同的组（需要适当权限）
    // 这里使用一些常见的系统组进行演示
    gid_t test_groups&#91;] = {1000, 1001, 1002};  // 假设的用户组
    int num_groups = sizeof(test_groups) / sizeof(test_groups&#91;0]);
    
    for (int i = 0; i < num_groups; i++) {
        printf("\n尝试切换到组 %d:\n", test_groups&#91;i]);
        
        // 尝试设置有效组 ID
        ret = setegid(test_groups&#91;i]);
        if (ret == -1) {
            printf("  切换失败: %s\n", strerror(errno));
            switch (errno) {
                case EPERM:
                    printf("  原因: 权限不足\n");
                    break;
                case EINVAL:
                    printf("  原因: 无效的组 ID\n");
                    break;
                default:
                    break;
            }
        } else {
            current_egid = getegid();
            printf("  切换成功，当前有效组 ID: %d\n", current_egid);
            
            // 切换回原始组 ID
            if (setegid(original_egid) == 0) {
                printf("  已切换回原始组 ID: %d\n", getegid());
            }
        }
    }
    
    printf("\n最终有效组 ID: %d\n", getegid());
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>
#include <pwd.h>

int main() {
    gid_t effective_gid;
    gid_t *group_list;
    int group_count;
    long max_groups;
    
    printf("=== 完整组信息展示 ===\n");
    
    // 获取有效组 ID
    effective_gid = getegid();
    printf("有效组 ID: %d\n", effective_gid);
    
    // 获取组名
    struct group *grp = getgrgid(effective_gid);
    if (grp != NULL) {
        printf("有效组名: %s\n", grp->gr_name);
    }
    
    // 获取补充组列表大小
    max_groups = sysconf(_SC_NGROUPS_MAX);
    if (max_groups == -1) {
        max_groups = 64;  // 默认值
    }
    
    printf("最大支持组数: %ld\n", max_groups);
    
    // 分配组列表内存
    group_list = malloc(max_groups * sizeof(gid_t));
    if (group_list == NULL) {
        perror("内存分配失败");
        return 1;
    }
    
    // 获取补充组列表
    group_count = getgroups(max_groups, group_list);
    if (group_count == -1) {
        perror("获取补充组列表失败");
        free(group_list);
        return 1;
    }
    
    printf("补充组数量: %d\n", group_count);
    
    if (group_count > 0) {
        printf("补充组列表:\n");
        for (int i = 0; i < group_count; i++) {
            printf("  组 %d: %d", i + 1, group_list&#91;i]);
            
            // 获取组名
            struct group *sup_grp = getgrgid(group_list&#91;i]);
            if (sup_grp != NULL) {
                printf(" (%s)", sup_grp->gr_name);
            }
            printf("\n");
        }
    }
    
    // 检查有效组 ID 是否在补充组列表中
    int found = 0;
    for (int i = 0; i < group_count; i++) {
        if (group_list&#91;i] == effective_gid) {
            found = 1;
            break;
        }
    }
    
    printf("\n有效组 ID %s 在补充组列表中\n", 
           found ? "存在" : "不存在");
    
    free(group_list);
    return 0;
}

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

// 检查当前进程是否属于指定组
int is_member_of_group(gid_t target_gid) {
    gid_t effective_gid = getegid();
    
    // 首先检查有效组 ID
    if (effective_gid == target_gid) {
        return 1;
    }
    
    // 检查补充组
    long max_groups = sysconf(_SC_NGROUPS_MAX);
    if (max_groups == -1) max_groups = 64;
    
    gid_t *groups = malloc(max_groups * sizeof(gid_t));
    if (groups == NULL) return 0;
    
    int ngroups = getgroups(max_groups, groups);
    if (ngroups == -1) {
        free(groups);
        return 0;
    }
    
    for (int i = 0; i < ngroups; i++) {
        if (groups&#91;i] == target_gid) {
            free(groups);
            return 1;
        }
    }
    
    free(groups);
    return 0;
}

// 获取当前用户的主要组信息
void print_user_primary_group() {
    uid_t uid = getuid();
    struct passwd *pwd = getpwuid(uid);
    
    if (pwd != NULL) {
        printf("用户 %s 的主要组: %d", pwd->pw_name, pwd->pw_gid);
        struct group *grp = getgrgid(pwd->pw_gid);
        if (grp != NULL) {
            printf(" (%s)", grp->gr_name);
        }
        printf("\n");
    }
}

int main() {
    printf("=== 权限检查应用示例 ===\n");
    
    // 显示基本信息
    printf("当前用户 ID: %d\n", getuid());
    printf("当前有效组 ID: %d\n", getegid());
    print_user_primary_group();
    
    // 检查是否属于 wheel 组（系统管理员组）
    struct group *wheel_grp = getgrnam("wheel");
    if (wheel_grp != NULL) {
        int is_wheel = is_member_of_group(wheel_grp->gr_gid);
        printf("是否属于 wheel 组: %s\n", is_wheel ? "是" : "否");
    }
    
    // 检查是否属于 sudo 组
    struct group *sudo_grp = getgrnam("sudo");
    if (sudo_grp != NULL) {
        int is_sudo = is_member_of_group(sudo_grp->gr_gid);
        printf("是否属于 sudo 组: %s\n", is_sudo ? "是" : "否");
    }
    
    // 检查是否具有 root 组权限
    int is_root_group = is_member_of_group(0);
    printf("是否具有 root 组权限: %s\n", is_root_group ? "是" : "否");
    
    // 根据组权限显示不同信息
    if (is_root_group) {
        printf("\n提示: 当前进程具有 root 组权限，可以执行特权操作\n");
    } else {
        printf("\n提示: 当前进程权限受限，某些操作可能需要提升权限\n");
    }
    
    return 0;
}

// 真实组 ID (Real Group ID)
// 标识启动进程的用户的组
gid_t real_gid = getgid();

// 有效组 ID (Effective Group ID)  
// 当前用于权限检查的组 ID
gid_t effective_gid = getegid();

// 保存的设置组 ID (Saved Set Group ID)
// 用于权限切换的备份 ID
// 通过 setregid() 或类似函数设置

// 特殊组 ID
0     // root 组 (超级用户组)
1     // bin 组 (系统二进制文件)
2     // daemon 组 (系统守护进程)
3     // sys 组 (系统文件)
4     // adm 组 (系统日志)
5     // tty 组 (终端设备)
6     // disk 组 (磁盘设备)
10    // wheel 组 (系统管理员，某些发行版)
100+  // 普通用户组

int check_file_access_permission(const char *filename) {
    gid_t effective_gid = getegid();
    // 根据有效组 ID 检查文件访问权限
    // ...
    return 0;
}

void audit_process_privileges() {
    gid_t egid = getegid();
    if (egid == 0) {
        syslog(LOG_WARNING, "进程以 root 组权限运行");
    }
}

int can_perform_admin_task() {
    return is_member_of_group(get_admin_group_id());
}

#include <unistd.h>
#include <sys/types.h>

// 完整的 ID 管理示例
void demonstrate_id_management() {
    printf("真实用户 ID: %d\n", getuid());
    printf("有效用户 ID: %d\n", geteuid());
    printf("真实组 ID: %d\n", getgid());
    printf("有效组 ID: %d\n", getegid());
    
    // 权限切换示例
    // seteuid(), setegid() 用于临时权限切换
    // setuid(), setgid() 用于永久权限切换
}

#include <unistd.h>
#include <sys/types.h>

uid_t geteuid(void);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>

int main() {
    uid_t real_uid, effective_uid;
    struct passwd *pwd_info;
    
    printf("=== 进程用户 ID 信息 ===\n\n");
    
    // 获取真实用户 ID
    real_uid = getuid();
    printf("真实用户 ID (real UID): %d\n", real_uid);
    
    // 获取有效用户 ID
    effective_uid = geteuid();
    printf("有效用户 ID (effective UID): %d\n", effective_uid);
    
    // 获取用户名信息
    pwd_info = getpwuid(real_uid);
    if (pwd_info != NULL) {
        printf("真实用户名: %s\n", pwd_info->pw_name);
        printf("主目录: %s\n", pwd_info->pw_dir);
        printf("登录 shell: %s\n", pwd_info->pw_shell);
    } else {
        printf("无法获取真实用户信息\n");
    }
    
    // 获取有效用户信息
    pwd_info = getpwuid(effective_uid);
    if (pwd_info != NULL) {
        printf("有效用户名: %s\n", pwd_info->pw_name);
    } else {
        printf("无法获取有效用户信息\n");
    }
    
    // 判断权限级别
    printf("\n权限状态:\n");
    if (effective_uid == 0) {
        printf("✓ 进程具有 root 权限\n");
    } else if (real_uid == 0 && effective_uid != 0) {
        printf("⚠ 进程已放弃 root 权限\n");
    } else {
        printf("✗ 进程为普通用户权限\n");
    }
    
    if (real_uid == effective_uid) {
        printf("✓ 真实 UID 和有效 UID 相同\n");
    } else {
        printf("⚠ 真实 UID 和有效 UID 不同\n");
    }
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <string.h>

// 权限检查函数
void check_permissions() {
    uid_t real_uid = getuid();
    uid_t effective_uid = geteuid();
    gid_t real_gid = getgid();
    gid_t effective_gid = getegid();
    
    printf("=== 权限检查 ===\n");
    
    // 用户权限检查
    printf("用户权限:\n");
    printf("  真实 UID: %d", real_uid);
    struct passwd *pwd = getpwuid(real_uid);
    if (pwd) printf(" (%s)", pwd->pw_name);
    printf("\n");
    
    printf("  有效 UID: %d", effective_uid);
    pwd = getpwuid(effective_uid);
    if (pwd) printf(" (%s)", pwd->pw_name);
    if (effective_uid == 0) {
        printf(" &#91;ROOT 权限!]");
    }
    printf("\n");
    
    // 组权限检查
    printf("组权限:\n");
    printf("  真实 GID: %d\n", real_gid);
    printf("  有效 GID: %d", effective_gid);
    if (effective_gid == 0) {
        printf(" &#91;ROOT 组权限!]");
    }
    printf("\n");
    
    // 安全状态分析
    printf("\n安全状态分析:\n");
    if (effective_uid == 0) {
        printf("  ⚠ 危险: 进程以 root 权限运行\n");
        printf("  建议: 在完成特权操作后立即降低权限\n");
    } else if (real_uid == 0 && effective_uid != 0) {
        printf("  ✓ 良好: 已安全放弃 root 权限\n");
    } else {
        printf("  ✓ 正常: 以普通用户权限运行\n");
    }
}

// 安全操作示例
void secure_operation_example() {
    uid_t real_uid = getuid();
    uid_t effective_uid = geteuid();
    
    printf("\n=== 安全操作示例 ===\n");
    
    if (effective_uid == 0) {
        printf("检测到 root 权限，执行特权操作...\n");
        
        // 模拟特权操作
        printf("  执行系统管理任务...\n");
        printf("  修改系统配置...\n");
        printf("  访问受保护资源...\n");
        
        // 如果真实 UID 不是 root，可以安全地放弃权限
        if (real_uid != 0) {
            printf("  准备放弃 root 权限...\n");
            // 注意：实际代码中需要使用 setuid() 系列函数
        }
    } else {
        printf("以普通用户权限执行操作...\n");
        printf("  执行用户级任务...\n");
        printf("  访问用户文件...\n");
    }
}

int main() {
    printf("=== 进程身份和权限管理系统 ===\n\n");
    
    // 显示基本进程信息
    printf("进程基本信息:\n");
    printf("  进程 ID: %d\n", getpid());
    printf("  父进程 ID: %d\n", getppid());
    printf("  真实 UID: %d\n", getuid());
    printf("  有效 UID: %d\n", geteuid());
    printf("  真实 GID: %d\n", getgid());
    printf("  有效 GID: %d\n\n", getegid());
    
    // 权限检查
    check_permissions();
    
    // 安全操作示例
    secure_operation_example();
    
    printf("\n=== 安全建议 ===\n");
    printf("1. 遵循最小权限原则\n");
    printf("2. 及时放弃不需要的特权\n");
    printf("3. 定期检查有效 UID 和真实 UID\n");
    printf("4. 避免长时间以 root 权限运行\n");
    
    return 0;
}

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

// 用户信息结构体
struct user_info {
    uid_t uid;
    gid_t gid;
    char username&#91;256];
    char groupname&#91;256];
    char homedir&#91;256];
    int is_root;
    int has_privileges;
};

// 获取用户信息
int get_user_information(struct user_info *info) {
    struct passwd *pwd;
    struct group *grp;
    
    // 获取 UID 和 GID
    info->uid = geteuid();
    info->gid = getegid();
    
    // 获取用户信息
    pwd = getpwuid(info->uid);
    if (pwd) {
        strncpy(info->username, pwd->pw_name, sizeof(info->username) - 1);
        info->username&#91;sizeof(info->username) - 1] = '\0';
        strncpy(info->homedir, pwd->pw_dir, sizeof(info->homedir) - 1);
        info->homedir&#91;sizeof(info->homedir) - 1] = '\0';
    } else {
        snprintf(info->username, sizeof(info->username), "uid_%d", info->uid);
        strcpy(info->homedir, "/tmp");
    }
    
    // 获取组信息
    grp = getgrgid(info->gid);
    if (grp) {
        strncpy(info->groupname, grp->gr_name, sizeof(info->groupname) - 1);
        info->groupname&#91;sizeof(info->groupname) - 1] = '\0';
    } else {
        snprintf(info->groupname, sizeof(info->groupname), "gid_%d", info->gid);
    }
    
    // 设置权限标志
    info->is_root = (info->uid == 0);
    info->has_privileges = (info->uid == 0 || info->gid == 0);
    
    return 0;
}

// 显示用户信息
void display_user_info(const struct user_info *info) {
    printf("=== 当前用户信息 ===\n");
    printf("用户名: %s\n", info->username);
    printf("用户 ID: %d\n", info->uid);
    printf("组名: %s\n", info->groupname);
    printf("组 ID: %d\n", info->gid);
    printf("主目录: %s\n", info->homedir);
    printf("权限状态: %s\n", 
           info->is_root ? "ROOT 权限" : 
           info->has_privileges ? "特权用户" : "普通用户");
}

// 权限验证函数
int check_operation_permission(const char *operation) {
    struct user_info info;
    get_user_information(&info);
    
    printf("权限检查: %s\n", operation);
    
    // 根据操作类型检查权限
    if (strcmp(operation, "read_system_files") == 0) {
        // 读取系统文件通常需要 root 权限
        return info.is_root ? 1 : 0;
    } else if (strcmp(operation, "write_user_files") == 0) {
        // 写入用户文件通常只需要有效权限
        return 1;  // 假设总是允许
    } else if (strcmp(operation, "network_admin") == 0) {
        // 网络管理需要 root 权限
        return info.is_root ? 1 : 0;
    } else {
        // 默认情况下，普通操作允许
        return 1;
    }
}

// 模拟受保护操作
void perform_protected_operation(const char *operation) {
    printf("\n--- 尝试执行操作: %s ---\n", operation);
    
    if (check_operation_permission(operation)) {
        printf("✓ 权限检查通过\n");
        printf("  执行操作: %s\n", operation);
        
        // 模拟操作执行
        if (strcmp(operation, "read_system_files") == 0) {
            printf("  读取 /etc/shadow...\n");
            printf("  读取系统配置文件...\n");
        } else if (strcmp(operation, "network_admin") == 0) {
            printf("  配置网络接口...\n");
            printf("  修改防火墙规则...\n");
        }
        
        printf("  操作完成\n");
    } else {
        printf("✗ 权限不足，拒绝执行操作\n");
        printf("  需要 ROOT 权限才能执行此操作\n");
    }
}

// 显示安全建议
void show_security_advice(const struct user_info *info) {
    printf("\n=== 安全建议 ===\n");
    
    if (info->is_root) {
        printf("⚠ 警告: 当前以 ROOT 权限运行\n");
        printf("  建议:\n");
        printf("  1. 完成必要操作后立即切换到普通用户\n");
        printf("  2. 避免在 root 权限下运行不必要的程序\n");
        printf("  3. 定期审计 root 权限的使用情况\n");
    } else if (info->has_privileges) {
        printf("⚠ 注意: 具有特权权限\n");
        printf("  建议:\n");
        printf("  1. 谨慎使用特权功能\n");
        printf("  2. 遵循最小权限原则\n");
    } else {
        printf("✓ 信息: 以普通用户权限运行\n");
        printf("  建议:\n");
        printf("  1. 如需特权操作，请使用 sudo\n");
        printf("  2. 保持系统和软件更新\n");
    }
}

int main() {
    struct user_info current_user;
    
    printf("=== 高级身份验证和权限管理系统 ===\n\n");
    
    // 获取并显示用户信息
    get_user_information(&current_user);
    display_user_info(&current_user);
    
    // 执行各种受保护操作
    perform_protected_operation("read_system_files");
    perform_protected_operation("write_user_files");
    perform_protected_operation("network_admin");
    
    // 显示安全建议
    show_security_advice(&current_user);
    
    printf("\n=== 系统信息 ===\n");
    printf("进程 ID: %d\n", getpid());
    printf("父进程 ID: %d\n", getppid());
    printf("真实 UID: %d\n", getuid());
    printf("有效 UID: %d\n", geteuid());
    printf("真实 GID: %d\n", getgid());
    printf("有效 GID: %d\n", getegid());
    
    return 0;
}

# 编译示例程序
gcc -o geteuid_example1 example1.c
gcc -o geteuid_example2 example2.c
gcc -o geteuid_example3 example3.c

# 运行示例
./geteuid_example1
./geteuid_example2
./geteuid_example3

# 以 root 权限运行（需要 sudo）
sudo ./geteuid_example1
sudo ./geteuid_example2
sudo ./geteuid_example3

# 查看当前用户信息
id

# 查看特定用户信息
id username

# 查看当前进程信息
ps -eo pid,ppid,uid,euid,gid,egid,comm

# 查看用户数据库
cat /etc/passwd
cat /etc/group

// 完整的身份信息获取
uid_t real_uid = getuid();     // 真实用户 ID
uid_t effective_uid = geteuid(); // 有效用户 ID
gid_t real_gid = getgid();     // 真实组 ID
gid_t effective_gid = getegid(); // 有效组 ID

// 权限切换示例
if (geteuid() == 0) {
    // 当前有 root 权限，执行特权操作
    // ...
    // 完成后可以放弃权限
    // setuid(getuid());  // 切换到真实 UID
}

#include <unistd.h>
#include <sys/types.h>

gid_t getgid(void);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>

int main() {
    gid_t real_gid, effective_gid;
    struct group *grp_info;
    
    printf("=== 进程组 ID 信息 ===\n\n");
    
    // 获取真实组 ID
    real_gid = getgid();
    printf("真实组 ID (real GID): %d\n", real_gid);
    
    // 获取有效组 ID
    effective_gid = getegid();
    printf("有效组 ID (effective GID): %d\n", effective_gid);
    
    // 获取组名信息
    grp_info = getgrgid(real_gid);
    if (grp_info != NULL) {
        printf("组名: %s\n", grp_info->gr_name);
        printf("组密码: %s\n", grp_info->gr_passwd ? grp_info->gr_passwd : "(无)");
        printf("组成员: ");
        if (grp_info->gr_mem && grp_info->gr_mem&#91;0]) {
            for (int i = 0; grp_info->gr_mem&#91;i]; i++) {
                printf("%s ", grp_info->gr_mem&#91;i]);
            }
        } else {
            printf("(无成员列表)");
        }
        printf("\n");
    } else {
        printf("无法获取组信息\n");
    }
    
    // 比较真实组 ID 和有效组 ID
    if (real_gid == effective_gid) {
        printf("\n真实组 ID 和有效组 ID 相同\n");
    } else {
        printf("\n真实组 ID 和有效组 ID 不同\n");
    }
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>

void print_user_info(uid_t uid) {
    struct passwd *pwd_info;
    
    pwd_info = getpwuid(uid);
    if (pwd_info != NULL) {
        printf("  用户名: %s\n", pwd_info->pw_name);
        printf("  用户 ID: %d\n", pwd_info->pw_uid);
        printf("  组 ID: %d\n", pwd_info->pw_gid);
        printf("  主目录: %s\n", pwd_info->pw_dir);
        printf("  登录 shell: %s\n", pwd_info->pw_shell);
    } else {
        printf("  无法获取用户信息\n");
    }
}

void print_group_info(gid_t gid) {
    struct group *grp_info;
    
    grp_info = getgrgid(gid);
    if (grp_info != NULL) {
        printf("  组名: %s\n", grp_info->gr_name);
        printf("  组 ID: %d\n", grp_info->gr_gid);
        printf("  组成员: ");
        if (grp_info->gr_mem && grp_info->gr_mem&#91;0]) {
            for (int i = 0; grp_info->gr_mem&#91;i]; i++) {
                printf("%s ", grp_info->gr_mem&#91;i]);
            }
        } else {
            printf("(无成员列表)");
        }
        printf("\n");
    } else {
        printf("  无法获取组信息\n");
    }
}

int main() {
    uid_t real_uid, effective_uid;
    gid_t real_gid, effective_gid;
    
    printf("=== 完整的用户和组信息 ===\n\n");
    
    // 获取用户 ID 信息
    printf("用户信息:\n");
    real_uid = getuid();
    effective_uid = geteuid();
    printf("  真实用户 ID: %d\n", real_uid);
    printf("  有效用户 ID: %d\n", effective_uid);
    print_user_info(real_uid);
    
    printf("\n");
    
    // 获取组 ID 信息
    printf("组信息:\n");
    real_gid = getgid();
    effective_gid = getegid();
    printf("  真实组 ID: %d\n", real_gid);
    printf("  有效组 ID: %d\n", effective_gid);
    print_group_info(real_gid);
    
    // 检查权限状态
    printf("\n权限状态分析:\n");
    if (real_uid == 0 || effective_uid == 0) {
        printf("  ✓ 进程具有 root 权限\n");
    } else {
        printf("  ✗ 进程为普通用户权限\n");
    }
    
    if (real_gid == effective_gid) {
        printf("  ✓ 组权限未被修改\n");
    } else {
        printf("  ⚠ 组权限可能被修改过\n");
    }
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>
#include <errno.h>

// 获取并显示所有组信息
void show_all_groups() {
    gid_t *groups;
    int ngroups;
    long ngroups_max;
    
    printf("=== 所有组信息 ===\n");
    
    // 获取最大组数
    ngroups_max = sysconf(_SC_NGROUPS_MAX);
    if (ngroups_max == -1) {
        ngroups_max = 1024;  // 默认值
    }
    
    // 分配内存
    groups = malloc(ngroups_max * sizeof(gid_t));
    if (groups == NULL) {
        perror("malloc");
        return;
    }
    
    // 获取组列表
    ngroups = getgroups(ngroups_max, groups);
    if (ngroups == -1) {
        perror("getgroups");
        free(groups);
        return;
    }
    
    printf("进程所属组数量: %d\n", ngroups);
    printf("组 ID 列表:\n");
    
    for (int i = 0; i < ngroups; i++) {
        struct group *grp_info = getgrgid(groups&#91;i]);
        printf("  &#91;%d] %d", i + 1, groups&#91;i]);
        if (grp_info != NULL) {
            printf(" (%s)", grp_info->gr_name);
        }
        printf("\n");
    }
    
    // 显示主组
    gid_t primary_gid = getgid();
    struct group *primary_grp = getgrgid(primary_gid);
    printf("\n主组 (getgid): %d", primary_gid);
    if (primary_grp != NULL) {
        printf(" (%s)", primary_grp->gr_name);
    }
    printf("\n");
    
    free(groups);
}

// 检查是否属于特定组
int is_member_of_group(gid_t target_gid) {
    gid_t *groups;
    int ngroups;
    long ngroups_max;
    int result = 0;
    
    // 获取最大组数
    ngroups_max = sysconf(_SC_NGROUPS_MAX);
    if (ngroups_max == -1) {
        ngroups_max = 1024;
    }
    
    // 分配内存
    groups = malloc(ngroups_max * sizeof(gid_t));
    if (groups == NULL) {
        return -1;
    }
    
    // 获取组列表
    ngroups = getgroups(ngroups_max, groups);
    if (ngroups == -1) {
        free(groups);
        return -1;
    }
    
    // 检查是否包含目标组
    for (int i = 0; i < ngroups; i++) {
        if (groups&#91;i] == target_gid) {
            result = 1;
            break;
        }
    }
    
    // 也要检查主组
    if (!result && getgid() == target_gid) {
        result = 1;
    }
    
    free(groups);
    return result;
}

// 特权检查函数
void check_privileges() {
    uid_t uid = getuid();
    uid_t euid = geteuid();
    gid_t gid = getgid();
    gid_t egid = getegid();
    
    printf("=== 权限检查 ===\n");
    
    printf("用户权限:\n");
    printf("  真实 UID: %d\n", uid);
    printf("  有效 UID: %d", euid);
    if (euid == 0) {
        printf(" (root 权限!)\n");
    } else {
        printf(" (普通用户)\n");
    }
    
    printf("组权限:\n");
    printf("  真实 GID: %d\n", gid);
    printf("  有效 GID: %d", egid);
    if (egid == 0) {
        printf(" (root 组权限!)\n");
    } else {
        printf(" (普通组)\n");
    }
    
    // 检查是否属于 wheel 或 sudo 组（管理员组）
    struct group *admin_group;
    
    admin_group = getgrnam("wheel");
    if (admin_group && is_member_of_group(admin_group->gr_gid)) {
        printf("  ✓ 属于 wheel 组 (管理员组)\n");
    }
    
    admin_group = getgrnam("sudo");
    if (admin_group && is_member_of_group(admin_group->gr_gid)) {
        printf("  ✓ 属于 sudo 组 (管理员组)\n");
    }
}

int main() {
    printf("=== 进程身份和权限信息工具 ===\n\n");
    
    // 显示基本身份信息
    printf("基本身份信息:\n");
    printf("  进程 ID: %d\n", getpid());
    printf("  父进程 ID: %d\n", getppid());
    printf("  真实用户 ID: %d\n", getuid());
    printf("  真实组 ID: %d\n", getgid());
    printf("  有效用户 ID: %d\n", geteuid());
    printf("  有效组 ID: %d\n\n", getegid());
    
    // 权限检查
    check_privileges();
    printf("\n");
    
    // 显示所有组信息
    show_all_groups();
    
    printf("\n=== 使用说明 ===\n");
    printf("此工具显示当前进程的完整身份和权限信息。\n");
    printf("包括用户 ID、组 ID、所属的所有组等信息。\n");
    
    return 0;
}

# 编译示例程序
gcc -o getgid_example1 example1.c
gcc -o getgid_example2 example2.c
gcc -o getgid_example3 example3.c

# 运行示例
./getgid_example1
./getgid_example2
./getgid_example3

# 查看当前用户信息
id

# 查看特定用户信息
id username

# 查看组信息
groups
cat /etc/group

# 查看当前进程信息
ps -eo pid,ppid,uid,gid,comm

// 完整的身份信息获取
uid_t uid = getuid();    // 真实用户 ID
gid_t gid = getgid();    // 真实组 ID
uid_t euid = geteuid();  // 有效用户 ID
gid_t egid = getegid();  // 有效组 ID

// 获取所有组
int ngroups = getgroups(0, NULL);  // 先获取数量
gid_t *groups = malloc(ngroups * sizeof(gid_t));
getgroups(ngroups, groups);        // 再获取组列表

#include <unistd.h>
#include <sys/types.h>

int getgroups(int size, gid_t list&#91;]);

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

int main() {
    int group_count;
    gid_t *group_list;
    long max_groups;
    
    printf("=== 获取进程补充组列表 ===\n");
    
    // 首先获取补充组数量
    group_count = getgroups(0, NULL);
    if (group_count == -1) {
        perror("获取补充组数量失败");
        exit(EXIT_FAILURE);
    }
    
    printf("补充组数量: %d\n", group_count);
    
    if (group_count == 0) {
        printf("当前进程没有补充组\n");
        return 0;
    }
    
    // 获取系统支持的最大组数
    max_groups = sysconf(_SC_NGROUPS_MAX);
    if (max_groups == -1) {
        max_groups = 65536;  // 设置一个较大的默认值
    }
    
    printf("系统最大支持组数: %ld\n", max_groups);
    
    // 确保不会超出系统限制
    if (group_count > max_groups) {
        printf("警告: 补充组数量超出系统限制\n");
        group_count = max_groups;
    }
    
    // 分配内存存储组列表
    group_list = malloc(group_count * sizeof(gid_t));
    if (group_list == NULL) {
        perror("内存分配失败");
        exit(EXIT_FAILURE);
    }
    
    // 获取补充组列表
    int result = getgroups(group_count, group_list);
    if (result == -1) {
        perror("获取补充组列表失败");
        free(group_list);
        exit(EXIT_FAILURE);
    }
    
    printf("成功获取 %d 个补充组:\n", result);
    printf("%-8s %-10s %s\n", "序号", "组ID", "组名");
    printf("%-8s %-10s %s\n", "----", "----", "----");
    
    // 显示每个组的信息
    for (int i = 0; i < result; i++) {
        printf("%-8d %-10d ", i + 1, group_list&#91;i]);
        
        // 尝试获取组名
        struct group *grp = getgrgid(group_list&#91;i]);
        if (grp != NULL) {
            printf("%s", grp->gr_name);
        } else {
            printf("(未知)");
        }
        printf("\n");
    }
    
    // 显示主要组信息进行对比
    gid_t primary_gid = getgid();
    printf("\n主要组信息:\n");
    printf("  组ID: %d\n", primary_gid);
    
    struct group *primary_grp = getgrgid(primary_gid);
    if (primary_grp != NULL) {
        printf("  组名: %s\n", primary_grp->gr_name);
    }
    
    // 检查主要组是否在补充组列表中
    int found_in_supplementary = 0;
    for (int i = 0; i < result; i++) {
        if (group_list&#91;i] == primary_gid) {
            found_in_supplementary = 1;
            break;
        }
    }
    
    printf("主要组是否在补充组中: %s\n", 
           found_in_supplementary ? "是" : "否");
    
    free(group_list);
    return 0;
}

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

void demonstrate_error_handling() {
    int result;
    gid_t small_buffer&#91;2];  // 故意使用小缓冲区
    
    printf("=== 错误处理演示 ===\n");
    
    // 获取实际补充组数量
    int actual_count = getgroups(0, NULL);
    if (actual_count == -1) {
        perror("获取补充组数量失败");
        return;
    }
    
    printf("实际补充组数量: %d\n", actual_count);
    
    if (actual_count > 0) {
        // 使用过小的缓冲区，应该返回错误
        printf("使用过小缓冲区测试 (大小: 2):\n");
        result = getgroups(2, small_buffer);
        
        if (result == -1) {
            if (errno == EINVAL) {
                printf("  错误处理正确: 缓冲区不足 (EINVAL)\n");
            } else {
                printf("  其他错误: %s\n", strerror(errno));
            }
        } else {
            printf("  意外成功，返回数量: %d\n", result);
        }
        
        // 使用 NULL 指针但 size > 0
        printf("使用 NULL 指针测试:\n");
        result = getgroups(10, NULL);
        if (result == -1) {
            if (errno == EFAULT) {
                printf("  错误处理正确: 无效指针 (EFAULT)\n");
            } else {
                printf("  其他错误: %s\n", strerror(errno));
            }
        }
    }
}

void demonstrate_empty_groups() {
    printf("\n=== 空组列表演示 ===\n");
    
    // 获取补充组数量
    int count = getgroups(0, NULL);
    if (count == -1) {
        perror("获取组数量失败");
        return;
    }
    
    printf("当前进程补充组数量: %d\n", count);
    
    if (count == 0) {
        printf("进程没有补充组权限\n");
        printf("这可能表示:\n");
        printf("  1. 进程以最小权限运行\n");
        printf("  2. 用户不属于任何补充组\n");
        printf("  3. 在容器或受限环境中运行\n");
    }
}

int main() {
    demonstrate_error_handling();
    demonstrate_empty_groups();
    return 0;
}